using HH.WCS.DaYang.core;
using HH.WCS.DaYang.dispatch;
using HH.WCS.DaYang.util;
using HH.WCS.DaYang.wms;
using Newtonsoft.Json;
using NLog.Fluent;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using static HH.WCS.DaYang.api.ApiModel;
using static HH.WCS.DaYang.util.Settings;
using static System.Net.WebRequestMethods;

namespace HH.WCS.DaYang.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 forkliftNo, string extData)
        {
            if (state == 1101)
            {
                //请求取货，
            }
            if (state == 1102)
            {
                //请求卸货，
                //根据终点判断，是cb02的入口，判断内存中状态（要状态时间），允许卸货，通知agv改参数
                var dic = new Dictionary<string, string>();
                //< Req >< Order No = 'TN2302020002' ParamNo = '18' Param1 = '12' /></ Req >
                dic.Add("No", no);
                dic.Add("ParamNo", "8");
                dic.Add("Param1", "1");
                NDC.ChangeOrder(dic);
                //改完参数车子就会自己卸货
            }
            if (state == 1103)
            {
                //大铁框叉走以后通知，我们要通知输送线
            }
        }

        /// <summary>
        /// 任务拦截
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        internal static bool Intercept(WCSTask mst)
        {
            var result = false;
            #region 空托回库任务需要判断有没有执行中的出库任务，接驳位有无托盘，如果有先不推送任务,任务任务需要agv任务完成再推
            if (mst.S_TYPE == "空托回库")
            {
                if (mst.N_SCHEDULE_TYPE == 1)
                {
                    //判断有无出库中的任务
                    var task = WCSHelper.GetTaskbyType("出库");
                    if (task.Count == 0)
                    {   //获取接驳位设备状态
                        HttpHelper httpHelper = new HttpHelper();
                        TableUrl tableUrl = Settings.tableUrls.Find(a => a.id == 3);
                        if (tableUrl != null)
                        {
                            Result<DeviceStatusModel> DeviceStatu = httpHelper.GetDeviceStatus(new string[] { mst.S_END_LOC }, tableUrl.url);
                            //设备状态空则允许推送
                            if (DeviceStatu != null && DeviceStatu.Data[0].PhotoStatus == 0)
                            {
                                result = true;

                            }
                            else
                            {
                                LogHelper.Info($"Intercept:设备状态不允许推送");
                            }
                        }
                        else
                        {
                            LogHelper.Info($"Intercept:获取接口url失败");
                        }
                    }
                }
                if (mst.N_SCHEDULE_TYPE == 2)
                {
                    var task = WCSHelper.GetTaskByOpName(mst.S_OP_CODE, 3);
                    if (task != null)
                    { result = true; }
                }
            }
            if (mst.S_TYPE == "出库")
            {
                //推送agv任务，判断设备任务是否完成
                if (mst.N_SCHEDULE_TYPE == 1)
                {
                    var task = WCSHelper.GetTaskByOpName(mst.S_OP_CODE, 3);
                    if (task != null)
                    { result = true; }
                }
            }
            #endregion


            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_SCHEDULE_TYPE == 1)//agv任务
            {
                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>();
                var sb1 = new StringBuilder();

                //dic.Add("No", mst.S_CODE.Trim());
                //dic.Add("Pri", mst.N_PRIORITY.ToString());
                dic.Add("From", start.ToString());
                dic.Add("To", end.ToString());
                dic.Add("Func", "0");
                dic.Add("DATA", "0");
                dic.Add("ItemHeight", "0");
                dic.Add("CntrType", "1");
                dic.Add("FromCol", "0");
                dic.Add("ToCol", "0");
                dic.Add("Ctype", "0");

                // dic.Add("Ext1", "1"); dic.Add("Ext2", "CALLADDAGV"); dic.Add("N_CNTR_COUNT", "");
                var res = NDC.AddNewOrderNew(5, mst.N_PRIORITY, mst.S_CODE.Trim(), dic);
                if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
                {
                    //推送成功，修改任务优先级
                    mst.N_B_STATE = 1;
                    WCSHelper.UpdateStatus(mst);
                    result = true;
                }
            }
            else if (mst.N_SCHEDULE_TYPE == 2)//输送线任务
            {
                HttpHelper http = new HttpHelper();
                TableUrl tableUrl = Settings.tableUrls.Find(a => a.id == 3);
                if (tableUrl != null)
                {
                    var Wcsrsult = http.TaskAssignment(mst, tableUrl.url);
                    if (Wcsrsult.Code == 200)
                    {
                        mst.N_B_STATE = 1;
                        WCSHelper.UpdateStatus(mst);
                        result = true;
                    }
                }
            }
            return result;
        }

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


            var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, trayCarryCount, startLayer, endLayer);
            if (res)
            {
                result = true;
                //任务创建成功，起点货位出库锁定，终点货位入库锁定
                LocationHelper.LockLoc(start, 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



    }
}