using AGVLib;
using CtuDeviceLib.model;
using log4net.Util;
using Mushiny;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

using System.Windows.Forms;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TextBox;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TrackBar;

namespace CtuDeviceLib
{
    /// <summary>
    /// 原材料运输-CTU
    /// </summary>
    public class FinishedTrans : IBusinessRobot, ICTUOp
    {
        public FinishedTrans()
        {
            Id = 3;
            Name = MushinyManager.FinishedCTUName;
            checkInletOutStoreTimer = new System.Timers.Timer();
            checkInletOutStoreTimer.Interval = 2000;
            checkInletOutStoreTimer.AutoReset = true;
            checkInletOutStoreTimer.Elapsed += CheckInletOutStoreTimer_Elapsed; ; ;
            checkInletOutStoreTimer.Enabled = true;
        }
        DateTime startTime = DateTime.Now;
        private void CheckInletOutStoreTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (MushinyManager.DisableCallAGV) return;
            if ((DateTime.Now - startTime).TotalSeconds < 10) return;
            if (System.Threading.Monitor.TryEnter(checkInletOutStoreTimer, 500))
            {
                try
                {
                    checkInEquipOustore(SMFManager.getInStoreBarcode(Name, ServerBase));
                }
                catch (Exception ex)
                {
                    LogUtil.error("检查空箱出库异常", ex);
                }
                finally
                {
                    System.Threading.Monitor.Exit(checkInletOutStoreTimer);
                }
            }
        }

