using iWareCommon.Common.Globle;
using iWareCommon.Utils;
using iWareModel;
using iWareModel.EnumType.XiGangPublicCommon;
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.Common.Helper
{
    /// <summary>
    /// 增补创建的扩展帮助类 【EditBy shaocx,2022-02-05】
    /// </summary>
    public class MyExtendHelper
    {

        /// <summary>
        /// 配置缺料原因
        /// </summary>
        /// <param name="oldRemark"></param>
        /// <param name="queliaoReason"></param>
        /// <returns></returns>
        public static string GetQueliaoReason(string oldRemark, string queliaoReason)
        {
            char splitStr = '|';
            var updateRemark = "缺料原因:" + queliaoReason;
            if (string.IsNullOrEmpty(oldRemark))
            {
                oldRemark = updateRemark + splitStr;
            }
            else
            {
                //解析字符串
                var arr = oldRemark.Split(splitStr);
                oldRemark = updateRemark + splitStr + arr.Last();
            }
            return oldRemark;
        }

        /// <summary>
        /// 清除缺料原因
        /// </summary>
        /// <param name="oldRemark"></param>
        /// <param name="queliaoReason"></param>
        /// <returns></returns>
        public static string CleareQueliaoReason(string oldRemark)
        {
            char splitStr = '|';
            if (string.IsNullOrEmpty(oldRemark))
            {
                return string.Empty;
            }
            else
            {
                //解析字符串
                var arr = oldRemark.Split(splitStr);
                oldRemark = arr.Last();
            }
            return oldRemark;
        }

        /// <summary>
        /// 设置强制完成信号
        /// </summary>
        /// <param name="srmStationCode"></param>
        /// <returns></returns>
        public static void SetSrm_IN_SMQZYZTG(EDevice device, bool value)
        {
            if (device == EDevice.一号堆垛机)
            {
                FormCC.Srm1_IN_SMQZYZTG = value;
            }
            else if (device == EDevice.二号堆垛机)
            {
                FormCC.Srm2_IN_SMQZYZTG = value;
            }
            else if (device == EDevice.三号堆垛机)
            {
                FormCC.Srm3_IN_SMQZYZTG = value;
            }
            else if (device == EDevice.四号堆垛机)
            {
                FormCC.Srm4_IN_SMQZYZTG = value;
            }
        }

        /// <summary>
        /// 根据堆垛机的入库口获取 输送线的站点号
        /// </summary>
        /// <param name="srmStationCode"></param>
        /// <returns></returns>
        public static string GetRgvStationCodeBySrm(EDevice device)
        {
            string stationCode = "";
            if (device == EDevice.一号堆垛机)
            {
                stationCode = "1002";
            }
            else if (device == EDevice.二号堆垛机)
            {
                stationCode = "1004";
            }
            else if (device == EDevice.三号堆垛机)
            {
                stationCode = "1006";
            }
            else if (device == EDevice.四号堆垛机)
            {
                stationCode = "1007";
            }
            return stationCode;
        }

        /// <summary>
        /// 四个入库口 扫描验证结果推送
        /// </summary>
        /// <param name="isReset"></param>
        /// <param name="handType"></param>
        /// <param name="stationCode"></param>
        /// <param name="plcTaskId"></param>
        /// <param name="value"></param>
        /// <param name="sysSalverCode"></param>
        /// <param name="scanCode"></param>
        public static bool WriteScanValidateACK(bool isReset, string handType, string stationCode, int plcTaskId, bool value, string sysSalverCode, string scanCode)
        {
            using (RgvService.RgvServiceClient clent = new RgvService.RgvServiceClient())
            {
                var res = clent.WriteScanValidateACK(isReset, (int)EDevice.RGV, stationCode, value, Convert.ToInt32(plcTaskId));
                if (res.result)
                {
                    Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.LineInScanTheadService, "HandlerLineInSacnResult 下发扫描验证下发成功，写入值value:" + value + "，stationCode：" + stationCode + ",PlcTaskId:" + plcTaskId + ",系统托盘号:" + sysSalverCode + ",扫描托盘号:" + scanCode + ",处理类型：" + handType);
                    return true;
                }
                else
                {
                    Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.LineInScanTheadService, "HandlerLineInSacnResult 下发扫描验证下发失败，写入值value:" + value + "，stationCode：" + stationCode + ",PlcTaskId:" + plcTaskId + ",系统托盘号:" + sysSalverCode + ",扫描托盘号:" + scanCode + ",处理类型：" + handType);
                    return false;
                }
            }
        }

        /// <summary>
        /// 托盘回收时，是否允许创建去1014的任务
        /// </summary>
        /// <param name="errMsg"></param>
        /// <returns>true:允许创建，false：不允许创建</returns>
        public static bool IsAllowSendTaskTo1014ByTPHS(ref string errMsg)
        {

            //增加验证，1009上两个光电有货，或 1010上其中一个光电有货，或 1011上一个光电有货,就先暂停不要下发去1014的任务,目的是为了优先让托盘回收的去1014位置，而不是立体库，挺高接怕 [EditBy shaocx,2022-05-01]
            EDevice rgvLocation = EDevice.空托缓存1009;
            var stationCode = Convert.ToInt32(rgvLocation).ToString();
            //bool isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattionForPH_1(stationCode);
            bool isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(stationCode);
            if (isGD_HasCatogryForRgvStattion)
            {
                errMsg = "1009显示PH_01光电有货，就暂时不创建从立体库去1014的任务,等着1009的托盘到了1011再定夺托盘区哪里";
                return false;
            }
            rgvLocation = EDevice.空托缓存1010;
            isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(stationCode);
            if (isGD_HasCatogryForRgvStattion)
            {
                errMsg = "1010显示一个光电有货，就暂时不创建从立体库去1014的任务,等着1010的托盘到了1011再定夺托盘区哪里";
                return false;
            }
            rgvLocation = EDevice.空托缓存1011;
            isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(stationCode);
            if (isGD_HasCatogryForRgvStattion)
            {
                errMsg = "1011显示一个光电有货，就暂时不创建从立体库去1014的任务";
                return false;
            }
            return true;
        }

        /// <summary>
        /// 根据1009站点的光电获取返回立体库的托盘数
        /// </summary>
        /// <returns></returns>
        public static int GetSalverStackCountForBackToStore()
        {
            var high3 = FormCC.rgvView.R_1009_High3;
            var high2 = FormCC.rgvView.R_1009_High2;
            var high1 = FormCC.rgvView.R_1009_High1;

            int count = 0;
            if (high1 && high2 && high3)
            {
                count = 3;
            }
            else if (high1 && high2 && !high3)
            {
                count = 2;
            }
            else if (high1 && !high2 && !high3)
            {
                count = 1;
            }
            return count;
        }
        /// <summary>
        /// 判断  出库的任务未完成的，超过了两个库区的设定
        /// </summary>
        /// <param name="context"></param>
        /// <param name="errMsg"></param>
        /// <returns>true：未超过限定 false：超过了限定</returns>
        public static bool IsNoFinishedOutTaskGroupbyArea(DbModel context, ref string errMsg)
        {
            var queryTaskType = (int)DeviceTaskTypeEnum.出库;

            var noFishisedList = context.Task_Part.Where(x => x.TaskType == queryTaskType &&
                (x.TaskState == (int)DeviceTaskStatusEnum.未开始 || x.TaskState == (int)DeviceTaskStatusEnum.已下发)
                && x.DeviceType == (int)EDeviceType.堆垛机
                ).ToList();

            if (noFishisedList == null || noFishisedList.Count == 0)
            {
                return true;
            }
            int num = noFishisedList.Select(x => x.DeviceId).Distinct().Count();
            if (num >= 2)
            {
                errMsg = "未结束的出库任务所占的库区，已经超过设定的值" + 2 + ",目前是:" + num;
                return false;
            }
            return true;
        }

        /*
        /// <summary>
        /// 是否条件允许做入库任务，只有当 当 没有出库计划，或者是 1012长时间被托盘占用的情况下 才允许分解组盘入库任务
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static bool IsAllowCreateTaskForInStore(DbModel context, ref string errMsg)
        {
            //查询状态=下发中的出库计划
            //注意：原则是优先执行出库任务

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

            //按照先 出库优先，再入库的原则来
            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)
            {//每次只处理一个
                if (FormCC.RGV_1012_HasCategory_COUNT > SysGloble.MAX_RGV_1012_HasCategory_COUNT)
                {//1012长时间被托盘占用的情况下 才允许分解组盘入库任务
                    return true;
                }
            }
            else
            {//只有当 没有出库计划，或者是 1012长时间被托盘占用的情况下 才允许分解组盘入库任务
                return true;
            }
            errMsg = "只有当 没有出库计划，或者是 1012长时间被托盘占用的情况下 才允许入库任务";
            return false;
        }

        //*/

        ///// <summary>
        ///// 是否有两个货物占用两个出库口，并且1012上显示有货
        ///// </summary>
        ///// <returns></returns>
        //public static bool IsHasTwoCatogryOnOutStationAndOn1012()
        //{
        //    //判断出库计划是否有两个出库口被货物占用了
        //    var _list = GetHasCatogryStationCodeAreaList();
        //    if (_list != null && _list.Count >= 2)
        //    {//说明有两个货物占用两个出库口
        //        var isHasCatogry_1012 = IsGD_HasCatogryForRgvStattion(((int)EDevice.出库口1012).ToString());
        //        if (isHasCatogry_1012)
        //        {
        //            return true;
        //        }
        //    }
        //    return false;
        //}

        /// <summary>
        /// 获取四个出库口 光电有货物占用的列表
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static List<string> GetHasCatogryStationCodeAreaList()
        {
            if (MyExtendHelper.IsAllowSimulatorHandle(null))
            {//如果是模拟,返回默认 [EditBy shaocx,2022-05-31]
                return new List<string>();
            }
            List<string> hasCatogryStationCodeAreaList = new List<string>();
            //优先从四个出库口目前未占用的地方出库
            var stationCode = ((int)EDevice.堆垛机1出库口1001).ToString();
            var isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isHasCatogry)
            {
                hasCatogryStationCodeAreaList.Add("1");
            }
            stationCode = ((int)EDevice.堆垛机2出库口1003).ToString();
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isHasCatogry)
            {
                hasCatogryStationCodeAreaList.Add("2");
            }
            stationCode = ((int)EDevice.堆垛机3出库口1005).ToString();
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isHasCatogry)
            {
                hasCatogryStationCodeAreaList.Add("3");
            }
            stationCode = ((int)EDevice.堆垛机4出库口1008).ToString();
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isHasCatogry)
            {
                hasCatogryStationCodeAreaList.Add("4");
            }
            return hasCatogryStationCodeAreaList;
        }

        /// <summary>
        /// 获取四个出库口 有出库任务未结束或有货物占用 的占用的列表
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static List<string> GetHasCatogryAndNoFinishedOutStoreTaskStationCodeAreaList(DbModel context, ref Dictionary<string, int> dict_hasNoFinishedOutStoreTaskStationCodeAreaList)
        {
            dict_hasNoFinishedOutStoreTaskStationCodeAreaList = new Dictionary<string, int>();
            List<string> hasNoFinishedOutStoreTaskStationCodeAreaList = new List<string>();
            if (MyExtendHelper.IsAllowSimulatorHandle(null))
            {//如果是模拟,返回默认 [EditBy shaocx,2022-05-31]
                return new List<string>();
            }

            //优先从四个出库口目前未占用的地方出库
            var stationCode = ((int)EDevice.堆垛机1出库口1001).ToString();
            var place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            bool isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);//判断堆垛机是否有出库任务未结束
            var isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry)
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("1");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("1", FormCC.RGV_1001_HasCategory_COUNT);
            }
            stationCode = ((int)EDevice.堆垛机2出库口1003).ToString();
            place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry)
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("2");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("2", FormCC.RGV_1003_HasCategory_COUNT);
            }
            stationCode = ((int)EDevice.堆垛机3出库口1005).ToString();
            place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry)
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("3");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("3", FormCC.RGV_1005_HasCategory_COUNT);
            }
            stationCode = ((int)EDevice.堆垛机4出库口1008).ToString();
            place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry)
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("4");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("4", FormCC.RGV_1008_HasCategory_COUNT);
            }
            return hasNoFinishedOutStoreTaskStationCodeAreaList;
        }

        public static List<string> GetHasCatogryAndNoFinishedOutStoreTaskStationCodeAreaListForOutSalver(DbModel context, ref Dictionary<string, int> dict_hasNoFinishedOutStoreTaskStationCodeAreaList)
        {
            dict_hasNoFinishedOutStoreTaskStationCodeAreaList = new Dictionary<string, int>();
            List<string> hasNoFinishedOutStoreTaskStationCodeAreaList = new List<string>();
            if (MyExtendHelper.IsAllowSimulatorHandle(null))
            {//如果是模拟,返回默认 [EditBy shaocx,2022-05-31]
                return new List<string>();
            }

            //优先从四个出库口目前未占用的地方出库
            var stationCode = ((int)EDevice.堆垛机1出库口1001).ToString();
            var place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            bool isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);//判断堆垛机是否有出库任务未结束
            var isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry || !IsKongXianForSrm(EDevice.一号堆垛机))
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("1");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("1", FormCC.RGV_1001_HasCategory_COUNT);
            }
            stationCode = ((int)EDevice.堆垛机2出库口1003).ToString();
            place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry || !IsKongXianForSrm(EDevice.二号堆垛机))
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("2");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("2", FormCC.RGV_1003_HasCategory_COUNT);
            }
            stationCode = ((int)EDevice.堆垛机3出库口1005).ToString();
            place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry || !IsKongXianForSrm(EDevice.三号堆垛机))
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("3");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("3", FormCC.RGV_1005_HasCategory_COUNT);
            }
            stationCode = ((int)EDevice.堆垛机4出库口1008).ToString();
            place = context.Base_Station.Where(x => x.RgvStationCode == stationCode).First();
            isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, place.Id);
            isHasCatogry = IsGD_HasCatogryForRgvStattion(stationCode);
            if (isExistOtherTaskDoing || isHasCatogry || !IsKongXianForSrm(EDevice.四号堆垛机))
            {
                hasNoFinishedOutStoreTaskStationCodeAreaList.Add("4");
                dict_hasNoFinishedOutStoreTaskStationCodeAreaList.Add("4", FormCC.RGV_1008_HasCategory_COUNT);
            }
            return hasNoFinishedOutStoreTaskStationCodeAreaList;
        }

        /// <summary>
        /// 判断堆垛机是否空闲
        /// </summary>
        /// <param name="devic"></param>
        private static bool IsKongXianForSrm(EDevice devic)
        {
            if (FormCC.srmViewDict[(int)devic].R_State == (int)ESrmState.空闲)
            {
                return true;
            }
            return false;
        }


        #region 寻找立体库中的空托，出库到1014位置

        /// <summary>
        /// 寻找立体库中的空托，出库到1014位置
        /// </summary>
        /// <param name="context"></param>
        /// <param name="outDetailTask"></param>
        /// <param name="errMsg"></param>
        public static V_Store FindStoreForEmptySalverTo1014(DbModel context, ref string errMsg)
        {
            var queryMaterialType = (int)MaterialTypeEnum.托盘;
            var findStoreList = context.V_Store.Where(x => x.MaterialType == queryMaterialType
                   && x.StationIsHasTaskDoing == false && x.StationIsLock == false
                   && x.StationIsDeleted == false).OrderBy(x => x.InStoreTime).ThenBy(x => x.Qty).ToList();//空托排序
            if (findStoreList == null || findStoreList.Count == 0)
            {
                errMsg = "未找到可用于到拆盘机入库的立体库空托盘库存";
                return null;
            }
            //注意:排除掉堆垛机不可用的 【EditBy shaocx,2022-04-16】
            findStoreList = StationHandler.FindPlacesFilterByBreakdown(findStoreList);//通过设备状态来过滤库位 [EditBy shaocx,2020-12-13]
            if (findStoreList == null || findStoreList.Count == 0)
            {
                errMsg = "未找到可用于到拆盘机入库的空托盘库存";
                return null;
            }

            #region 优先从四个出库口目前未占用的地方出库
            Dictionary<string, int> dict_hasNoFinishedOutStoreTaskStationCodeAreaList = new Dictionary<string, int>();
            List<string> hasCatogryStationCodeAreaList = GetHasCatogryAndNoFinishedOutStoreTaskStationCodeAreaListForOutSalver(context, ref dict_hasNoFinishedOutStoreTaskStationCodeAreaList);

            var resultStore = findStoreList.FirstOrDefault();
            if (hasCatogryStationCodeAreaList.Count == 0)
            {
                return resultStore;
            }
            else
            {
                var new_findStoreList = findStoreList.Where(x => !hasCatogryStationCodeAreaList.Contains(x.Area)).OrderBy(x => x.InStoreTime).ThenBy(x => x.Qty).ToList();//空托排序
                if (new_findStoreList == null || new_findStoreList.Count == 0)
                {
                    //无奈，只好排队了，先找有货秒数=0的那个 
                    var myArea = "";
                    foreach (var item in dict_hasNoFinishedOutStoreTaskStationCodeAreaList)
                    {
                        if (item.Value == 0)
                        {
                            myArea = item.Key;
                            break;
                        }
                    }
                    if (!string.IsNullOrEmpty(myArea))
                    {
                        resultStore = findStoreList.Where(x => x.Area == myArea).OrderBy(x => x.InStoreTime).ThenBy(x => x.Qty).First();//空托排序
                    }
                    else
                    {
                        //无奈，只好排队了,排队也要排最长的那个
                        var dict = dict_hasNoFinishedOutStoreTaskStationCodeAreaList.OrderByDescending(x => x.Value).First();//取排队时间最长的那个
                        resultStore = findStoreList.Where(x => x.Area == dict.Key).OrderBy(x => x.InStoreTime).ThenBy(x => x.Qty).First();//空托排序
                    }

                    return resultStore;
                }
                else
                {//找到最优的
                    return new_findStoreList.FirstOrDefault();
                }
            }
            #endregion
        }

        #endregion

        /// <summary>
        /// 新建转运任务
        /// </summary>
        /// <param name="flag">1:转移到1014位置 2:转移到立体库中  3:1009到1011 4:立体库到1014位置 </param>
        /// <param name="rgvEDevice">RGV设备号</param>
        /// <param name="user"></param>
        /// <param name="store"></param>
        /// <returns></returns>
        public static FunRetEntity AddTransferTask(AddTransferTaskEnum flag, EDevice rgvEDevice, SysUser user, V_AllStore store)
        {
            FunRetEntity fr = new FunRetEntity();
            var errMsg = "";
            var remark = "新增转运任务";
            try
            {
                #region 事务
                #endregion
                using (DbModel edm = new DbModel())
                {
                    //增加验证 【EditBy shaocx,2022-04-28】
                    switch (flag)
                    {
                        case AddTransferTaskEnum.位置1011转移到1014位置:
                        case AddTransferTaskEnum.位置1011转移到立体库中:
                            //去掉这个验证，前面允许创建任务就创建吧 【EditBy shaocx,2022-05-15】
                            /*    
                            var isAllow = IsAllowCreateTaskForInStore(edm, ref errMsg);
                                if (!isAllow)
                                {
                                    return FunRetEntity.Fail(errMsg);
                                }
                                //*/
                            break;
                    }

                    using (var trans = edm.Database.BeginTransaction())
                    {
                        try
                        {
                            Task_Main mainTask = new Task_Main();
                            mainTask.IsVirtual = false;//非虚拟入库
                            mainTask.TaskNo = TaskNoHelper.GenerateTaskNo("TR");
                            mainTask.TaskName = "空托转运";



                            #region 获取任务起点

                            //起点
                            var realSourcePlace = "";
                            Base_Station sourcePlace = null;
                            if (flag == AddTransferTaskEnum.立体库到1014位置)
                            {//4:立体库到1014位置
                                var srmStore = MyExtendHelper.FindStoreForEmptySalverTo1014(edm, ref errMsg);
                                if (srmStore == null)
                                {
                                    return FunRetEntity.Fail(errMsg);
                                }
                                store = ClassHelper.RotationMapping<V_AllStore, V_Store>(srmStore);
                                sourcePlace = StationHandler.GetPlaceByPlaceId(store.StationId, edm);
                                realSourcePlace = sourcePlace.SrmStationCode;

                                //记录区域 [EditBy shaocx,2022-05-02]
                                var device = BusinessHelper.GetSrmDeviceByPlaceNo(sourcePlace.SrmStationCode);
                                mainTask.Area = ((int)device).ToString();
                            }
                            else if (flag == AddTransferTaskEnum.位置1014到1020)
                            {//5:位置1014到1020
                                sourcePlace = StationHandler.GetPlaceByPlaceId(store.StationId, edm);
                                realSourcePlace = sourcePlace.RgvStationCode;
                            }
                            else
                            {
                                var getSourcePlaceResult = StationHandler.GetTargtStationForAddTransferTask(edm, rgvEDevice, ref errMsg, ref sourcePlace);
                                if (getSourcePlaceResult.result == false) return getSourcePlaceResult;
                                realSourcePlace = sourcePlace.RgvStationCode;
                            }
                            mainTask.SourcePlace = sourcePlace.Id;
                            mainTask.RealSourcePlace = realSourcePlace;

                            #endregion

                            #region 获取中间点和目标点

                            Base_Station toPlace = null;
                            Base_Station midPlace = null;
                            var getMidToPlaceResult = MainTaskHandler.GetMidToPlaceForAddTransferTask(sourcePlace, flag, edm, ref errMsg, ref toPlace, ref midPlace, ref mainTask);
                            if (getMidToPlaceResult.result == false) return getMidToPlaceResult;

                            #endregion

                            SetTaskTypeStateAndInOutFlagForMainTask(flag, ref mainTask);

                            Base_Salver salver = null;
                            Base_Material newMaterial = null;
                            if (store == null)
                            {//新建物料，新建托盘，新建绑定关系
                                //绑定托盘和站点的关系
                                //新建物料
                                var salverStackCount = GetSalverStackCountForBackToStore();
                                if (salverStackCount == 0)
                                {
                                    //报错
                                    return FunRetEntity.Fail("根据1009站点的光电获取返回立体库的托盘数为0");
                                }

                                newMaterial = MaterialHandler.CreateEmptySlaverMaterial(edm, "空托盘转运时创建", salverStackCount);
                                //判断托盘是否存在，如果存在，就不需要重建，如果不存在，就新建托盘
                                salver = SalverHandler.CreateVirtualSalver(edm, "空托盘转运");
                                if (!string.IsNullOrEmpty(errMsg))
                                {
                                    return FunRetEntity.Fail(errMsg);
                                }
                                //绑定托盘和物料的关系
                                Salver_Material_Handler.CreateCvIRelation(edm, user.Name, salver, newMaterial, remark);
                                //绑定托盘和站点的关系
                                Salver_Station_Handler.CreateCvPRelation(edm, user.Name, salver, sourcePlace, Salver_V_Station_StateEnum.入库绑定, remark);
                            }
                            else
                            {
                                salver = SalverHandler.GetSalveById(edm, store.SalverId);
                                newMaterial = MaterialHandler.GetMaterialById(edm, store.MaterialId);
                            }

                            mainTask.SalverId = salver.Id;
                            mainTask.SalverCode = salver.SalverCode;
                            mainTask.MaterialId = newMaterial.Id;
                            //物料信息
                            MainTaskHandler.SetMaterialForMainTask(ref mainTask, newMaterial);

                            //序列号和订货号赋值  [Editby shaocx,2022-04-05]
                            mainTask.SerialNumber = "";
                            mainTask.OrderNo = "";

                            mainTask.CreateTime = mainTask.ModifyTime = mainTask.StartTime = DateTime.Now;
                            mainTask.CreateBy = mainTask.ModifyBy = user.Name;
                            mainTask.CreateId = mainTask.ModifyId = user.ID;
                            mainTask.OperationRemark = "添加";

                            string taskSequenceGuid = "";
                            mainTask.TaskSequence = MainTaskHandler.GenerateTaskSequence(edm, ref taskSequenceGuid);//生成任务序列号
                            mainTask.TaskSequenceGuid = taskSequenceGuid;

                            edm.Task_Main.Add(mainTask);
                            edm.SaveChanges();//保存一次，此时mainTask的自增ID就有值了

                            var plcTaskNo = BusinessHelper.CreatePlcTaskIdForSrmTask();
                            var createTime = DateTime.Now;

                            if (flag == AddTransferTaskEnum.位置1011转移到1014位置)
                            {//转移到1014位置
                                //创建RGV任务
                                FunRetEntity fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.RGV, user.Name, 1, DeviceTaskTypeEnum.空托转运到拆盘机入口, mainTask, salver, sourcePlace, toPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                            }
                            else if (flag == AddTransferTaskEnum.位置1011转移到立体库中)
                            {//转移到立体库中
                                //创建RGV任务
                                FunRetEntity fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.RGV, user.Name, 1, DeviceTaskTypeEnum.空托转运到立体库, mainTask, salver, sourcePlace, midPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                                //创建堆垛机任务
                                fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.堆垛机, user.Name, 2, DeviceTaskTypeEnum.空托转运到立体库, mainTask, salver, midPlace, toPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                            }
                            else if (flag == AddTransferTaskEnum.位置1009到位置1011)
                            {// 3:1009到1011 
                                //创建RGV任务
                                FunRetEntity fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.RGV, user.Name, 1, DeviceTaskTypeEnum.空托缓存位转运, mainTask, salver, sourcePlace, toPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                            }
                            else if (flag == AddTransferTaskEnum.立体库到1014位置)
                            {//4:立体库到1014位置

                                //创建堆垛机任务
                                FunRetEntity fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.堆垛机, user.Name, 1, DeviceTaskTypeEnum.立库空托到拆盘机入口, mainTask, salver, sourcePlace, midPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                                //创建RGV任务
                                fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.RGV, user.Name, 2, DeviceTaskTypeEnum.立库空托到拆盘机入口, mainTask, salver, midPlace, toPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                            }
                            else if (flag == AddTransferTaskEnum.位置1014到1020)
                            {//5:1014到1020位置
                                //创建RGV任务
                                FunRetEntity fre = PartTaskHandler.CreatePartTask(createTime, plcTaskNo, edm, EDeviceType.RGV, user.Name, 1, DeviceTaskTypeEnum.拆盘机入口到拆盘机, mainTask, salver, sourcePlace, toPlace, remark);
                                if (fre.result == false)
                                {
                                    throw new Exception(fr.resMsg);
                                }
                            }

                            edm.SaveChanges();//第二次保存

                            trans.Commit();//事务提交
                        }
                        catch (Exception ex)
                        {
                            trans.Rollback();
                            throw ex;
                        }
                    }
                    return FunRetEntity.Success("成功");
                }
            }
            catch (System.Exception ex)
            {
                throw ex;
            }
        }

        private static void SetTaskTypeStateAndInOutFlagForMainTask(AddTransferTaskEnum flag, ref Task_Main mainTask)
        {
            var _InOutFlag = default(MainInOutFlagEnum);
            var _taskType = default(MainTaskTypeEnum);
            var _taskState = default(MainTaskStatusEnum);
            switch (flag)
            {
                case AddTransferTaskEnum.立体库到1014位置:
                    _taskType = MainTaskTypeEnum.自动出库;
                    _taskState = MainTaskStatusEnum.出库中;
                    _InOutFlag = MainInOutFlagEnum.出库;
                    break;
                case AddTransferTaskEnum.位置1009到位置1011:
                case AddTransferTaskEnum.位置1011转移到1014位置:
                case AddTransferTaskEnum.位置1014到1020:
                    _taskType = MainTaskTypeEnum.空托转运;
                    _taskState = MainTaskStatusEnum.待转运;
                    _InOutFlag = MainInOutFlagEnum.转运;
                    break;
                case AddTransferTaskEnum.位置1011转移到立体库中:
                    _taskType = MainTaskTypeEnum.自动入库;
                    _taskState = MainTaskStatusEnum.入库中;
                    _InOutFlag = MainInOutFlagEnum.入库;
                    break;
                default:
                    throw new Exception("不支持的类型");
            }
            mainTask.TaskType = Convert.ToInt32(_taskType);
            mainTask.TaskTypeName = _taskType.ToString();
            mainTask.TaskState = Convert.ToInt32(_taskState);
            mainTask.TaskStateName = _taskState.ToString();

            mainTask.InOutFlag = (int)_InOutFlag;
            mainTask.InOutFlagName = _InOutFlag.ToString();
        }


        /// <summary>
        /// 是否允许给1014发送目标点是1014的任务
        /// </summary>
        /// <param name="context"></param>
        /// <param name="stationCode"></param>
        /// <param name="store"></param>
        /// <returns>true:允许，false：不允许</returns>
        public static bool IsAllowSendTaskToPlace1014(DbModel context, string stationCode, ref V_AllStore store)
        {
            var isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(stationCode);
            var isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(stationCode);
            var isSys_HasCatogryForRgvStattion = MyExtendHelper.IsSys_HasCatogryForRgvStattion(context, stationCode, ref store);//1014上是否有系统库存

            var isExistOtherTaskDoingForDeviceTaskTypeEnum_立库空托到拆盘机入口 = PartTaskHandler.IsExistOtherTaskDoingForDeviceTaskTypeEnum(DeviceTaskTypeEnum.立库空托到拆盘机入口);
            var isExistOtherTaskDoingForDeviceTaskTypeEnum_空托转运到拆盘机入口 = PartTaskHandler.IsExistOtherTaskDoingForDeviceTaskTypeEnum(DeviceTaskTypeEnum.空托转运到拆盘机入口);


            if (!isSys_HasCatogryForRgvStattion && //没有系统库存
                !isGD_HasCatogryForRgvStattion &&  //光电显示无货
                !isExistOtherTaskDoing //没有其他任务占用
                && isExistOtherTaskDoingForDeviceTaskTypeEnum_立库空托到拆盘机入口 == false
                && isExistOtherTaskDoingForDeviceTaskTypeEnum_空托转运到拆盘机入口 == false
                )
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 站点光电是否有货(只需要判断其中一个光电，就认为，有货)
        /// </summary>
        /// <param name="stationCode"></param>
        /// <returns>true:光电有货，false：光电无货</returns>
        public static bool IsGD_HasCatogryForRgvStattion(string stationCode)
        {
            if (FormCC.rgvView == null) return false;
            var rgv = FormCC.rgvView.R_RgvForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (rgv.R_PH_2 == true || rgv.R_PH_1 == true)
            {//只需要判断其中一个光电，就认为，有货
                return true;
            }
            return false;
        }

        /// <summary>
        /// 站点光电是否有货(两个光电必须全是有货)
        /// </summary>
        /// <param name="stationCode"></param>
        /// <returns>true:光电有货，false：光电无货</returns>
        public static bool IsGD_HasCatogryForRgvStattionFor2(string stationCode)
        {
            if (FormCC.rgvView == null) return false;
            var rgv = FormCC.rgvView.R_RgvForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (rgv.R_PH_1 == true && rgv.R_PH_2 == true)
            {//有货，两个光电必须全是有货
                return true;
            }
            return false;
        }

        /// <summary>
        /// 站点PH_1光电是否有货 （PH_1是指他的停止光电）
        /// </summary>
        /// <param name="stationCode"></param>
        /// <returns>true:光电有货，false：光电无货</returns>
        public static bool IsGD_HasCatogryForRgvStattionForPH_1(string stationCode)
        {
            if (FormCC.rgvView == null) return false;
            var rgv = FormCC.rgvView.R_RgvForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (rgv.R_PH_1 == true)
            {//PH_1有货
                return true;
            }
            return false;
        }

        /// <summary>
        /// 站点PH_2光电是否有货 （PH_2是指他的有货光电）
        /// </summary>
        /// <param name="stationCode"></param>
        /// <returns>true:光电有货，false：光电无货</returns>
        public static bool IsGD_HasCatogryForRgvStattionForPH_2(string stationCode)
        {
            var rgv = FormCC.rgvView.R_RgvForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (rgv.R_PH_2 == true)
            {//PH_2有货
                return true;
            }
            return false;
        }

        /// <summary>
        /// 站点系统是否有货
        /// </summary>
        /// <param name="stationCode"></param>
        /// <returns>true:系统有货，false：系统无货</returns>
        public static bool IsSys_HasCatogryForRgvStattion(DbModel context, string stationCode, ref V_AllStore store)
        {
            store = StoreHandler.GetV_AllStoreByRgvStationCode(context, stationCode);
            if (store != null)
            {//有货
                return true;
            }
            return false;
        }

        public static FunRetEntity DoHandler(DbModel context, V_AllStore store, EDevice rgvStationCode)
        {
            try
            {
                SysUser user = new SysUser()
                {
                    ID = 0,
                    Name = SysGloble.WCSSystem
                };
                if (rgvStationCode == EDevice.空托缓存1011)
                {
                    //判断1014是否有空位
                    var queryRgvStationCode = ((int)EDevice.拆盘机入口1014).ToString();
                    V_AllStore my1014Store = null;
                    var isAllow = MyExtendHelper.IsAllowSendTaskToPlace1014(context, queryRgvStationCode, ref my1014Store);
                    if (isAllow)
                    {
                        return AddTransferTask(AddTransferTaskEnum.位置1011转移到1014位置, rgvStationCode, user, store);
                    }
                    else
                    {
                        //寻找立体库是否有库存
                        return AddTransferTask(AddTransferTaskEnum.位置1011转移到立体库中, rgvStationCode, user, store);
                    }
                    //*/
                    //var isGD_HasCatogryForRgvStattion = IsGD_HasCatogryForRgvStattion(queryRgvStationCode);
                    //var store_1014_count = context.V_AllStore.Where(x => x.RgvStationCode == queryRgvStationCode).Count();
                    //if (store_1014_count > 0 || isGD_HasCatogryForRgvStattion)
                    //{

                    //}
                    //else
                    //{//1014无货，创建任务
                    //    return MainTaskHandler.AddTransferTask(AddTransferTaskEnum.转移到1014位置, rgvStationCode, user, store);
                    //}
                }
                else if (rgvStationCode == EDevice.空托缓存1009)
                {
                    return AddTransferTask(AddTransferTaskEnum.位置1009到位置1011, rgvStationCode, user, store);
                }
                else if (rgvStationCode == EDevice.拆盘机入口1014)
                {//拆盘机入口1014处新建从立体库叫托盘任务
                    return AddTransferTask(AddTransferTaskEnum.立体库到1014位置, rgvStationCode, user, store);
                }
                else if (rgvStationCode == EDevice.拆盘机1020)
                {// 从1014到1020
                    return AddTransferTask(AddTransferTaskEnum.位置1014到1020, rgvStationCode, user, store);
                }
                return null;
            }
            catch (Exception ex)
            {
                return FunRetEntity.Fail("新增空托盘转运任务异常:" + ex.Message);
            }
        }

        /// <summary>
        /// 判断任务是否允许模拟完成(虚拟模拟或者是强制完成模式)
        /// </summary>
        /// <param name="_task"></param>
        /// <returns></returns>
        public static bool IsAllowSimulatorHandle(Task_Part _task)
        {
            if (WCSConfigHelper.GetConfig_IsSimulationPLC())
            {
                return true;
            }
            if (_task != null && _task.IsAllowSimulateExecute == true)
            {
                return true;
            }
            return false;
        }
    }
}