using HH.WCS.Mobox3.pinggao.api;
using HH.WCS.Mobox3.pinggao.models;
using HH.WCS.Mobox3.pinggao.core;
using HH.WCS.Mobox3.pinggao.dispatch;
using HH.WCS.Mobox3.pinggao.util;
using HH.WCS.Mobox3.pinggao.wms;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Threading.Tasks;
using static HH.WCS.Mobox3.pinggao.models.SapRoot.WcReturnRoot;
using static HH.WCS.Mobox3.pinggao.api.OtherModel;
using NLog.Fluent;
using System.Xml.Linq;

namespace HH.WCS.Mobox3.pinggao.process
{
    internal class TaskProcess
    {
        #region 任务相关
        //--------------------------------------------------任务相关--------------------------------------------------
        /// <summary>
        /// 取货卸货完成，缓存位状态更新
        /// </summary>
        /// <param name="mst"></param>
        /// <param name="load"></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}");
                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}");
                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);
                if (mst.N_TYPE == 1)
                {
                    WmsSpaHelper.AddMaterOrder(mst.S_BS_NO, mst.S_CNTR_CODE);
                }
            }
            else
            {
                //起点终点解锁
                LocationHelper.UnLockLoc(mst.S_START_LOC);
                LocationHelper.UnLockLoc(mst.S_END_LOC);

            }

        }

        /// <summary>
        /// 安全请求
        /// </summary>
        /// <param name="no">任务号</param>
        /// <param name="state">信号值</param>
        /// <param name="forkliftNo">车号</param>
        /// <param name="extData">重量</param>
        /// <param name="Ext1">高度</param>
        internal static void OperateReq(WCSTask TN_Task, int state, string forkliftNo, string extData)
        {
            if (state == 1002)//信号
            {

            }
            else if (state == 2000)//信号
            {
                var db = new SqlHelper<object>().GetInstance();
                TN_Task.S_EQ_TASK_CODE = extData;//高度
                db.Updateable<WCSTask>(TN_Task).UpdateColumns(a => new { a.S_EQ_TASK_CODE }).ExecuteCommand();
                db.CommitTran();
                if (!string.IsNullOrEmpty(TN_Task.S_STATE_PRE) && !string.IsNullOrEmpty(TN_Task.S_EQ_TASK_CODE))
                {
                    if (TN_Task.S_START_LOC == TN_Task.S_END_LOC)
                    {
                        weight(TN_Task);
                    }
                }



            }
            else if (state == 2001)//信号
            {
                var db = new SqlHelper<object>().GetInstance();
                TN_Task.S_STATE_PRE = extData;//高度
                db.Updateable<WCSTask>(TN_Task).UpdateColumns(a => new { a.S_STATE_PRE }).ExecuteCommand();
                db.CommitTran();
                if (!string.IsNullOrEmpty(TN_Task.S_STATE_PRE) && !string.IsNullOrEmpty(TN_Task.S_EQ_TASK_CODE))
                {
                    if (TN_Task.S_START_LOC == TN_Task.S_END_LOC)
                    {
                        weight(TN_Task);
                    }
                }

            }

            if (state == 1103)
            {
                //大铁框叉走以后通知，我们要通知输送线
            }
        }



        internal static void weight(WCSTask TN_Task)
        {


            if (!string.IsNullOrEmpty(TN_Task.S_STATE_PRE) && !string.IsNullOrEmpty(TN_Task.S_EQ_TASK_CODE))
            {
                string extData = TN_Task.S_STATE_PRE;
                string Ext1 = TN_Task.S_EQ_TASK_CODE;
                LogHelper.Info($"称重分配入库终点货位高度重量{extData}，高度{Ext1},容器{TN_Task.S_CNTR_CODE}");
                var db = new SqlHelper<object>().GetInstance();
                var WMStask = db.Queryable<WMSTask>().Where(s => s.S_CODE == TN_Task.S_OP_CODE).First();
                if (WMStask == null)
                {
                    LogHelper.Info($"未找到此任务对应的作业");
                }
                try
                {
                    Location result = null;
                    //var TN_Task = WCSHelper.GetTask(no);
                    //判断当前容器为托盘还是料框
                    //托盘只能放在1-2层 料箱3-9层

                    //获取集合
                    var locklist = db.Queryable<Location>();


                    if (TN_Task.S_CNTR_CODE.Substring(0, 2) == "TP")//托盘
                    {
                        var endlist = locklist
                                   .Where(it => it.N_CURRENT_NUM < it.N_CAPACITY && it.N_LAYER < 3 && it.N_LOCK_STATE == 0 && it.S_AREA_CODE == "HJQ")
                                   .OrderBy(it => it.N_COL)
                                   .PartitionBy(it => it.N_ROW)
                                   .PartitionBy(it => it.N_LAYER)
                                   .Take(1)
                                   .ToList();
                        if (TN_Task.N_ERR == 2)//前移车
                        {

                            endlist = endlist.Where(s => s.N_LAYER < 7).ToList();
                        }
                        foreach (var item in endlist)
                        {
                            LogHelper.Info($"重量{decimal.Parse(extData)}");
                            //大于800kg
                            if (decimal.Parse(extData) > 1)
                            {
                                LogHelper.Info($"高度{Ext1}");
                                //高度大于1050mm 只放在第一层
                                if (decimal.Parse(Ext1) <= 3)
                                {
                                    var lockinfo = locklist.Where(it => it.N_LOCK_STATE != 0 && it.N_LOCK_STATE != 0 && it.N_ROW == item.N_ROW
                                                    && it.N_LAYER == 1).First();
                                    if (lockinfo == null)
                                    {
                                        result = item;
                                        break;
                                    }
                                    else
                                    {
                                        LogHelper.Info($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                        //throw new Exception($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                    }
                                }
                                else
                                {
                                    LogHelper.Info($"高度{decimal.Parse(Ext1)}过高 联系人工处理");
                                    throw new Exception($"高度{decimal.Parse(Ext1)}过高 联系人工处理");

                                }

                            }
                            else//不超重 即 不超过800kg
                            {
                                //高度<450mm 2-9层
                                if (decimal.Parse(Ext1) < 2)
                                {
                                    LogHelper.Info($"高度<450mm 2-9层");
                                    var lockinfo = locklist.Where(it => it.N_LOCK_STATE != 0 && it.N_ROW == item.N_ROW
                                                        && it.N_LAYER == 2).First();
                                    if (lockinfo == null)
                                    {
                                        result = item;

                                        break;
                                    }
                                    else
                                    {
                                        LogHelper.Info($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                        //throw new Exception($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                    }
                                }
                                else if (decimal.Parse(Ext1) >= 2 && decimal.Parse(Ext1) < 4)
                                {
                                    var lockinfo = locklist.Where(it => it.N_LOCK_STATE != 0 && it.N_ROW == item.N_ROW
                                                   && it.N_LAYER >= 1 && it.N_LAYER <= 2).First();
                                    if (lockinfo == null)
                                    {
                                        result = item;


                                        db.Updateable<WMSTask>(TN_Task).UpdateColumns(a => new { a.S_END_LOC, a.S_END_AREA, a.S_END_WH }).ExecuteCommand();

                                        break;
                                    }
                                    else
                                    {
                                        LogHelper.Info($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                        //throw new Exception($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                    }
                                }
                                else
                                {
                                    LogHelper.Info($"托盘高度{decimal.Parse(Ext1)}过高 联系人工处理");
                                    throw new Exception($"托盘高度{decimal.Parse(Ext1)}过高 联系人工处理");

                                }
                            }
                        }
                    }
                    else
                    { //容器为料箱 则放到3-9层

                        var endlist = locklist
                                   .Where(it => it.N_CURRENT_NUM < it.N_CAPACITY && it.N_LAYER >= 3 && it.N_LOCK_STATE == 0 && it.S_AREA_CODE == "HJQ")
                                   .OrderBy(it => it.N_COL)
                                   .PartitionBy(it => it.N_ROW)
                                   .PartitionBy(it => it.N_LAYER)
                                   .Take(1)
                                   .ToList();
                        if (TN_Task.N_ERR == 2)//前移车
                        {
                            endlist = endlist.Where(s => s.N_LAYER < 7).ToList();
                        }
                        foreach (var item in endlist)
                        {
                            LogHelper.Info($"重量{decimal.Parse(extData)}");
                            //大于800kg
                            if (decimal.Parse(extData) > 1)
                            {
                                LogHelper.Info($"料箱重量超过800kg");
                                throw new Exception($"料箱重量超过800kg");
                            }
                            else
                            {
                                if (decimal.Parse(Ext1) < 4)
                                {
                                    var lockinfo = locklist.Where(it => it.N_LOCK_STATE != 0 && it.N_LOCK_STATE != 0 && it.S_AREA_CODE == item.S_AREA_CODE && it.N_ROW == item.N_ROW
                                                   && it.N_LAYER >= 3 && it.N_LAYER <= 9).First();
                                    if (lockinfo == null)
                                    {
                                        result = item;
                                        TN_Task.S_END_LOC = item.S_CODE;
                                        db.Updateable<WMSTask>(TN_Task).UpdateColumns(a => new { a.S_END_LOC }).ExecuteCommand();

                                        break;
                                    }
                                    else
                                    {
                                        LogHelper.Info($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                        throw new Exception($"货位{lockinfo.S_CODE} 有锁 当排层不可使用");
                                    }
                                }
                                else
                                {
                                    LogHelper.Info($"料箱高度 {decimal.Parse(Ext1)} 过高 联系人工处理");
                                    throw new Exception($"料箱高度 {decimal.Parse(Ext1)} 过高 联系人工处理");
                                }
                            }
                        }
                    }


                    if (result == null)
                    {
                        LogHelper.Info($"小车回调未找到可用库位");
                        throw new Exception($"小车回调未找到可用库位");
                    }

                    //var lcrList = db.Queryable<LocCntrRel>().Includes(a => a.Container).Where(a => a.S_LOC_CODE == TN_Task.S_CNTR_CODE).ToList();
                    //if (lcrList.Count == 0) {
                    TN_Task.S_END_LOC = result.S_CODE;
                    TN_Task.S_END_AREA = result.S_AREA_CODE;
                    TN_Task.S_END_WH = result.S_WH_CODE;
                    db.Updateable<WCSTask>(TN_Task).UpdateColumns(a => new { a.S_END_LOC, a.S_END_AREA, a.S_END_WH }).ExecuteCommand();
                    WMStask.S_END_LOC = result.S_CODE;
                    WMStask.S_END_AREA = result.S_AREA_CODE;
                    WMStask.S_END_WH = result.S_WH_CODE;

                    db.Updateable<WMSTask>(WMStask).UpdateColumns(a => new { a.S_END_LOC, a.S_END_AREA, a.S_END_WH }).ExecuteCommand();
                    //}

                    var S_AGV_SITE = "";
                    if (TN_Task.N_ERR == 1)//前移车
                    {
                        //前移车
                        S_AGV_SITE = LocationHelper.GetAgvSite(TN_Task.S_END_LOC);
                    }
                    else //堆垛车
                    {

                        //堆垛车
                        S_AGV_SITE = db.Queryable<TN_Location_Ext>().Where(a => a.S_LOC_CODE == TN_Task.S_END_LOC).First()?.S_AGV_SITE;
                    }
                    var dic = new Dictionary<string, string>();
                    dic.Add("No", TN_Task.S_CODE);
                    dic.Add("ParamNo", "2");
                    dic.Add("Param1", S_AGV_SITE);
                    //dic.Add("Pri", TN_Task.N_PRIORITY.ToString());
                    //dic.Add("No", TN_Task.S_CODE.Trim());
                    //dic.Add("From", TN_Task.S_START_LOC);
                    //dic.Add("To", TN_Task.S_END_LOC);
                    //dic.Add("Func", "0");
                    //dic.Add("Data", "512");
                    //dic.Add("FRow", "0");

                    var res = NDC.ChangeOrder(dic);
                    LogHelper.Info($"修改终点货位" + JsonConvert.SerializeObject(res));
                    if (res.Res.ErrCode != -1)
                    {
                        var dics = new Dictionary<string, string>();
                        dics.Add("No", TN_Task.S_CODE);
                        dics.Add("ParamNo", "6");
                        dics.Add("Param1", "2");
                        var ss = NDC.ChangeOrder(dics);
                        LogHelper.Info($"小车前往新库位" + JsonConvert.SerializeObject(ss));


                        //if (lcrList.Count()==0)
                        //{
                        LocationHelper.BindingLoc(TN_Task.S_END_LOC, TN_Task.S_CNTR_CODE.Split(',').ToList());
                        LocationHelper.LockLoc(TN_Task.S_END_LOC, 1);
                        //}
                    }

                    db.CommitTran();
                }
                catch (Exception)
                {
                    db.RollbackTran();
                    throw;
                }
            }

        }


        internal static void UpdateAgvNo(WCSTask mst, string forkliftNo)
        {
            var db = new SqlHelper<object>().GetInstance();
            mst.S_EQ_NO = forkliftNo;
            db.Updateable(mst).UpdateColumns(it => new { it.S_EQ_NO }).ExecuteCommand();
        }

        internal static void ThirdReportStatus(WCSTask mst, int state, string forkliftNo)
        {

        }




        /// <summary>
        /// 任务拦截
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        internal static bool Intercept(WCSTask mst)
        {
            var result = false;
            //出库任务是批量生成的，初始终点我们先给一个虚拟点，不推送。有单独的现场去判断出库缓存区光电，空了再给出库任务分配终点
            if (mst.S_END_LOC.Trim() == "出库虚拟点")
            {
                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;


        }
        public static DateTime? ParseCustomFormatDate(string dateStr)
        {
            // 假设日期格式是 yy:mm
            if (DateTime.TryParseExact(dateStr, "HH:mm", null, System.Globalization.DateTimeStyles.None, out DateTime result))
            {
                return result;
            }
            return null;
        }
        public static bool SendCd()
        {
            var db = new SqlHelper<object>().GetInstance();
            var dstart = db.Queryable<TN_CD>().Where(s => s.N_STATE == 0).First();

            var result = false;
            if (dstart != null)
            {
                DateTime currentDate = DateTime.Now;
                // 格式化输出时分部分
                string currentHourMinute = currentDate.ToString("HH:mm");
             
                if (dstart.S_TIME == currentHourMinute)
                {
                    var dic = new Dictionary<string, string>();
                    var dic1 = new Dictionary<string, string>();
                    var no = WMSHelper.GenerateTaskNo();
                    dic.Add("No", no);
                    dic.Add("Pri", "0");
                    dic1.Add("ExtDeviceNo", "1");

                    //判断
                    var res = NDC.OrderAdd(99, dic, dic1);
                    if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                    {
                        //    dstart.N_STATE = 1;
                        //    db.Updateable<TN_CD>(dstart).UpdateColumns(a => new { a.N_STATE }).ExecuteCommand();

                        // result = true;
                    }


                    var dic12 = new Dictionary<string, string>();
                    var dic11 = new Dictionary<string, string>();
                    var no1 = WMSHelper.GenerateTaskNo();
                    dic12.Add("No", no1);
                    dic12.Add("Pri", "0");
                    dic11.Add("ExtDeviceNo", "2");

                    //判断
                    var res1 = NDC.OrderAdd(99, dic12, dic11);
                    if (res1 != null && (res1.Res.ErrCode == 0 || res1.Res.ErrCode == 50009))
                    {
                        dstart.N_STATE = 1;
                        db.Updateable<TN_CD>(dstart).UpdateColumns(a => new { a.N_STATE }).ExecuteCommand();

                        result = true;
                    }
                }

            }

            return result;
        }

        public static bool SendCZ()
        {
            var db = new SqlHelper<object>().GetInstance();
            var dstart = db.Queryable<TN_CD>().Where(s => s.N_STATE == 1).First();

            var result = false;
            if (dstart != null)
            {
                DateTime currentDate = DateTime.Now;
                // 格式化输出时分部分
                string currentHourMinute = currentDate.ToString("HH:mm");
                if (currentHourMinute == "00:00")
                {

                    dstart.N_STATE = 0;
                    db.Updateable<TN_CD>(dstart).UpdateColumns(a => new { a.N_STATE }).ExecuteCommand();
                }
                result = true;

            }

            return result;
        }
        /// <summary>
        /// 推送任务
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendTask(WCSTask mst)
        {
            var result = false;
            var start = ""; var end = "";
            var taskType = mst.S_TYPE.Trim();
            try
            {
                LogHelper.Info($"推送任务{mst.S_CODE}");
                Console.WriteLine("推送任务", mst.S_CODE);
                //前移车
                var startlocs = LocationHelper.GetAgvSite(mst.S_START_LOC);
                var endlocs = LocationHelper.GetAgvSite(mst.S_END_LOC);
                //堆垛车
                var db = new SqlHelper<object>().GetInstance();
                var dstart = db.Queryable<TN_Location_Ext>().Where(a => a.S_LOC_CODE == mst.S_START_LOC).First()?.S_AGV_SITE;
                var dend = db.Queryable<TN_Location_Ext>().Where(a => a.S_LOC_CODE == mst.S_END_LOC).First()?.S_AGV_SITE;
                LogHelper.Info($"获取库位{mst.S_START_LOC}{mst.S_END_LOC}||{mst.N_B_STATE}");
                LogHelper.Info($"站点数据信息{dstart}/{dend}||{startlocs}/{endlocs}");
                if (mst.N_B_STATE == 0)
                {
                    //堆垛车去站点表找
                    if (mst.S_SCHEDULE_TYPE == "NDC")
                    {

                        var startloc = LocationHelper.GetLoc(mst.S_START_LOC);
                        var endloc = LocationHelper.GetLoc(mst.S_END_LOC);
                        LogHelper.Info($"获取站点{startloc.N_LAYER}");
                        if (mst.S_TYPE.Contains("入库"))
                        {
                            var task = WCSHelper.GetWaitingTaskGoList();//查询是否有前移车正在执行的任务
                            if (task.Count() == 0)
                            {
                                mst.N_ERR = 1;
                                start = startlocs;
                                end = endlocs;
                            }
                            else
                            {
                                var task12 = WCSHelper.GetWaitingTaskGoBackList();//查询是否有堆垛车正在执行的任务、
                                LogHelper.Info($"count{task12.Count()}");
                                if (task12.Count() == 0)
                                {      //堆垛车 去 站点表去查
                                    mst.N_ERR = 2;
                                    start = dstart;
                                    end = dend;
                                }
                                else
                                {
                                    var task1 = WCSHelper.GetWaitingTaskGoList();///查询是否有前移车正在执行的任务
                                    LogHelper.Info($"查询是否有前移车正在执行的任务count{task1.Count()}");
                                    if (task1.Count() == 0)
                                    {
                                        mst.N_ERR = 1;
                                        start = startlocs;
                                        end = endlocs;
                                    }
                                }
                            }

                        }
                        else
                        {
                            if (startloc.N_LAYER > 7 || endloc.N_LAYER > 7)//大于七层 找有无 前移车的任务 有 不推 无推送
                            {
                                var task = WCSHelper.GetWaitingTaskGoList();//查询是否有前移车正在执行的任务
                                if (task.Count() == 0)
                                {
                                    mst.N_ERR = 1;
                                    start = startlocs;
                                    end = endlocs;
                                }
                            }
                            else //小于
                            {
                                LogHelper.Info($"小于7");
                                var task = WCSHelper.GetWaitingTaskGoBackList();//查询是否有堆垛车正在执行的任务、
                                LogHelper.Info($"count{task.Count()}");
                                if (task.Count() == 0)
                                {      //堆垛车 去 站点表去查
                                    mst.N_ERR = 2;
                                    start = dstart;
                                    end = dend;
                                }
                                else
                                {
                                    var task1 = WCSHelper.GetWaitingTaskGoList();///查询是否有前移车正在执行的任务
                                    LogHelper.Info($"查询是否有前移车正在执行的任务count{task1.Count()}");
                                    if (task1.Count() == 0)
                                    {
                                        mst.N_ERR = 1;
                                        start = startlocs;
                                        end = endlocs;
                                    }
                                }
                            }

                        }
                        LogHelper.Info($"站点{start}/{end}");
                        if (!string.IsNullOrEmpty(start) && !string.IsNullOrEmpty(end))
                        {
                            var dic = new Dictionary<string, string>();
                            var dic1 = new Dictionary<string, string>();
                            dic.Add("Pri", mst.N_PRIORITY.ToString());
                            dic.Add("No", mst.S_CODE.Trim());
                            dic1.Add("From", start);
                            dic1.Add("To", end);
                            dic1.Add("Func", "0");
                            if (mst.S_TYPE.Contains("入库"))
                            {
                                dic1.Add("Data", "512");
                            }
                            else
                            {
                                dic1.Add("Data", "0");
                            }
                            dic1.Add("FRow", "0");
                            LogHelper.Info($"推送{start}{end}");
                            //判断
                            var res = NDC.OrderAdd(1, dic, dic1);
                            if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                            {
                                //推送成功，修改任务优先级
                                mst.N_B_STATE = 1;
                                WCSHelper.UpdateStatus(mst, "已推送");
                                result = true;
                            }

                        }
                        else
                        {
                            LogHelper.Info($"起始站点信息缺失");
                        }


                    }

                }
                else
                {
                    LogHelper.Info($"任务不是等待状态{mst.N_B_STATE}");
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info("推送小车错误信息", ex.Message);
                throw;
            }
            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, 1);
                LocationHelper.LockLoc(end, 2);
            }
            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;
        }
        #endregion



    }
}