        protected override void Execute()
        {
            process();
        }
        System.Timers.Timer checkInletOutStoreTimer = null;
        /// <summary>
        /// 验证料箱定位码和料箱码是否匹配
        /// </summary>
        bool validatelocateCode = ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "validateLocateCode", true);
        void process()
        {
            var executingTasks = ctuBean.GetExecutingCTUTasks();
            if (executingTasks != null)
            {
                foreach (var task in executingTasks)
                {
                    try
                    {
                        if (validatelocateCode)
                        {
                            bool checkFail = false;
                            var ctu = task.CTU;
                            if (ctu != null)
                            {
                                foreach (var item in ctu.Baskets)
                                {
                                    if (string.IsNullOrEmpty(item.TaskId))
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        if (!item.CheckCodeIsSame())
                                        {
                                            checkFail = true;
                                            //sbWarnMsgDetails.AppendLine($"【{ctu.Name}】执行的任务【{item.TaskId}】所在背篓【{item.Row}】料箱码【{item.ContainerCode}】与定位码【{item.LocateCode}】不匹配，存在接错料箱风险，无法继续任务，请手动处理");
                                        }
                                    }
                                }
                            }
                            if (checkFail)
                                continue;
                        }
                        task.Process();
                        var finished = task as CTUTask_Finished;
                        if (finished != null)
                        {
                            if (!string.IsNullOrEmpty(finished.ctuTransit?.WarnMsg ?? ""))
                            {
                                sbWarnMsgDetails.AppendLine(finished.ctuTransit?.WarnMsg ?? "");
                            }
                        }
                        sbRealtimeMsg.AppendLine();
                    }
                    catch (Exception ex)
                    {
                        LogUtil.error($"{task?.CTU?.Name} 执行任务【{task?.CurRobotTask?.TaskId}】异常：", ex);
                    }

                }
            }
            var busyCtus = ctuBean.GetInOutCtus();
            busyCtus?.ForEach(s => handleEmptyCtuWithTask(s));
        }


        public override void RemoveTask(RobotTask task, bool force = false)
        {
            ctuBean.RemoveCTUTask(task.TaskId, force);
            base.RemoveTask(task, force);
        }
        /// <summary>
        /// 检查任务
        /// </summary>
        protected override void CheckTask()
        {
            try
            {
                //取消任务操作
                var cancelTasks = robotTasks.FindAll(s => s.TaskState == RobotTaskState.取消);
                if (cancelTasks != null && cancelTasks.Count > 0)
                {
                    cancelTasks.ForEach(s => { RemoveTask(s, true); });
                }

                var finishedTasks = robotTasks.FindAll(s => s.TaskState == RobotTaskState.完成 || s.TaskState == RobotTaskState.手动完成);
                if (finishedTasks != null && finishedTasks.Count > 0)
                {
                    finishedTasks.ForEach(s => { RemoveTask(s); });
                }

                var enables = ctuBean.GetEnabledCTUs();
                if (enables != null && enables.Count > 0)
                {
                    assignInletStand(enables);
                    foreach (var enableCtu in enables)
                    {
                        if (ctuBean.CheckCtuHasTask(enableCtu)) continue;//已有任务，不获取新任务
                        bool canGetNewTask = true;
                        if (enableCtu.RunState == Mushiny.RunState.Offline)
                        {
                            canGetNewTask = false;
                            sbWarnMsgDetails.AppendLine($"【{enableCtu.Name}】状态【{enableCtu.RunState}】,未复位，不接任务");
                        }
                        if (enableCtu.RunState == RunState.Executing)//复位完成，运行中
                        {
                            if (enableCtu.CurLandMark == 10001)
                            {
                                canGetNewTask = false;
                                sbWarnMsgDetails.AppendLine($"【{enableCtu.Name}】在辅助码【{enableCtu.CurLandMark}】,上不接任务");
                            }
                            if (enableCtu.SOC < CTUBean.executeMinPow)
                            {
                                canGetNewTask = false;
                                sbWarnMsgDetails.AppendLine($"【{enableCtu.Name}】电量【{enableCtu.SOC}】小于【{enableCtu.SOC}】,不接任务");
                            }
                            if (!enableCtu.HasEmptyBasket(out _))
                            {
                                canGetNewTask = false;
                                sbWarnMsgDetails.AppendLine($"【{enableCtu.Name}】无可用背篓,不接任务");
                            }
                        }
                        if (!canGetNewTask)
                        {
                            continue;
                        }
                        if (AssignTask(enableCtu))
                        {
                            if (ctuBean.CheckCtuHasTask(enableCtu, out CTUTask cTUTask))
                            {
                                if (cTUTask.TaskType == RobotTaskType.Insotre)
                                {
                                    cTUTask.MoveInfo.NewMove(MoveType.InStore);
                                }
                                else if (cTUTask.TaskType == RobotTaskType.Outstore)
                                {
                                    cTUTask.MoveInfo.NewMove(MoveType.OutStore);
                                }
                                else if (cTUTask.TaskType == RobotTaskType.Standby)
                                {
                                    cTUTask.MoveInfo.NewMove(MoveType.Standby);
                                }
                                else if (cTUTask.TaskType == RobotTaskType.Charge)
                                {
                                    cTUTask.MoveInfo.NewMove(MoveType.Charge);
                                }

                                if (MushinyManager.GetCtuTaskByState(cTUTask.AllTasks, RobotTaskState.已分配车, out cTUTask.CurRobotTask))
                                {
                                    ctuBean.StartExecuteCtutask(cTUTask);
                                    if (cTUTask.TaskGroup == RobotTaskGroup.Common)
                                    {
                                        cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_00_Start);
                                        cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                    }
                                    else if (cTUTask.TaskGroup == RobotTaskGroup.Finished_InEquip)
                                    {
                                        if (cTUTask.TaskType == RobotTaskType.Insotre)
                                        {
                                            cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_InEquip_Instore_01_Start);
                                            cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                        }
                                        else
                                        {
                                            cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_InEquip_Outstore_01_Start);
                                            cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                        }
                                    }
                                    else if (cTUTask.TaskGroup == RobotTaskGroup.Finished_OutEquip)
                                    {
                                        if (cTUTask.TaskType == RobotTaskType.Insotre)
                                        {
                                            cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_OutEquip_Instore_01_Start);
                                            cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                        }
                                        else
                                        {
                                            cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_OutEquip_Outstore_01_Start);
                                            cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                        }
                                    }
                                    else if (cTUTask.TaskGroup == RobotTaskGroup.Finished_ManualLine)
                                    {
                                        if (cTUTask.TaskType == RobotTaskType.Insotre)
                                        {
                                            cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_ManualLine_Instore_01_Start);
                                            cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                        }
                                        else
                                        {
                                            cTUTask.MoveInfo.NextMoveStep(RunStep.CTU_ManualLine_Outstore_01_Start);
                                            cTUTask.MoveInfo.Info($"【{cTUTask.CurRobotTask.TaskId}】开始执行");
                                        }
                                    }
                                }

                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                sbWarnMsgDetails.AppendLine($"【{Name}】CheckTask error:{ex.ToString()}");
                LogUtil.error($"【{Name}】CheckTask error:", ex);
            }
        }

        bool test_EnableNewOutstore { get { return ConfigAppSettings.GetValue("Debug_EnableNewOutstoreLogic", false); } }
        void autoCreateTask()
        {
            try
            {
                if (clientNodes == null) return;
                var groups = clientNodes.GroupBy(s => s.logicGroup);
                foreach (var group in groups)
                {
                    string taskname = group.Key;
                    var lst = group.ToList();
                    if (lst == null || lst.Count == 0) continue;

                    if (!MushinyManager.DisableCallAGV)
                    {
                        //查询出库任务
                        if (test_EnableNewOutstore)
                        {
                            checkOutstore_new(lst, taskname);
                        }
                        else
                            checkOutstore(lst, taskname);

                        //出入料机构出口，料箱需要离开
                        //有料箱需要离开
                        checkInstore(lst, taskname);
                    }
                    //空闲车检查是否去待机点
                    checkStandby();
                    checkCharge();
                }
            }
            catch (Exception ex)
            {
                sbWarnMsgDetails.AppendLine($"【{Name}】autoCreateTask error:{ex.ToString()}");
                LogUtil.error($"【{Name}】autoCreateTask error:", ex);
            }
        }
        /// <summary>
        /// 启用获取手动线任务
        /// </summary>
        bool enableGetManualInstore { get { return ConfigAppSettings.GetValue("Enable_GetManualInstore", true); } }
        void checkInstore(List<ClientNode> lst, string taskname)
        {
            var instores = SMFManager.GetLineToShelfTasks(Name, ServerBase);
            instores.Sort((a, b) => { return (int)(b.createDate - a.createDate).TotalSeconds; });
            var manualInstore = instores?.Find(s => (Setting_Init.Manual_DischargeHole.Equals(s.fromLoc)
            || Setting_Init.rawLine_out.Equals(s.fromLoc)));
            if (enableGetManualInstore && manualInstore != null)
            {
                string taskName = manualInstore.id;
                string containerCode = manualInstore.boxCode;
                string posname = manualInstore.toLoc;
                string flag = $"{containerCode}-{posname}";
                var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                if (task == null)
                {
                    task = new RobotTask()
                    {
                        TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Insotre.ToString()),
                        TaskName = taskName,
                        CreateTime = DateTime.Now,
                        RobotType = Id,
                        TaskFlag = flag,
                        TaskState = RobotTaskState.已生成,
                        SrcPoint = manualInstore.fromLoc,
                        DestPoint = posname,
                        TaskType = RobotTaskType.Insotre,
                        ContainerCode = containerCode,
                        NeedReAssignTarget = true,
                        Priority = manualInstore.priority,
                        TaskGroup = RobotTaskGroup.Finished_ManualLine
                    };
                    // UpdateLocInfo(task, TaskStatus.EXECUTING);
                    LogUtil.info($"创建入库任务,手动线 【{JsonHelper.SerializeObject(task)}】 【{JsonHelper.SerializeObject(manualInstore)}】");
                    AddTask(task);
                }
            }

            var needleaves = lst.FindAll(s => s.status == AGVLib.NodeStatus.NeedLeave && s.type == Setting_Init.type_autoline);
            if (needleaves != null)
            {
                foreach (var needleave in needleaves)
                {
                    if (Setting_Init.rawLine_out.Equals(needleave.name)) continue;
                    string shelf_id = needleave.shelf_id;
                    if (string.IsNullOrEmpty(shelf_id))
                    {
                        sbWarnMsgDetails.AppendLine($"【{needleave.name}】无法创建任务。 有料箱离开，但料箱号为空");
                        continue;
                    }
                    string posname = "";
                    FinishedCtuTask instore = null;
                    if (ConfigAppSettings.simulationMode)
                    {
                        posname = ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_InPosname", "W000001R01000153");
                    }
                    else
                    {
                        if (!shelf_id.StartsWith("C"))
                        {
                            sbWarnMsgDetails.AppendLine($"【{needleave.name}】无法创建任务。 有料箱离开，但料箱号不是以C开头");
                            continue;
                        }
                        if (instores == null || instores.Count == 0) continue;
                        instore = instores.Find(s => s.fromLoc.Equals(needleave.name) && shelf_id.StartsWith(s.boxCode));
                        if (instore == null)
                        {
                            sbWarnMsgDetails.AppendLine($"无法创建任务，因未找到【{needleave.name}】的料箱【{shelf_id}】需要离开(NeedLeave)");
                            continue;
                        }
                        posname = instore.toLoc;

                        if (!ctuBean.CheckPosExist(posname))
                        {
                            sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的货架号【{posname}】，请检查");
                            continue;
                        }
                    }

                    // var target = ctuBean.GetPosInfoByName(posname);

                    string flag = $"{instore.boxCode}-{posname}";
                    var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));//s.TaskName.Equals(taskname)
                    if (task == null)
                    {
                        task = new RobotTask()
                        {
                            TaskId = RobotTask.GenTaskId(flag, $"{RobotTaskType.Insotre}"),
                            TaskName = taskname,
                            CreateTime = DateTime.Now,
                            RobotType = Id,
                            TaskFlag = flag,
                            TaskState = RobotTaskState.已生成,
                            //节点描述为货架码
                            SrcPoint = needleave.name,
                            DestPoint = posname,
                            TaskType = RobotTaskType.Insotre,
                            ContainerCode = instore.boxCode,
                            Priority = instore.priority
                        };
                        //UpdateLocInfo(task, TaskStatus.EXECUTING);
                        LogUtil.info($"创建任务 入库任务 [{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(instore)}");
                        AddTask(task);
                    }
                }
            }

            var outEquipBuffLines = lst.FindAll(s => s.type == Setting_Init.type_manualautoline && s.dir == Setting_Init.dir_out);
            foreach (var item in outEquipBuffLines)
            {
                var instore = instores?.Find(s => s.fromLoc.Equals(item.name));
                if (instore != null)
                {
                    string shelf_id = instore.boxCode;
                    string posname = instore.toLoc;

                    if (!shelf_id.StartsWith("C"))
                    {
                        sbWarnMsgDetails.AppendLine($"【{item.name}】无法创建任务。 有料箱离开，但料箱号不是以C开头");
                        continue;
                    }
                    if (instores == null || instores.Count == 0) continue;
                    if (ctuBean.GetPosInfoByName(item.name) == null)
                    {
                        sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的位置【{item.name}】，请检查配置");
                        continue;
                    }
                    if (!ctuBean.CheckPosExist(posname))
                    {
                        sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的货架号【{posname}】，请检查");
                        continue;
                    }
                    string flag = $"{instore.boxCode}-{posname}";
                    var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));//s.TaskName.Equals(taskname)
                    if (task == null)
                    {
                        task = new RobotTask()
                        {
                            TaskId = RobotTask.GenTaskId(flag, $"{RobotTaskType.Insotre}"),
                            TaskName = taskname,
                            CreateTime = DateTime.Now,
                            RobotType = Id,
                            TaskFlag = flag,
                            TaskState = RobotTaskState.已生成,
                            //节点描述为货架码
                            SrcPoint = item.name,
                            DestPoint = posname,
                            TaskType = RobotTaskType.Insotre,
                            ContainerCode = instore.boxCode,
                            Priority = instore.priority,
                            TaskGroup = RobotTaskGroup.Finished_OutEquip
                        };
                        //UpdateLocInfo(task, TaskStatus.EXECUTING);
                        LogUtil.info($"创建任务 入库任务 出料缓存线[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(instore)}");
                        AddTask(task);
                    }
                }
            }
        }
        void checkOutstore(List<ClientNode> lst, string taskname)
        {
            List<FinishedCtuTask> outTasks = null;
            if (ConfigAppSettings.simulationMode)
            {
                outTasks = new List<FinishedCtuTask>
                    {
                        new FinishedCtuTask()
                        {
                             boxCode=ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_Barcode", "C0700"),
                             toLoc = ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_OutLoc", "In1_FeedingInlet"),
                             fromLoc =ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_OutPosname", "W000001R01000153")
                        } };
            }
            else
            {
                outTasks = SMFManager.GetShelfToLineTasks(Name, ServerBase);
            }

            if (outTasks != null && outTasks.Count > 0)
            {
                var outLetTasks = outTasks.FindAll(s => Setting_Init.Out_FeedingInlet.Equals(s.toLoc));
                if (outLetTasks != null && outLetTasks.Count > 0)
                {
                    foreach (var outLetTask in outLetTasks)
                    {
                        string posname = outLetTask.fromLoc;
                        string target = outLetTask.toLoc;
                        string containerCode = outLetTask.boxCode;
                        // taskname = outTask.id;
                        var outEqips = lst.FindAll(s => s.name.StartsWith("Out") && s.name.EndsWith("FeedingInlet"));
                        foreach (var item in outEqips)
                        {
                            var allTasks = TaskManager.GetAllTasks()?.FindAll(s => s.TaskType == RobotTaskType.Outstore && item.name.Equals(s.DestPoint));
                            if (allTasks != null && allTasks.Count >= MushinyManager.OutEquipMaxOutCnt * outEqips.Count)
                            {
                                continue;
                            }
                            string flag = $"{containerCode}-{posname}";
                            var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                            if (task == null)
                            {
                                task = new RobotTask()
                                {
                                    TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                    TaskName = taskname,
                                    CreateTime = DateTime.Now,
                                    RobotType = Id,
                                    TaskFlag = flag,
                                    TaskState = RobotTaskState.已生成,
                                    SrcPoint = posname,
                                    DestPoint = item.name,
                                    TaskType = RobotTaskType.Outstore,
                                    ContainerCode = containerCode,
                                    NeedReAssignTarget = true,
                                    Priority = outLetTask.priority,
                                };
                                //UpdateLocInfo(task, TaskStatus.EXECUTING);
                                LogUtil.info($"创建出库任务,目的地暂定类型[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outLetTask)}");
                                AddTask(task);
                            }
                        }

                        // continue;
                    }
                }

                foreach (var outTask in outTasks)
                {
                    string posname = outTask.fromLoc;
                    string target = outTask.toLoc;
                    string containerCode = outTask.boxCode;

                    if (!ctuBean.CheckPosExist(posname))
                    {
                        sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的货架号【{posname}】，请检查");
                        continue;
                    }
                    if (Setting_Init.In_FeedingInlet.Equals(target))
                    {
                        taskname = outTask.id;
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                NeedReAssignTarget = true,
                                Priority = outTask.priority,
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建任务 出库任务[[{JsonHelper.SerializeObject(task)}]],目的地暂定：{JsonHelper.SerializeObject(outTask)}");
                            AddTask(task);
                        }
                        continue;
                    }
                    else if (Setting_Init.Out_FeedingInlet.Equals(target))
                    {
                        continue;
                    }
                    else if (Setting_Init.Manual_FeedingInlet.Equals(target))
                    {
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                NeedReAssignTarget = true,
                                Priority = outTask.priority,
                                TaskGroup = RobotTaskGroup.Finished_ManualLine,
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建出库任务,手动线[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outTask)}");
                            AddTask(task);
                        }

                        continue;
                    }
                    List<ClientNode> enters = null;
                    enters = lst.FindAll(s => s.name.Equals(target) && s.status == AGVLib.NodeStatus.NeedEnter);
                    if (enters == null || enters.Count == 0)
                    {
                        //这里需优化，使得分配的箱子均匀到各分拣机构
                        if (target.Equals(Setting_Init.In_FeedingInlet))
                        {
                            enters = lst.FindAll(s => s.name.StartsWith("In") && s.status == AGVLib.NodeStatus.NeedEnter);
                        }
                        else if (target.Equals(Setting_Init.Out_FeedingInlet))
                        {
                            enters = lst.FindAll(s => s.name.StartsWith("Out") && s.status == AGVLib.NodeStatus.NeedEnter);
                        }
                    }

                    if (enters == null || enters.Count == 0) continue;

                    foreach (var needenter in enters)
                    {
                        target = needenter.name;
                        if (lst.Find(s => s.name.Equals(target)) == null)
                        {
                            LogUtil.debug($"【{Name}】不存在的出入料机构名[{target}]，请检查");
                            sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的出入料机构名[{target}]，请检查");
                            continue;
                        }
                        taskname = outTask.id;
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));//               &&          && s.TaskFlag.Equals(flag)

                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                Priority = outTask.priority,
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建任务 出库任务[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outTask)}");
                            AddTask(task);
                        }

                    }

                }

            }
        }
        void checkOutstore_new(List<ClientNode> lst, string taskname)
        {
            List<FinishedCtuTask> outTasks = null;
            if (ConfigAppSettings.simulationMode)
            {
                outTasks = new List<FinishedCtuTask>
                    {
                        new FinishedCtuTask()
                        {
                             boxCode=ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_Barcode", "C0700"),
                             toLoc = ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_OutLoc", "In1_FeedingInlet"),
                             fromLoc =ConfigAppSettings.GetValue(Setting_Init.simulationMode + "_Finished_OutPosname", "W000001R01000153")
                        } };
            }
            else
            {
                outTasks = SMFManager.GetAllShelfToLineTasks(Name, ServerBase);
            }


            if (outTasks != null && outTasks.Count > 0)
            {
                checkOutEquipOustore(lst, outTasks);
                outTasks.Sort((a, b) => { return b.priority - a.priority; });
                foreach (var outTask in outTasks)
                {
                    string posname = outTask.fromLoc;
                    string target = outTask.toLoc;
                    string containerCode = outTask.boxCode;

                    if (!ctuBean.CheckPosExist(posname))
                    {
                        sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的货架号【{posname}】，请检查");
                        continue;
                    }
                    if (Setting_Init.In_FeedingInlet.Equals(target))
                    {
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                NeedReAssignTarget = true,
                                TaskGroup = RobotTaskGroup.Finished_InEquip,
                                Priority = outTask.priority,
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建任务 出库任务 入料机构[{JsonHelper.SerializeObject(task)}]],目的地暂定：{JsonHelper.SerializeObject(outTask)}");
                            AddTask(task);
                        }
                        continue;
                    }
                    else if (Setting_Init.Out_FeedingInlet.Equals(target))
                    {
                        continue;
                    }
                    else if (Setting_Init.Manual_FeedingInlet.Equals(target) || Setting_Init.rawLine_in.Equals(target))
                    {
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                NeedReAssignTarget = true,
                                Priority = outTask.priority,
                                TaskGroup = RobotTaskGroup.Finished_ManualLine
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建出库任务,手动线[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outTask)}");
                            AddTask(task);
                        }

                        continue;
                    }
                    List<ClientNode> enters = null;
                    enters = lst.FindAll(s => s.name.Equals(target) && s.status == AGVLib.NodeStatus.NeedEnter);
                    if (enters == null || enters.Count == 0)
                    {
                        //这里需优化，使得分配的箱子均匀到各分拣机构
                        if (target.Equals(Setting_Init.In_FeedingInlet))
                        {
                            enters = lst.FindAll(s => s.name.StartsWith("In") && s.name.EndsWith("FeedingInlet"));
                        }
                    }

                    if (enters == null || enters.Count == 0) continue;

                    foreach (var needenter in enters)
                    {
                        if (lst.Find(s => s.name.Equals(target)) == null)
                        {
                            LogUtil.debug($"【{Name}】不存在的出入料机构名[{target}]，请检查");
                            sbWarnMsgDetails.AppendLine($"【{Name}】无法创建任务。 不存在的出入料机构名[{target}]，请检查");
                            continue;
                        }
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));//               &&          && s.TaskFlag.Equals(flag)

                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                Priority = outTask.priority,
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建任务 出库任务[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outTask)}");
                            AddTask(task);
                        }

                    }

                }

            }
        }
        /// <summary>
        /// 创建出料机构-出库任务
        /// </summary>
        /// <param name="lst"></param>
        /// <param name="outTasks"></param>
        void checkOutEquipOustore(List<ClientNode> lst, List<FinishedCtuTask> outTasks)
        {
            bool enableOutEquipOutstore = ConfigAppSettings.GetValue($"Enable_GetOutEquipOutstore", true);
            if (!enableOutEquipOutstore) return;
            #region 出料机构-出库任务创建逻辑
            //筛选未接的出库任务
            var outLetTasks = outTasks.FindAll(s => Setting_Init.Out_FeedingInlet.Equals(s.toLoc) && (robotTasks.Find(ss => s.boxCode.Equals(ss.ContainerCode)) == null));
            if (outLetTasks != null && outLetTasks.Count > 0)
            {
                //工单出到手动线
                if (MushinyManager.OutEquipStoreSwitchToManualLine)
                {
                    foreach (var item in outLetTasks)
                    {
                        int switchMaxCnt = ConfigAppSettings.GetValue($"OutEquipOutstoreSwitchManualMaxCnt", 30);
                        var waitGetTasks = robotTasks.FindAll(s => s.TaskGroup == RobotTaskGroup.Finished_ManualLine && s.TaskState < RobotTaskState.已分配车);
                        if (waitGetTasks != null && waitGetTasks.Count > switchMaxCnt)
                        {
                            return;
                        }
                        var containerCode = item.boxCode;
                        var posname = item.fromLoc;
                        var shelve = ctuBean.GetPosInfoByName(posname);
                        if (shelve != null)
                        {
                            if (shelve.Row < MushinyManager.OutEquipOutStoreMinRow)
                            {
                                continue;
                            }
                        }
                        var taskname = item.id;
                        var target = Setting_Init.rawLine_in;
                        string flag = $"{containerCode}-{posname}";
                        var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                        if (task == null)
                        {
                            task = new RobotTask()
                            {
                                TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                                TaskName = taskname,
                                CreateTime = DateTime.Now,
                                RobotType = Id,
                                TaskFlag = flag,
                                TaskState = RobotTaskState.已生成,
                                SrcPoint = posname,
                                DestPoint = target,
                                TaskType = RobotTaskType.Outstore,
                                ContainerCode = containerCode,
                                NeedReAssignTarget = true,
                                Priority = item.priority,
                                TaskGroup = RobotTaskGroup.Finished_ManualLine
                            };
                            //UpdateLocInfo(task, TaskStatus.EXECUTING);
                            LogUtil.info($"创建出库任务,工单切为手动线[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(item)}");
                            AddTask(task);
                        }
                    }
                    return;
                }

                //出库任务
                var finishedOutTasks = new List<finishedOutTask>();

                foreach (var outTask in outLetTasks)
                {
                    finishedOutTasks.Add(new finishedOutTask(outTask, ctuBean.GetPosInfoByName(outTask.fromLoc)));
                }
                //将出库任务根据巷道分组
                var lanePos = finishedOutTasks.GroupBy(s => s.PosInfo.Lanway);

                //找出所有出料机构
                var outEqips = lst.FindAll(s => s.opened && s.name.StartsWith("outLine") && s.name.EndsWith("in"));//s.name.StartsWith("Out") && s.name.EndsWith("FeedingInlet")
                string equipName = "";
                bool enable_OutEquipUseNewLogic = ConfigAppSettings.GetValue("Enable_OutEquipUseNewLogic", true);
                if (enable_OutEquipUseNewLogic)
                {
                    #region 新逻辑 待修改
                    foreach (var equip in outEqips)
                    {
                        if (!equip.opened) continue;

                        //var ctuScope = MushinyManager.GetScopeByEquipName(equipName);
                        //该机构任务占用的巷道
                        List<string> equipLanes = new List<string>();
                        var allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && equip.name.Equals(s.DestPoint)
                          && s.TaskState < RobotTaskState.已分配车);
                        if (allTasks != null && allTasks.Count > 0)
                        {
                            allTasks.ForEach(s =>
                            {
                                var pos = ctuBean.GetPosInfoByName(s.SrcPoint);
                                if (!equipLanes.Contains(pos.Lanway))
                                {
                                    equipLanes.Add(pos.Lanway);
                                }
                            });
                        }

                        //查看当前机构出库的巷道，查找是否有剩余可接的任务
                        var outEquipTask = robotTasks.Find(s => s.TaskType == RobotTaskType.Outstore && equipName.Equals(s.DestPoint));
                        bool hasSameLaneTasks = false;
                        string sameLaneCode = "";
                        if (outEquipTask != null)//已有任务，先找同巷道，再找不同巷道
                        {
                            var posInfo = ctuBean.GetPosInfoByName(outEquipTask.SrcPoint);
                            foreach (var lane in lanePos)
                            {
                                string laneCode = lane.Key;
                                if (laneCode == posInfo.Lanway)
                                {
                                    sameLaneCode = laneCode;
                                    hasSameLaneTasks = true;
                                    break;
                                }
                            }
                        }
                        else //没有该点任务
                        {

                        }

                        if (equipLanes != null && equipLanes.Count > 0)//其他巷道有ctu占用
                        {
                            foreach (var lane in lanePos)
                            {
                                string laneCode = lane.Key;
                                if (!equipLanes.Contains(laneCode))//其他机构的ctu未占用该巷道，使用该巷道
                                {
                                    sameLaneCode = laneCode;
                                    hasSameLaneTasks = true;
                                }
                            }
                        }
                        foreach (var lane in lanePos)
                        {
                            var outs = lane.ToList();
                            string laneCode = lane.Key;
                            if (hasSameLaneTasks)//有相同巷道的任务，则找该巷道
                            {
                                if (laneCode != sameLaneCode)
                                {
                                    continue;
                                }
                            }
                            //检查该分拣出库机构所负责的巷道
                            //if (ctuScope != null)
                            //{
                            //    if (!ctuScope.LaneCodes.Contains(laneCode))
                            //    {
                            //        continue;
                            //    }
                            //}
                            createOutEquipOutStores(lst, outs, equipName);

                        }
                    }
                    #endregion
                }
                else //旧逻辑
                {
                    #region 出料旧逻辑
                    foreach (var equip in outEqips)
                    {
                        if (!equip.opened) continue;
                        var allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && equip.name.Equals(s.DestPoint)
                         && s.TaskState < RobotTaskState.已分配车);
                        if (allTasks != null)
                        {
                            if (allTasks.Count >= MushinyManager.OutEquipMaxOutCnt)//* outEqips.Count
                            {
                                continue;
                            }
                            else if (allTasks.Count <= 0)
                            {

                            }
                            else //检查其他机构是否有任务，避免数量不足，其他机构无任务
                            {
                                allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && !equip.name.Equals(s.DestPoint) && s.TaskState < RobotTaskState.已分配车);
                                if (allTasks == null || allTasks.Count == 0)
                                {
                                    continue;
                                }
                            }
                        }

                        equipName = equip.name;
                        break;
                    }

                    if (string.IsNullOrEmpty(equipName))//没有机构可接
                    {

                    }
                    else //有机构需要料箱
                    {
                        //其他ctu占用的巷道
                        List<string> equipLanes = new List<string>();
                        foreach (var equip in outEqips)
                        {
                            if (equip.name.Equals(equipName)) continue;
                            var allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && equip.name.Equals(s.DestPoint));
                            if (allTasks != null && allTasks.Count > 0)
                            {
                                allTasks.ForEach(s =>
                                {
                                    var pos = ctuBean.GetPosInfoByName(s.SrcPoint);
                                    if (!equipLanes.Contains(pos.Lanway))
                                    {
                                        equipLanes.Add(pos.Lanway);
                                    }
                                });
                            }
                        }

                        //查看当前机构出库的巷道，查找是否有剩余可接的任务
                        var outEquipTask = robotTasks.Find(s => s.TaskType == RobotTaskType.Outstore && equipName.Equals(s.DestPoint));
                        bool hasSameLaneTasks = false;
                        string sameLaneCode = "";
                        if (outEquipTask != null)//已有任务，先找同巷道，再找不同巷道
                        {
                            var posInfo = ctuBean.GetPosInfoByName(outEquipTask.SrcPoint);
                            foreach (var lane in lanePos)
                            {
                                string laneCode = lane.Key;
                                if (laneCode == posInfo.Lanway)
                                {
                                    sameLaneCode = laneCode;
                                    hasSameLaneTasks = true;
                                    break;
                                }
                            }
                        }
                        else //没有该点任务
                        {

                        }

                        if (equipLanes != null && equipLanes.Count > 0)//其他巷道有ctu占用
                        {
                            foreach (var lane in lanePos)
                            {
                                string laneCode = lane.Key;
                                if (!equipLanes.Contains(laneCode))//其他机构的ctu未占用该巷道，使用该巷道
                                {
                                    sameLaneCode = laneCode;
                                    hasSameLaneTasks = true;
                                }
                            }
                        }
                        foreach (var lane in lanePos)
                        {
                            var outs = lane.ToList();
                            string laneCode = lane.Key;
                            if (hasSameLaneTasks)//有相同巷道的任务，则找该巷道
                            {
                                if (laneCode != sameLaneCode)
                                {
                                    continue;
                                }
                            }
                            createOutEquipOutStores(lst, outs, equipName);
                        }
                    }
                    #endregion
                }

            }
            #endregion
        }

        /// <summary>
        /// 入料机构出库任务检查并创建
        /// </summary>
        /// <param name="outTasks"></param>
        void checkInEquipOustore(List<InletOutBox> outTasks)
        {
            #region 入料机构-出库任务创建逻辑
            //筛选未接的出库任务
            var outLetTasks = outTasks.FindAll(s => (robotTasks.Find(ss => s.box.Equals(ss.ContainerCode)) == null));
            if (outLetTasks != null && outLetTasks.Count > 0)
            {
                //出库任务
                var finishedOutTasks = new List<finishedOutEmptyBoxTask>();

                var wareCodes = ConfigAppSettings.GetValue("WarehouseCodes", new string[] { "W10B" });

                foreach (var outTask in outLetTasks)
                {
                    if (wareCodes.Contains(outTask.warehouseCode))
                        finishedOutTasks.Add(new finishedOutEmptyBoxTask(outTask, ctuBean.GetPosInfoByName(outTask.posName)));
                }
                //将出库任务根据巷道分组
                var lanePos = finishedOutTasks.GroupBy(s => s.PosInfo.Lanway);

                //查询所有入料待机点
                var inletStands = MushinyManager.GetInletCtuStands(Setting_Init.In_FeedingInlet);



                foreach (var inlet in inletStands)
                {
                    //已使用的巷道
                    List<string> equipLanes = new List<string>();
                    var allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && s.TaskGroup == RobotTaskGroup.Finished_InEquip
                    && s.TaskState >= RobotTaskState.已分配车);
                    if (allTasks != null && allTasks.Count > 0)
                    {
                        allTasks.ForEach(s =>
                        {
                            var pos = ctuBean.GetPosInfoByName(s.SrcPoint);
                            if (!equipLanes.Contains(pos.Lanway))
                            {
                                equipLanes.Add(pos.Lanway);
                            }
                        });
                    }
                    bool hasLeftLaneTasks = false;
                    string sameLanCode = "";
                    List<finishedOutEmptyBoxTask> waitCreateTasks = null;
                    //foreach (var lane in lanePos)
                    //{
                    //    var outs = lane.ToList();
                    //    string laneCode = lane.Key;
                    //    if (!inlet.LaneWays.Contains(laneCode))
                    //    {
                    //        continue;
                    //    }
                    //    if (equipLanes.Contains(laneCode))
                    //    {
                    //        if (inlet.BoxTypes == null || inlet.BoxTypes.Count == 0)
                    //        {
                    //            hasLeftLaneTasks = true;
                    //            sameLanCode = laneCode;
                    //            waitCreateTasks = lane.ToList();
                    //        }
                    //        else
                    //        {
                    //            bool containsAllTypes = true;
                    //            foreach (var item in inlet.BoxTypes)
                    //            {
                    //                var tasks = lane.ToList();
                    //                var find = tasks?.Find(s => s.OutTask.box.StartsWith(item));
                    //                if (find == null)
                    //                {
                    //                    containsAllTypes = false;
                    //                }
                    //            }
                    //            if (containsAllTypes)
                    //            {
                    //                hasLeftLaneTasks = true;
                    //                sameLanCode = laneCode;
                    //                waitCreateTasks = lane.ToList();
                    //            }
                    //        }
                    //    }
                    //}

                    //if (hasLeftLaneTasks)
                    //{
                    //    createInEquipOutStores(inlet, waitCreateTasks);
                    //}
                    //else
                    {
                        foreach (var lane in lanePos)
                        {
                            var outs = lane.ToList();
                            string laneCode = lane.Key;
                            if (inlet.LaneWays.Contains(laneCode))
                                createInEquipOutStores(inlet, outs);
                        }
                    }

                }
            }
            #endregion
        }
        //void checkInEquipOustore(List<ClientNode> lst, List<FinishedCtuTask> outTasks)
        //{
        //    #region 入料机构-出库任务创建逻辑
        //    //筛选未接的出库任务
        //    var outLetTasks = outTasks.FindAll(s => (robotTasks.Find(ss => s.boxCode.Equals(ss.ContainerCode)) == null));
        //    if (outLetTasks != null && outLetTasks.Count > 0)
        //    {
        //        //出库任务
        //        var finishedOutTasks = new List<finishedOutTask>();

        //        foreach (var outTask in outLetTasks)
        //        {
        //            finishedOutTasks.Add(new finishedOutTask(outTask, ctuBean.GetPosInfoByName(outTask.fromLoc)));
        //        }
        //        //将出库任务根据巷道分组
        //        var lanePos = finishedOutTasks.GroupBy(s => s.PosInfo.Lanway);

        //        //查询所有入料待机点
        //        var inletStands = MushinyManager.GetInletCtuStands(Setting_Init.In_FeedingInlet);
        //        foreach (var inlet in inletStands)
        //        {
        //            //已使用的巷道
        //            List<string> equipLanes = new List<string>();
        //            var allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && s.TaskGroup == RobotTaskGroup.Finished_InEquip
        //            && s.TaskState >= RobotTaskState.已分配车);
        //            if (allTasks != null && allTasks.Count > 0)
        //            {
        //                allTasks.ForEach(s =>
        //                {
        //                    var pos = ctuBean.GetPosInfoByName(s.SrcPoint);
        //                    if (!equipLanes.Contains(pos.Lanway))
        //                    {
        //                        equipLanes.Add(pos.Lanway);
        //                    }
        //                });
        //            }
        //            bool hasLeftLaneTasks = false;
        //            string sameLanCode = "";
        //            List<finishedOutTask> waitCreateTasks = null;
        //            foreach (var lane in lanePos)
        //            {
        //                var outs = lane.ToList();
        //                string laneCode = lane.Key;
        //                if (!inlet.LaneWays.Contains(laneCode))
        //                {
        //                    continue;
        //                }
        //                if (equipLanes.Contains(laneCode))
        //                {
        //                    hasLeftLaneTasks = true;
        //                    sameLanCode = laneCode;
        //                    waitCreateTasks = lane.ToList();
        //                }
        //            }

        //            if (hasLeftLaneTasks)
        //            {
        //                createInEquipOutStores(inlet, waitCreateTasks);
        //            }
        //            else
        //            {
        //                foreach (var lane in lanePos)
        //                {
        //                    var outs = lane.ToList();
        //                    string laneCode = lane.Key;
        //                    if (inlet.LaneWays.Contains(laneCode))
        //                        createInEquipOutStores(inlet, outs);
        //                }
        //            }

        //        }



        //    }
        //    #endregion
        //}
        /// <summary>
        /// 创建出料机构出库任务
        /// </summary>
        /// <param name="outs"></param>
        /// <param name="equipName"></param>
        void createOutEquipOutStores(List<ClientNode> lst, List<finishedOutTask> outs, string equipName)
        {
            foreach (var outLetTask in outs)
            {
                string posname = outLetTask.OutTask.fromLoc;
                string target = outLetTask.OutTask.toLoc;
                string containerCode = outLetTask.OutTask.boxCode;
                string taskname = outLetTask.BoxType;
                //找出该机构的所有出库任务
                var allTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore && equipName.Equals(s.DestPoint)
                && s.TaskState < RobotTaskState.已分配车);
                // var outEqips = lst.FindAll(s => s.name.StartsWith("outLine") && s.name.EndsWith("in"));
                if (allTasks != null && allTasks.Count >= MushinyManager.OutEquipMaxOutCnt)//超过数量，不接
                {
                    return;
                }

                //var sameBoxTasks = allTasks.FindAll(s => taskname.Equals(s.TaskName) && equipName.Equals(s.DestPoint));
                //if (sameBoxTasks != null && sameBoxTasks.Count >= MushinyManager.OutEquipMaxOutCnt)//已经存在指定个数该类型
                //{
                //    continue;
                //}
                string flag = $"{containerCode}-{posname}";
                var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                var shelve = ctuBean.GetPosInfoByName(posname);
                if (shelve != null)
                {
                    if (shelve.Row < MushinyManager.OutEquipOutStoreMinRow)
                    {
                        continue;
                    }
                }
                //强制指定大料为出料机构1
                if (equipName.Equals("outLine01_in") || equipName.Equals("Out1_FeedingInlet"))
                {
                    if (containerCode.StartsWith("C13") || containerCode.StartsWith("C15"))
                    {
                        equipName = "outLine01_in";
                    }
                    else
                    {
                        continue;
                    }
                }
                else
                {
                    if (containerCode.StartsWith("C13") || containerCode.StartsWith("C15"))
                    {
                        equipName = "outLine01_in";
                    }

                }
                if (task == null)
                {
                    task = new RobotTask()
                    {
                        TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                        TaskName = taskname,
                        CreateTime = DateTime.Now,
                        RobotType = Id,
                        TaskFlag = flag,
                        TaskState = RobotTaskState.已生成,
                        SrcPoint = posname,
                        DestPoint = equipName,
                        TaskType = RobotTaskType.Outstore,
                        ContainerCode = containerCode,
                        NeedReAssignTarget = true,
                        Priority = outLetTask.Priority,
                        TaskGroup = RobotTaskGroup.Finished_OutEquip,
                        A = outLetTask.A,
                        B = outLetTask.B,
                        C = outLetTask.C,
                        Remark = $"{outLetTask.A}-{outLetTask.B}-{outLetTask.C}"
                    };
                    //UpdateLocInfo(task, TaskStatus.EXECUTING);
                    LogUtil.info($"创建任务 出库任务 出料机构[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outLetTask)}");
                    AddTask(task);
                }

                // continue;
            }
        }
        int inletOutStoreMaxCnt { get { return ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "InLetOutStoreMaxCnt", 2); } }
        /// <summary>
        /// 创建入料机构出库任务-新逻辑
        /// </summary>
        /// <param name="lst"></param>
        /// <param name="outs"></param>
        /// <param name="equipName"></param>
        void createInEquipOutStores(CtuStandby ctuStandby, List<finishedOutEmptyBoxTask> outs)
        {
            if (outs == null || outs.Count == 0) { return; }
            outs.Sort((a, b) => { return b.OutTask.remainNum - a.OutTask.remainNum; });
            foreach (var outLetTask in outs)
            {
                string posname = outLetTask.OutTask.posName;
                string target = Setting_Init.In_FeedingInlet;
                string containerCode = outLetTask.OutTask.box;
                string taskname = outLetTask.OutTask.warehouseCode;
                string prefixCode = containerCode.Substring(0, 3);
                if (!ctuStandby.BoxTypes.Contains(prefixCode))
                {
                    continue;
                }
                //找出该任务组的所有出库任务
                List<string> boxTypes = ctuStandby.BoxTypes;
                if (boxTypes == null || boxTypes.Count == 0)
                {
                    sbRealtimeMsg.AppendLine($"【{ctuStandby.Name}】未设置料箱尺寸信息，无法创建空箱任务");
                    return;
                }
                int typeCnt = boxTypes.Count;
                bool needCreateNew = true;
                foreach (var item in boxTypes)
                {
                    var allWaitTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore
                        && s.TaskGroup == RobotTaskGroup.Finished_InEquip //&& s.TaskState < RobotTaskState.已分配车
                        && s.ContainerCode.StartsWith(item));

                    if (allWaitTasks != null && allWaitTasks.Count > (inletOutStoreMaxCnt / typeCnt))//超过数量，不接
                    {
                        needCreateNew = false;
                        break;
                    }
                }
                if (!needCreateNew) continue;
                string flag = $"{containerCode}-{posname}";
                var task = robotTasks.Find(s => s.TaskFlag.Equals(flag));
                if (task == null)
                {
                    task = new RobotTask()
                    {
                        TaskId = RobotTask.GenTaskId(flag, RobotTaskType.Outstore.ToString()),
                        TaskName = taskname,
                        CreateTime = DateTime.Now,
                        RobotType = Id,
                        TaskFlag = flag,
                        TaskState = RobotTaskState.已生成,
                        SrcPoint = posname,
                        DestPoint = target,
                        TaskType = RobotTaskType.Outstore,
                        ContainerCode = containerCode,
                        NeedReAssignTarget = true,
                        TaskGroup = RobotTaskGroup.Finished_InEquip,
                        Remark = $"{outLetTask.OutTask.warehouseCode}"
                    };
                    bool enable_InletNewLogic = ConfigAppSettings.GetValue("Enable_InletUseNewLogic", false);
                    if (enable_InletNewLogic)
                    {
                        var allWaitTasks = robotTasks.FindAll(s => s.TaskType == RobotTaskType.Outstore
                         && s.TaskGroup == RobotTaskGroup.Finished_InEquip && s.TaskState < RobotTaskState.已分配车);

                        if (allWaitTasks != null && allWaitTasks.Count > 0)
                        {
                            if (allWaitTasks.Count >= inletOutStoreMaxCnt * MushinyManager.GetInletCtuStands(Setting_Init.In_FeedingInlet)?.Count)
                            {
                                return;
                            }
                        }
                        if (SMFManager.boxCheckOut(ServerBase, containerCode))
                        {
                            AddTask(task);
                            LogUtil.info($"创建任务 出库空箱任务 入料机构[{JsonHelper.SerializeObject(task)}]：{JsonHelper.SerializeObject(outLetTask)}");
                        }
                    }
                }
            }
        }
        public bool AssignAGV(RobotTask createTask)
        {
            return ctuBean.AssignFinishedAGV(createTask);
        }

        #region CTU找任务逻辑
        /// <summary>
        /// ctu找任务
        /// </summary>
        /// <param name="ctu"></param>
        /// <returns></returns>
        public bool AssignTask(CTU ctu)
        {
            var inLetStands = MushinyManager.GetInletCtuStands(Setting_Init.In_FeedingInlet);
            var findInletStand = inLetStands.Find(s => ctu.IP.Equals(s.OccupiedCtu));
            //该ctu是入料机构的
            if (findInletStand != null)
            {
                return assignInletTask(ctu, findInletStand);
            }
            else
            {
                return assignOutletTask(ctu);
            }
        }
        /// <summary>
        /// 给入料机构分ctu
        /// </summary>
        /// <param name="enableCtus"></param>
        void assignInletStand(List<CTU> enableCtus)
        {
            var instores = GetInletInStores();
            var outstores = GetInletOutStores();
            if ((instores != null && instores.Count > 0) || (outstores != null && outstores.Count > 0))
            {
                var onlineCtus = enableCtus.FindAll(s => s.RunState >= RunState.Online && s.CurLandMark != 10001 && s.CurLandMark != 0 && s.SOC >= CTUBean.executeMinPow);
                var inletStands = MushinyManager.GetInletCtuStands(Setting_Init.In_FeedingInlet)?.FindAll(s => !s.IsOccupied());
                if (inletStands != null)
                {
                    foreach (var st in inletStands)
                    {
                        int minDis = int.MaxValue;
                        string minCtu = "";
                        foreach (var item in onlineCtus)
                        {
                            if (ctuBean.CheckCtuHasTask(item)) continue;//已有任务
                            var dst = ctuBean.GetPosInfoByName(st.DstPoint);
                            if (dst == null) continue;
                            var dis = MushinyManager.GetPToPDis(item.CurLandMark, dst.PointCode);
                            if (dis < minDis)
                            {
                                minDis = dis;
                                minCtu = item.IP;
                            }
                        }
                        if (!string.IsNullOrEmpty(minCtu))
                        {
                            st.OccupiedCtu = minCtu;
                            LogUtil.info("给");
                        }

                    }

                }
            }
        }
        /// <summary>
        /// 找入料机构相关任务
        /// </summary>
        /// <param name="ctu"></param>
        /// <returns></returns>
        bool assignInletTask(CTU ctu, CtuStandby ctuStandby)
        {
            if (!ctu.HasEmptyBasket(out byte row))
            {
                return false;
            }
            finishedOutTask needCreate = null;
            var finishedTasks = GetInletOutStores();
            if (finishedTasks != null && finishedTasks.Count > 0)
            {
                //可执行的所有任务
                var fTasks = MushinyManager.FilterExecuteTasksByLanCode(ctu, finishedTasks);

                if (fTasks == null || fTasks.Count == 0) return false;
                var nearEquips = ctuStandby.NearedEquips;
                if (nearEquips != null && nearEquips.Count > 0)
                {
                    foreach (var tasks in fTasks.Values)
                    {
                        //优化--可找出距离当前ctu最近的巷道
                        var includeBoxSizeTasks = MushinyManager.FilterTasksByBoxType(tasks, ctuStandby.BoxTypes);

                        var includedEquipTasks = MushinyManager.FilterTasksByEquipName(includeBoxSizeTasks, nearEquips);

                        if (includedEquipTasks != null && includedEquipTasks.Count > 0)
                        {
                            needCreate = includedEquipTasks[0];
                        }
                    }

                }
                else
                {
                    needCreate = fTasks.Values.ToList()[0][0];
                }
                if (CreateInletOutstore(needCreate, ctu, out RobotTask robotTask))
                {
                    ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                    return true;
                }
            }

            //未分配出库，找入库
            finishedTasks = GetInletInStores();
            if (finishedTasks != null && finishedTasks.Count > 0)
            {
                //可执行的所有任务
                var fTasks = MushinyManager.FilterExecuteTasksByLanCode(ctu, finishedTasks);

                if (fTasks == null || fTasks.Count == 0) return false;
                var nearEquips = ctuStandby.NearedEquips;
                if (nearEquips != null && nearEquips.Count > 0)
                {
                    foreach (var tasks in fTasks.Values)
                    {
                        //优化--可找出距离当前ctu最近的巷道
                        var includeBoxSizeTasks = MushinyManager.FilterTasksByBoxType(tasks, ctuStandby.BoxTypes);

                        var includedEquipTasks = MushinyManager.FilterTasksByEquipName(includeBoxSizeTasks, nearEquips);

                        if (includedEquipTasks != null && includedEquipTasks.Count > 0)
                        {
                            int minDis = int.MaxValue;
                            foreach (var task in includedEquipTasks)
                            {
                                var dstPos = ctuBean.GetPosInfoByName(task.OutTask.fromLoc);
                                if (dstPos == null)
                                {
                                    continue;
                                }
                                var dis = MushinyManager.GetPToPDis(ctu.CurLandMark, dstPos.PointCode);
                                if (dis < minDis)
                                {
                                    needCreate = task;
                                }
                            }
                        }
                    }

                }
                else
                {
                    needCreate = fTasks.Values.ToList()[0][0];
                }
                if (CreateInletInstore(needCreate, ctu, out RobotTask robotTask))
                {
                    ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                    return true;
                }

            }

            return false;
        }
        /// <summary>
        /// 出料机构出库分配巷道
        /// </summary>
        bool planOutEquipOutstoreLancodes(Dictionary<string, List<finishedOutTask>> fTasks)
        {
            try
            {
                var scopes = MushinyManager.GetCtuScopes();
                if (clientNodes == null || clientNodes.Count == 0) { return false; }
                var enabledClientNodes = clientNodes.FindAll(s => s.opened && s.name.StartsWith(Setting_Init.outLine) && s.name.EndsWith(Setting_Init.dir_in));
                if (enabledClientNodes == null || enabledClientNodes.Count == 0)
                {
                    return false;
                }
                //if (!CtuScope.IsAssigned)
                {

                    var lanCodes = fTasks.Keys.ToList();
                    lanCodes.Sort();
                    var nodeCnt = enabledClientNodes.Count;
                    var lanCnts = lanCodes.Count;
                    var difVal = (int)Math.Ceiling(1.0 * lanCnts / nodeCnt);

                    if (scopes != null && scopes.Count > 0)
                    {
                        scopes.ForEach(s => s.LaneCodes.Clear());

                        var curUsingScopes = scopes.FindAll(
                            ss =>
                            {
                                var curNode = enabledClientNodes.Find(s => ss.OutEquipNames.Contains(s.name));
                                if (curNode == null) return false;
                                return true;
                            }
                            );
                        if (curUsingScopes == null || curUsingScopes.Count == 0) return false;
                        var curLanIdx = 0;
                        curUsingScopes.ForEach(scope =>
                        {
                            var maxIdx = curLanIdx + difVal;
                            if (curLanIdx > lanCodes.Count - 1) curLanIdx = lanCodes.Count - 1;
                            if (maxIdx > lanCodes.Count - 1) maxIdx = lanCodes.Count - 1;
                            for (int i = curLanIdx; i <= maxIdx; i++)
                            {
                                scope.LaneCodes.Add(lanCodes[i]);
                            }
                            curLanIdx = maxIdx + 1;
                        });
                        StringBuilder sb = new StringBuilder();
                        enabledClientNodes.ForEach(s => sb.Append($"{s.name},"));
                        LogUtil.info($"出料机构出库巷道分配：【{string.Join(",", lanCodes)}】【{sb.ToString()}】分配的巷道数【{difVal}】【{JsonHelper.SerializeObject(scopes)}】");
                        return true;
                    }


                }
            }
            catch (Exception ex)
            {
                LogUtil.error("出料机构分配巷道异常", ex);
            }
            return false;
        }
        /// <summary>
        /// 找出料机构相关任务,出库分拣机、手动线
        /// </summary>
        /// <param name="ctu"></param>
        /// <returns></returns>
        bool assignOutletTask(CTU ctu)
        {
            if (!ctu.HasEmptyBasket(out byte row))
            {
                return false;
            }
            finishedOutTask needCreate = null;

            //先找出料机构出库
            var finishedTasks = GetOutletOutStores();
            if (finishedTasks != null && finishedTasks.Count > 0)
            {
                //可执行的所有任务
                var fTasks = MushinyManager.FilterExecuteTasksByLanCode(ctu, finishedTasks);

                if (fTasks == null || fTasks.Count == 0) return false;

                //检查是否将工单转为手动线
                if (MushinyManager.OutEquipStoreSwitchToManualLine)
                {
                    needCreate = fTasks.Values.ToList()[0][0];
                    if (CreateManualLineOutstore(needCreate, ctu, out RobotTask robotTask))
                    {
                        ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                        return true;
                    }
                    return false;
                }


                if (!planOutEquipOutstoreLancodes(fTasks))
                    return false;
                var scopes = MushinyManager.GetCtuScopes();

                foreach (var scope in scopes)
                {
                    if (scope.LaneCodes == null || scope.LaneCodes.Count == 0)
                    {
                        if (!string.IsNullOrEmpty(scope.CtuName))
                        {
                            LogUtil.info($"【{scope.ScopeName}】未分配巷道，但存在占用CTU【{scope.CtuName}】,清空当前CTU");
                            scope.CtuName = "";
                        }
                        continue;//未分配巷道
                    }
                    if (!string.IsNullOrEmpty(scope.CtuName))//有车执行该机构任务,不查询
                    {
                        continue;
                    }
                    //查找巷道任务
                    foreach (var fTask in fTasks)
                    {
                        string laneCode = fTask.Key;
                        var waitTasks = fTask.Value;

                        if (scope.LaneCodes.Contains(laneCode))
                        {
                            var includeBoxSizeTasks = MushinyManager.FilterTasksByBoxType(waitTasks, scope.BoxTypes);
                            var includedEquipTasks = MushinyManager.FilterTasksByEquipName(includeBoxSizeTasks, scope.OutEquipNames);
                            if (includedEquipTasks == null || includedEquipTasks.Count == 0) continue;//无可执行任务，不满足尺寸和设备要求

                            //待优化--找最近的巷道任务
                            needCreate = includedEquipTasks[0];
                            break;
                        }

                    }
                    if (CreateOutletOutstore(needCreate, ctu, out RobotTask robotTask))
                    {
                        ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                        return true;
                    }

                }
            }

            //未找到出料机构出库，找入库

            finishedTasks = GetOutletInStores();

            if (finishedTasks != null && finishedTasks.Count > 0)
            {
                //可执行的所有任务
                var fTasks = MushinyManager.FilterExecuteTasksByLanCode(ctu, finishedTasks);

                if (fTasks == null || fTasks.Count == 0) return false;
                //查找巷道任务
                foreach (var fTask in fTasks)
                {
                    string laneCode = fTask.Key;
                    var waitTasks = fTask.Value;
                    var scopes = MushinyManager.GetCtuScopes();
                    foreach (var scope in scopes)
                    {
                        if (!string.IsNullOrEmpty(scope.CtuName)) continue;//有车在执行该机构任务
                        var includedEquipTasks = MushinyManager.FilterTasksByEquipName(waitTasks, scope.OutEquipNames);
                        if (includedEquipTasks == null || includedEquipTasks.Count == 0) continue;//无可执行任务，不满足设备要求

                        //待优化--找最近的巷道任务
                        needCreate = includedEquipTasks[0];
                        break;
                    }
                }
                if (CreateOutletInstore(needCreate, ctu, out RobotTask robotTask))
                {
                    ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                    return true;
                }
            }

            //查询手动线任务
            finishedTasks = GetManualOutStores();
            if (finishedTasks != null && finishedTasks.Count > 0)
            {
                //可执行的所有任务
                var fTasks = MushinyManager.FilterExecuteTasksByLanCode(ctu, finishedTasks);

                if (fTasks == null || fTasks.Count == 0) return false;
                //查找巷道任务
                foreach (var fTask in fTasks)
                {
                    string laneCode = fTask.Key;
                    var waitTasks = fTask.Value;
                    //待优化--找最近的巷道任务
                    needCreate = waitTasks[0];
                }
                if (CreateManualLineOutstore(needCreate, ctu, out RobotTask robotTask))
                {
                    ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                    return true;
                }
            }


            //查询手动线任务
            finishedTasks = GetManualInStores();
            if (finishedTasks != null && finishedTasks.Count > 0)
            {
                //可执行的所有任务
                var fTasks = MushinyManager.FilterExecuteTasksByLanCode(ctu, finishedTasks);

                if (fTasks == null || fTasks.Count == 0) return false;
                //查找巷道任务
                foreach (var fTask in fTasks)
                {
                    string laneCode = fTask.Key;
                    var waitTasks = fTask.Value;
                    //待优化--找最近的巷道任务
                    needCreate = waitTasks[0];
                }
                if (CreateManualLineInstore(needCreate, ctu, out RobotTask robotTask))
                {
                    ctuBean.AddOrUpdateCtuTask(ctu, robotTask, row);
                    return true;
                }
            }
            return false;
        }



        /// <summary>
        /// 原材料-获取所有出库任务
        /// </summary>
        /// <param name="robot"></param>
        /// <returns></returns>
        List<FinishedCtuTask> GetAllShelfToLineTasks()
        {
            return SMFManager.GetAllShelfToLineTasks(Name, ServerBase);
        }
        /// <summary>
        /// 获取所有入库任务
        /// </summary>
        /// <param name="robot"></param>
        /// <returns></returns>
        List<FinishedCtuTask> GetLineToShelfTasks()
        {
            return SMFManager.GetLineToShelfTasks(Name, ServerBase);
        }
        /// <summary>
        /// 获取入料机构所有出库任务
        /// </summary>
        /// <returns></returns>
        public List<FinishedCtuTask> GetInletOutStores()
        {
            return GetAllShelfToLineTasks()?.FindAll(s => (s.toLoc.StartsWith("In")));
        }
        /// <summary>
        /// 获取出料机构所有出库任务
        /// </summary>
        /// <returns></returns>
        public List<FinishedCtuTask> GetOutletOutStores()
        {
            return GetAllShelfToLineTasks()?.FindAll(s => (s.toLoc.StartsWith("Out")));
        }
        /// <summary>
        /// 获取手动线出库任务
        /// </summary>
        /// <returns></returns>
        public List<FinishedCtuTask> GetManualOutStores()
        {
            return GetAllShelfToLineTasks()?.FindAll(s => (s.toLoc.StartsWith(Setting_Init.rawLine_in)));
        }
        /// <summary>
        /// 获取手动线入库任务
        /// </summary>
        /// <returns></returns>
        public List<FinishedCtuTask> GetManualInStores()
        {
            return GetLineToShelfTasks()?.FindAll(s => (s.fromLoc.StartsWith(Setting_Init.rawLine_out)));
        }
        /// <summary>
        /// 获取入料机构所有入库任务
        /// </summary>
        /// <returns></returns>
        public List<FinishedCtuTask> GetInletInStores()
        {
            return GetLineToShelfTasks()?.FindAll(s => (s.fromLoc.StartsWith("In")));
        }
        /// <summary>
        /// 获取出料机构所有入库任务
        /// </summary>
        /// <returns></returns>
        public List<FinishedCtuTask> GetOutletInStores()
        {
            return GetLineToShelfTasks()?.FindAll(s => (s.fromLoc.StartsWith("outLine")));
        }

        #endregion
        public override void UploadAGVState()
        {
            try
            {
                if ((DateTime.Now - uploadTime).TotalSeconds > 5)
                {
                    var ctus = ctuBean.GetCTUs();
                    if (ctus != null)
                    {
                        RobotStatus = new List<RobotStatus>();
                        foreach (var item in ctus)
                        {
                            bool cargo = item.Baskets.Find(s => !string.IsNullOrEmpty(s.TaskId)) != null;
                            var point = ctuBean.GetPointCode(item.CurLandMark);
                            RobotStatus status = new RobotStatus()
                            {
                                Cargo = cargo,
                                X = point?.X ?? 0,
                                Y = point?.Y ?? 0,
                                Power = item.SOC,
                                Name = $"{item.Name}",
                                Theta = item.CurDir,
                                Data = item,
                                Loc = $"{item.CurLandMark}",
                                Enabled = item.Enabled,
                                RunState = item.RunState,
                            };
                            if (item.FaultInfo?.HasFault ?? false)
                            {
                               
                            }
                            RobotStatus.Add(status);
                        }
                        base.UploadAGVState();
                    }
                    uploadTime = DateTime.Now;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error($"UploadAGVState error【{Name}】:", ex);
            }

        }


        DateTime uploadTime = DateTime.Now;
    }
    public class finishedOutTask
    {
        public finishedOutTask(FinishedCtuTask finishedCtuTask, PosInfo posInfo)
        {
            OutTask = finishedCtuTask;
            PosInfo = posInfo;
            if (OutTask != null && OutTask.outCount != null && OutTask.outCount.Count > 0)
            {
                foreach (var item in OutTask.outCount)
                {
                    string key = item.Key;
                    string[] tmp1 = key.Split('-');
                    if (tmp1 != null && tmp1.Length == 2)
                    {
                        if (outCount.ContainsKey(tmp1[1]))
                        {
                            outCount[tmp1[1]] = item.Value;
                        }
                    }
                }
            }
        }
        //  "C0700379-06": 1
        Dictionary<string, int> outCount = new Dictionary<string, int>()
            {
                {"01",0 },
                {"02",0 },
                {"03",0 },
                {"04",0 },
                {"05",0 },
                {"06",0 }
            };
        public FinishedCtuTask OutTask { get; set; }

        public PosInfo PosInfo { get; set; }

        public int Priority
        {
            get
            {
                //if (BoxType.Equals(type_Common))
                //{
                //    return 0;
                //}
                //else if (BoxType.Equals(type_MaxA))
                //{
                //    return 600 + A;
                //}
                //else if (BoxType.Equals(type_MaxB))
                //{
                //    return 200 + B;
                //}
                //else if (BoxType.Equals(type_MaxC))
                //{
                //    return 400 + C;
                //}
                //else if (BoxType.Equals(type_MinA))
                //{
                //    return 100 + A;
                //}
                //else if (BoxType.Equals(type_MinB))
                //{
                //    return 300 + B;
                //}
                //else if (BoxType.Equals(type_MinC))
                //{
                //    return 100 + C;
                //}
                return A + B + C;
            }
        }

        /// <summary>
        /// 格口剩余数量=1+2
        /// </summary>
        public int A { get { return outCount["01"] + outCount["02"]; } }
        /// <summary>
        /// 格口剩余数量=3+4
        /// </summary>
        public int B { get { return outCount["03"] + outCount["04"]; } }
        /// <summary>
        /// 格口剩余数量=5+6
        /// </summary>
        public int C { get { return outCount["05"] + outCount["06"]; } }
        /// <summary>
        /// 箱子类型-哪个格口数量信息
        /// </summary>
        public string BoxType
        {
            get
            {
                if (A > B && A > C)
                {
                    return type_MaxA;
                }
                else if (B > A && B > C)
                {
                    return type_MaxB;
                }
                else if (C > A && C > B)
                {
                    return type_MaxC;
                }
                else if (A < B && A < C)
                {
                    return type_MinA;
                }
                else if (B < A && B < C)
                {
                    return type_MinB;
                }
                else if (C < A && C < B)
                {
                    return type_MinC;
                }
                return type_Common;
            }
        }
        public const string type_Common = "Common";
        public const string type_MinA = "MinA";
        public const string type_MinB = "MinB";
        public const string type_MinC = "MinC";
        public const string type_MaxA = "MaxA";
        public const string type_MaxB = "MaxB";
        public const string type_MaxC = "MaxC";
    }



    class finishedOutEmptyBoxTask
    {
        public finishedOutEmptyBoxTask(InletOutBox finishedCtuTask, PosInfo posInfo)
        {
            OutTask = finishedCtuTask;
            PosInfo = posInfo;
        }
        public InletOutBox OutTask { get; set; }

        public PosInfo PosInfo { get; set; }
    }
}