using iWareCC.Common.Helper;
using iWareCommon.Common.Globle;
using iWareCommon.Utils;
using iWareModel;
using iWareSql;
using iWareSql.DataAccess;
using iWareSql.DBModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using XiGang.Core.Model;

namespace iWareCC
{
    /// <summary>
    /// 任务分解线程
    /// </summary>
    public static class MainTaskDecompose
    {
        /// <summary>
        /// 任务分解线程
        /// </summary>
        public static void HandlerMainTaskDecompose()
        {
            while (true)
            {
                try
                {
                    SystemWarningMsg._lbl_Alert_MainTaskDecompose = "";
                    if (SystemValue.isAllowRuning_MainTaskDecompose && SystemValue.isStartedModel)
                    {
                        using (DbModel context = new DbModel())
                        {
                            //查询状态=下发中的出库计划
                            //注意：原则是优先执行出库任务

                            var queryState2 = (int)MainTaskStatusEnum.待出库;

                            //var mainList = context.Task_Main.Where(x => x.TaskState == queryState1 || x.TaskState == queryState2).OrderBy(x => x.TaskSequence).ToList();//按照顺序号升序排列
                            //if (mainList != null && mainList.Count > 0)
                            //{//每次只处理一个
                            //    Do_HandlerMainTaskDecompose(mainList, context);
                            //}
                            //else
                            //{
                            //    SystemWarningMsg._lbl_Alert_MainTaskDecompose = "没有要分解的任务";
                            //}

                            var isAllowDecomposeOutTask = true;//是否允许分解出库任务
                            //按照先 出库优先，再入库的原则来
                            var mainList = context.Task_Main.Where(x => x.TaskState == queryState2).OrderBy(x => x.TaskSequence).ThenBy(x => x.CreateTime).ToList();//按照顺序号升序排列
                            if (mainList != null && mainList.Count > 0)
                            {//每次只处理一个
                                //验证 如果连续出库任务分解了两次，并且1012
                                var errMsg = "";
                                if (!MyExtendHelper.IsNoFinishedOutTaskGroupbyArea(context, ref errMsg))
                                {
                                    SystemWarningMsg._lbl_Alert_MainTaskDecompose += "不允许分解出库任务:" + errMsg + SysGloble.SPLIT_STR;
                                    isAllowDecomposeOutTask = false;
                                }
                                //var _list = MyExtendHelper.GetHasCatogryStationCodeAreaList();
                                Dictionary<string, int> dict_hasNoFinishedOutStoreTaskStationCodeAreaList = new Dictionary<string, int>();
                                var _list = MyExtendHelper.GetHasCatogryAndNoFinishedOutStoreTaskStationCodeAreaList(context, ref dict_hasNoFinishedOutStoreTaskStationCodeAreaList);
                                if (_list != null && _list.Count >= 2)
                                {
                                    SystemWarningMsg._lbl_Alert_MainTaskDecompose += "不允许分解出库任务:四个出库口目前有" + _list.Count + "个被占用了,超过了设定值:" + 2 + SysGloble.SPLIT_STR;
                                    isAllowDecomposeOutTask = false;
                                }
                                if (isAllowDecomposeOutTask)
                                {
                                    Do_HandlerMainTaskDecomposeForOut(mainList, context);
                                }
                            }
                            else
                            {//当前没有要出库的主任务，或者是 1012长时间被托盘占用的情况下 才允许分解组盘入库任务
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    SystemWarningMsg._lbl_Alert_MainTaskDecompose += "分解线程出现异常:" + ex.Message + SysGloble.SPLIT_STR;
                    Log4NetHelper.WriteErrorLog(LogType.CCWCFService, "HandlerIssuingTask出现异常：" + ex.Message, ex);
                }
                Thread.Sleep(2000);//休眠2秒
            }
        }



        private static void Do_HandlerMainTaskDecomposeForOut(List<Task_Main> mainList, DbModel context)
        {
            if (mainList != null && mainList.Count > 0)
            {//出库任务，严格按照 出库计划的顺序来执行。不能调个。
                //取前2台要出库的发动机,必须只能是处理2个，否则会出现顺序不对的情况
                var _mainList = mainList.OrderBy(x => x.TaskSequence).ThenBy(x => x.CreateTime).ToList().Take(2);
                List<string> areaList = new List<string>();
                List<Task_Main> doMainList = new List<Task_Main>();
                foreach (var item in _mainList)
                {
                    if (string.IsNullOrEmpty(item.Area))
                    {
                        throw new Exception("出库任务" + item.TaskNo + "的区域为空!");
                    }
                    if (areaList.Count >= 2)
                    {
                        break;
                    }
                    if (!areaList.Contains(item.Area))
                    {
                        areaList.Add(item.Area);
                        doMainList.Add(item);
                    }
                }
                //获取要处理的这些任务
                foreach (var doMain in doMainList)
                {
                    FunRetEntity result = null;

                    result = SingleHandlerForOutTask(context, doMain);

                    if (result.result) context.SaveChanges();
                    SystemWarningMsg._lbl_Alert_MainTaskDecompose = result.resMsg + SysGloble.SPLIT_STR;
                }
            }
            else
            {
                SystemWarningMsg._lbl_Alert_MainTaskDecompose += "没有要分解的任务" + SysGloble.SPLIT_STR;
            }
        }

        private static FunRetEntity SingleHandlerForOutTask(DbModel context, Task_Main mainTask)
        {
            try
            {
                //再次判断主任务是否已经被分解
                var aa = context.Task_Main.Where(x => x.Id == mainTask.Id).First();
                if (aa.TaskState != (int)MainTaskStatusEnum.待出库)
                {
                    return FunRetEntity.Fail("主任务不是待出库状态");
                }

                var toPlace = StationHandler.GetPlaceByPlaceId((int)mainTask.ToPlace, context);
                var sourcePlace = StationHandler.GetPlaceByPlaceId((int)mainTask.SourcePlace, context);
                var salver = SalverHandler.GetSalveById(context, mainTask.SalverId);

                //中间点
                var midPlace = StationHandler.GetRgvPlaceBySrmPlaceForOutStore(context, sourcePlace);
                if (midPlace == null)
                {
                    return FunRetEntity.Fail("没有找到RGV出库位置");
                }

                //去掉这个验证 【EditBy shaocx,2022-05-19】
                //判断rgv站点是否有光电占用 [EditBy shaocx,2022-04-29]
                /*
                var isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(midPlace.RgvStationCode);
                if (isGD_HasCatogryForRgvStattion)
                {
                    return FunRetEntity.Fail("RGV出库口站点" + midPlace.RgvStationCode + "上面光电显示有货，不允许创建堆垛机出库任务");
                }
                //*/

                //增加验证同一个目标点，是否存在未结束的任务，如果有，则不允许了 【EditBy shaocx,2022-04-29】
                //同一个堆垛机的前面未结束的任务,且同种类型
                var queryTaskState1 = (int)DeviceTaskStatusEnum.未开始;
                var queryTaskState2 = (int)DeviceTaskStatusEnum.已下发;
                var otherSrmTask = context.Task_Part.Where(x => x.ToPlace == midPlace.Id
                    && x.DeviceType == (int)EDeviceType.堆垛机
                     && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
                     ).FirstOrDefault();
                if (otherSrmTask != null)
                {
                    return FunRetEntity.Fail("上一个堆垛机任务未完成，不允许创建堆垛机出库任务,上一个堆垛机任务号:" + otherSrmTask.PlcTaskId);
                }

                var plcTaskNo = BusinessHelper.CreatePlcTaskIdForSrmTask();
                var createTime = DateTime.Now;
                //创建堆垛机任务
                FunRetEntity fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, context, EDeviceType.堆垛机, mainTask.CreateBy, 1, DeviceTaskTypeEnum.出库, mainTask, salver, sourcePlace, midPlace, mainTask.OperationRemark);
                if (fre.result == false)
                {
                    return fre;
                }
                //创建RGV任务
                fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, context, EDeviceType.RGV, mainTask.CreateBy, 2, DeviceTaskTypeEnum.出库, mainTask, salver, midPlace, toPlace, mainTask.OperationRemark);
                if (fre.result == false)
                {
                    return fre;
                }

                //更新主表的任务状态
                var _changeTaskState = MainTaskStatusEnum.出库任务已分解;
                mainTask.TaskState = (int)_changeTaskState;
                mainTask.TaskStateName = _changeTaskState.ToString();


                return FunRetEntity.Success("成功新建出库设备任务");
            }
            catch (Exception ex)
            {
                return FunRetEntity.Fail("新增出库设备任务异常:" + ex.Message);
            }

        }
    }
}