using HH.WCS.HangYang.api;
using HH.WCS.HangYang.core;
using HH.WCS.HangYang.dispatch;
using HH.WCS.HangYang.LISTA.models;
using HH.WCS.HangYang.LISTA.process;
using HH.WCS.HangYang.util;
using HH.WCS.HangYang.wms;
using Newtonsoft.Json;
using NLog.Fluent;
using Opc.Ua;
using SqlSugar;
using Swashbuckle.Swagger;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Threading.Tasks;
using static HH.WCS.HangYang.api.OtherModel.Putaway_Order_In;
using static HH.WCS.HangYang.LISTA.process.HttpModel;
using static HH.WCS.HangYang.wms.WMSHelper;
using static System.Runtime.CompilerServices.RuntimeHelpers;

namespace HH.WCS.HangYang.process
{
    internal class TaskProcess
    {
        #region 任务相关
        //--------------------------------------------------任务相关--------------------------------------------------
        /// <summary>
        /// 取货卸货完成，缓存位状态更新
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="v"></param>
        internal static void CacheBitUpdate(WCSTask mst, bool load)
        {
            var trayCarryCount = mst.N_CNTR_COUNT > 0 ? mst.N_CNTR_COUNT : 1;
            if (load)
            {
                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
                LocationHelper.UnBindingLoc(mst.S_START_LOC, mst.S_CNTR_CODE.Split(',').ToList());

            }
            else
            {

                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
                LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList(),mst.S_NOTE);
            }

        }

        /// <summary>
        /// 任务取消，缓存位状态更新
        /// </summary>
        /// <param name="mst"></param>
        internal static void CacheBitCancelUpdate(WCSTask mst)
        {
            //任务取消，取货完成前的，起点的loadingCount和终点unLoadingCount都清除，取货完成的只处理终点
            if (WCSHelper.CheckActionRecordExist(mst.S_CODE, 4))
            {
                //根据客户现场要求，如果取货完成任务失败人工拉到终点，我们就当卸货完成处理；如果是人工拉走到其它区域，我们就解锁终点，删除托盘。
                //终点绑定
                CacheBitUpdate(mst, false);
                LocationHelper.UnLockLoc(mst.S_END_LOC);
            }
            else
            {

                //起点终点解锁
                LocationHelper.UnLockLoc(mst.S_START_LOC);
                LocationHelper.UnLockLoc(mst.S_END_LOC);

            }

        }


        /// <summary>
        /// 任务拦截
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        internal static bool Intercept(WCSTask mst)
        {
            var result = false;
           
            return result;
        }

        /// <summary>
        /// 任务状态更新处理
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="state"></param>
        internal static void OperateStatus(WCSTask mst, int state)
        {
            if (state == 4)
            {
                CacheBitUpdate(mst, true);
            }
            if (state == 6)//卸货完成
            {
                CacheBitUpdate(mst, false);
            }
            if (state == 7)
            {
                CacheBitCancelUpdate(mst);
            }
        }

        /// <summary>
        /// 推送任务
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendTask(WCSTask mst)
        {


            var result = false;
            var start = "0"; var end = "0";
            var taskType = mst.S_TYPE.Trim();
            // if (mst.N_B_STATE == 0) {
            if (mst.N_SCHEDULE_TYPE == 1)
            {
                start = LocationHelper.GetAgvSite(mst.S_START_LOC);
                end = LocationHelper.GetAgvSite(mst.S_END_LOC);


                Console.WriteLine($"SendTask {mst.S_CODE}");
                Console.WriteLine("start=" + start);
                Console.WriteLine("end= " + end);
                var dic = new Dictionary<string, string>();
                dic.Add("Pri", mst.N_PRIORITY.ToString());
                dic.Add("From", start.ToString());
                dic.Add("To", end.ToString());
                dic.Add("No", mst.S_CODE.Trim());// dic.Add("Ext1", "1"); dic.Add("Ext2", "CALLADDAGV"); dic.Add("N_CNTR_COUNT", "");
                var res = NDC.AddNewOrder(5, dic);
                if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                {
                    //推送成功，修改任务优先级
                    mst.N_B_STATE = 1;
                    WCSHelper.UpdateStatus(mst);
                    result = true;
                }
            }
            //else if (mst.N_SCHEDULE_TYPE == 5) {
            //    //调第三方接口
            //    var model = new HanAo.TaskInfoModel
            //    {
            //        requestPk = mst.S_CODE,
            //        frmPos = mst.S_START_LOC,
            //        toPos = mst.S_END_LOC,
            //        trkType = mst.S_OP_NAME == "入库" ? "1" : "2",
            //        contNo = mst.S_CNTR_CODE
            //    };
            //    if (HanAo.CreateOrder(model)) {
            //        mst.N_B_STATE = 1;
            //        WCSHelper.UpdateStatus(mst);
            //    }
            //}
            //else if (mst.N_SCHEDULE_TYPE == 3)
            //{
            //    var code = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, JsonConvert.SerializeObject(new { src = mst.S_START_LOC, dst = mst.S_END_LOC }), "p2p");
            //    if (code > 0)
            //    {
            //        更新任务状态
            //        mst.N_B_STATE = 1;
            //        mst.S_EQ_TASK_CODE = code.ToString();
            //        WCSHelper.UpdateStatus(mst);
            //        WCSHelper.UpdateEQNo(mst);

            //    }
            //}

            //}
            return result;
        }

