using AGVLib;
using CtuDeviceLib.model;
using Mushiny;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.UI;
using System.Windows.Forms;

namespace CtuDeviceLib
{
    public class MushinyManager
    {
        public static string WarnMsgSummary = "";
        public static string WarnMsgDetails = "";
        static string appPath = System.Windows.Forms.Application.StartupPath;
        public static string FinishedCTUName = "原材料运输";
        public static string SemiFinishedCTUName = "半成品运输";
        /// <summary>
        /// 出料机构工单出库执行的最低层数
        /// </summary>
        public static int OutEquipOutStoreMinRow = 1;
        /// <summary>
        /// 出料机构工单任务切换到手动线
        /// </summary>

        public static bool OutEquipStoreSwitchToManualLine = false;
        /// <summary>
        /// 出料机构手动线切换到工单任务
        /// </summary>
        public static bool OutEquipManualSwitchToOutLine = false;

        /// <summary>
        /// 屏蔽呼叫
        /// </summary>
        public static bool DisableCallAGV = false;
        /// <summary>
        /// 当前机器人类型
        /// 2=半成品
        /// 3=原材料
        /// </summary>
        public static int CurRobotType = ConfigAppSettings.GetValue("CurRobotType", 3);
        /// <summary>
        /// 3=原材料
        /// </summary>
        public static int FinishedCTUIndex = 3;
        /// <summary>
        /// 2=半成品
        /// </summary>
        public static int SemiFinishedCTUIndex = 2;

