using HH.WCS.JiaTong.api;
using HH.WCS.JiaTong.core;
using HH.WCS.JiaTong.dispatch;
using HH.WCS.JiaTong.LISTA.process;
using HH.WCS.JiaTong.util;
using HH.WCS.JiaTong.wms;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Diagnostics.Eventing.Reader;
using System.IdentityModel.Protocols.WSTrust;
using System.Linq;
using System.Security.Cryptography;
using static HH.WCS.JiaTong.LISTA.process.HttpModel;

namespace HH.WCS.JiaTong.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}");
                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);
            }
            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>
        internal static void OperateReq(string no, int state, string url, string forkliftNo, string extData, int Z_type)
        {
            try
            {
                LogHelper.Info($"-------开始安全请求------");
                var TN_Task = WCSHelper.GetTask(no);
                if (TN_Task != null)
                {
                    int type = 0;
                    string loc = "";
                    if (state == 1101)
                    {

                        //请求取货，
                        type = 1;
                        loc = TN_Task.S_START_LOC;
                        if (Z_type == 4)
                        {
                            if (GZOperateReqByPost(url, TN_Task.S_EQ_NO, loc, type))
                            {
                                // NDCHelper.ChangeParam(TN_Task.S_CODE.Trim(), 1101, 18);
                                // NDCApi.ChangeOrderParam(TN_Task.S_CODE.Trim(), 6, "1");
                            }
                        }
                        else
                        {
                            if (OperateReqByPost(url, TN_Task.S_EQ_NO, TN_Task.S_CODE, loc, type, state))
                            {
                                // NDCHelper.ChangeParam(TN_Task.S_CODE.Trim(), 1101, 18);
                                NDCApi.ChangeOrderParam(TN_Task.S_CODE.Trim(), 6, "1");
                            }
                        }


                    }
                    if (state == 1102)
                    {
                        type = 3;
                        if (Z_type == 4)
                        {
                            loc = TN_Task.S_START_LOC;
                            if (GZOperateReqByPost(url, TN_Task.S_EQ_NO, loc, type))
                            {
                                //NDCHelper.ChangeParam(TN_Task.S_CODE.Trim(), 1101, 18);
                            }
                        }
                    }
                    if (state == 1103)
                    {
                        //请求卸货
                        type = 2;
                        loc = TN_Task.S_END_LOC;
                        if (Z_type == 4)
                        {
                            loc = TN_Task.S_END_LOC;
                            if (GZOperateReqByPost(url, TN_Task.S_EQ_NO, loc, type))
                            {
                                // NDCHelper.ChangeParam(TN_Task.S_CODE.Trim(), 1103, 18);
                                // NDCApi.ChangeOrderParam(TN_Task.S_CODE.Trim(), 6, "1");
                            }
                        }
                        else
                        {
                            if (OperateReqByPost(url, TN_Task.S_EQ_NO, TN_Task.S_CODE, loc, type, state))
                            {
                                NDCApi.ChangeOrderParam(TN_Task.S_CODE.Trim(), 6, "1");
                            }
                        }


                    }
                    if (state == 1104)
                    {
                        type = 4;
                        if (Z_type == 4)
                        {
                            loc = TN_Task.S_END_LOC;
                            if (GZOperateReqByPost(url, TN_Task.S_EQ_NO, loc, type))
                            {
                                //  NDCHelper.ChangeParam(TN_Task.S_CODE.Trim(), 1101, 18);
                            }
                        }
                    }
                }
                else
                {
                    LogHelper.Info($"安全请求==》根据任务号{no}未找到对应任务");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"OperateReq Error ==》{ex.ToString()}");
            }


        }

        /// <summary>
        /// 安全请求
        /// </summary>
        /// <param name="url"></param>
        /// <param name="tasknum"></param>
        /// <param name="ordernum"></param>
        /// <param name="station"></param>
        /// <param name="type"></param>
        /// <param name="taskStatus"></param>
        /// <returns></returns>
        internal static bool OperateReqByPost(string url, string tasknum, string ordernum, string station, int type, int taskStatus)
        {
            bool permit = false;
            try
            {
                //RequestList<TaskAccess> requestList = new RequestList<TaskAccess>();
                TaskAccess taskAccess = new TaskAccess() { taskNum = tasknum, orderNum = ordernum, station = station, type = type, taskStatus = taskStatus };
                // requestList.data.Add(taskAccess);
                HttpHelper httpHelper = new HttpHelper();
                Result result = new Result();
                string date = JsonConvert.SerializeObject(taskAccess);
                // string url = Settings.tableUrls.Find(a => a.id == 2).url;
                LogHelper.Info($"安全请求：地址:{url}，内容：{date}");
                var r = httpHelper.WebPost(url, date);
                result = JsonConvert.DeserializeObject<Result>(r);
                if (result.code == "0")
                {
                    permit = true;
                    LogHelper.Info($"安全请求成功");
                }
                else
                {
                    LogHelper.Info($"安全请求失败=>msg:{result.msg}");
                }
                return permit;
            }
            catch (Exception)
            {

                return permit;
            }


        }
        /// <summary>
        /// 安全请求国资
        /// </summary>
        /// <param name="url"></param>
        /// <param name="tasknum"></param>
        /// <param name="ordernum"></param>
        /// <param name="station"></param>
        /// <param name="type"></param>
        /// <param name="taskStatus"></param>
        /// <returns></returns>
        internal static bool GZOperateReqByPost(string url, string no, string station, int type)
        {
            bool permit = false;
            try
            {
                LogHelper.Info($"国资安全请求");
                //RequestList<TaskAccess> requestList = new RequestList<TaskAccess>();
                //返回数据
                Resultmobox<GzTaskAccess> resultmobox = new Resultmobox<GzTaskAccess>() { Name = "LocState", Source = "HostToAgv" };

                GzTaskAccess taskAccess = new GzTaskAccess() { task_no = no, loc_code = station, type = type.ToString() };
                resultmobox.data = taskAccess;
                // requestList.data.Add(taskAccess);
                HttpHelper httpHelper = new HttpHelper();
                GzResult result = new GzResult();
                string date = JsonConvert.SerializeObject(resultmobox);
                // string url = Settings.tableUrls.Find(a => a.id == 2).url;
                LogHelper.Info($"安全请求：地址:{url}，内容：{date}");
                var r = httpHelper.WebPostycl(url, date);
                result = JsonConvert.DeserializeObject<GzResult>(r);
                if (result.err_code == "0")
                {
                    permit = true;
                    LogHelper.Info($"安全请求成功");
                }
                else
                {
                    LogHelper.Info($"安全请求失败=>msg:{result.err_msg}");
                }
                return permit;
            }
            catch (Exception)
            {

                return permit;
            }


        }

        /// <summary>
        /// 任务拦截
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        internal static bool Intercept(WCSTask mst)
        {
            var result = true;
            var db = new SqlHelper<object>().GetInstance();
            var mstbyEqno = db.Queryable<WCSTask>().Where(a => a.S_EQ_NO == mst.S_EQ_NO).ToList();
            if (mstbyEqno.Count() == 1)
            {
                //预备库任务拦截
                if (mst.Z_TYPE == 3)
                {
                    var Ybkmst = db.Queryable<WCSTask>().Where(a => a.Z_TYPE == 3 && a.S_TYPE == "1" && a.S_B_STATE != "完成").First();
                    if (Ybkmst != null)
                    {
                        result = false;
                    }
                }

                return result;
            }
            else
            {
                //电梯分档任务拦截
                if (mst.S_TYPE == "电梯1")
                {
                    return result;
                }
                else if (mst.S_TYPE == "电梯2")
                {
                    var mst2 = mstbyEqno.Where(a => a.S_TYPE == "电梯1").First();
                    if (mst2.S_B_STATE == "卸货完成" || mst2.S_B_STATE == "完成")
                    {
                        return result;
                    }
                    else
                    {
                        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>
        /// <returns></returns>
        internal static void CancelTaskSection(WCSTask mst)
        {
            //取消任务判断是否存在分段任务，如果有分段任务第一段取消后续任务
            var db = new SqlHelper<object>().GetInstance();
            var mstbyEqno = db.Queryable<WCSTask>().Where(a => a.S_EQ_NO == mst.S_EQ_NO).ToList();
            if (mstbyEqno.Count() >= 2)
            {
                if (mst.S_TYPE == "电梯1")
                {
                    var mst2 = mstbyEqno.Where(a => a.S_TYPE == "电梯2").First();
                    if (mst2 != null)
                    {
                        OperateStatus(mst2, 7);
                        WCSHelper.Fail(mst2);
                    }
                }
            }

        }
        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)
            {
                LogHelper.Info($"任务推送数据：{JsonConvert.SerializeObject(mst)}");
                start = LocationHelper.GetAgvSite(mst.S_START_LOC);
                end = LocationHelper.GetAgvSite(mst.S_END_LOC);
                //if (mst.N_START_LAYER > 1)
                //{
                //    start = LocationHelper.GetAgvSite(mst.S_START_LOC, mst.N_START_LAYER.ToString()).ToString();
                //}
                if (mst.N_END_LAYER > 1)
                {
                    end = LocationHelper.GetAgvSite(mst.S_END_LOC, mst.N_END_LAYER.ToString()).ToString();
                    LogHelper.Info($"任务推送：终点层数为{mst.N_END_LAYER}，推送站点为:{end}");
                }
                Console.WriteLine($"SendTask {mst.S_CODE}");
                Console.WriteLine("start=" + start);
                Console.WriteLine("end= " + end);
                var dic = new List<param>();
                dic.Add(new param() { name = "From", value = start.ToString() });
                dic.Add(new param() { name = "To", value = end.ToString() });
                dic.Add(new param() { name = "FUNC", value = "0" });
                dic.Add(new param() { name = "DATA", value = "0" });
                dic.Add(new param() { name = "Ctype", value = "0" });


                var res = NDCApi.AddOrderNew(1, 1, mst.S_CODE, dic);//添加新命令
                                                                    //dic.Add("Pri", mst.N_PRIORITY.ToString());
                                                                    //dic.Add("From", start.ToString());
                                                                    //dic.Add("To", end.ToString());
                                                                    //dic.Add("task_no", mst.S_CODE.Trim());// dic.Add("Ext1", "1"); dic.Add("Ext2", "CALLADDAGV"); dic.Add("N_CNTR_COUNT", "");
                                                                    //var res = NDC.AddNewOrder(1, dic);



                if (res != null && (res.err_code == 0 || res.err_code == 50009))
                {
                    //推送成功，修改任务优先级
                    mst.N_B_STATE = 1;
                    mst.S_B_STATE = WCSTask.GetStateStr(1);
                    WCSHelper.UpdateStatus(mst);//更新任务状态
                    result = true;
                    LogHelper.Info($"NDC推送任务成功 {mst.S_CODE}start= {mst.S_START_LOC} + end = {mst.S_END_LOC}");
                }
                else
                {
                    LogHelper.Info($"NDC推送任务失败 {mst.S_CODE};Res:" + JsonConvert.SerializeObject(res));
                }
            }
            //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="taskNum">任务号</param>
        /// <param name="orderNum">单号</param>
        /// <param name="taskStatus">任务状态</param>
        /// <param name="url">上报接口</param>
        public static void Reportback(string taskNum, string orderNum, int taskStatus, string url)
        {
            LogHelper.Info($"------------开始任务回报-----------");
            try
            {
                //返回数据
                // Result<Reportback> resultreportback = new Result<Reportback>();
                Reportback reportback = new Reportback() { taskNum = taskNum, orderNum = orderNum, taskStatus = taskStatus };
                //  resultreportback.data.Add(reportback);
                //调用接口
                HttpHelper httpHelper = new HttpHelper();
                Result result = new Result();
                string date = JsonConvert.SerializeObject(reportback);

                LogHelper.Info($"任务回报：地址:{url}，内容：{date}");

                string r = "";

                r = httpHelper.WebPost(url, date);


                result = JsonConvert.DeserializeObject<Result>(r);
                if (result.code == "0")
                {
                    LogHelper.Info($"任务回报成功");
                }
                else
                {
                    LogHelper.Info($"任务回报失败=>msg:{result.msg}");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"任务回报错误：error：{ex.ToString()}");
            }

        }


        /// <summary>
        /// 任务状态回报
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="orderNum">单号</param>
        /// <param name="taskStatus">任务状态</param>
        /// <param name="url">上报接口</param>
        public static void WmsReportback(string taskNum, string orderNum, int taskStatus, string url)
        {
            LogHelper.Info($"------------开始wms任务回报-----------");
            try
            {
                int state = 2;
                //返回数据
                if (taskStatus == 7)
                {
                    state = 1;
                }

                GTWMSData data = new GTWMSData() { task_no = orderNum, status = state };
                GTWMS reportback = new GTWMS() { data = data };
                //  resultreportback.data.Add(reportback);
                //调用接口
                HttpHelper httpHelper = new HttpHelper();
                WmsResult result = new WmsResult();
                string date = JsonConvert.SerializeObject(reportback);

                LogHelper.Info($"任务回报：地址:{url}，内容：{date}");

                string r = "";

                r = httpHelper.WebPost(url, date);


                result = JsonConvert.DeserializeObject<WmsResult>(r);
                if (result.success)
                {
                    LogHelper.Info($"任务回报成功");
                }
                else
                {
                    LogHelper.Info($"任务回报失败=");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"任务回报错误：error：{ex.ToString()}");
            }

        }
        /// <summary>
        /// 原材料任务状态回报
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="orderNum">单号</param>
        /// <param name="taskStatus">任务状态</param>
        /// <param name="url">上报接口</param>
        public static void Reportbackmobox(string taskNum, string orderNum, int taskStatus, string url)
        {
            LogHelper.Info($"------------开始任务回报(原材料任务回报)-----------");
            try
            {
                //返回数据
                Resultmobox<Reportback> resultmobox = new Resultmobox<Reportback>() { Name = "AGVTaskStatus", Source = "HostToAgv" };
                Reportback reportback = new Reportback() { taskNum = taskNum, orderNum = orderNum, taskStatus = taskStatus };
                resultmobox.data = reportback;
                //调用接口
                HttpHelper httpHelper = new HttpHelper();
                Resultmobox result = new Resultmobox();
                string date = JsonConvert.SerializeObject(resultmobox);

                LogHelper.Info($"任务回报：地址:{url}，内容：{date}");

                string r = "";

                r = httpHelper.WebPostycl(url, date);


                result = JsonConvert.DeserializeObject<Resultmobox>(r);
                if (result != null && result.err_code == "0")
                {
                    LogHelper.Info($"任务回报成功");
                }
                else
                {
                    LogHelper.Info($"任务回报失败=>msg:{result.err_msg}");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"任务回报错误：error：{ex.ToString()}");
            }

        }
        /// <summary>
        /// MES任务状态回报
        /// </summary>
        /// <param name="taskNum"></param>
        /// <param name="orderNum"></param>
        /// <param name="taskStatus"></param>
        public static void MESReportback(WCSTask mst, int status, string url)
        {
            LogHelper.Info($"------------开始MES任务回报-----------");
            try
            {
                //回报数据获取
                Request<StatusArrive> statusarrive = new Request<StatusArrive>();
                //获取时间戳
                var time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                statusarrive.RequestId = "杭叉AGV" + time;

                //List<StatusArrive> statusArrives = new List<StatusArrive>();
                StatusArrive statusArrive = new StatusArrive();
                statusarrive.UseToken = "iFQ5fExGrLYLXliHYWzs";
                statusArrive.TaskNumber = mst.S_EQ_NO;
                statusArrive.LocationNum = mst.S_END_LOC;
                statusArrive.Time = DateTime.Now.ToString();
                statusArrive.Status = status.ToString();
                //statusArrives.Add(statusArrive);
                statusarrive.data = statusArrive;
                //开始回报
                HttpHelper httpHelper = new HttpHelper();
                MesResult result = new MesResult();
                string date = JsonConvert.SerializeObject(statusarrive);

                LogHelper.Info($"任务回报：地址:{url}，内容：{date}");
                var r = httpHelper.MesWebPost(url, date);
                LogHelper.Info($"任务回报：返回内容：{r}");
                result = JsonConvert.DeserializeObject<MesResult>(r);
                if (result != null && result.icode == "200")
                {
                    LogHelper.Info($"任务回报成功");
                }
                else
                {
                    LogHelper.Info($"任务回报失败=>msg:{result.imsg}");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"任务回报错误：error：{ex.Message}，行号:{ex.StackTrace}");
            }

        }

        /// <summary>
        /// mes物料到位同步
        /// </summary>
        /// <param name="taskNum"></param>
        /// <param name="orderNum"></param>
        /// <param name="taskStatus"></param>
        public static void MESIteminfoback(WCSTask mst, string url)
        {
            LogHelper.Info($"------------开始物料信息回报-----------");
            try
            {
                var cntritem = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE).FirstOrDefault();
                //回报数据
                Request<iteminfoArrive> statusarrive = new Request<iteminfoArrive>();
                List<LotListh> lotLists = new List<LotListh>();
                string TaskNumber = mst.S_EQ_NO;
                if (!string.IsNullOrEmpty(mst.S_WMS_NO))
                {
                    TaskNumber = mst.S_WMS_NO;
                }
                //获取时间戳
                var time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                //物料到位接口和状态反馈同时调IIOT，为了区分id，物料到位长度加一区分
                statusarrive.RequestId = "杭叉AGV" + time + "1";
                statusarrive.UseToken = "iFQ5fExGrLYLXliHYWzs";

                iteminfoArrive iteminfoArrive = new iteminfoArrive();
                iteminfoArrive.TaskNumber = TaskNumber;
                iteminfoArrive.LocationNum = mst.S_END_LOC;
                iteminfoArrive.Rfid = mst.S_CNTR_CODE;
                iteminfoArrive.ArricalTime = DateTime.Now.ToString("yyyy-MM-dd");
                if (cntritem != null)
                {
                    lotLists.Add(new LotListh() { LotNumber = cntritem.S_BATCH_NO, Weight = double.Parse(cntritem.F_WEIGHT) });
                    iteminfoArrive.PartDesc = cntritem.S_ITEM_NAME;
                    iteminfoArrive.PartNumber = cntritem.S_ITEM_CODE;

                }
                iteminfoArrive.LotList = lotLists;
                statusarrive.data = iteminfoArrive;
                //任务上报
                HttpHelper httpHelper = new HttpHelper();
                MesResult result = new MesResult();
                string date = JsonConvert.SerializeObject(statusarrive);

                LogHelper.Info($"物料到位回报：地址:{url}，内容：{date}");
                var r = httpHelper.MesWebPost(url, date);
                LogHelper.Info($"物料到位回报：返回内容：{r}");
                result = JsonConvert.DeserializeObject<MesResult>(r);
                if (result != null && result.icode == "200")
                {
                    LogHelper.Info($"物料到位回报成功");
                }
                else
                {
                    LogHelper.Info($"物料到位回报失败=>msg:{result.imsg}");
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info($"物料到位回报错误：error：{ex.ToString()}");
            }

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



    }
}