        /// <summary>
        /// 国自推送任务
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendGZTask(WCSTask mst)
        {
            var result = false;
            var taskState = mst.S_B_STATE.Trim();
            if (taskState == "等待")
            {
                Console.WriteLine($"任务mst {JsonConvert.SerializeObject(mst)}");
                LogHelper.Info($"任务mst {JsonConvert.SerializeObject(mst)}", "任务");
                var startLoc = LocationHelper.GetLoc(mst.S_START_LOC);
                var endLoc = LocationHelper.GetLoc(mst.S_END_LOC);
                if (startLoc != null && endLoc != null)
                {
                    //"parameters": "{\"src\":\"a\",\"dst\":\"b\",\" carcode \":\"aaaaa\",\" orderid \":1}"
                    //src:起点, dst:终点，carcode:车号，orderid:
                    string src = $"\"src\":\"{startLoc.S_AGV_SITE}\","; ;
                    string dst = $"\"dst\":\"{endLoc.S_AGV_SITE}\"";
                    string parmeS = "{";
                    string parmeD = "}";
                    string parme = parmeS + src + dst + parmeD;
                    LogHelper.Info($"推送任务参数{parme}", "任务");
                    var res = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, parme);
                    if (res > 0)
                    {
                        //更新任务状态
                        mst.N_B_STATE = 1;
                        mst.S_EQ_TASK_CODE = res.ToString();
                        WCSHelper.UpdateStatus(mst);
                        WCSHelper.UpdateEQNo(mst);

                        ////推送成功，修改任务状态
                        //TaskHelper.UpdateStatus(mst, "已推送");
                        ////推送成功，修改国自ID
                        //TaskHelper.UpdateGzId(mst, res);
                        LogHelper.Info($"任务mst {mst.S_CODE}推送成功", "任务");
                        result = true;
                    }
                }


            }
            else { result = true; }
            return result;
        }


        /// <summary>
        /// 创建搬运任务
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="taskType"></param>
        /// <param name="cntrs"></param>
        /// <param name="startLayer"></param>
        /// <param name="endLayer"></param>
        /// <param name="trayCarryCount"></param>
        /// <param name="priority"></param>
        /// <returns></returns>
        public static bool CreateTransport(string start, string end, string taskType, List<string> cntrs, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1)
        {
            var result = false;
            //批次号存托盘号，1~3个托盘
            var trayCodes = string.Join(",", cntrs);
            var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, trayCarryCount, startLayer, endLayer);
            if (res)
            {
                result = true;
                //任务创建成功，起点货位出库锁定，终点货位入库锁定
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);
            }
            return result;
        }


        public static bool CreateTransport(string start, string end, string taskType, List<string> cntrs, int priority = 1)
        {
            var result = false;
            //批次号存托盘号，1~3个托盘
            var trayCodes = string.Join(",", cntrs);
            var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, 1, 1, 1);
            if (res)
            {
                result = true;
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);

            }
            return result;
        }

        internal static Result cancelTask1(cancleTaskParme model)
        {
            var result = new Result();
            LogHelper.Info("cancelTask1取消任务信息：" + JsonConvert.SerializeObject(model), "API");
            if (model == null)
            {

                result.success = false;
                result.errMsg = "参数为null";
                result.errCode = 1;
                return result;
            }
            var task = WCSHelper.GetTask(model.taskNo);
            if (task != null)
            {
                if (task.S_B_STATE.Trim() == "未执行")
                {
                    //未执行直接修改状态为取消
                    TaskProcess.OperateStatus(task, 7);
                    WCSHelper.UpdateStatus(task, "取消");
                    result.success = true;
                    result.errMsg = "取消任务成功";
                    result.errCode = 0;
                }
                else if (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "完成")
                {

                    if (GZRobot.CancelOrder(int.Parse(task.S_EQ_TASK_CODE)))
                    {
                        TaskProcess.OperateStatus(task, 7);
                        WCSHelper.Fail(task);
                        result.success = true;
                        result.errMsg = "国自取消任务成功";
                        result.errCode = 0;
                    }
                    else
                    {
                        result.success = false;
                        result.errMsg = "国自取消任务失败";
                        result.errCode = 1;
                    }

                }
                else
                {
                    result.success = false;
                    result.errMsg = "任务已经结束";
                    result.errCode = 1;
                }
            }
            else
            {
                result.success = false;
                result.errMsg = "任务不存在";
                result.errCode = 1;
            }
            LogHelper.Info("cancelTask1取消任务返回结果：" + JsonConvert.SerializeObject(result), "API");
            return result;
        }


        #endregion

        #region 杭氧
        /// <summary>
        /// 杭氧创建搬运任务
        /// </summary>
        /// <param name="start">起点</param>
        /// <param name="end">终点</param>
        /// <param name="taskType">任务类型</param>
        /// <param name="cntrs">托盘号</param>
        /// <param name="priority">优先级</param>
        /// <param name="taskNo">作业编码</param>
        /// <returns></returns>
        public static bool HYCreateTransport(string start, string end, string taskType, string cntrs, string taskNo = "", int priority = 1)
        {
            var result = false;
            //批次号存托盘号，1~3个托盘
            var trayCodes = string.Join(",", cntrs);
            //var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes);
            if (res)
            {
                result = true;
                //任务创建成功，起点货位出库锁定，终点货位入库锁定
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);
            }
            return result;
        }

        /// <summary>
        /// 入库单新增
        /// </summary>
        /// <param name="model">入库单</param>
        /// <returns></returns>
        public static Result GetMaterialData(List<MES_Material> model)
        {
            Result result = new Result() { success = false, };
            try
            {
                if (model == null)
                {
                    result.errMsg = "入库单不可为空值！";
                    return result;
                }

                //foreach (var item in model.InOrderDetail)
                //{
                //    var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
                //    if (itemType == null)
                //    {
                //        result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
                //        return result;
                //    }
                //    item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
                //}

                //var groupedInOrders = model.InOrderDetail
                //                      .GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
                //                      .Select((group, index) => new InOrder
                //                      {
                //                          S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
                //                          S_BS_NO = model.S_BS_NO,
                //                          S_OP_TYPE = model.S_OP_TYPE,
                //                          S_BS_TYPE = model.S_BS_TYPE,
                //                          S_NOTE = model.S_NOTE,
                //                          InOrderDetail = group.Select(detail =>
                //                          {
                //                              // 修改 group 中的 S_IO_NO 字段为 S_NO 的值
                //                              detail.S_IO_NO = $"{model.S_BS_NO}_{index + 1}";
                //                              detail.S_BS_NO = model.S_BS_NO;
                //                              return detail;
                //                          }).ToList() // 分组后的明细
                //                      })
                //                      .ToList();
                //var res = WMSHelper.CreateOrderIn(groupedInOrders);
                //if (res)
                //{
                //    result.success = true;
                //}
                return result;
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }

        }

        /// <summary>
        /// 入库单新增
        /// </summary>
        /// <param name="model">入库单</param>
        /// <returns></returns>
        public static Result GetInboundOrder(InOrder model)
        {
            Result result = new Result() { success = false, };
            try
            {
                if (model == null || !model.InOrderDetail.Any())
                {
                    result.errMsg = "入库单不可为空值！";
                    return result;
                }

                foreach (var item in model.InOrderDetail)
                {
                    var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
                    if (itemType == null)
                    {
                        result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
                        return result;
                    }
                    item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
                    item.S_ITEM_NAME = itemType.S_ITEM_NAME;
                }

                var groupedInOrders = model.InOrderDetail
                                      .GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
                                      .Select((group, index) => new InOrder
                                      {
                                          S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
                                          S_BS_NO = model.S_BS_NO,
                                          S_OP_TYPE = model.S_OP_TYPE,
                                          S_BS_TYPE = model.S_BS_TYPE,
                                          S_NOTE = model.S_NOTE,
                                          S_FACTORY = "HY001",
                                          S_WH_CODE = "CK001",
                                          S_AREA_CODE = group.Key.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
                                          InOrderDetail = group.Select(detail =>
                                          {
                                              // 修改 group 中的 S_IO_NO 字段为 S_NO 的值
                                              detail.S_IO_NO = $"{model.S_BS_NO}_{index + 1}";
                                              detail.S_BS_NO = model.S_BS_NO;
                                              return detail;
                                          }).ToList() // 分组后的明细
                                      })
                                      .ToList();
                var res = WMSHelper.CreateOrderIn(groupedInOrders);
                if (res)
                {
                    result.success = true;
                }
                return result;
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }

        }

        /// <summary>
        /// 出库单新增
        /// </summary>
        /// <param name="model">入库单</param>
        /// <returns></returns>
        public static Result GetOutboundOrder(OutOrder model)
        {
            Result result = new Result() { success = false, };
            try
            {
                if (model == null || !model.OutOrderDetail.Any())
                {
                    result.errMsg = "出库单不可为空值！";
                    return result;
                }

                foreach (var item in model.OutOrderDetail)
                {
                    var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
                    if (itemType == null)
                    {
                        result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
                        return result;
                    }
                    item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
                    item.S_ITEM_NAME  = itemType.S_ITEM_NAME;
                }

                var groupedInOrders = model.OutOrderDetail
                                      .GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
                                      .Select((group, index) => new OutOrder
                                      {
                                          S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
                                          S_BS_NO = model.S_BS_NO,
                                          S_OP_TYPE = model.S_OP_TYPE,
                                          S_NOTE = model.S_NOTE,
                                          S_BS_TYPE = "ERP",
                                          S_FACTORY = "HY001",
                                          S_WH_CODE = "CK001",
                                          S_AREA_CODE = group.Key.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
                                          OutOrderDetail = group.Select(detail =>
                                          {
                                              // 修改 group 中的 S_IO_NO 字段为 S_NO 的值
                                              detail.S_OO_NO = $"{model.S_BS_NO}_{index + 1}";
                                              detail.S_BS_NO = model.S_BS_NO;
                                              return detail;
                                          }).ToList() // 分组后的明细
                                      })
                                      .ToList();
                var res = WMSHelper.CreateOrderOut(groupedInOrders);
                if (res)
                {
                    result.success = true;
                }
                return result;
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }

        }

        /// <summary>
        /// 获取作业创建入库任务
        /// </summary>
        /// <param name="mst"></param>
        /// <returns></returns>
        internal static bool CreateInTask(WMSTask mst)
        {
            try
            {
                var result = false;
                var taskState = mst.S_B_STATE.Trim();
                if (taskState == "等待")
                {
                    if (!string.IsNullOrEmpty(mst.S_START_LOC))
                    {
                        //杭氧所有库区
                        var reservoirs = Settings.ReservoirAreas.ToList();
                        if (!reservoirs.Any() || reservoirs == null)
                        {
                            LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
                            return false;
                        }
                        if (mst.S_TYPE == "托盘转运")
                        {
                            var lxAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault().areaCode);
                            if (lxAnyLoc.Any())
                            {

                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxAnyLoc.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
                                if (!res)
                                {
                                    LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
                                    return false;
                                }
                                WMSHelper.UpdateStatus(mst, 1);
                            }
                            else
                            {
                                var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                                if (rkAnyLoc.Any())
                                {
                                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                                    if (!res)
                                    {
                                        LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                                        return false;
                                    }
                                    WMSHelper.UpdateStatus(mst, 1);
                                    //标记为合托
                                    ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
                                }
                                else
                                {
                                    LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                                    return false;
                                }
                            }
                        }
                        if (mst.S_TYPE == "托盘入库")
                        {
                            //1.查询下下库里面是否有要合托的托盘
                            var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
                            if (locMerge != null)
                            {
                                //（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
                                var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
                                if (anyLoc.Any())
                                {
                                    
                                    //生成一条出库的任务
                                    var relevancys = Settings.Relevancys.Where(s => s.InLoc == anyLoc.FirstOrDefault().S_CODE).FirstOrDefault();
                                    if (relevancys == null)
                                    {
                                        LogHelper.Info("Settings出现错误未查询到合托入库位对应的出库位！", "杭氧");
                                        return false;
                                    }
                                    //生成到合托区的任务
                                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
                                    if (!res)
                                    {
                                        LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
                                        return false;
                                    }
                                    res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
                                    if (!res)
                                    {
                                        LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
                                        return false;
                                    }
                                    //（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
                                    ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");

                                    WMSHelper.UpdateStatus(mst, 1);
                                }
                                else
                                {
                                    //（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
                                    //生成到入库缓存区的任务
                                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                                    if (rkAnyLoc.Any())
                                    {
                                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                                        if (!res)
                                        {
                                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                                            return false;
                                        }
                                        WMSHelper.UpdateStatus(mst, 1);
                                        //标记为合托
                                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
                                    }
                                    else
                                    {
                                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                                        return false;
                                    }
                                }

                            }
                            else
                            {
                                //2.如果没有要合托的托盘
                                var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                                if (area == null)
                                {
                                    LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                                    return false;
                                }
                                //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
                                var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                                if (anyLoc.Any())
                                {
                                    //生成到接驳位的任务
                                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
                                    if (!res)
                                    {
                                        LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
                                        return false;
                                    }
                                    WMSHelper.UpdateStatus(mst, 1);
                                }
                                else
                                {
                                    //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
                                    //生成到入库缓存区的任务
                                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                                    if (rkAnyLoc.Any())
                                    {
                                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                                        if (!res)
                                        {
                                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                                            return false;
                                        }
                                        WMSHelper.UpdateStatus(mst, 1);
                                        //标记为不合托
                                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
                                    }
                                    else
                                    {
                                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                                        return false;
                                    }

                                }

                            }
                        }
                        if (mst.S_TYPE == "合托回库")
                        {
                            var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
                            if (trayLst.Any())
                            {
                                //满托回库
                                var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                                if (area == null)
                                {
                                    LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                                    return false;
                                }
                                //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
                                var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                                if (anyLoc.Any())
                                {
                                    //生成到接驳位的任务
                                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
                                    if (!res)
                                    {
                                        LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
                                        return false;
                                    }
                                    WMSHelper.UpdateStatus(mst, 1);
                                }
                                else
                                {
                                    //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
                                    //生成到入库缓存区的任务
                                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                                    if (rkAnyLoc.Any())
                                    {
                                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                                        if (!res)
                                        {
                                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                                            return false;
                                        }
                                        WMSHelper.UpdateStatus(mst, 1);
                                        //标记为不合托
                                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
                                    }
                                    else
                                    {
                                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                                        return false;
                                    }

                                }
                            }
                            else
                            {
                                //空托回库
                                var area = reservoirs.Where(s => s.areaName == "人机接驳位-空托位").FirstOrDefault();
                                if (area == null)
                                {
                                    LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                                    return false;
                                }
                                //(2.1)先查询人机接驳位-空托位是否为空，如果为空直接生成到入库的任务
                                var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                                if (anyLoc.Any())
                                {
                                    //生成到接驳位的任务
                                    var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "人机接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
                                    if (!res)
                                    {
                                        LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
                                        return false;
                                    }
                                    WMSHelper.UpdateStatus(mst, 1);
                                }
                                else
                                {
                                    //生成到入库缓存区的任务
                                    var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
                                    if (rkAnyLoc.Any())
                                    {
                                        var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
                                        if (!res)
                                        {
                                            LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
                                            return false;
                                        }
                                        //标记为不合托
                                        ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
                                        WMSHelper.UpdateStatus(mst, 1);

                                    }
                                    else
                                    {
                                        LogHelper.Info("入库缓存区没有空货位！", "杭氧");
                                        return false;
                                    }
                                }
                            }
                        }
                        if (mst.S_TYPE == "料箱出库")
                        {

                            //满托回库
                            var area = reservoirs.Where(s => s.areaName == "料箱码盘区").FirstOrDefault();
                            if (area == null)
                            {
                                LogHelper.Info("Settings出现错误未查询到料箱码盘区！", "杭氧");
                                return false;
                            }
                            //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
                            var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                            if (anyLoc.Any())
                            {
                                //生成到接驳位的任务
                                var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "料箱出库", mst.S_CNTR_CODE, mst.S_CODE);
                                if (!res)
                                {
                                    LogHelper.Info("料箱出库任务创建失败！", "杭氧");
                                    return false;
                                }
                                WMSHelper.UpdateStatus(mst, 1);
                            }
                            else
                            {
                                LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
                            }
                        }
                    }
                }
                else { result = true; }
                return result;
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"CreateInTask获取作业创建入库任务出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return false;
            }

        }

        /// <summary>
        /// 循环入库缓存区查询合托工位和入库接驳位是否有空货位（创建任务）
        /// </summary>
        /// <returns></returns>
        internal static bool BatchInWork()
        {
            try
            {
                bool res = false;
                //杭氧所有库区
                var reservoirs = Settings.ReservoirAreas.ToList();
                if (!reservoirs.Any() || reservoirs == null)
                {
                    LogHelper.Info("Settings出现错误未查询到的杭氧库区！", "杭氧");
                    return false;
                }

                var rkAnyLoc = reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault();
                if (rkAnyLoc == null)
                {
                    LogHelper.Info("Settings出现错误未查询到入库缓存区！", "杭氧");
                    return false;
                }

                //合托逻辑
                var cntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "合托").FirstOrDefault();
                if (cntrAbouts != null)
                {
                    var area = reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault();
                    if (area != null)
                    {
                        //1.查询合托工位的状态
                        var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                        if (anyLoc.Any())
                        {
                            var list = WMSHelper.GetWmsTaskList("执行", cntrAbouts.S_CNTR_CODE);
                            if (list == null)
                            {
                                LogHelper.Info($"未查询到在执行中的作业:{cntrAbouts.S_CNTR_CODE}！", "杭氧");
                                return false;
                            }
                            //1.2创建码盘合托入库的任务，同时生成一个码盘合托出库的任务
                            //查询下要出库合托的托盘
                            var locMerge = WMSHelper.GetLocMerge(cntrAbouts.S_CNTR_CODE);
                            if (locMerge == null)
                            {
                                return false;
                            }
                           
                            //生成一条出库的任务
                            var relevancys = Settings.Relevancys.Where(s => s.InLoc == anyLoc.FirstOrDefault().S_CODE).FirstOrDefault();
                            if (relevancys == null)
                            {
                                LogHelper.Info("Settings出现错误未查询到合托入库位对应的出库位！", "杭氧");
                                return false;
                            }
                            //生成到合托区的任务
                            res = TaskProcess.HYCreateTransport(cntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘合托入库", cntrAbouts.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
                                return false;
                            }
                            res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info("Settings出现错误未查询到合托区！", "杭氧");
                        return false;
                    }
                }
                
                //不合托逻辑
                var noCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "不合托").FirstOrDefault();
                if (noCntrAbouts != null)
                {
                    //2.查询入库接驳位的状态
                    var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
                    if (area != null)
                    {
                        var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                        if (anyLoc.Any())
                        {
                            var list = WMSHelper.GetWmsTaskList("执行", noCntrAbouts.S_CNTR_CODE);
                            if (list == null)
                            {
                                LogHelper.Info($"未查询到在执行中的作业:{noCntrAbouts.S_CNTR_CODE}！", "杭氧");
                                return false;
                            }
                            //2.2如果入库接驳位为空创建码盘接驳入库的任务
                            //生成到接驳位的任务
                            res = TaskProcess.HYCreateTransport(noCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", noCntrAbouts.S_CNTR_CODE,list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
                        return false;
                    }
                }

                //料箱合托逻辑
                var lxCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "料箱合托").FirstOrDefault();
                if (lxCntrAbouts != null)
                {
                    //2.查询入库接驳位的状态
                    var area = reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault();
                    if (area != null)
                    {
                        var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
                        if (anyLoc.Any())
                        {
                            var list = WMSHelper.GetWmsTaskList("执行", lxCntrAbouts.S_CNTR_CODE);
                            if (list == null)
                            {
                                LogHelper.Info($"未查询到在执行中的作业:{lxCntrAbouts.S_CNTR_CODE}！", "杭氧");
                                return false;
                            }
                            //生成到接驳位的任务
                            res = TaskProcess.HYCreateTransport(lxCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "料箱缓存入库", lxCntrAbouts.S_CNTR_CODE, list.S_CODE);
                            if (!res)
                            {
                                LogHelper.Info("料箱缓存入库任务创建失败！", "杭氧");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info("Settings出现错误未查询到料箱入库缓存位！", "杭氧");
                        return false;
                    }
                }

                return res;
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"BatchInWork循环入库缓存区出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return false;
            }

        }

        /// <summary>
        /// WCS调用设备信号反馈
        /// </summary>
        /// <param name="model">请求参数</param>
        /// <returns></returns>
        public static async Task<Result> notifyDeviceSignal(List<Wcsmodel> model)
        {
            Result result = new Result() { success = false, };
            try
            {
                foreach (var item in model)
                {
                    if (string.IsNullOrEmpty(item.cntrNo))
                    {
                        result.errMsg = "托盘号为空！";
                        return result;
                    }
                    var list = WMSHelper.GetWmsTaskList("等待", item.cntrNo);
                    if (list == null)
                    {
                        list = WMSHelper.GetWmsTaskList("执行", item.cntrNo);
                    }
                    if (list == null)
                    {
                        result.errMsg = "未查询到在等待中的作业！";
                        return result;
                    }

                    var inbound = new Inbound()
                    {
                        areaCode = list.S_END_AREA
                    };
                    var wh = new Warehouse(inbound);
                    var stored = await wh.StoreItemAsync();
                    if (stored == null)
                    {
                        result.errMsg = "立库区未查询到可用货位！";
                        return result;
                    }

                    var startLoc = ContainerHelper.GetCntrLoc(list.S_CNTR_CODE);
                    if (startLoc == null)
                    {
                        result.errMsg = $"未查询到托盘{list.S_CNTR_CODE}所在的货位！";
                        return result;
                    }
                    var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, stored.loationCode, list.S_B_STATE == "等待" ? "料箱入库" : "托盘入库", list.S_CNTR_CODE, list.S_CODE);
                    if (!res)
                    {
                        result.errMsg = "入库任务创建失败！";
                        return result;
                    }
                    WMSHelper.UpdateTaskStatus(list.S_CODE, 1);
                    ContainerHelper.UpdateCntrAbouts(list.S_CNTR_CODE, "");
                }
                

                result.success = true;
                return result;
            }
            catch (Exception ex)
            {
                result.success = false;
                result.errMsg = ex.Message;
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"notifyDeviceSignalWCS调用设备信号反馈出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return result;
            }
        }

        /// <summary>
        /// 根据配盘单生成出库任务
        /// </summary>
        /// <param name="distributionCntr">配盘单</param>
        /// <returns></returns>
        internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntr)
        {
            try
            {
                // 创建调度器
                var scheduler =  new DoubleDeepOutboundScheduler(distributionCntr);

                var listOut = new List<Outbound>();
                foreach (var item in distributionCntr)
                {
                    listOut.Add(new Outbound
                    {
                        locCode = item.S_LOC_CODE,
                        areaCode = item.S_AREA_CODE,
                        endArea = item.S_EXIT_AREA_CODE,
                        endBit = item.S_EXIT_LOC_CODE,
                        trayCode = item.S_CNTR_CODE,
                        taskType = "配盘出库"
                    });
                }
                // 请求出库
                var tasks = scheduler.GenerateOutboundTasks(listOut);
                foreach (var item in tasks)
                {
                    // 创建出库任务
                    var res = TaskProcess.HYCreateTransport(item.S_START_LOC, item.S_END_LOC, item.S_TYPE, item.S_CNTR_CODE, item.S_OP_CODE);
                    UpdateDistributionCntrState("作业中", item.S_CNTR_CODE);
                    if (!res)
                    {
                        LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
                        return false;
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"根据配盘单生成出库任务！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
                return false;
            }

        }

        #endregion



    }
}