        /// <summary>
        /// 启用异常ctu转移
        /// </summary>
        public static bool EnableCheckEnabledCtuIsOk { get { return ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "EnableCheckEnabledCtuIsOk", true); } }
        /// <summary>
        /// 异常转移等待时间
        /// </summary>
        public static int TaskTransWaitMinute { get { return ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "TaskTransWaitMinute", 10); } }

        public static int RePlaneWaitSeconds { get { return ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "RePlaneWaitSeconds", 15); } }

        public static bool EnableAutoRePlane { get { return ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "EnableAutoRePlane", false); } }

        public static bool UseBuff { get { return ConfigAppSettings.GetValue("Buff_Enable", false); } }

        /// <summary>
        /// 启用手动出库优先
        /// </summary>
        public static bool EnableManualFirst { get { return ConfigAppSettings.GetValue("Enable_ManualOutstoreFirst", false); } }

        /// <summary>
        /// 出料机构 出库最多数量
        /// </summary>
        public static int OutEquipMaxOutCnt { get { return ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "OutEquipMaxOutCnt", 4); } }
        /// <summary>
        /// 出入库模式--半成品使用
        /// 0=均衡
        /// 1=优先入库
        /// 2=优先出库
        /// </summary>
        public static int InOutMode
        {
            get { return ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "InOutMode", 0); }
            set
            {
                ConfigAppSettings.SaveValue(Mushiny.Common.Mushiny_ + "InOutMode", value);
                LogUtil.info($"设置出入库模式为【{value}】【0=均衡，1=优先入库，2=优先出库】");
            }
        }
        public static string ServerBase
        {
            get
            {
                if (MushinyManager.CurRobotType == MushinyManager.FinishedCTUIndex)
                {
                    return ConfigAppSettings.GetValue(Setting_Init.http_server, "http://10.68.27.83/smf-core/");
                }
                else if (MushinyManager.CurRobotType == MushinyManager.SemiFinishedCTUIndex)
                {
                    return ConfigAppSettings.GetValue(Setting_Init.http_server, "http://10.68.27.86/smf-core/");
                }
                else
                {
                    return ConfigAppSettings.GetValue(Setting_Init.http_server, "http://localhost/smf-core/");
                }
            }
        }
        /// <summary>
        /// 加载配置
        /// </summary>
        public static void Load()
        {
            CTUManager.Init();
            Init();
            loadCtuScopes();
        }

        #region 待机点

        //public static CtuStandby GetIdleCtuStand(List<PathWay> usedPathway)
        //{
        //    if (ctuStandbies == null || ctuStandbies.Count == 0)
        //    {
        //        return ctuStandbies.Find(s => !s.IsOccupied());
        //    }
        //    var usedPoints = ctuBean.GetAllUsedPoint();
        //    foreach (var item in ctuStandbies)
        //    {
        //        if (!string.IsNullOrEmpty(item.StandbyGroup)) continue;//固定待机点，不使用
        //        if (item.IsOccupied()) continue;
        //        if (usedPoints.Contains(item.PointCode)) continue;//待机点被占用，不分配
        //        var find = usedPathway?.Find(s => s.Paths.Contains(item.PointCode));
        //        if (find == null)//当前待机点未被占用
        //        {
        //            return item;
        //        }
        //    }
        //    return null;
        //}

        /// <summary>
        /// 获取其他ctu占用的路线
        /// </summary>
        /// <param name="ctu"></param>
        /// <returns></returns>
        //public static List<PathWay> GetOtherCtuUsedPaths(CTU ctu)
        //{
        //    var usedPathways = new List<PathWay>();
        //    var busyCtus = ctuBean.GetCTUs();
        //    if (busyCtus != null)
        //    {
        //        busyCtus.ForEach(s =>
        //        {
        //            if (ctu.IP.Equals(s.IP))
        //            {

        //            }
        //            else
        //            {
        //                var path = PathWays.GetPathWay(s.CurLandMark);
        //                if (path != null)
        //                {
        //                    usedPathways.Add(path);
        //                }
        //                //当前ctu目的所在路线是否占用
        //                var find = RunningCtuRealtimeInfos.Find(ss => s.IP.Equals(ss.Ctu.IP));
        //                if (find != null && find.DstPosInfo != null)
        //                {
        //                    path = PathWays.GetPathWay(find.DstPosInfo.PointCode);
        //                    if (path != null)
        //                    {
        //                        usedPathways.Add(path);
        //                    }
        //                }
        //            }

        //        });
        //    }
        //    return usedPathways;
        //}







        //    return ctuStandby != null;
        //}



        /// <summary>
        /// 查找路径距离
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="barriers"></param>
        /// <param name="dis"></param>
        /// <returns></returns>
        //public static bool FindPathDis(PointCode start, PointCode end, List<PointCode> barriers, out int dis)
        //{
        //    dis = 0;
        //    if (start == null || end == null) return false;
        //    var startPoint = new AStartPoint(start);
        //    var endPoint = new AStartPoint(end);
        //    List<AStartPoint> barrierPoints = null;
        //    if (barriers != null && barriers.Count > 0)
        //    {
        //        barrierPoints = new List<AStartPoint>();
        //        barriers.ForEach(s =>
        //        {
        //            var asp = new AStartPoint(s);
        //            barrierPoints.Add(asp);
        //        });
        //    }
        //    var rtnPoint = ctuBean.AStart.FindPath(startPoint, endPoint, barrierPoints);
        //    if (rtnPoint == null) return false;
        //    dis = rtnPoint.F;
        //    return true;
        //}
        /// <summary>
        /// 获取起始到目标的点顺序
        /// </summary>
        /// <param name="curCtu"></param>
        /// <param name="src"></param>
        /// <param name="dst"></param>
        /// <param name="pointCodes"></param>
        /// <param name="useBarrier"></param>
        /// <returns></returns>
        //public static bool GetPointsBySrcDst(CTU curCtu, uint src, uint dst, out List<PointCode> pointCodes, bool useBarrier = true)
        //{
        //    return ctuBean.GenPointsBySrcDst(curCtu, src, dst, out pointCodes, useBarrier);
        //}
        ///// <summary>
        ///// 检查是否存在可到达的路线点
        ///// </summary>
        ///// <param name="curCtu"></param>
        ///// <param name="src"></param>
        ///// <param name="dst"></param>
        ///// <param name="useBarrier"></param>
        ///// <returns></returns>
        //public static bool CheckHasPathFromSrcToDst(CTU curCtu, uint src, uint dst, bool useBarrier = true)
        //{
        //    return ctuBean.CheckPointsBySrcDst(curCtu, src, dst, out List<PointCode> pointCodes, useBarrier);
        //}
        /// <summary>
        /// 获取指定待机点组的待机点
        /// </summary>
        /// <param name="standGroup"></param>
        /// <returns></returns>




        /// <summary>
        /// 检查当前地码所在的巷道是否将被使用（已有ctu接任务过来）
        /// </summary>
        /// <param name="pointCode"></param>
        /// <returns></returns>
        //public static bool CheckIsCurLaneWillBeUsed(uint pointCode)
        //{
        //    var find = ctuBean.PosInfos.Find(s => s.PointCode == pointCode);
        //    if (find != null)
        //    {
        //        var lane = find.Lanway;
        //        var allTasks = TaskManager.GetAllTasks();
        //        foreach (var item in allTasks)
        //        {
        //            if (item.TaskState >= RobotTaskState.已分配车)
        //            {
        //                if (item.TaskType == RobotTaskType.Insotre)
        //                {
        //                    var tarname = item.DestPoint;
        //                    var tarInfo = ctuBean.GetPosInfoByName(tarname);
        //                    if (tarInfo.Lanway == lane)
        //                    {
        //                        return true;
        //                    }
        //                }
        //                else if (item.TaskType == RobotTaskType.Outstore)
        //                {
        //                    var tarname = item.SrcPoint;
        //                    var tarInfo = ctuBean.GetPosInfoByName(tarname);
        //                    if (tarInfo.Lanway == lane)
        //                    {
        //                        return true;
        //                    }
        //                }
        //            }

        //        }
        //    }
        //    return false;
        //}
        #endregion

        #region 出料机构区域逻辑
        /// <summary>
        /// 启用出料机构根据区域
        /// </summary>
        public static bool Enable_OutEquipByScope { get { return ConfigAppSettings.GetValue("Enable_OutEquipByScope", false); } }
        /// <summary>
        /// 加载待机点信息
        /// </summary>
        static void loadCtuScopes()
        {
            if (CurRobotType == 2) return;
            {
                var laneways = new List<string>();

                PosInfos.GetAllPosInfos().ForEach(s =>
                {
                    if (s.Lanway.StartsWith("0") || s.Lanway.StartsWith("1"))
                    {

                    }
                    else
                    {
                        if (!laneways.Contains(s.Lanway))
                        {
                            laneways.Add(s.Lanway);
                        }
                    }
                });

                for (int i = 1; i < 7; i++)
                {
                    var outTmp = new CtuScope("outLine0" + i);
                    outTmp.OutEquipNames.Add($"outLine0{i}_in");
                    outTmp.OutEquipNames.Add($"outLine0{i}_out");
                }
                setCtuScopeInfo();
            }
        }
        public static void setCtuScopeInfo()
        {
            // if (CurRobotType == 2) return;
            //ConfigAppSettings.SaveValue(Mushiny.Common.Mushiny_ + "CtuScopes", JsonHelper.SerializeObject(CtuScopes));
        }
        public static CtuScope GetScopeByCtu(string ctuName)
        {
            return GetCtuScopes().Find(s => ctuName.Equals(s.CtuName));
        }
        public static CtuScope GetScopeByEquipName(string equipName)
        {
            return GetCtuScopes().Find(s => s.OutEquipNames.Contains(equipName));
        }
        public static CtuScope GetScopeByLaneCode(string lanCode)
        {
            return GetCtuScopes().Find(s => s.LaneCodes.Contains(lanCode));
        }
        public static List<CtuScope> GetCtuScopes()
        {
            return CtuScope.ctuScopes;
        }
        #endregion


        public static void Init()
        {
            try
            {

                string linefilePath = appPath + $"/CtuService/Config/CSV/CTU/tbl_landmarks.csv";
                LandMarks.Load(linefilePath);

                linefilePath = appPath + $"/CtuService/Config/CSV/CTU/tbl_shelves.csv";
                PosInfos.Load(linefilePath);



                linefilePath = appPath + $"/CtuService/Config/CSV/CTU/tbl_pathways.csv";
                PathWays.Load(linefilePath);
            }
            catch (Exception ex)
            {
                LogUtil.error("加载CTU配置异常", ex);
            }

        }

        /// <summary>
        /// 获取路线的关键点
        /// </summary>
        /// <param name="pathWay">路线</param>
        /// <returns></returns>
        static List<uint> getKeyPointIds(PathWay pathWay, bool isSrc)
        {
            if (pathWay == null || pathWay.Paths == null) return new List<uint>();
            int idx = pathWay.Paths.Count - 1;
            if (pathWay.IsTwoWayLanes)
            {
                return new List<uint> { pathWay.Paths[0], pathWay.Paths[idx] };
            }
            else
            {
                if (isSrc)
                {
                    return new List<uint> { pathWay.Paths[0] };
                }
                else
                {
                    return new List<uint> { pathWay.Paths[idx] };
                }
            }
        }



        /// <summary>
        /// 移动速度
        /// </summary>
        static byte moveSpeed { get { return (byte)ConfigHelper.Config.Get(Mushiny.Common.Mushiny_ + "MoveSpeed", 1); } }
        /// <summary>
        /// 在巷道统一车头朝右（货叉一侧）
        /// </summary>
        static short ctuHeadAngleAtLane = ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "HeadAngleAtLane", (short)270);
        /// <summary>
        /// 是否检查料箱定位码
        /// </summary>
        static bool CheckContainerLocCode { get { return ConfigAppSettings.GetValue(Mushiny.Common.Mushiny_ + "CheckContainerLocCode", false); } }

        #region 生成路径点
        /// <summary>
        /// 是否可以旋转
        /// </summary>
        /// <param name="pointCode"></param>
        /// <returns></returns>
        static bool canXunzhuan(PointCode pointCode)
        {
            if (pointCode.Type == LandmarkType.Turning) return false;
            if (pointCode.Type == LandmarkType.Shelves) return false;
            var codeInPath = PathWays.GetPathWay(pointCode.Id);
            if (codeInPath != null) return false;

            return true;
        }
        /// <summary>
        /// 生成CTU移动的路径点
        /// </summary>
        /// <param name="ctu"></param>
        /// <param name="pointCodes"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenMovePathPoints(CTU ctu, List<PointCode> pointCodes, out List<PathPoint> pathPoints,out string errmsg)
        {
            errmsg = "";
            pathPoints = new List<PathPoint>();
            if (pointCodes == null || pointCodes.Count == 0)
            {
                errmsg = "移动点数量为0";
                return false;
            }
            //ctu最新角度
            var ctuLastDir = ctu.CurDir;
            bool isForkInDown = false;
            //目标点
            var targetPoint = pointCodes.Last();
            if (pointCodes.Count > 2)
            {
                var first = pointCodes[0];

                if (first.Type != LandmarkType.Shelves)//在货架里面不降到最低
                {
                    short upHeight = (short)ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "DefaultUpdownHeight", 250);
                    var preAction = PathPoint.GenReadyToPutToShelves(pointCodes[0].Id, 1, upHeight);
                    pathPoints.Add(preAction);
                    isForkInDown = true;
                }

            }
            if (pointCodes.Count == 1)//当前点就是目标点
            {
                pathPoints.Add(PathPoint.Add(ActionCode.整个路径结束, pointCodes[0].Id, 0, 0));
                return true;
            }
            else if (pointCodes.Count == 2)//移动一个距离
            {
                var firstPoint = pointCodes[0];
                var second = pointCodes[1];
                if (firstPoint.Type == LandmarkType.Turning)
                {
                    var angle = firstPoint.GetAngle(second.Id);
                    var dis = firstPoint.GetDis(second.Id);
                    if (second.Type == LandmarkType.Docking_0)
                    {
                        if (ctuLastDir != 0)
                            pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 0));
                        ctuLastDir = 0;
                    }
                    else if (second.Type == LandmarkType.Docking_90)
                    {
                        if (ctuLastDir != 90)
                            pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 90));
                        ctuLastDir = 90;
                    }
                    else if (second.Type == LandmarkType.Docking_180)
                    {
                        if (ctuLastDir != 180)
                            pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 180));
                        ctuLastDir = 180;
                    }
                    else if (second.Type == LandmarkType.Docking_270)
                    {
                        if (ctuLastDir != 270)
                            pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 270));
                        ctuLastDir = 270;
                    }
                    else
                    {
                        if (ctuLastDir != angle)
                            pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, angle));
                        ctuLastDir = angle;
                    }
                    if (Math.Abs(angle - ctuLastDir) < 90)
                    {
                        pathPoints.Add(PathPoint.GenDirectMove(firstPoint.Id, moveSpeed, dis));
                    }
                    else
                    {
                        pathPoints.Add(PathPoint.GenDirectBackMove(firstPoint.Id, moveSpeed, dis));
                    }
                }

                else if (firstPoint.Type == LandmarkType.Shelves || firstPoint.Type == LandmarkType.Docking_0 || firstPoint.Type == LandmarkType.Docking_90 || firstPoint.Type == LandmarkType.Docking_180 || firstPoint.Type == LandmarkType.Docking_270)
                {
                    var angle = firstPoint.GetAngle(second.Id);
                    var dis = firstPoint.GetDis(second.Id);
                    if (Math.Abs(angle - ctuLastDir) < 90)
                    {
                        pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                    }
                    else
                    {
                        pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                    }
                }
                else //其他点类型
                {
                    var angle = firstPoint.GetAngle(second.Id);
                    var dis = firstPoint.GetDis(second.Id);
                    if (Math.Abs(angle - ctuLastDir) < 90)
                    {
                        pathPoints.Add(PathPoint.GenDirectMove(firstPoint.Id, moveSpeed, dis));
                    }
                    else
                    {
                        pathPoints.Add(PathPoint.GenDirectBackMove(firstPoint.Id, moveSpeed, dis));
                    }
                }
                pathPoints.Add(PathPoint.GenAllPathEnd(second.Id));
                return true;
            }
            else //三个以上
            {

                var firstPoint = pointCodes[0];
                var second = pointCodes[1];
                var lastPoint = pointCodes[pointCodes.Count - 1];
                var angle = firstPoint.GetAngle(second.Id);
                var dis = firstPoint.GetDis(second.Id);
                //最后一个转弯点
                var lastTurnPointCode = pointCodes.FindLast(s => s.CanTurning || s.Type == LandmarkType.Turning);
                if (lastTurnPointCode != null)
                {
                    if (lastTurnPointCode.Id == firstPoint.Id)
                    {
                        if (targetPoint.Type == LandmarkType.Shelves)
                        {
                            //在巷道同一车头朝右（货叉一侧）
                            if (ctuLastDir != ctuHeadAngleAtLane)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, ctuHeadAngleAtLane));
                            ctuLastDir = ctuHeadAngleAtLane;
                            if (Math.Abs(angle - ctuHeadAngleAtLane) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                        }
                        else if (targetPoint.Type == LandmarkType.Docking_0)
                        {
                            if (ctuLastDir != 0)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 0));
                            ctuLastDir = 0;
                            if (Math.Abs(angle - 0) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                        }
                        else if (targetPoint.Type == LandmarkType.Docking_90)
                        {
                            if (ctuLastDir != 90)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 90));
                            ctuLastDir = 90;
                            if (Math.Abs(angle - ctuLastDir) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                        }
                        else if (targetPoint.Type == LandmarkType.Docking_180)
                        {
                            if (ctuLastDir != 180)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 180));
                            ctuLastDir = 180;
                            if (Math.Abs(angle - ctuLastDir) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                        }
                        else if (targetPoint.Type == LandmarkType.Docking_270)
                        {
                            if (ctuLastDir != 270)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, 270));
                            ctuLastDir = 270;
                            if (Math.Abs(angle - ctuLastDir) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                        }
                        else
                        {
                            if (ctuLastDir != angle)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, angle));
                            ctuLastDir = angle;
                            if (Math.Abs(angle - angle) < 90)
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                        }
                    }
                    else
                    {
                        if (firstPoint.CanTurning || firstPoint.Type == LandmarkType.Turning)
                        {
                            if (ctuLastDir != angle)
                                pathPoints.Add(PathPoint.GenTurn(firstPoint.Id, angle));
                            ctuLastDir = angle;
                        }
                        if (Math.Abs(angle - ctuLastDir) < 90)
                        {
                            if (firstPoint.Type == LandmarkType.Shelves)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else if (firstPoint.Type == LandmarkType.Docking_0 ||
               firstPoint.Type == LandmarkType.Docking_90 ||
                  firstPoint.Type == LandmarkType.Docking_180 ||
                     firstPoint.Type == LandmarkType.Docking_270
)
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                                pathPoints.Add(PathPoint.GenDirectMove(firstPoint.Id, moveSpeed, dis));
                        }
                        else
                        {
                            if (firstPoint.Type == LandmarkType.Shelves)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else if (firstPoint.Type == LandmarkType.Docking_0 ||
                                     firstPoint.Type == LandmarkType.Docking_90 ||
                                        firstPoint.Type == LandmarkType.Docking_180 ||
                                           firstPoint.Type == LandmarkType.Docking_270
         )
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectBackMove(firstPoint.Id, moveSpeed, dis));
                            }
                            else
                                pathPoints.Add(PathPoint.GenDirectBackMove(firstPoint.Id, moveSpeed, dis));
                        }
                    }

                    for (int i = 1; i < pointCodes.Count - 1; i++)
                    {
                        var cur = pointCodes[i];
                        var next = pointCodes[i + 1];
                        angle = cur.GetAngle(next.Id);
                        dis = cur.GetDis(next.Id);
                        if (!isForkInDown)
                        {
                            var prePoint = pointCodes[i - 1];
                            if (cur.Type != LandmarkType.Shelves && prePoint.Type != LandmarkType.Shelves)//上一个跟当前都不是货架
                            {
                                short upHeight = (short)ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "DefaultUpdownHeight", 250);
                                var preAction = PathPoint.GenReadyToPutToShelves(cur.Id, 1, upHeight);
                                pathPoints.Add(preAction);
                                isForkInDown = true;
                            }
                        }
                        if (cur.Id == lastTurnPointCode.Id)
                        {
                            if (targetPoint.Type == LandmarkType.Shelves)
                            {
                                //在巷道同一车头朝右（货叉一侧）
                                if (ctuLastDir != ctuHeadAngleAtLane)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, ctuHeadAngleAtLane));
                                ctuLastDir = ctuHeadAngleAtLane;
                                if (Math.Abs(angle - ctuHeadAngleAtLane) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                            else if (targetPoint.Type == LandmarkType.Docking_0)
                            {
                                if (ctuLastDir != 0)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, 0));
                                ctuLastDir = 0;
                                if (Math.Abs(angle - ctuLastDir) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                            else if (targetPoint.Type == LandmarkType.Docking_90)
                            {
                                if (ctuLastDir != 90)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, 90));
                                ctuLastDir = 90;
                                if (Math.Abs(angle - ctuLastDir) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                            else if (targetPoint.Type == LandmarkType.Docking_180)
                            {
                                if (ctuLastDir != 180)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, 180));
                                ctuLastDir = 180;
                                if (Math.Abs(angle - ctuLastDir) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                            else if (targetPoint.Type == LandmarkType.Docking_270)
                            {
                                if (ctuLastDir != 270)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, 270));
                                ctuLastDir = 270;
                                if (Math.Abs(angle - ctuLastDir) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                            else
                            {
                                if (ctuLastDir != angle)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, angle));
                                ctuLastDir = angle;
                                if (Math.Abs(angle - ctuLastDir) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenFollowDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenFollowDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                        }
                        else if (cur.Type == LandmarkType.Turning)
                        {
                            if (next.Type == LandmarkType.Shelves)
                            {
                                //在巷道同一车头朝右（货叉一侧）
                                if (ctuLastDir != ctuHeadAngleAtLane)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, ctuHeadAngleAtLane));
                                ctuLastDir = ctuHeadAngleAtLane;
                                if (Math.Abs(angle - ctuHeadAngleAtLane) < 90)
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                                }
                                else
                                {
                                    pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                                }
                            }
                            else
                            {
                                //不是最后一个转弯点，不需要每个转弯点都转完
                                if (ctuLastDir != angle)
                                    pathPoints.Add(PathPoint.GenTurn(cur.Id, angle));
                                ctuLastDir = angle;
                                pathPoints.Add(PathPoint.GenDirectMove(cur.Id, moveSpeed, dis));
                            }

                        }
                        else if (cur.Type == LandmarkType.Shelves)
                        {
                            //在巷道同一车头朝右（货叉一侧）
                            if (Math.Abs(angle - ctuLastDir) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                            }
                        }
                        else if (cur.Type == LandmarkType.Docking_0 ||
                              cur.Type == LandmarkType.Docking_90 ||
                                 cur.Type == LandmarkType.Docking_180 ||
                                    cur.Type == LandmarkType.Docking_270
                              )
                        {

                            if (Math.Abs(angle - ctuLastDir) < 90)//车头和下一点方向一直
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectMove(cur.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectBackMove(cur.Id, moveSpeed, dis));
                            }
                        }
                        else
                        {
                            if (Math.Abs(angle - ctuLastDir) < 90)//车头和下一点方向一直
                            {
                                pathPoints.Add(PathPoint.GenDirectMove(cur.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenDirectBackMove(cur.Id, moveSpeed, dis));
                            }

                        }
                    }

                }
                else //无转弯点
                {
                    var firstCode = pointCodes[0];
                    if (firstCode.Type == LandmarkType.Shelves)
                    {
                        if (Math.Abs(ctuLastDir - ctuHeadAngleAtLane) >= 90)
                        {
                            List<uint> ps = new List<uint>();
                            pointCodes.ForEach(s => ps.Add(s.Id));
                            errmsg=($"当前路径点[{string.Join("->", ps)}]无转弯点，车头方向[{ctuLastDir}]与[{ctuHeadAngleAtLane}]不同，无法生成路径点");
                            return false;
                        }
                    }
                    else if (
                    firstCode.Type == LandmarkType.Docking_0)
                    {
                        if (Math.Abs(ctuLastDir - 0) >= 90)
                        {
                            List<uint> ps = new List<uint>();
                            pointCodes.ForEach(s => ps.Add(s.Id));
                            errmsg = ($"当前路径点[{string.Join("->", ps)}]无转弯点，车头方向[{ctuLastDir}]与[{ctuHeadAngleAtLane}]不同，无法生成路径点");
                            return false;
                        }
                    }
                    else if (firstCode.Type == LandmarkType.Docking_90)
                    {
                        if (Math.Abs(ctuLastDir - 90) >= 90)
                        {
                            List<uint> ps = new List<uint>();
                            pointCodes.ForEach(s => ps.Add(s.Id));
                            errmsg = ($"当前路径点[{string.Join("->", ps)}]无转弯点，车头方向[{ctuLastDir}]与[{ctuHeadAngleAtLane}]不同，无法生成路径点");
                            return false;
                        }
                    }
                    else if (
                  firstCode.Type == LandmarkType.Docking_180)
                    {
                        if (Math.Abs(ctuLastDir - 180) >= 90)
                        {
                            List<uint> ps = new List<uint>();
                            pointCodes.ForEach(s => ps.Add(s.Id));
                            LogUtil.error($"当前路径点[{string.Join("->", ps)}]无转弯点，车头方向[{ctuLastDir}]与[{ctuHeadAngleAtLane}]不同，无法生成路径点");
                            return false;
                        }
                    }
                    else if (
                     firstCode.Type == LandmarkType.Docking_270)
                    {
                        if (Math.Abs(ctuLastDir - 270) >= 90)
                        {
                            List<uint> ps = new List<uint>();
                            pointCodes.ForEach(s => ps.Add(s.Id));
                            errmsg = ($"当前路径点[{string.Join("->", ps)}]无转弯点，车头方向[{ctuLastDir}]与[{ctuHeadAngleAtLane}]不同，无法生成路径点");
                            return false;
                        }
                    }
                    for (int i = 0; i < pointCodes.Count - 1; i++)
                    {
                        var cur = pointCodes[i];
                        var next = pointCodes[i + 1];
                        angle = cur.GetAngle(next.Id);
                        dis = cur.GetDis(next.Id);
                        //if (cur.Type == LandmarkType.Turning)
                        //{
                        //    if (next.Type == LandmarkType.Shelves)
                        //    {
                        //        //在巷道同一车头朝右（货叉一侧）
                        //        pathPoints.Add(PathPoint.GenTurn(cur.Id, ctuHeadAngleAtLane));
                        //        ctuLastDir = ctuHeadAngleAtLane;
                        //        if (Math.Abs(angle - ctuHeadAngleAtLane) < 90)
                        //        {
                        //            pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                        //        }
                        //        else
                        //        {
                        //            pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                        //        }
                        //    }
                        //    else if (next.Type == LandmarkType.Turning)
                        //    {
                        //        if (Math.Abs(angle - ctuLastDir) < 90)
                        //        {
                        //            pathPoints.Add(PathPoint.GenDirectMove(cur.Id, moveSpeed, dis));
                        //        }
                        //        else
                        //        {
                        //            pathPoints.Add(PathPoint.GenTurn(cur.Id, angle));
                        //            ctuLastDir = angle;
                        //            pathPoints.Add(PathPoint.GenDirectBackMove(cur.Id, moveSpeed, dis));
                        //        }
                        //    }
                        //    else
                        //    {
                        //        pathPoints.Add(PathPoint.GenTurn(cur.Id, angle));
                        //        ctuLastDir = angle;
                        //        pathPoints.Add(PathPoint.GenDirectMove(cur.Id, moveSpeed, dis));
                        //    }

                        //}
                        //else 

                        if (cur.Type == LandmarkType.Shelves)
                        {
                            //在巷道同一车头朝右（货叉一侧）
                            if (Math.Abs(angle - ctuLastDir) < 90)
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectMove(cur.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenChannelDirectBackMove(cur.Id, moveSpeed, dis));
                            }
                        }
                        else if (cur.Type == LandmarkType.Docking_0 ||
                                       cur.Type == LandmarkType.Docking_90 ||
                                          cur.Type == LandmarkType.Docking_180 ||
                                             cur.Type == LandmarkType.Docking_270
                                       )
                        {

                            if (Math.Abs(angle - ctuLastDir) < 90)//车头和下一点方向一直
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectMove(cur.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenFollowDirectBackMove(cur.Id, moveSpeed, dis));
                            }
                        }
                        else
                        {
                            if (Math.Abs(angle - ctuLastDir) < 90)//车头和下一点方向一直
                            {
                                pathPoints.Add(PathPoint.GenDirectMove(cur.Id, moveSpeed, dis));
                            }
                            else
                            {
                                pathPoints.Add(PathPoint.GenDirectBackMove(cur.Id, moveSpeed, dis));
                            }
                        }
                    }
                }
                pathPoints.Add(PathPoint.GenAllPathEnd(lastPoint.Id));
                return true;
            }
        }

        /// <summary>
        ///生成手动从背篓取料箱的路径点
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="row"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenManualGetFromBunkerPathPoints(CTU curCTU, byte row, out List<PathPoint> pathPoints)
        {
            pathPoints = new List<PathPoint>();

            byte[] containerLocateCode = new byte[12];
            var pathPoint1 = PathPoint.GenGetFromBunker(curCTU.CurLandMark, row, containerLocateCode);
            short upHeight = (short)ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "DefaultUpdownHeight", 250);
            var preAction = PathPoint.GenReadyToPutToShelves(curCTU.CurLandMark, 1, upHeight);

            pathPoints.Add(pathPoint1);
            pathPoints.Add(preAction);
            return true;
        }

        /// <summary>
        /// 生成从料架/设备取货->背篓放货
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="boxCode"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenTakePathPoints(CTU curCTU, PosInfo posInfo, string boxCode, out List<PathPoint> pathPoints, out string errmsg, out Basket basket)
        {
            pathPoints = new List<PathPoint>();
            errmsg = "";
            basket = curCTU.GetEnabledBaskets().Find(s => boxCode.Equals(s.BoxCode));
            if (curCTU.CurLandMark != posInfo.PointCode)
            {
                errmsg = ($"【{curCTU.Name}】当前地标【{curCTU.CurLandMark}】与取料的地标【{posInfo.PointCode}】不符,不生成取料任务");
                LogUtil.error(errmsg);
                return false;
            }
            if (basket == null)
            {
                if (!curCTU.HasEmptyBasket(out basket))
                {
                    errmsg = ($"【{curCTU.Name}】无可用背篓，不生成取料任务");
                    LogUtil.error(errmsg);
                    return false;
                }
            }

            string shelfCodeStr = posInfo.ShelveCode;
            byte[] shelfCode = Mushiny.Common.ConvertToBytes(shelfCodeStr, 16);

            var tmpStr = Basket.BoxCodeToLocateCode(boxCode);
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0 + basket.Row);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00 + basket.Row);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }

            short updown = (short)posInfo.UpDownHeight;
            ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            short depth = (short)posInfo.InoutDepth;
            byte dir = (byte)posInfo.Dir;
            var pathPoint1 = PathPoint.GenGetFromShelves(posInfo.PointCode, dir,
                shelfCode, containerLocateCode, updown, scanCodeShift, depth);

            var pathPoint2 = PathPoint.GenPutToBunker(posInfo.PointCode, (byte)basket.Row,
                    containerLocateCode);

            pathPoints.Add(pathPoint1);
            pathPoints.Add(pathPoint2);
            return true;
        }
        /// <summary>
        /// 生成从背篓取货-》往料架放货
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="taskId"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenGetPutPathPoints(CTU curCTU, PosInfo posInfo, string boxCode, out List<PathPoint> pathPoints, out string errmsg)
        {
            pathPoints = new List<PathPoint>();
            errmsg = "";
            if (curCTU.CurLandMark != posInfo.PointCode)
            {
                errmsg = $"【{curCTU.Name}】当前地标【{curCTU.CurLandMark}】与取料的地标【{posInfo.PointCode}】不符,不生成放料任务";
                LogUtil.error(errmsg);
                return false;
            }
            var row = curCTU.GetAllBaskets().Find(s => s.BoxCode == boxCode);
            if (row == null)
            {
                errmsg = ($"【{curCTU.Name}】未在背篓里找到料箱【{boxCode}】,不生成取料任务");
                LogUtil.error(errmsg);
                return false;
            }

            string shelfCodeStr = posInfo.ShelveCode;
            byte[] shelfCode = Mushiny.Common.ConvertToBytes(shelfCodeStr, 16);
            short updown = (short)posInfo.UpDownHeight;
            ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            short depth = (short)posInfo.InoutDepth;
            byte dir = (byte)posInfo.Dir;
            var tmpStr = row.GetLocateCodeByContainerCode();
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0 + row.Row);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00 + row.Row);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }

            var pathPoint1 = PathPoint.GenGetFromBunker(posInfo.PointCode, (byte)row.Row,
                                   containerLocateCode);
            var pathPoint2 = PathPoint.GenPutToShelves(posInfo.PointCode, dir,
                    shelfCode, containerLocateCode, updown, scanCodeShift, depth);

            pathPoints.Add(pathPoint1);
            pathPoints.Add(pathPoint2);

            // pathPoints.Add(PathPoint.Add(ActionCode.整个路径结束, posInfo.PointCode, 0, 0));
            return true;
        }

        /// <summary>
        ///  生成从背篓取货-》准备往料架/设备放货等待
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="boxCode"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenReadyPutPathPoints(CTU curCTU, PosInfo posInfo, string boxCode, out List<PathPoint> pathPoints)
        {
            pathPoints = new List<PathPoint>();

            if (curCTU.CurLandMark != posInfo.PointCode)
            {
                LogUtil.error($"【{curCTU.Name}】当前地标【{curCTU.CurLandMark}】与取料的地标【{posInfo.PointCode}】不符,不生成放料任务");
                return false;
            }
            var row = curCTU.GetAllBaskets().Find(s => s.BoxCode == boxCode);
            if (row == null)
            {
                LogUtil.error($"【{curCTU.Name}】未在背篓里找到料箱【{boxCode}】,不生成取料任务");
                return false;
            }

            string shelfCodeStr = posInfo.ShelveCode;
            byte[] shelfCode = Mushiny.Common.ConvertToBytes(shelfCodeStr, 16);
            short updown = (short)posInfo.UpDownHeight;
            ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            short depth = (short)posInfo.InoutDepth;
            byte dir = (byte)posInfo.Dir;
            var tmpStr = row.GetLocateCodeByContainerCode();
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0 + row.Row);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00 + row.Row);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }
            var pathPoint1 = PathPoint.GenGetFromBunker(posInfo.PointCode, (byte)row.Row,
                                   containerLocateCode);
            var pathPoint2 = PathPoint.GenReadyToPutToShelves(posInfo.PointCode, dir,
                     updown);

            pathPoints.Add(pathPoint1);
            pathPoints.Add(pathPoint2);
            return true;
        }


        /// <summary>
        /// 生成将料箱从货叉放入货架
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="boxCode"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenPutToShelfPathPoints(CTU curCTU, PosInfo posInfo, string boxCode, out List<PathPoint> pathPoints)
        {
            pathPoints = new List<PathPoint>();

            if (curCTU.CurLandMark != posInfo.PointCode)
            {
                LogUtil.error($"【{curCTU.Name}】当前地标【{curCTU.CurLandMark}】与取料的地标【{posInfo.PointCode}】不符,不生成放料任务");
                return false;
            }
            var row = curCTU.GetAllBaskets().Find(s => s.BoxCode == boxCode);
            if (row == null)
            {
                LogUtil.error($"【{curCTU.Name}】未在背篓里找到料箱【{boxCode}】,不生成放料任务");
                return false;
            }

            string shelfCodeStr = posInfo.ShelveCode;
            byte[] shelfCode = Mushiny.Common.ConvertToBytes(shelfCodeStr, 16);
            short updown = (short)posInfo.UpDownHeight;
            ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            short depth = (short)posInfo.InoutDepth;
            byte dir = (byte)posInfo.Dir;
            var tmpStr = row.GetLocateCodeByContainerCode();
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0 + row.Row);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00 + row.Row);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }
            var pathPoint2 = PathPoint.GenPutToShelves(posInfo.PointCode, dir,
                    shelfCode, containerLocateCode, updown, scanCodeShift, depth);
            pathPoints.Add(pathPoint2);

            // pathPoints.Add(PathPoint.Add(ActionCode.整个路径结束, posInfo.PointCode, 0, 0));
            return true;
        }

        /// <summary>
        /// 生成从背篓取箱子
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="boxCode"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GetBoxFromBasket(CTU curCTU, string boxCode, out List<PathPoint> pathPoints)
        {
            pathPoints = new List<PathPoint>();
            var row = curCTU.GetAllBaskets().Find(s => s.BoxCode == boxCode);
            if (row == null)
            {
                LogUtil.error($"【{curCTU.Name}】未在背篓里找到料箱【{boxCode}】,不生成取料任务");
                return false;
            }
            // short updown = (short)posInfo.UpDownHeight;
            //ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            //  short depth = (short)posInfo.InoutDepth;
            // byte dir = (byte)posInfo.Dir;
            var tmpStr = row.GetLocateCodeByContainerCode();
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0 + row.Row);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00 + row.Row);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }
            var pathPoint1 = PathPoint.GenGetFromBunker(curCTU.CurLandMark, (byte)row.Row,
                                   containerLocateCode);

            pathPoints.Add(pathPoint1);
            return true;
        }


        /// <summary>
        /// 生成开始充电
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenStartChargePathPoints(CTU curCTU, PosInfo posInfo, out PathPoint pathPoint)
        {
            pathPoint = null;

            if (curCTU.CurLandMark != posInfo.PointCode)
            {
                LogUtil.error($"【{curCTU.Name}】当前地标【{curCTU.CurLandMark}】与充电的地标【{posInfo.PointCode}】不符,不生成充电任务");
                return false;
            }
            pathPoint = PathPoint.Add(ActionCode.进入充电, (uint)posInfo.PointCode, (byte)0, (short)0);
            return true;
        }
        /// <summary>
        /// 生成退出充电
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="pathPoint"></param>
        /// <returns></returns>
        public static bool GenStopChargePathPoints(CTU curCTU, PosInfo posInfo, out PathPoint pathPoint)
        {
            pathPoint = null;

            if (curCTU.CurLandMark != posInfo.PointCode)
            {
                LogUtil.error($"【{curCTU.Name}】当前地标【{curCTU.CurLandMark}】与充点地标【{posInfo.PointCode}】不符,不生成退出充电任务");
                return false;
            }
            // pathPoint = PathPoint.Add(ActionCode.退出充电, (uint)posInfo.PointCode, (byte)0, (short)0);
            pathPoint = PathPoint.GenTurn(curCTU.CurLandMark, (short)curCTU.CurDir);
            LogUtil.info($"【{curCTU.Name}】在当前地标【{curCTU.CurLandMark}】角度【{curCTU.CurDir}】生成退出充电任务");
            return true;
        }

        /// <summary>
        /// 将料箱放入背篓
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="boxCode"></param>
        /// <param name="pathPoints"></param>
        /// <param name="errmsg"></param>
        /// <param name="basket"></param>
        /// <returns></returns>
        public static bool PutBoxToBasket(CTU curCTU, PosInfo posInfo, string boxCode, out List<PathPoint> pathPoints, out string errmsg, out Basket basket)
        {
            pathPoints = new List<PathPoint>();
            errmsg = "";
            basket = curCTU.GetEnabledBaskets().Find(s => boxCode.Equals(s.BoxCode));
            if (basket == null)
            {
                if (!curCTU.HasEmptyBasket(out basket))
                {
                    errmsg = ($"【{curCTU.Name}】无可用背篓，不生成取料任务");
                    LogUtil.error(errmsg);
                    return false;
                }
            }

            string shelfCodeStr = posInfo.ShelveCode;
            byte[] shelfCode = Mushiny.Common.ConvertToBytes(shelfCodeStr, 16);

            var tmpStr = Basket.BoxCodeToLocateCode(boxCode);
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0 + basket.Row);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00 + basket.Row);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }

            short updown = (short)posInfo.UpDownHeight;
            ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            short depth = (short)posInfo.InoutDepth;
            byte dir = (byte)posInfo.Dir;
            var pathPoint2 = PathPoint.GenPutToBunker(posInfo.PointCode, (byte)basket.Row,
                    containerLocateCode);
            pathPoints.Add(pathPoint2);
            return true;
        }


        /// <summary>
        /// 生成从料架/设备取货
        /// </summary>
        /// <param name="curCTU"></param>
        /// <param name="posInfo"></param>
        /// <param name="boxCode"></param>
        /// <param name="pathPoints"></param>
        /// <returns></returns>
        public static bool GenGetBoxFomShelf(CTU curCTU, PosInfo posInfo, string boxCode, out List<PathPoint> pathPoints, out string errmsg)
        {
            pathPoints = new List<PathPoint>();
            errmsg = "";
            string shelfCodeStr = posInfo.ShelveCode;
            byte[] shelfCode = Mushiny.Common.ConvertToBytes(shelfCodeStr, 16);

            var tmpStr = Basket.BoxCodeToLocateCode(boxCode);
            byte[] containerLocateCode = new byte[12];
            if (string.IsNullOrEmpty(tmpStr))
            {
                if (CheckContainerLocCode)
                {
                    containerLocateCode[0] = (byte)(0xf0);
                }
                else
                {
                    containerLocateCode[0] = (byte)(0x00);
                }
            }
            else
            {
                containerLocateCode = Mushiny.Common.ConvertToBytes(tmpStr, 12);
            }

            short updown = (short)posInfo.UpDownHeight;
            ushort scanCodeShift = (ushort)posInfo.ScanCodeShift;
            short depth = (short)posInfo.InoutDepth;
            byte dir = (byte)posInfo.Dir;
            var pathPoint1 = PathPoint.GenGetFromShelves(posInfo.PointCode, dir,
                shelfCode, containerLocateCode, updown, scanCodeShift, depth);

            pathPoints.Add(pathPoint1);
            return true;
        }

        #endregion

        #region 两车相遇问题
        static List<CTURealtimeInfo> RunningCtuRealtimeInfos = new List<CTURealtimeInfo>();

        public static CTURealtimeInfo GetRealTimeInfo(CTU ctu)
        {
            return RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
        }
        public static void UpdateCtuMoveState(CTU ctu, CtuMoveState moveState)
        {
            var find = RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
            if (find != null)
            {
                find.MoveState = moveState;
                if (moveState == CtuMoveState.空闲)
                {
                    UpdateCtuRealTimeLoc(ctu, new List<PointCode>());
                }
            }
        }
        public static void UpdateCtuDstInfo(CTU ctu, PosInfo posInfo)
        {
            var find = RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
            if (find != null)
            {
                find.DstPosInfo = posInfo;
            }
        }
        static string preRealtimeInfo = "";

        public static void UpdateCtuRealTimeLoc(CTU ctu, List<PointCode> movePoints)
        {
            var find = RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
            if (find != null)
            {
                find.SetNextPathWay(movePoints);
                find.SetBlockedPoints(movePoints);
            }
            StringBuilder stringBuilder = new StringBuilder();
            RunningCtuRealtimeInfos.ForEach(s =>
            {
                stringBuilder.AppendLine($"【CTU实时】【{s.Ctu?.Name}】优先级【{s.Priority}】" +
                    $"目的地【{s.DstPosInfo?.Name}】移动状态【{s.MoveState}】【{s.DstPosInfo?.PointCode}】路径上的CTU【{string.Join(",", s.CtusInPath)}】当前路线【{s.CurPathWay?.Name}】下一路线【{s.NextPathWay?.Name}】");
            });
            string curInfo = stringBuilder.ToString();
            if (!preRealtimeInfo.Equals(curInfo))
            {
                preRealtimeInfo = curInfo;
                LogUtil.debug(curInfo);
            }
        }
        public static void UpdateCtuRealTimeLoc(CTU ctu, List<uint> movePoints)
        {
            var find = RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
            if (find != null)
            {
                var points = new List<PointCode>();
                movePoints.ForEach(s =>
                {
                    var pp = LandMarks.GetPointCode(s);
                    if (pp != null)
                    {
                        points.Add(pp);
                    }
                });
                find.SetNextPathWay(points);
                find.SetBlockedPoints(points);
            }
            StringBuilder stringBuilder = new StringBuilder();
            RunningCtuRealtimeInfos.ForEach(s =>
            {
                stringBuilder.AppendLine($"【CTU实时】【{s.Ctu?.Name}】优先级【{s.Priority}】" +
                    $"目的地【{s.DstPosInfo?.Name}】移动状态【{s.MoveState}】【{s.DstPosInfo?.PointCode}】路径上的CTU【{string.Join(",", s.CtusInPath)}】当前路线【{s.CurPathWay?.Name}】下一路线【{s.NextPathWay?.Name}】");
            });
            string curInfo = stringBuilder.ToString();
            if (!preRealtimeInfo.Equals(curInfo))
            {
                preRealtimeInfo = curInfo;
                LogUtil.debug(curInfo);
            }
        }
        public static void ClearCtuRealtimeInfo(CTU ctu)
        {
            var find = RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
            if (find != null)
            {
                UpdateCtuDstInfo(ctu, null);
                UpdateCtuMoveState(ctu, CtuMoveState.空闲);
                UpdateCtuRealTimeLoc(ctu, new List<PointCode>());
            }
        }
        /// <summary>
        /// 检查是否有互相冲突的CTU
        /// </summary>
        /// <param name="ctuNames"></param>
        /// <returns></returns>
        public static bool CheckHasLockedStatus(CTU curCtu, out List<string> ctuNames, out bool willReplane)
        {
            willReplane = false;
            ctuNames = new List<string>();
            var hasCtus = RunningCtuRealtimeInfos.FindAll(s => s.CtusInPath.Contains(curCtu.Name));
            if (hasCtus != null && hasCtus.Count > 0)
            {
                foreach (var item in hasCtus)
                {
                    ctuNames.Add(item.Ctu.Name);
                }
                hasCtus.Sort((a, b) => { return a.Priority - b.Priority; });
                willReplane = hasCtus[0].Ctu.Name.Equals(curCtu.Name);
            }
            return ctuNames.Count > 0;
        }
        public static CTURealtimeInfo AddOrUpdateCtuRealtimeInfo(CTU ctu)
        {
            var find = RunningCtuRealtimeInfos.Find(s => ctu.IP.Equals(s.Ctu.IP));
            if (find != null)
            {
            }
            else
            {
                find = new CTURealtimeInfo(ctu);
                RunningCtuRealtimeInfos.Add(find);
            }
            return find;
        }
        #endregion

        //public static void SetBasket(CTU ctu, byte row, string taskId, string containerCode, string locateCode = "")
        //{
        //    ctu.SetBasket(row, taskId, containerCode, locateCode);
        //}
        #region 限制区
        /// <summary>
        /// 获取限制区域
        /// </summary>
        public static bool GetLimitareas(out List<LimitAreaInfo> limitAreaInfos)
        {
            if (manager.HttpManager.GetLimitAreas(out limitAreaInfos))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 检查该地标所在限制区是否被占用
        /// </summary>
        /// <param name="pointCode"></param>
        /// <returns></returns>
        public static bool IsLimitAreaOccupied(string ctuName, uint pointCode, out string areaName, out string occupyAgv)
        {
            areaName = "";
            occupyAgv = "";
            if (GetLimitareas(out List<LimitAreaInfo> areas))
            {
                var finds = areas.FindAll(s => s.CtuPointCodes.Contains(pointCode));
                if (finds != null && finds.Count > 0)
                {
                    foreach (var item in finds)
                    {
                        if (!item.Enabled) continue;
                        if (!string.IsNullOrEmpty(item.OccupiedAgvName))
                        {
                            if (!ctuName.Equals(item.OccupiedAgvName))
                            {
                                areaName = item.Name;
                                occupyAgv = item.OccupiedAgvName;
                                return true;
                            }

                        }
                    }
                }
            }
            else //获取失败，认为在限制区
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 获取该点所在的空闲限制区
        /// </summary>
        /// <param name="ctuName"></param>
        /// <param name="pointCode"></param>
        /// <param name="areaNames"></param>
        /// <returns></returns>
        public static bool GetIdleLimitAreasByPoint(string ctuName, uint pointCode, out List<string> areaNames)
        {
            areaNames = new List<string>();
            if (GetLimitareas(out List<LimitAreaInfo> areas))
            {
                foreach (var area in areas)
                {
                    if (!area.Enabled) continue;
                    if (area.CtuPointCodes.Contains(pointCode))
                    {
                        if (string.IsNullOrEmpty(area.OccupiedAgvName))
                        {
                            areaNames.Add(area.Name);
                        }
                        else if (ctuName.Equals(area.OccupiedAgvName))
                        {
                            areaNames.Add(area.Name);
                        }
                    }
                }
            }
            else
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 查找该点所在的限制区域
        /// </summary>
        /// <param name="pointCode"></param>
        /// <param name="areaNames"></param>
        /// <returns>true:获取成功</returns>
        public static bool GetLimitAreasByPoint(uint pointCode, out List<string> areaNames)
        {
            areaNames = new List<string>();
            if (GetLimitareas(out List<LimitAreaInfo> areas))
            {
                foreach (var area in areas)
                {
                    if (!area.Enabled) continue;
                    if (area.CtuPointCodes.Contains(pointCode))
                    {
                        areaNames.Add(area.Name);
                    }
                }
            }
            else
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 地标是否在限制区
        /// </summary>
        /// <param name="pointCode"></param>
        /// <param name="areaName"></param>
        /// <returns></returns>
        public static bool PointIsInLimitArea(uint pointCode, out string areaName)
        {
            areaName = "";
            if (GetLimitareas(out List<LimitAreaInfo> areas))
            {
                foreach (var area in areas)
                {
                    if (!area.Enabled) continue;
                    if (area.CtuPointCodes.Contains(pointCode))
                    {
                        areaName = area.Name;
                    }
                }
            }
            else
            {
                return false;
            }
            return !string.IsNullOrEmpty(areaName);
        }
        #endregion
        /// <summary>
        /// 获取当前ctu的占地面积
        /// ctu的范围内占用的点
        /// </summary>
        /// <param name="ctu"></param>
        /// <returns></returns>
        public static List<uint> GetCurCtuOccupyArea(CTU ctu)
        {
            int len = ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "CtuSelfSemiLength", 990);
            var limitArea = new List<uint>();
            if (ctu.CurLandMark == 0 || ctu.CurLandMark == 10001) return limitArea;
            var posInfo = LandMarks.GetPointCode(ctu.CurLandMark);
            if (posInfo == null) return limitArea;
            int sumLen = 0;
            var neighboor = posInfo.Above;
            while (neighboor != null)
            {
                var dis = neighboor.Distance;
                var id = neighboor.Id;
                sumLen += dis;
                limitArea.Add(id);
                if (sumLen > len)
                {
                    break;
                }
                else
                {
                    var tmpPP = LandMarks.GetPointCode(id);
                    neighboor = tmpPP.Above;
                }
            }
            sumLen = 0;
            neighboor = posInfo.Right;
            while (neighboor != null)
            {
                var dis = neighboor.Distance;
                var id = neighboor.Id;
                sumLen += dis;
                limitArea.Add(id);
                if (sumLen > len)
                {
                    break;
                }
                else
                {
                    var tmpPP = LandMarks.GetPointCode(id);
                    neighboor = tmpPP.Right;
                }
            }
            sumLen = 0;
            neighboor = posInfo.Below;
            while (neighboor != null)
            {
                var dis = neighboor.Distance;
                var id = neighboor.Id;
                sumLen += dis;
                limitArea.Add(id);
                if (sumLen > len)
                {
                    break;
                }
                else
                {
                    var tmpPP = LandMarks.GetPointCode(id);
                    neighboor = tmpPP.Below;
                }
            }

            sumLen = 0;
            neighboor = posInfo.Left;
            while (neighboor != null)
            {
                var dis = neighboor.Distance;
                var id = neighboor.Id;
                sumLen += dis;
                limitArea.Add(id);
                if (sumLen > len)
                {
                    break;
                }
                else
                {
                    var tmpPP = LandMarks.GetPointCode(id);
                    neighboor = tmpPP.Left;
                }
            }

            if (limitArea.Contains(ctu.CurLandMark))
            {
                limitArea.Remove(ctu.CurLandMark);
            }
            return limitArea;
        }
        /// <summary>
        /// 获取该Ctu路径点的限制区域
        /// </summary>
        /// <param name="ctu"></param>
        /// <param name="usedPoints"></param>
        /// <returns></returns>
        public static List<uint> GetCtuOccupyArea(CTU ctu, List<uint> usedPoints)
        {
            int len = ConfigAppSettings.GetIntValue(Mushiny.Common.Mushiny_ + "CtuSelfSemiLength", 990);
            var limitArea = new List<uint>();
            if (usedPoints.Count == 0) return limitArea;
            foreach (var pp in usedPoints)
            {
                var ppc = LandMarks.GetPointCode(pp);
                if (ppc == null) continue;
                if (ppc.Type != LandmarkType.Turning) continue;
                int sumLen = 0;
                var neighboor = ppc.Above;
                while (neighboor != null)
                {
                    var dis = neighboor.Distance;
                    var id = neighboor.Id;
                    sumLen += dis;
                    limitArea.Add(id);
                    if (sumLen > len)
                    {
                        break;
                    }
                    else
                    {
                        var tmpPP = LandMarks.GetPointCode(id);
                        neighboor = tmpPP.Above;
                    }
                }
                sumLen = 0;
                neighboor = ppc.Right;
                while (neighboor != null)
                {
                    var dis = neighboor.Distance;
                    var id = neighboor.Id;
                    sumLen += dis;
                    limitArea.Add(id);
                    if (sumLen > len)
                    {
                        break;
                    }
                    else
                    {
                        var tmpPP = LandMarks.GetPointCode(id);
                        neighboor = tmpPP.Right;
                    }
                }
                sumLen = 0;
                neighboor = ppc.Below;
                while (neighboor != null)
                {
                    var dis = neighboor.Distance;
                    var id = neighboor.Id;
                    sumLen += dis;
                    limitArea.Add(id);
                    if (sumLen > len)
                    {
                        break;
                    }
                    else
                    {
                        var tmpPP = LandMarks.GetPointCode(id);
                        neighboor = tmpPP.Below;
                    }
                }

                sumLen = 0;
                neighboor = ppc.Left;
                while (neighboor != null)
                {
                    var dis = neighboor.Distance;
                    var id = neighboor.Id;
                    sumLen += dis;
                    limitArea.Add(id);
                    if (sumLen > len)
                    {
                        break;
                    }
                    else
                    {
                        var tmpPP = LandMarks.GetPointCode(id);
                        neighboor = tmpPP.Left;
                    }
                }
            }
            if (limitArea.Contains(ctu.CurLandMark))
            {
                limitArea.Remove(ctu.CurLandMark);
            }
            return limitArea;
        }


        public static bool canShow(FaultId faultId)
        {
            if (FaultId.待机状态下丢码.Equals(faultId) || FaultId.直行中丢码.Equals(faultId)
                || FaultId.直行中错码.Equals(faultId) || FaultId.直行过程因错码停下_要求路径重算.Equals(faultId)
                || FaultId.直行末尾点丢码.Equals(faultId) || FaultId.转弯中丢码.Equals(faultId)
                || FaultId.转弯中错码_要求路径重算.Equals(faultId) || FaultId.校正过程中丢码.Equals(faultId)
                || FaultId.位姿融合失败.Equals(faultId)
                || FaultId.直行过程中发生角度切换.Equals(faultId) || FaultId.充电对接过程中左右偏差过大.Equals(faultId)
                || FaultId.动作码参数异常.Equals(faultId) || FaultId.命令码参数异常.Equals(faultId)
                || FaultId.液晶屏失联.Equals(faultId) || FaultId.顶端灯带失联.Equals(faultId)
                || FaultId.语音播报模块失联.Equals(faultId))
            {
                return false;
            }
            return true;
        }
        ///// <summary>
        ///// 对任务按照巷道分组
        ///// </summary>
        ///// <param name="tasks"></param>
        ///// <returns></returns>
        //public static Dictionary<string, List<finishedOutTask>> GroupTaskByLanCode(List<FinishedCtuTask> tasks)
        //{
        //    if (tasks == null || tasks.Count == 0) return null;
        //    var finishedTasks = new List<finishedOutTask>();

        //    foreach (var task in tasks)
        //    {
        //        if (task.taskType == SmfTaskType.OutStore)
        //            finishedTasks.Add(new finishedOutTask(task, ctuBean.GetPosInfoByName(task.fromLoc)));
        //        else if (task.taskType == SmfTaskType.Instore)
        //            finishedTasks.Add(new finishedOutTask(task, ctuBean.GetPosInfoByName(task.toLoc)));
        //    }
        //    var lanePos = finishedTasks.GroupBy(s => s.PosInfo.Lanway);
        //    Dictionary<string, List<finishedOutTask>> pairs = new Dictionary<string, List<finishedOutTask>>();
        //    foreach (var lane in lanePos)
        //    {
        //        string laneCode = lane.Key;
        //        var outs = lane.ToList();
        //        pairs.Add(laneCode, outs);
        //    }
        //    return pairs;
        //}

        //public static List<finishedOutTask> SwitchTaskType(List<FinishedCtuTask> finishedCtuTasks)
        //{
        //    if (finishedCtuTasks == null || finishedCtuTasks.Count == 0) return null;
        //    var finishedTasks = new List<finishedOutTask>();

        //    foreach (var task in finishedCtuTasks)
        //    {
        //        if (task.taskType == SmfTaskType.OutStore)
        //            finishedTasks.Add(new finishedOutTask(task, ctuBean.GetPosInfoByName(task.fromLoc)));
        //        else if (task.taskType == SmfTaskType.Instore)
        //        {
        //            finishedTasks.Add(new finishedOutTask(task, ctuBean.GetPosInfoByName(task.toLoc)));
        //        }

        //    }
        //    return finishedTasks;
        //}
        ///// <summary>
        ///// 找到ctu可执行的巷道任务
        ///// </summary>
        ///// <param name="ctu"></param>
        ///// <param name="tasks"></param>
        ///// <returns></returns>
        //public static Dictionary<string, List<finishedOutTask>> FilterExecuteTasksByLanCode(CTU ctu, List<FinishedCtuTask> tasks)
        //{
        //    if (tasks == null || tasks.Count == 0) return null;
        //    var finishedTasks = SwitchTaskType(tasks);
        //    var lanePos = finishedTasks.GroupBy(s => s.PosInfo.Lanway);
        //    Dictionary<string, List<finishedOutTask>> pairs = new Dictionary<string, List<finishedOutTask>>();
        //    foreach (var lane in lanePos)
        //    {
        //        string laneCode = lane.Key;
        //        var outs = lane.ToList();
        //        if (outs == null || outs.Count == 0) continue;
        //        var task = outs[0];
        //        string tar = "";
        //        if (task.OutTask.taskType == SmfTaskType.Instore)
        //        {
        //            tar = task.OutTask.fromLoc;//入库看起点是否有车
        //        }
        //        else if (task.OutTask.taskType == SmfTaskType.OutStore)
        //        {
        //            tar = task.OutTask.fromLoc;
        //        }
        //        var posInfo = ctuBean.GetPosInfoByName(tar);
        //        if (posInfo == null)
        //        {
        //            continue;
        //        }
        //        var otherCtus = ctuBean.GetEnabledCTUs()?.FindAll(s => !ctu.IP.Equals(s.IP));
        //        if (otherCtus != null)
        //        {
        //            bool hasAgvAtTask = false;
        //            foreach (var agv in otherCtus)
        //            {
        //                if (ctuBean.IsInSamePath(ctu.CurLandMark, agv.CurLandMark))
        //                {
        //                    hasAgvAtTask = true;
        //                }
        //            }
        //            if (hasAgvAtTask)
        //            {
        //                continue;
        //            }
        //        }
        //        pairs.Add(laneCode, outs);
        //    }
        //    return pairs;
        //}

        /// <summary>
        /// 根据料箱尺寸筛选任务
        /// </summary>
        /// <param name="pairs"></param>
        /// <param name="boxSizes"></param>
        /// <returns></returns>
        //public static List<finishedOutTask> FilterTasksByBoxType(List<finishedOutTask> pairs, List<string> boxSizes)
        //{
        //    if (pairs == null || pairs.Count == 0) return null;
        //    if (boxSizes == null || boxSizes.Count == 0) return pairs;

        //    return pairs.FindAll(s =>
        //    {
        //        string preCode = s.OutTask.boxCode.Substring(0, 3);
        //        return boxSizes.Contains(preCode);
        //    });
        //}
        /// <summary>
        /// 根据设备名筛选任务
        /// </summary>
        /// <param name="pairs"></param>
        /// <param name="equipNames"></param>
        /// <returns></returns>
        //public static List<finishedOutTask> FilterTasksByEquipName(List<finishedOutTask> pairs, List<string> equipNames)
        //{
        //    if (pairs == null || pairs.Count == 0) return null;
        //    if (equipNames == null || equipNames.Count == 0) return pairs;

        //    return pairs.FindAll(s =>
        //    {
        //        if (s.OutTask.taskType == SmfTaskType.Instore)
        //        {
        //            return equipNames.Contains(s.OutTask.fromLoc);
        //        }
        //        else if (s.OutTask.taskType == SmfTaskType.OutStore)
        //        {
        //            return equipNames.Contains(s.OutTask.toLoc);
        //        }
        //        return false;
        //    });
        //}
    }


    public class TasktateChangeEventArg : EventArgs
    {
        public string TaskId { get; set; }

        public RobotTaskState State { get; set; }
    }


}