using NX_CommonClassLibrary;
using NX_JsonClassLibrary;
using NX_ModelClassLibrary.BaseModel;
using NX_ModelClassLibrary.Common;
using NX_ModelClassLibrary.CrnModel;
using NX_ModelClassLibrary.CustomEnum;
using NX_ModelClassLibrary.TranModel;
using NX_ModelClassLibrary.WcsDispatch;
using NX_ModelClassLibrary.WmsTask;
using NX_WcsBiz.CommonBusiness;
using NX_WcsDal.WcsDispatch;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NX_WcsBiz.WcsDispatch
{
    /// <summary>
    /// 任务请求调度类
    /// </summary>
    public class TaskRequest_Disp
    {
        #region 单例模式
        /// <summary>
        /// 单例模式对象
        /// </summary>
        private static TaskRequest_Disp _instance = null;
        private static readonly object lockObj = new object();
        /// <summary>
        /// 单例模式方法
        /// </summary>
        public static TaskRequest_Disp Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (lockObj)
                    {
                        if (_instance == null)
                        {
                            _instance = new TaskRequest_Disp();
                        }
                    }
                }
                return _instance;
            }
        }
        #endregion

        /// <summary>
        /// 任务请求调度入口函数
        /// </summary>
        /// <param name="taskRequestMd">任务请求传入参数对象</param>
        /// <returns></returns>
        public DispUntilityReturnMd TaskRequestHandleFunc(TaskRequestMd taskRequestMd)
        {
            try
            {
                if (taskRequestMd == null)
                {
                    return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"任务请求调度函数传入参数为空！！" };
                }
                DispUntilityReturnMd retMd;
                switch (taskRequestMd.TaskHandleType)
                {
                    case DispatchRequestHandleTypeEnum.托盘申请上线:
                        retMd = PalletApplyOnLine(taskRequestMd);
                        break;
                    case DispatchRequestHandleTypeEnum.自动拆解MWS大任务:                        
                        retMd = AutoDisassembleWmsTask();
                        break;
                    default:
                        retMd = new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"未定义任务请求处理枚举，任务请求调度无法识别此类型！！" };
                        break;
                }
                return retMd;
            }
            catch (Exception ex)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"任务请求调度函数发生异常：【{ex.Message}】。" };
            }
        }

        private DispUntilityReturnMd PalletApplyOnLine(TaskRequestMd taskRequestMd)
        {
            BasWcsLocMd taskRequestLoc = BasCommon_Biz.Instance.allWcsLocList.FirstOrDefault(x => x.LocCode == taskRequestMd.CurrentLocNo && (x.LocTypeCode == "OnLineLoc" || x.LocTypeCode == "OnLineAndGeneralLoc"));
            if (taskRequestLoc == null)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"托盘上线处理的请求参数验证错误，传入站台不是系统配置好的站台号,不允许上线！{GetRetMsg(taskRequestMd)}" };
            }
            WmsTskTaskMd wmsTskTaskMd = TaskRequest_Dal.Instance.GetUnfinishWmsTaskOfPalletCode(taskRequestMd.PalletCode);
            if (wmsTskTaskMd != null)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"托盘上线处理的请求参数验证错误，传入托盘号已经存在未完成的WMS大任务数据，不允许再次上线！{GetRetMsg(taskRequestMd)}" };
            }
            WcsCrnCmdMd wcsCrnCmdMd = TaskRequest_Dal.Instance.GetUnfinishWcsCrnCmdOfPalletCode(taskRequestMd.PalletCode);
            if (wcsCrnCmdMd != null)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"托盘上线处理的请求参数验证错误，传入托盘号已经存在未完成的堆垛机指令数据，不允许再次上线！{GetRetMsg(taskRequestMd)}" };
            }
            WcsTranCmdMd wcsTranCmdMd = TaskRequest_Dal.Instance.GetUnfinishWcsTranCmdOfPalletCode(taskRequestMd.PalletCode);
            if (wcsTranCmdMd != null)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"托盘上线处理的请求参数验证错误，传入托盘号已经存在未完成的输送线指令数据，不允许再次上线！{GetRetMsg(taskRequestMd)}" };
            }
            string trayCode = string.Empty;
            if (!TaskRequest_Dal.Instance.VerifyTrayMsgAndBalanceMsg(taskRequestMd.PalletCode, out trayCode))
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"托盘上线处理的请求参数验证错误，校验传入托盘号的库存和组盘信息错误，不允许上线！{GetRetMsg(taskRequestMd)}" };
            }

            //目前只有一个库区，后续增加多库区分配和负载均衡配置 TODO：孙亚龙
            BasWcsLocMd eLocNo = BasCommon_Biz.Instance.allWcsLocList.FirstOrDefault(x => x.LocTypeCode == "RegionLoc");
            BasNextLocRouteMd basNextLocRouteMd = TaskRequest_Dal.Instance.GetRouteMsg(taskRequestLoc, eLocNo);
            if (basNextLocRouteMd == null)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"托盘上线处理的请求参数验证错误，获取起点：【{taskRequestLoc.LocCode}】到终点：【{eLocNo.LocCode}】的路线信息发生错误，不允许上线！{GetRetMsg(taskRequestMd)}" };
            }
            BasRegionMd regionMd = TaskRequest_Dal.Instance.GetRegionMd(eLocNo.RegionCode);
            //生成WMS大任务信息。
            int row = TaskRequest_Dal.Instance.InsertWmsTaskData(taskRequestMd, eLocNo, trayCode, basNextLocRouteMd, regionMd);
            if (row > 0)
            {
                return new DispUntilityReturnMd { IsSuccess = true, RetMsg = "托盘上线处理成功！" };
            }
            else
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = "托盘上线处理失败！生成WMS大任务数据错误！！" };
            }            
        }

        private DispUntilityReturnMd AutoDisassembleWmsTask()
        {
            try
            {
                WmsTskTaskMd wmsTskTaskMd = TaskRequest_Dal.Instance.GetWmsTaskOriginalState(AppConfigHelper.Get("CurrWcsControlRegionCode"));
                if (wmsTskTaskMd != null)
                {
                    BasWcsLocMd sLocMd = BasCommon_Biz.Instance.allWcsLocList.FirstOrDefault(x => x.LocCode == wmsTskTaskMd.SlocCode);
                    BasWcsLocMd eLocMd = BasCommon_Biz.Instance.allWcsLocList.FirstOrDefault(x => x.LocCode == wmsTskTaskMd.ElocCode);

                    if (sLocMd.LocCode == eLocMd.LocCode && sLocMd.LocTypeCode == "RegionLoc" && eLocMd.LocTypeCode == "RegionLoc" && wmsTskTaskMd.TaskType == WmsTaskTypeEnum.内伸货位移库任务)
                    {
                        BasBinMd sBinMd = TaskRequest_Dal.Instance.GetBinMdOfCode(wmsTskTaskMd.SbinCode);
                        BasBinMd eBin = TaskRequest_Dal.Instance.GetBinMdOfCode(wmsTskTaskMd.EbinCode);
                        BasWcsDevMd DevMd = TaskRequest_Dal.Instance.GetCrnDevMsg(sBinMd.ShelfCode);
                        WmsTskTaskMd retWmsTaskMd = TaskRequest_Dal.Instance.InsertCrnCmdAndUpdateWmsTask(wmsTskTaskMd, sBinMd, eBin, DevMd);
                        if (retWmsTaskMd != null)
                        {
                            return new DispUntilityReturnMd { IsSuccess = true, RetMsg = $"WMS大任务拆解为堆垛机指令成功。【{JsonHelper.ToJson(retWmsTaskMd)}】" };
                        }
                        else
                        {
                            return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"WMS大任务拆解为堆垛机指令失败。【{JsonHelper.ToJson(wmsTskTaskMd)}】" };
                        }
                    }

                    BasNextLocRouteMd basNextLocRouteMd = TaskRequest_Dal.Instance.GetRouteMsg(sLocMd, eLocMd);
                    BasWcsDevMd devMd = BasCommon_Biz.Instance.basWcsDevMdList.FirstOrDefault(x => x.DevCode == basNextLocRouteMd.DevNo);
                    eLocMd = BasCommon_Biz.Instance.allWcsLocList.FirstOrDefault(x => x.LocCode == basNextLocRouteMd.NextLocNo);
                    if (basNextLocRouteMd == null)
                    {
                        return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"WMS大任务验证错误，无法进行拆解。获取起点：【{sLocMd.LocCode}】到终点：【{eLocMd.LocCode}】的路线信息发生错误！【{JsonHelper.ToJson(wmsTskTaskMd)}】" };
                    }

                    //拆解为输送线指令
                    if (devMd.DevTypeCode == "TranType")
                    {
                        //ToDo: 增加正在作业任务数量的限制，获取参数表入库作业的最大任务数量。
                        int WmsInstockTaskLimitNum = TaskRequest_Dal.Instance.GetLimitWmsTaskNum("InStockTaskMaxNum");
                        int runingWmsInstockTaskNum = TaskRequest_Dal.Instance.GetRuningWmsInstockTaskNum();
                        if (runingWmsInstockTaskNum >= WmsInstockTaskLimitNum)
                        {
                            return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"WMS正在作业的入库大任务数量已经超过入库最大的限制任务数量，请等待前面的入库任务做完。【{JsonHelper.ToJson(wmsTskTaskMd)}】" };
                        }
                        WmsTskTaskMd retWmsTaskMd = TaskRequest_Dal.Instance.InsertTranCmdAndUpdateWmsTask(wmsTskTaskMd,sLocMd,eLocMd, basNextLocRouteMd);
                        if (retWmsTaskMd != null)
                        {
                            return new DispUntilityReturnMd { IsSuccess = true, RetMsg = $"WMS大任务拆解为输送线指令成功。【{JsonHelper.ToJson(retWmsTaskMd)}】" };
                        }
                        else
                        {
                            return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"WMS大任务拆解为输送线指令失败。【{JsonHelper.ToJson(wmsTskTaskMd)}】" };
                        }
                    }

                    //拆解为堆垛机指令
                    if (devMd.DevTypeCode == "CrnType")
                    {
                        //ToDo: 增加正在作业任务数量的限制，获取参数表入库作业的最大任务数量。
                        int WmsOutstockTaskLimitNum = TaskRequest_Dal.Instance.GetLimitWmsTaskNum("OutStockTaskMaxNum");
                        int runingWmsOutstockTaskNum = TaskRequest_Dal.Instance.GetRuningWmsOutstockTaskNum();
                        if (runingWmsOutstockTaskNum >= WmsOutstockTaskLimitNum)
                        {
                            return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"WMS正在作业的出库大任务数量已经超过出库最大的限制任务数量，请等待前面的出库任务做完。【{JsonHelper.ToJson(wmsTskTaskMd)}】" };
                        }

                        BasBinMd sBin = TaskRequest_Dal.Instance.GetBinMdOfCode(wmsTskTaskMd.SbinCode);
                        BasBinMd eBin = TaskRequest_Dal.Instance.GetBinMdOfCode(wmsTskTaskMd.EbinCode);
                        WmsTskTaskMd retWmsTaskMd = TaskRequest_Dal.Instance.InsertCrnCmdAndUpdateWmsTask(wmsTskTaskMd, sBin, eBin, basNextLocRouteMd);
                        if (retWmsTaskMd != null)
                        {
                            return new DispUntilityReturnMd { IsSuccess = true, RetMsg = $"WMS大任务拆解为堆垛机指令成功。【{JsonHelper.ToJson(retWmsTaskMd)}】" };
                        }
                        else
                        {
                            return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"WMS大任务拆解为堆垛机指令失败。【{JsonHelper.ToJson(wmsTskTaskMd)}】" };
                        }
                    }
                }

                return null;
            }
            catch (Exception ex)
            {
                return new DispUntilityReturnMd { IsSuccess = false, RetMsg = $"自动拆解WMS大任务函数发生异常：【{ex.Message}】。" };
            }
        }

        private string GetRetMsg(TaskRequestMd taskRequestMd)
        {
            return $"请求参数 --- 托盘号：【{taskRequestMd.PalletCode}】，请求站台号：【{taskRequestMd.CurrentLocNo}】，请求处理类型：【{taskRequestMd.TaskHandleType}】";
        }
    }
}