using HH.WCS.XiaoMi.api;
using HH.WCS.XiaoMi.core;
using HH.WCS.XiaoMi.dispatch;
using HH.WCS.XiaoMi.LISTA.process;
using HH.WCS.XiaoMi.util;
using HH.WCS.XiaoMi.wms;
using HH.WCS.XiaoMi;
using Newtonsoft.Json;
using NLog.Fluent;
using SqlSugar;
using Swashbuckle.Swagger;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using static HH.WCS.XiaoMi.LISTA.process.HttpModel;
using static System.Runtime.CompilerServices.RuntimeHelpers;
using HH.WCS.XiaoMi.device;
using Org.BouncyCastle.Utilities;
using Opc.Ua;
using System.Collections;
using System.Xml.Linq;
using System.Threading;
using static HH.WCS.XiaoMi.dispatch.NDC;
using static HH.WCS.XiaoMi.util.Settings;
using System.ComponentModel;
using Newtonsoft.Json.Linq;
using S7.Net;
using System.Threading.Tasks;
using HH.WCS.XiaoMi.LISTA.dispatch;
using static HH.WCS.XiaoMi.LISTA.dispatch.RcsHelper;

namespace HH.WCS.XiaoMi.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)
            {
                Console.WriteLine($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
                if (mst.S_FRAME_CODE != null)
                {
                    LocationHelper.UnBindingLocHj(mst.S_START_LOC, mst.S_FRAME_CODE);

                }
                else
                {
                    LocationHelper.UnBindingLoc(mst.S_START_LOC, mst.S_CNTR_CODE.Split(',').ToList());

                }
            }
            else
            {
                Console.WriteLine($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
                //如果货架有值则绑货架
                if (mst.S_FRAME_CODE!=null)
                {
                    LocationHelper.BindingLocHj(mst.S_END_LOC, mst.S_FRAME_CODE);

                }
                else
                {
                    LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList());

                }
            }

        }

        /// <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;
            //  if (mst.S_TYPE == "自动转运") {
            //判断人工卸货区开关
            //     result = true;

            // }
            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);
            }
        }
        
        private static object locLocker = new object();

        /// <summary>
        /// 堆叠库区出入库任务申请
        /// </summary>
        /// <param name="ls"></param>
        /// <param name="cntrs"></param>
        /// <param name="area"></param>
        /// <param name="itemCode"></param>
        /// <param name="itemBatch"></param>
        /// <param name="taskType"></param>
        /// <param name="insStock"></param>
        /// <returns></returns>
        internal static bool ApplyTN_Task(Location ls, ref List<string> cntrs, string area, string itemCode, string itemBatch, string taskType, bool insStock = true)
        {
            var result = false;
            lock (locLocker)
            {
                try
                {
                    if (insStock)
                    {
                        Console.WriteLine($"MoboxHelperCreateTask: {area}-{itemCode}-{itemBatch}-{taskType}");
                        var endTN_Location = GetLocation4In(area, itemCode, itemBatch, 3);
                        if (endTN_Location != null)
                        {
                            var endLayer = endTN_Location.N_CURRENT_NUM == 0 ? 1 : 2;
                            var taskNo = DateTime.Now.Ticks.ToString();
                            result = TaskProcess.CreateTransport(ls.S_CODE, endTN_Location.S_CODE, taskType, cntrs, 1, endLayer, 3, 70);
                        }
                        else
                        {
                            Console.WriteLine($"MoboxHelperCreateTask: 未找到终点货位");
                        }
                    }
                    else
                    {
                        var startTN_Location = GetLocation4Out(area, itemCode, itemBatch, 3);
                        if (startTN_Location != null)
                        {
                            var startLayer = startTN_Location.N_CURRENT_NUM <= 3 ? 1 : 2;
                            var taskNo = DateTime.Now.Ticks.ToString();
                            var carryCount = startTN_Location.N_CURRENT_NUM > 3 ? startTN_Location.N_CURRENT_NUM - 3 : startTN_Location.N_CURRENT_NUM;
                            //出库要从起点获取托盘
                            var cntrList = LocationHelper.GetLocCntr(startTN_Location.S_CODE);
                            if (cntrList.Count == startTN_Location.N_CURRENT_NUM)
                            {
                                cntrs = cntrList.OrderByDescending(a => a.T_CREATE).Take(carryCount).Select(a => a.S_CNTR_CODE.Trim()).ToList();
                                result = TaskProcess.CreateTransport(startTN_Location.S_CODE, ls.S_CODE, taskType, cntrs, startLayer, 1, carryCount, 65);
                            }
                            else
                            {
                                Console.WriteLine($"起点托盘数量和货位容器表不符合，请检查【货位表】和【货位容器表】");
                            }

                        }
                    }
                }
                catch (Exception ex)
                {

                    Console.WriteLine("MoboxHelperCreateTask:" + ex.Message);
                    LogHelper.Error("MoboxHelperCreateTask:" + ex.Message, ex);
                }
            }
            return result;


        }

        private static Location GetLocation4Out(string area, string itemCode, string itemBatch, int v)
        {
            throw new NotImplementedException();
        }

        private static Location GetLocation4In(string area, string itemCode, string itemBatch, int v)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 普通货架区的出入库申请
        /// </summary>
        /// <param name="ls"></param>
        /// <param name="cntrs"></param>
        /// <param name="area"></param>
        /// <param name="taskType"></param>
        /// <param name="itemCode"></param>
        /// <param name="insStock"></param>
        /// <returns></returns>
        internal static bool ApplyNormalTN_Task(Location ls, ref List<string> cntrs, string area, string taskType, string itemCode, bool insStock = true)
        {
            var result = false;
            lock (locLocker)
            {
                try
                {
                    if (insStock)
                    {
                        Console.WriteLine($"MoboxHelperCreateTask: {area}-{taskType}");
                        var endTN_Location = new Location();
                        if (endTN_Location != null)
                        {
                            var taskNo = DateTime.Now.Ticks.ToString();
                            result = TaskProcess.CreateTransport(ls.S_CODE, endTN_Location.S_CODE, taskType, cntrs, 70);
                        }
                        else
                        {
                            Console.WriteLine($"MoboxHelperCreateTask: 未找到终点货位");
                        }
                    }
                    else
                    {
                        var startTN_Location = new Location();
                        if (startTN_Location != null)
                        {
                            //出库要从起点获取托盘
                            var cntrList = LocationHelper.GetLocCntr(startTN_Location.S_CODE);
                            if (cntrList.Count == startTN_Location.N_CURRENT_NUM)
                            {
                                result = TaskProcess.CreateTransport(startTN_Location.S_CODE, ls.S_CODE, taskType, new List<string> { cntrList[0].S_CNTR_CODE }, 65);
                            }
                            else
                            {
                                Console.WriteLine($"起点托盘数量和货位容器表不符合，请检查【货位表】和【货位容器表】");
                            }

                        }
                    }
                }
                catch (Exception ex)
                {

                    Console.WriteLine("MoboxHelperCreateTask:" + ex.Message);
                    LogHelper.Error("MoboxHelperCreateTask:" + ex.Message, ex);
                }
            }
            return result;


        }

        /// <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;
                }
            }

            return result;
        }

        /// <summary>
        /// 国自推送任务
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendGZTask(WCSTask mst)
        {
            var result = false;
            var taskState = mst.N_B_STATE;
            if (taskState == 0)
            {
                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)
                {
                    string src = $"\"src\":\"{startLoc.S_AGV_SITE}\",";
                    string dst = $"\"dst\":\"{endLoc.S_AGV_SITE}\"";
                    string parmeS = "{";
                    string parmeD = "}";
                    string parme = parmeS + src + dst + parmeD;
                    int res = 0;
                    LogHelper.Info($"推送任务参数{parme}", "任务");
                    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;
        }
        //小米推送任务
        internal static bool SendXmTask(WCSTask mst)
        {
            var result = false;
            var taskState = mst.N_B_STATE;
            if (taskState == 0)
            {
                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 (mst.S_START_LOC != null && mst.S_END_LOC != null)
                {
                    string src = $"\"src\":\"{mst.S_START_LOC}\",";
                    string dst = $"\"dst\":\"{mst.S_END_LOC}\",";
                    string carrier_type_id = $"\"carrier_type_id\":\"1\"";
                    string parmeS = "{";
                    string parmeD = "}";
                    string parme = parmeS + src + dst + carrier_type_id + parmeD;
                    
                    LogHelper.Info($"推送任务参数{parme}", "任务");
                    AntsTaskModel model = new AntsTaskModel();
                    model.order_name = mst.S_CODE;
                    model.priority = 1;
                    model.dead_line = DateTime.Now.ToString();
                    model.ts_name = mst.S_TYPE;
                    model.parameters = parme;
                    //model.parameters = new AntsParasModel { 
                    //    src = mst.S_START_LOC,
                    //    dst = mst.S_END_LOC,
                    //    carrier_type_id="-99"
                    //};
                    var res = RcsHelper.CreateAntsOrder(model);
                    if (res)
                    {
                        //更新任务状态
                        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, string cntrs, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1)
        {
            var result = false;
            var trayCodes = 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 CreateTransportDj(string start, string end, string taskType, string cntrs,string orderName, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1)
        {
            var result = false;
            var trayCodes = cntrs;
            //var taskNo = DateTime.Now.Ticks.ToString();
            var taskNo = orderName;
            


            var res = WCSHelper.CreateTaskDj(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, orderName,trayCarryCount, startLayer, endLayer);
            if (res)
            {
                result = true;
                //任务创建成功，起点货位出库锁定，终点货位入库锁定
                LocationHelper.LockLoc(start, 2);
                LocationHelper.LockLoc(end, 1);
            }
            return result;
        }
        //小米货架任务
        public static bool CreateTransportHj(string start, string end, string taskType, string frame, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1)
        {
            var result = false;
            var trayCodes = frame;
            var taskNo = DateTime.Now.Ticks.ToString();


            var res = WCSHelper.CreateTaskHj(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;
        }
        /// <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;
            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;
        }

        /// <summary>
        /// 创建入库任务
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static Result CreateInWork(moboxParam model)
        {

            var result = new Result() { success = true, errMsg = "入库任务生成成功！" };
            var db = new SqlHelper<Location>().GetInstance();
            var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.S_LOC_CODE).First();
            if (loc == null || loc.S_LOCK_STATE.Trim() != "无")
            {
                return new Result { success = false, errMsg = $"{model.S_LOC_CODE}库位已被锁定!" };
            }
            if (string.IsNullOrEmpty(model.S_LOC_CODE))
            {
                return new Result { success = false, errMsg = "入库未传起点货位!" };
            }
            var end = Settings.LocAreas.Where(s => s.startBit.Split(',').ToList().Contains(model.S_LOC_CODE)).FirstOrDefault();
            if (end == null)
            {
                return new Result { success = false, errMsg = "起点未找到对应的终点库区!" };
            }
            Location InLoc = TaskProcess.InWorkTransport(end.endArea);
            if (InLoc == null)
            {
                return new Result { success = false, errMsg = $"终点库区{end.endArea}未找到空货位!" };
            }
            //if (model.S_TASK_TYPE == "成品入库")
            //{
            //    var locs = db.Queryable<Location>().Where(a => a.S_CODE == "KZB-A").First();
            //    if (locs == null || locs.S_LOCK_STATE.Trim() != "无")
            //    {
            //        return new Result { success = false, errMsg = $"KZB-A货位在锁定中!" };
            //    }

            //    var locTray = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == "KZB-A").OrderByDescending(s=>s.T_CREATE).First();
            //    if (locTray != null)
            //    {
            //        var resl = TaskProcess.CreateTransport("KZB-A", "CP", "基坑空托转运", locTray.S_CNTR_CODE.Split(',').ToList(), locs.N_CURRENT_NUM, 1,1,15);
            //        if (!resl)
            //        {
            //            return new Result { success = false, errMsg = "空托出库任务生成失败!" };

            //        }
            //    }

            //}

            string trayCode = ContainerHelper.GenerateCntrNo();

            var res = TaskProcess.CreateTransport(model.S_LOC_CODE, InLoc.S_CODE, model.S_TASK_TYPE, trayCode.Split(',').ToList(), 1, 1);
            if (!res)
            {
                return new Result { success = false, errMsg = "入库任务生成失败!" };

            }
            ContainerHelper.BindLocCntrs(model.S_LOC_CODE, trayCode, model.S_ITEM_CODE, model.S_ITEM_NAME, model.S_CK == "是" ? 1 : 0);


            return result;
        }

        /// <summary>
        /// 创建出库任务
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static Result CreateOutWork(moboxParam model)
        {
            var result = new Result() { success = true, errMsg = "出库任务生成成功！" };
            var db = new SqlHelper<Location>().GetInstance();
            var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.S_LOC_CODE).First();
            if (loc == null || loc.S_LOCK_STATE.Trim() != "无")
            {
                return new Result { success = false, errMsg = $"{model.S_LOC_CODE}库位已被锁定!" };
            }
            if (string.IsNullOrEmpty(model.S_LOC_CODE))
            {
                return new Result { success = false, errMsg = "出库未传终点货位!" };
            }
            var start = Settings.LocAreas.Where(s => s.endBit != null && s.endBit.Split(',').ToList().Contains(model.S_LOC_CODE)).FirstOrDefault();
            if (start == null)
            {
                return new Result { success = false, errMsg = "终点未找到对应的起点库区!" };
            }
            Location OutLoc = TaskProcess.OutWorkTransport(start.startArea, model.S_ITEM_CODE);
            if (OutLoc == null)
            {
                return new Result { success = false, errMsg = $"起点库区{start.startArea}未找到对应的满货位!" };
            }
            var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == OutLoc.S_CODE).First();

            var res = TaskProcess.CreateTransport(OutLoc.S_CODE, model.S_LOC_CODE, model.S_TASK_TYPE, locCntrRel.S_CNTR_CODE.Split(',').ToList(), 1, 1);
            if (!res)
            {
                return new Result { success = false, errMsg = "出库任务生成失败!" };

            }



            return result;
        }

        /// <summary>
        /// 创建空托转运任务
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static Result EmptyTrayTransport(moboxParam model)
        {
            var result = new Result() { success = true, errMsg = "空托转运任务生成成功！" };
            var db = new SqlHelper<Location>().GetInstance();
            var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.S_START_LOC).First();
            if (loc == null || loc.S_LOCK_STATE.Trim() != "无")
            {
                return new Result { success = false, errMsg = $"{model.S_START_LOC}库位已被锁定!" };
            }
            if (string.IsNullOrEmpty(model.S_START_LOC))
            {
                return new Result { success = false, errMsg = "空托转运未传起点货位!" };
            }

            Location InLoc = TaskProcess.InWorkTransport(model.S_END_AREA);
            if (InLoc == null)
            {
                return new Result { success = false, errMsg = $"终点库区{model.S_END_AREA}未找到空货位!" };
            }
            //string trayCode = ContainerHelper.GenerateCntrNo();
            var locCntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.S_START_LOC).ToList();
            if (!locCntr.Any())
            {
                return new Result { success = false, errMsg = $"{model.S_START_LOC}货位未找到托盘!" };
            }
            var res = TaskProcess.CreateTransport(model.S_START_LOC, InLoc.S_CODE, model.S_TASK_TYPE, locCntr.Select(s => s.S_CNTR_CODE).ToList(), loc.N_CURRENT_NUM, InLoc.N_CURRENT_NUM + 1);
            if (!res)
            {
                return new Result { success = false, errMsg = "空托转运任务生成失败!" };

            }
            //ContainerHelper.BindLocCntrs(model.S_LOC_CODE, trayCode, model.S_ITEM_CODE, model.S_ITEM_NAME);


            return result;

        }

        #endregion


        /// <summary>
        /// 入库货位
        /// </summary>
        /// <param name="area">库区</param>
        /// <returns></returns>
        public static Location InWorkTransport(string area)
        {
            Location result = null;
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                //查询这个库区的空托盘与满托盘
                var list = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == area).OrderByDescending(a => a.N_ROW).ToList();
                //LogHelper.Info($"查询这个库区的空托盘与满托盘：{JsonConvert.SerializeObject(list)}");
                if (list.Count > 0)
                {
                    List<string> loca = new List<string>();
                    for (int i = 0; i < list.Count; i++)
                    {
                        //如果锁了或者容量满了                   当前数量                 容器容量
                        if (list[i].N_LOCK_STATE != 0 || list[i].N_CURRENT_NUM >= list[i].N_CAPACITY)
                        {
                            loca.Add(list[i].S_CODE);
                        }
                    }
                    //移除
                    if (loca.Any())
                    {
                        list.RemoveAll(s => loca.Contains(s.S_CODE));
                    }
                    //符合条件的排序选第一个  先找第一个
                    if (list.Count > 0)
                    {
                        result = list.OrderBy(s => s.N_ROW).ThenBy(x => x.N_COL).FirstOrDefault();

                    }
                    
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("InWorkTransport:" + ex.Message + ex.StackTrace);
                LogHelper.Error("InWorkTransport:" + ex.Message, ex);
            }
            return result;
        }


        /// <summary>
        /// 出库算法
        /// </summary>
        /// <param name="area">库区</param>
        /// <returns></returns>
        public static Location OutWorkTransport(string area)
        {
            Location result = null;
            try
            {
                var db = new SqlHelper<Location>().GetInstance();

                var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).ToList();
                //list = list.OrderByDescending(s => s.N_ROW).OrderByDescending(s => s.N_COL).OrderByDescending(s => s.N_LAYER).ToList();
                list = list.OrderBy(s => s.T_CREATE).ToList();//先进先出

                for (int i = 0; i < list.Count; i++)
                {
                    //判断货位是否被锁住了 与 是否有托盘
                    if (list[i].N_LOCK_STATE == 0)
                    {
                        var locCntrRel = db.Queryable<LocCntrRel>().Where(s => s.S_LOC_CODE == list[i].S_CODE).First();

                        if (locCntrRel != null)
                        {
                            result = list[i];
                        }
                        if (result != null)
                        {
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("OutWorkTransport:" + ex.Message + ex.StackTrace);
                LogHelper.Error("OutWorkTransport:" + ex.Message, ex);
            }
            return result;
        }
        /// <summary>
        /// WMS出库转运
        /// </summary>
        /// <param name="area">库区</param>
        /// <param name="itemCode">物料编码</param>
        /// <returns></returns>
        public static Location OutWorkTransport(string area, string itemCode)
        {
            Location result = null;
            try
            {
                var db = new SqlHelper<Location>().GetInstance();

                var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.N_LOCK_STATE == 0 && a.S_AREA_CODE == area).OrderBy(a => a.N_ROW).ToList();
                list = list.OrderBy(s => s.N_ROW).ThenBy(s => s.N_COL).ToList();

                for (int i = 0; i < list.Count; i++)
                {
                    //判断货位是否被锁住了 与 是否有托盘
                    if (list[i].N_LOCK_STATE == 0)
                    {
                        var locCntrRel = db.Queryable<LocCntrRel>().Where(s => s.S_LOC_CODE == list[i].S_CODE).First();

                        //判断是否传了物料
                        if (!string.IsNullOrEmpty(itemCode))
                        {
                            #region 满托盘出库
                            if (locCntrRel != null)
                            {
                                var cntrItemRels = db.Queryable<CntrItemDetail>().Where(s => s.S_CNTR_CODE == locCntrRel.S_CNTR_CODE).First();
                                if (cntrItemRels != null)
                                {
                                    LogHelper.Info($"货位有托盘：{JsonConvert.SerializeObject(cntrItemRels)}");

                                    if (cntrItemRels.S_ITEM_CODE.Equals(itemCode))
                                    {
                                        result = list[i];
                                    }
                                }

                            }
                            #endregion
                        }
                        else
                        {
                            if (locCntrRel != null)
                            {
                                result = list[i];
                            }
                        }
                        if (result != null)
                        {
                            break;
                        }
                    }
                }
                //if (result == null)
                //{
                //    for (int i = 0; i < list.Count; i++)
                //    {
                //        //判断货位是否被锁住了与是否有托盘
                //        if (list[i].S_LOCK_STATE.Trim() == "无")
                //        {
                //            var locCntrRel = db.Queryable<LocCntrRel>().Where(s => s.S_LOC_CODE == list[i].S_CODE).First();

                //            //判断是否传了物料
                //            if (!string.IsNullOrEmpty(itemCode))
                //            {
                //                #region 满托盘出库
                //                if (locCntrRel != null)
                //                {
                //                    var cntrItemRels = db.Queryable<CntrItemDetail>().Where(s => s.S_CNTR_CODE == locCntrRel.S_CNTR_CODE).First();
                //                    if (cntrItemRels != null)
                //                    {
                //                        LogHelper.Info($"货位有托盘：{JsonConvert.SerializeObject(cntrItemRels)}");

                //                        if (cntrItemRels.S_ITEM_CODE.Equals(itemCode))
                //                        {
                //                            result = list[i];
                //                        }
                //                    }

                //                }
                //                #endregion
                //            }
                //            else
                //            {
                //                if (locCntrRel != null)
                //                {
                //                    result = list[i];
                //                }
                //            }
                //            if (result != null)
                //            {
                //                break;
                //            }
                //        }
                //    }
                //}
            }
            catch (Exception ex)
            {
                Console.WriteLine("OutWorkTransport:" + ex.Message + ex.StackTrace);
                LogHelper.Error("OutWorkTransport:" + ex.Message, ex);
            }
            return result;
        }


        /// <summary>
        /// 大件
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static TaskResponse bigMaterial(bigMaterial model)
        {
            var db = new SqlHelper<Location>().GetInstance();

            try
            {
                var startLoc = new Location();
                string endLocStr = null;
                string Message = null;
                switch (model.ts_name)
                {
                    case "p2p":
                        startLoc = db.Queryable<Location>().Where(a => a.S_CODE == model.parameters.src).First();
                        if (startLoc == null || startLoc.N_LOCK_STATE != 0 || startLoc.C_ENABLE != "Y")
                        {
                            Message = $"{model.parameters.src}库位已被锁定!";
                        }
                        endLocStr = model.parameters.dst;
                        
                        break;
                    case "p2a":
                        startLoc = db.Queryable<Location>().Where(a => a.S_CODE == model.parameters.src).First();
                        if (startLoc == null || startLoc.N_LOCK_STATE != 0 || startLoc.C_ENABLE != "Y")
                        {
                            Message = $"{model.parameters.src}库位已被锁定!";
                        }
                        var endLoc = InWorkTransport(model.parameters.dst_area);
                        if (endLoc==null)
                        {
                            //如果没找到就等第一条
                            endLocStr = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.parameters.dst).OrderByDescending(a => a.N_ROW).ToList()[0].S_CODE;

                        }
                        break;
                    case "a2p":
                        startLoc = OutWorkTransport(model.parameters.src_area);
                        if (startLoc==null)
                        {
                            Message = $"{model.parameters.dst}库区没有可出货位!";
                        }

                        endLocStr = model.parameters.dst;
                        break;
                    case "a2a":
                        startLoc = OutWorkTransport(model.parameters.src_area);
                        if (startLoc == null)
                        {
                            Message = $"{model.parameters.src}库区没有可出货位!";
                        }
                        var endLoc1 = InWorkTransport(model.parameters.dst_area);
                        if (endLoc1 == null)
                        {
                            //如果没找到就等第一条
                            endLocStr = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.parameters.dst).OrderByDescending(a => a.N_ROW).ToList()[0].S_CODE;

                        }
                        break;
                    case "p2u":
                        startLoc = OutWorkTransport(model.parameters.src);
                        if (startLoc == null)
                        {
                            Message = $"{model.parameters.src}库区没有可出货位!";
                        }
                        endLocStr = "";
                        break;
                }

                LogHelper.Info($"bigMaterial  接收参数{JsonConvert.SerializeObject(model) }");
                //创建托盘货位绑定关系
                string trayCode = ContainerHelper.GenerateCntrNo();
                //绑定起点货位(产线)和物料
                ContainerHelper.BindLocCntrsXm(startLoc.S_CODE, trayCode, model.parameters.sku, "", model.parameters.BatchNo, model.parameters.issueMode, model.parameters.num);

                var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startLoc.S_CODE).First();
                //创建任务
                LogHelper.Info($"创建任务 起点:{startLoc.S_CODE}终点:{endLocStr}", model.ts_name);
                var res = TaskProcess.CreateTransportDj(startLoc.S_CODE, endLocStr, model.ts_name, locCntrRel.S_CNTR_CODE, model.order_name, 1, 1);
                if (!res)
                {
                    return new TaskResponse
                    {
                        header = new ResponseHead { code = 1, desc = Message }
                    };

                }
                var result = new TaskResponse();
                if (Message != null)
                {
                    result = new TaskResponse
                    {
                        header = new ResponseHead { code = 0, desc = Message }
                    };
                }
                else
                {
                    result = new TaskResponse
                    {
                        header = new ResponseHead { code = 200, desc = "SUCCESS" },
                        body = new ResponseBody
                        {
                            msg = "success",
                            app_name = "Guozi client",
                            data = new List<ResponseData> { new ResponseData { in_order_id = model.taskID } },
                            version = ""
                        }
                    };
                }
                return result;

            }
            catch (Exception ex)
            {
                Console.WriteLine("bigMaterial:" + ex.Message + ex.StackTrace);
                LogHelper.Error("bigMaterial:" + ex.Message, ex);
                throw;
            }

        }

        
        //public static TaskResponse smallMaterial(smallMaterial model) {
        //    var db = new SqlHelper<Location>().GetInstance();

        //    string Message = null;

        //    //拆分成两条任务，一条是料架到指定的缓存区，二是料架上的托盘到指定的工位（小米wcs传）一对多
        //    var startFrame = db.Queryable<LocFrameRel>().Where(a => a.S_LOC_CODE == model.taskList[0].parameters[0].src).First();

        //    var startLoc = db.Queryable<Location>().Where(a => a.S_CODE == startFrame.S_FRAME_CODE).First();
        //    if (startLoc == null || startLoc.N_LOCK_STATE != 0)
        //    {
        //        return new TaskResponse
        //        {
        //            header = new ResponseHead { code = 0, desc = $"{model.taskList[0].parameters[0].src}库位已被锁定!" }
        //        };
        //    }
        //    var endLoc = TaskProcess.InWorkTransport(model.shippingRoute);
        //    if (endLoc != null)
        //    {
        //        //创建到缓存区任务
        //        var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startLoc.S_CODE).First();
        //        //创建任务
        //        LogHelper.Info($"创建任务 起点:{startLoc.S_CODE}终点:{endLoc.S_CODE}", model.ts_name);
        //        var res = TaskProcess.CreateTransportHj(startLoc.S_CODE, endLoc.S_CODE, model.ts_name, locCntrRel.S_FRAME_CODE, 1, 1);
        //        if (!res)
        //        {
        //            return new TaskResponse
        //            {
        //                header = new ResponseHead { code = 0, desc = "自动上线任务创建失败" }
        //            }; 
        //        }
        //    }
        //    //料架上的托盘到指定的工位
        //    foreach (var parameter in model.parameters)
        //    {
        //        var startLocHj = db.Queryable<Location>().Where(a => a.S_CODE == parameter.src).First();
        //        if (startLocHj == null || startLocHj.N_LOCK_STATE != 0)
        //        {
        //             Message = Message==null? $"{model.parameters[0].src}库位已被锁定!": Message+ $"{model.parameters[0].src}库位已被锁定!";
        //        }
        //        else
        //        {
        //            //货架上的货判断一下货架有没有锁
        //            var startFrameParent = db.Queryable<LocFrameRel>().Where(a => a.S_LOC_CODE == parameter.src).First();
        //            if (startFrameParent != null)
        //            {
        //                var startLocParent = db.Queryable<Location>().Where(a => a.S_CODE == startFrameParent.S_FRAME_CODE).First();
        //                if (startLocParent == null || startLocParent.N_LOCK_STATE != 0)
        //                {
        //                    return new TaskResponse
        //                    {
        //                        header = new ResponseHead { code = 0, desc = $"{startFrameParent.S_FRAME_CODE}货架已被锁定!" }
        //                    };
        //                }
        //            }
        //            var endLocHj = db.Queryable<Location>().Where(a => a.S_CODE == parameter.dst).First();
        //            if (endLocHj == null || endLocHj.N_LOCK_STATE != 0 || endLocHj.C_ENABLE != "Y")
        //            {
        //                //应该绕路

        //                Message = Message == null ? $"{parameter.dst}库位已被锁定!" : Message + $"{parameter.dst}库位已被锁定!";
        //            }
        //            else
        //            {
        //                //货架上的货判断一下货架有没有锁
        //                var endFrameParent = db.Queryable<LocFrameRel>().Where(a => a.S_LOC_CODE == parameter.dst).First();
        //                if (endFrameParent != null)
        //                {
        //                    var endLocParent = db.Queryable<Location>().Where(a => a.S_CODE == endFrameParent.S_FRAME_CODE).First();
        //                    if (endLocParent == null || endLocParent.N_LOCK_STATE != 0)
        //                    {
        //                        return new TaskResponse
        //                        {
        //                            header = new ResponseHead { code = 0, desc = $"{endFrameParent.S_FRAME_CODE}货架已被锁定!" }
        //                        };
        //                    }
        //                }
        //                //创建到缓存区任务
        //                var locCntrRel1 = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startLocHj.S_CODE).First();
        //                //创建任务
        //                LogHelper.Info($"创建任务 起点:{startLocHj.S_CODE}终点:{endLocHj.S_CODE}", model.ts_name);
        //                var res = TaskProcess.CreateTransport(startLocHj.S_CODE, endLocHj.S_CODE, model.ts_name, locCntrRel1.S_CNTR_CODE, 1, 1);
        //                if (!res)
        //                {
        //                    return new TaskResponse
        //                    {
        //                        header = new ResponseHead { code = 0, desc = "自动上线任务2创建失败" }
        //                    };
        //                }

        //            }
                    
        //        }
        //    }
        //    var result = new TaskResponse();
        //    if (Message != null)
        //    {
        //        result = new TaskResponse
        //        {
        //            header = new ResponseHead { code = 0, desc = Message }
        //        };
        //    }
        //    else
        //    {
        //        result = new TaskResponse
        //        {
        //            header = new ResponseHead { code = 200, desc = "SUCCESS" },
        //            body = new ResponseBody
        //            {
        //                msg = "success",
        //                app_name = "Guozi client",
        //                data = new List<ResponseData> { new ResponseData { in_order_id = model.taskID } },
        //                version = ""
        //            }
        //        };
        //    }
        //    return result;
        //}
        


    }
}