using AGVLib;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 周转箱
    /// </summary>
    public class TurnoverBox
    {
        /// <summary>
        /// 箱子rfid
        /// </summary>
        public string BoxId = "";
        public string RFID_IP = "";
        public string Name = "";
        InputEquip_Config config;
        public DeviceMoveInfo MoveInfo;
        public string WarnMsg = "";
        public bool AutoClearBoxBind = false;
        /// <summary>
        /// 周转箱线体AGV检测
        /// </summary>
        string DI_SafetyRasterSignal = "TurnoverBoxA_SafetyRasterSignal";
        /// <summary>
        /// 周转箱线体前端周转箱检测
        /// </summary>
        string DI_FrontCheck = "TurnoverBoxA_FrontCheck";
        /// <summary>
        /// 周转箱线体末端周转箱检测
        /// </summary>
        string DI_InPlaceCheck = "TurnoverBoxA_InPlaceCheck";

        /// <summary>
        /// 线体挡停上升端
        /// </summary>
        string DI_StopUpCheck = "TurnoverBoxA_StopUpCheck";
        /// <summary>
        /// 线体挡停下降端
        /// </summary>
        string DI_StopDownCheck = "TurnoverBoxA_StopDownCheck";
        /// <summary>
        /// 线体横移顶升上升端
        /// </summary>
        string DI_TranverseUpCheck = "TurnoverBoxA_TranverseUpCheck";
        /// <summary>
        /// 线体横移顶升下降端
        /// </summary>
        string DI_TranverseDownCheck = "TurnoverBoxA_TranverseDownCheck";
        /// <summary>
        /// 体缓存前端检测
        /// </summary>
        string DI_CacheFrontCheck = "TurnoverBoxA_CacheFrontCheck";
        /// <summary>
        /// 线体缓存后端检测
        /// </summary>
        string DI_CacheBackCheck = "TurnoverBoxA_CacheBackCheck";


        /// <summary>
        /// 周转箱线体正转
        /// </summary>
        string DO_LineRun = "TurnoverBoxA_LineRun";
        /// <summary>
        /// 周转箱线体反转
        /// </summary>
        string DO_LineBackRun = "TurnoverBoxA_LineBackRun";


        string DO_StopUp = "TurnoverBoxA_StopUp";
        string DO_StopDown = "TurnoverBoxA_StopDown";
        string DO_TranverseUp = "TurnoverBoxA_TranverseUp";
        string DO_TranverseDown = "TurnoverBoxA_TranverseDown";
        string DO_TranverseRun = "TurnoverBoxA_TranverseRun";
        string DO_TranverseBackRun = "TurnoverBoxA_TranverseBackRun";

        string DO_Transition_RollerRun = "Transition_RollerRun";
        string DO_Transition_RollerBackRun = "Transition_RollerBackRun";
        public string outLet = "A";
        /// <summary>
        /// 另一边的周转箱线体
        /// </summary>
        TurnoverBox otherTurnoverBox { get { return turnoverBoxes.Find(s => !outLet.Equals(s.outLet)); } }
        static List<TurnoverBox> turnoverBoxes = new List<TurnoverBox>();
        public TurnoverBox(string name, string rfidIp, InputEquip_Config inputEquip_Config)
        {
            Name = name;
            if (name.Contains("B"))
            {
                outLet = "B";
                DI_SafetyRasterSignal = "TurnoverBoxB_SafetyRasterSignal";
                DI_FrontCheck = "TurnoverBoxB_FrontCheck";
                DI_InPlaceCheck = "TurnoverBoxB_InPlaceCheck";

                DO_LineRun = "TurnoverBoxB_LineRun";
                DO_LineBackRun = "TurnoverBoxB_LineBackRun";

                DI_StopUpCheck = "TurnoverBoxB_StopUpCheck";
                DI_StopDownCheck = "TurnoverBoxB_StopDownCheck";
                DI_TranverseUpCheck = "TurnoverBoxB_TranverseUpCheck";
                DI_TranverseDownCheck = "TurnoverBoxB_TranverseDownCheck";
                DI_CacheFrontCheck = "TurnoverBoxB_CacheFrontCheck";
                DI_CacheBackCheck = "TurnoverBoxB_CacheBackCheck";

                DO_StopUp = "TurnoverBoxB_StopUp";
                DO_StopDown = "TurnoverBoxB_StopDown";
                DO_TranverseUp = "TurnoverBoxB_TranverseUp";
                DO_TranverseDown = "TurnoverBoxB_TranverseDown";
                //以A方向的正转，对于B就是反转
                DO_TranverseRun = "TurnoverBoxB_TranverseRun";
                DO_TranverseBackRun = "TurnoverBoxB_TranverseBackRun";
                DO_Transition_RollerRun = "Transition_RollerRun";
                DO_Transition_RollerBackRun = "Transition_RollerBackRun";
            }
            RFID_IP = rfidIp;
            config = inputEquip_Config;
            MoveInfo = new DeviceMoveInfo(Name);
            turnoverBoxes.Add(this);
        }
        #region 改造线体
        /// <summary>
        /// 线体挡停上升
        /// </summary>
        /// <param name="moveInfo"></param>
        public void StopUp(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_StopDown, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_StopUp, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_StopDown, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_StopUp, IO_VALUE.HIGH));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_StopUpCheck, IO_VALUE.HIGH));
            }
        }
        /// <summary>
        /// 线体挡停下降
        /// </summary>
        /// <param name="moveInfo"></param>
        public void StopDown(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_StopUp, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_StopDown, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_StopUp, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_StopDown, IO_VALUE.HIGH));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_StopDownCheck, IO_VALUE.HIGH));
            }
        }
        /// <summary>
        /// 横移上升
        /// </summary>
        /// <param name="moveInfo"></param>
        public void TranverseUp(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_TranverseDown, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_TranverseUp, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseDown, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseUp, IO_VALUE.HIGH));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_TranverseUpCheck, IO_VALUE.HIGH));
            }
        }
        /// <summary>
        /// 横移下降
        /// </summary>
        /// <param name="moveInfo"></param>
        public void TranverseDown(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_TranverseUp, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_TranverseDown, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseUp, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseDown, IO_VALUE.HIGH));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DI_TranverseDownCheck, IO_VALUE.HIGH));
            }
        }
        bool isBoxA()
        {
            return "A".Equals(outLet);
        }
        /// <summary>
        /// 横移往外转
        /// </summary>
        /// <param name="moveInfo"></param>
        public void TranverseRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_TranverseBackRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_TranverseRun, IO_VALUE.HIGH, config.Id);
            //if (moveInfo != null)
            //{
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseBackRun, IO_VALUE.LOW));
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseRun, IO_VALUE.HIGH));
            //}
        }
        /// <summary>
        /// 横移往里转
        /// </summary>
        /// <param name="moveInfo"></param>
        public void TranverseBackRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_TranverseBackRun, IO_VALUE.HIGH, config.Id);
            IOManager.IOMove(DO_TranverseRun, IO_VALUE.HIGH, config.Id);
            //if (moveInfo != null)
            //{
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseRun, IO_VALUE.LOW));
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseBackRun, IO_VALUE.HIGH));
            //}
        }
        public void TranverseStopRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_TranverseRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_TranverseBackRun, IO_VALUE.LOW, config.Id);
            //if (moveInfo != null)
            //{
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseRun, IO_VALUE.LOW));
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_TranverseBackRun, IO_VALUE.LOW));
            //}
        }
        /// <summary>
        /// 过渡滚筒正转A-B
        /// </summary>
        /// <param name="moveInfo"></param>
        public void Transition_RollerRunAtoB(DeviceMoveInfo moveInfo = null)
        {
            if (isBoxA())
            {

                IOManager.IOMove(DO_Transition_RollerBackRun, IO_VALUE.LOW, config.Id);
                IOManager.IOMove(DO_Transition_RollerRun, IO_VALUE.HIGH, config.Id);
            }
            else
            {
                IOManager.IOMove(DO_Transition_RollerRun, IO_VALUE.LOW, config.Id);
                IOManager.IOMove(DO_Transition_RollerBackRun, IO_VALUE.HIGH, config.Id);

            }


            //if (moveInfo != null)
            //{
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_Transition_RollerBackRun, IO_VALUE.LOW));
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_Transition_RollerRun, IO_VALUE.HIGH));
            //}
        }
        /// <summary>
        /// 过渡滚筒反转B-A
        /// </summary>
        /// <param name="moveInfo"></param>
        public void Transition_RollerBackRunBToA(DeviceMoveInfo moveInfo = null)
        {
            if (isBoxA())
            {
                IOManager.IOMove(DO_Transition_RollerRun, IO_VALUE.LOW, config.Id);
                IOManager.IOMove(DO_Transition_RollerBackRun, IO_VALUE.HIGH, config.Id);
            }
            else
            {
                IOManager.IOMove(DO_Transition_RollerBackRun, IO_VALUE.LOW, config.Id);
                IOManager.IOMove(DO_Transition_RollerRun, IO_VALUE.HIGH, config.Id);
            }
            //if (moveInfo != null)
            //{
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_Transition_RollerRun, IO_VALUE.LOW));
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_Transition_RollerBackRun, IO_VALUE.HIGH));
            //}
        }
        public void Transition_RollerStopRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_Transition_RollerRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_Transition_RollerBackRun, IO_VALUE.LOW, config.Id);
            //if (moveInfo != null)
            //{
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_Transition_RollerRun, IO_VALUE.LOW));
            //    moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_Transition_RollerBackRun, IO_VALUE.LOW));
            //}
        }

        public bool CacheFrontCheck(IO_VALUE iO_VALUE)
        {
            bool result = IOManager.IOValue(DI_CacheFrontCheck, config.Id).Equals(iO_VALUE);
            return result;
        }
        public bool CacheBackCheck(IO_VALUE iO_VALUE)
        {
            bool result = IOManager.IOValue(DI_CacheBackCheck, config.Id).Equals(iO_VALUE);
            return result;
        }
        public bool InPlaceCheck(IO_VALUE iO_VALUE)
        {
            bool result = IOManager.IOValue(DI_InPlaceCheck, config.Id).Equals(iO_VALUE);
            return result;
        }
        public bool FrontCheck(IO_VALUE iO_VALUE)
        {
            bool result = IOManager.IOValue(DI_FrontCheck, config.Id).Equals(iO_VALUE);
            return result;
        }
        #endregion


        public string GetMoveStr()
        {
            return $"料箱：{BoxId} " + $"【格口最大数量：{MaxCntOnSide}】【" + (BoxTaskInfo?.ToStr() ?? "") + "】";
        }
        public void StartReset()
        {
            WarnMsg = "";
            bool needLeave = false;
            ReadBoxId();
            GetBoxTaskInfo();
            if (BoxTaskInfo != null)
            {
                needLeave = (BoxTaskInfo.boxTCount >= MaxCntOnSide || BoxTaskInfo.boxBCount >= MaxCntOnSide || BoxTaskInfo.remainTaskCount <= 0);
            }
            ProcessShelfOut = false;
            ProcessShelfEnter = false;
            recvAGVSig = false;
            SetToNone();
            Task.Factory.StartNew(delegate
            {
                Transition_RollerStopRun();
                Thread.Sleep(100);
                TranverseStopRun();
                Thread.Sleep(100);
                TranverseDown();
                Thread.Sleep(100);
                if (InPlaceCheck(IO_VALUE.HIGH))//末端有料箱
                {
                    if (CacheFrontCheck(IO_VALUE.HIGH) || CacheBackCheck(IO_VALUE.HIGH) || FrontCheck(IO_VALUE.HIGH))
                    {
                        StopUp();
                    }
                }
                else //末端没料箱
                {
                    if (CacheFrontCheck(IO_VALUE.HIGH) || CacheBackCheck(IO_VALUE.HIGH) || FrontCheck(IO_VALUE.HIGH))
                    {
                        StopDown();
                    }
                }
                LineRun();
                Thread.Sleep(10000);
                LineStopRun();

                if (needLeave)
                {
                    NeedLeave();
                    LogUtil.info($"复位 {Name}已满/无剩余任务，需要离开。{BoxTaskInfo?.ToStr() ?? ""}");
                }

            });

        }
        public void LineRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_LineBackRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_LineRun, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineBackRun, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineRun, IO_VALUE.HIGH));
            }
        }

        public void LineBackRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_LineRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_LineBackRun, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineRun, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineBackRun, IO_VALUE.HIGH));
            }
        }
        public void LineStopRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_LineRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_LineBackRun, IO_VALUE.LOW, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineRun, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineBackRun, IO_VALUE.LOW));
            }
        }
        bool recvAGVSig = false;
        public void RecvMsgFromServer(Node node)
        {
            if (node == null) return;
            if (node.id == AgvNode.id && AgvNode.name.Equals(node.name))
            {
                AgvNode.status = node.status;
                AgvNode.level = node.level;
                AgvNode.shelf_id = node.shelf_id;
                if (node.status.Equals(NodeStatus.RequestEnter))
                {
                    LogUtil.info($"收到AGV服务端消息：【{node.name}】【{node.status.ToString()}】【{node.ToText()}】");
                    recvAGVSig = true;
                    BoxEnterProcess();
                }
                else if (node.status.Equals(NodeStatus.RequestLeave))
                {
                    LogUtil.info($"收到AGV服务端消息：【{node.name}】【{node.status.ToString()}】【{node.ToText()}】");
                    recvAGVSig = true;
                    BoxOutProcess();
                }
            }
        }
        bool ProcessShelfOut = false;
        bool ProcessShelfEnter = false;
        bool DIValue(string iotype, IO_VALUE iO_VALUE)
        {
            return IOManager.IOValue(iotype, config.Id).Equals(iO_VALUE);
        }
        /// <summary>
        /// 转移到另一侧
        /// </summary>
        void BoxTranverse(string logname)
        {
            if (outLet.Equals("A"))
            {
                AToB(logname, true);
            }
            else
            {
                BToA(logname, true);
            }
        }
        /// <summary>
        /// 转移回来
        /// </summary>
        void BoxTranverseBack(string logname)
        {
            if (outLet.Equals("A"))
            {
                BToA(logname, false);
            }
            else
            {
                AToB(logname, false);
            }
        }
        /// <summary>
        /// A->B
        /// </summary>
        void AToB(string logname, bool istranverse)
        {
            TurnoverBox from = null;
            TurnoverBox to = null;
            if (outLet.Equals("A"))
            {
                from = this;
                to = otherTurnoverBox;
            }
            else
            {
                to = this;
                from = otherTurnoverBox;
            }
            tranverseProcess(logname + $"   A开始横移到B:", from, to, istranverse);

        }
        /// <summary>
        /// B->A
        /// </summary>
        void BToA(string logname, bool istranverse)
        {
            TurnoverBox from = null;
            TurnoverBox to = null;
            if (outLet.Equals("A"))
            {
                to = this;
                from = otherTurnoverBox;

            }
            else
            {
                from = this;
                to = otherTurnoverBox;
            }
            tranverseProcess(logname + $"   B开始横移到A:", from, to, istranverse);
        }
        void tranverseProcess(string logname, TurnoverBox from, TurnoverBox to, bool istranverse)
        {
            LogUtil.info(logname + "横移上升");
            from.TranverseUp();
            to.TranverseUp();
            LogUtil.info(logname + "横移正转");
            from.TranverseRun();
            from.Transition_RollerRunAtoB();
            to.TranverseBackRun();
            if (to.isBoxA())
            {
                bool result = WaitIo(to.DI_CacheBackCheck, IO_VALUE.HIGH, 600_000);
                if (!result)
                {
                    LogUtil.error(logname + $" 等待 {to.DI_CacheBackCheck} =High 超时");
                }
                else
                {
                    LogUtil.info(logname + $"已收到 {to.DI_CacheBackCheck} =High ");
                }
            }
            else
            {
                bool result = WaitIo(to.DI_CacheFrontCheck, IO_VALUE.HIGH, 600_000);
                if (!result)
                {
                    LogUtil.error(logname + $" 等待 {to.DI_CacheFrontCheck} =High 超时");
                }
                else
                {
                    LogUtil.info(logname + $"已收到 {to.DI_CacheFrontCheck} =High ");
                }
            }

            Thread.Sleep(2000);

            LogUtil.info(logname + "横移停止");
            from.TranverseStopRun();
            to.TranverseStopRun();
            from.Transition_RollerStopRun();
            from.TranverseDown();
            if (!istranverse)
            {
                to.TranverseDown();
            }
            else
            {
                LogUtil.info(logname + "转移目的地，横移不下降");
            }
        }
        public void BoxOutProcess()
        {
            //AGV已到达，将料串送入AGV中
            Task.Factory.StartNew(delegate
            {
                string logName = Name + " 料箱" + BoxId + "[" + AgvNode.name + "->AGV ]  ";
                try
                {
                    bool isTranverse = false;
                    if (CacheFrontCheck(IO_VALUE.HIGH) || CacheBackCheck(IO_VALUE.HIGH))//横移处有料箱
                    {
                        if (otherTurnoverBox.CacheFrontCheck(IO_VALUE.LOW) && otherTurnoverBox.CacheBackCheck(IO_VALUE.LOW))
                        {
                            BoxTranverse(logName);
                            isTranverse = true;
                            LogUtil.info(logName + " 另一侧没有料箱，可以横移过去");
                        }
                        else
                        {
                            LogUtil.info(logName + " 另一侧有料箱，不能横移过去，等待处理");
                        }

                    }

                    if (DIValue(DI_FrontCheck, IO_VALUE.HIGH) || DIValue(DI_InPlaceCheck, IO_VALUE.HIGH))
                    {
                        LogUtil.info(logName + "   开始出料箱");
                        ProcessShelfOut = true;
                        LogUtil.info(logName + "   横移停止运行");
                        TranverseStopRun();
                        LogUtil.info(logName + "   横移下降");
                        TranverseDown();
                        LogUtil.info(logName + "   阻挡下降");
                        StopDown();
                        LogUtil.info(logName + "   允许离开");
                        MayLeave();
                        LogUtil.info(logName + "   线体反转");
                        LineBackRun();
                        bool result = WaitIo(DI_InPlaceCheck, IO_VALUE.LOW, 60000);
                        if (!result)
                        {
                            LogUtil.error(logName + $"  等待 {DI_InPlaceCheck}=LOW超时，等待8000后停止转动");
                        }
                        else
                        {
                            LogUtil.info(logName + $"  已收到 {DI_InPlaceCheck}=LOW ，等待8000后停止转动");
                        }
                        //再转动8000
                        //Thread.Sleep(8000);

                        // Complete();
                        if (ConfigHelper.Config.Get("BoxLeaveNeedCompleSig", false))
                        {
                            while (!AgvNode.status.Equals(NodeStatus.Complete))
                            {
                                Thread.Sleep(1000);
                            }
                        }

                        if (!ProcessShelfOut) return;
                        Thread.Sleep(1000);
                        FinishLeave();
                        //Thread.Sleep(8000);
                        //Task.Factory.StartNew(delegate
                        //{
                        //    Thread.Sleep(10000);
                        //    AgvClient.SetToNone(AgvNode.id);
                        //});
                        LineStopRun();
                        ProcessShelfOut = false;
                        BoxTaskInfo = new BoxTaskInfo();
                        LogUtil.info(logName + "结束,停止转动，清空料箱[" + BoxId + "] ");
                        BoxId = "";
                        if (!isTranverse)
                        {
                            if (otherTurnoverBox.CacheBackCheck(IO_VALUE.HIGH) || otherTurnoverBox.CacheFrontCheck(IO_VALUE.HIGH))
                            {
                                LogUtil.info(logName + " 没有横移过去料箱，但另一侧有料箱，可以横移过来");
                                isTranverse = true;
                            }
                        }
                        if (isTranverse)
                        {
                            BoxTranverseBack(logName);
                            LogUtil.info(logName + "   结束横移回转");
                            //让料箱流到位置
                            LogUtil.info(logName + "   开始进料箱");
                            ProcessShelfEnter = true;
                            LogUtil.info(logName + "   横移停止运行");
                            TranverseStopRun();
                            LogUtil.info(logName + "   横移下降");
                            TranverseDown();
                            LogUtil.info(logName + "   阻挡下降");
                            StopDown();
                            LogUtil.info(logName + "   线体正转");
                            LineRun();

                            result = WaitIo(DI_InPlaceCheck, IO_VALUE.HIGH, 60000);

                            if (!result)
                            {
                                LogUtil.error(logName + $" 等待 {DI_CacheFrontCheck} =High 超时");
                            }
                            else
                            {
                                LogUtil.info(logName + $"已收到 {DI_CacheFrontCheck} =High ");
                            }
                            Thread.Sleep(3000);
                            LogUtil.info(logName + "等待3000后，停止链条转动");
                            LineStopRun();
                            GetBoxTaskInfo();
                        }
                        else
                        {
                            LogUtil.info(logName + "   无横移，直接结束");
                        }
                    }
                    else
                    {
                        LogUtil.info(logName + " 未检测到料箱，暂不处理");
                        Task.Factory.StartNew(delegate
                        {
                            Thread.Sleep(3000);
                            AgvClient.SetToNone(AgvNode.id);
                        });
                    }
                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + " 超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + " 出错：", ex);
                }
                finally
                {
                    LineStopRun();
                    ProcessShelfOut = false;
                    recvAGVSig = false;
                }
            });
        }
        public void BoxEnterProcess()
        {
            Task.Factory.StartNew(delegate
            {
                BoxId = "";
                string logName = Name + "料箱 " + BoxId + " [AGV->" + AgvNode.name + "] ";
                try
                {
                    //确保当前横移和另一个地方横移都没料箱
                    if (DIValue(DI_FrontCheck, IO_VALUE.LOW) && DIValue(DI_CacheFrontCheck, IO_VALUE.LOW)
                    && DIValue(DI_CacheBackCheck, IO_VALUE.LOW) && otherTurnoverBox.CacheBackCheck(IO_VALUE.LOW) && otherTurnoverBox.CacheFrontCheck(IO_VALUE.LOW))
                    {
                        LogUtil.info(logName + "   开始进料箱");
                        ProcessShelfEnter = true;
                        LogUtil.info(logName + "   横移停止运行");
                        TranverseStopRun();
                        LogUtil.info(logName + "   横移下降");
                        TranverseDown();
                        LogUtil.info(logName + "   阻挡上升");
                        StopUp();
                        LogUtil.info(logName + "   允许进入");
                        MayEnter();
                        LogUtil.info(logName + "   线体正转");
                        LineRun();

                        //等待进料检测信号
                        bool result = WaitIo(DI_FrontCheck, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待{DI_FrontCheck}=High 超时");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {DI_FrontCheck}=High ");
                        }

                        result = WaitIo(DI_CacheFrontCheck, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待 {DI_CacheFrontCheck} =High 超时");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {DI_CacheFrontCheck} =High ");
                        }

                        result = WaitIo(DI_CacheBackCheck, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待 {DI_CacheBackCheck} =High 超时");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {DI_CacheBackCheck} =High");
                        }
                        DateTime dateTime = DateTime.Now;
                        if (ConfigHelper.Config.Get("BoxEnterNeedCompleSig", true))
                        {
                            while (!AgvNode.status.Equals(NodeStatus.Complete))
                            {
                                Thread.Sleep(1000);
                            }
                        }

                        if (!ProcessShelfEnter) return;
                        // Complete();
                        FinishEnter();
                        //等待200毫秒后停止转动
                        Thread.Sleep(2000);
                        LogUtil.info(logName + "等待2000后，停止链条转动");
                        LineStopRun();
                        //GetBoxTaskInfo();
                        //if (ReadBoxId())
                        //{

                        //    //SServerManager.BoxTakeAway(BoxId);
                        //    //Thread.Sleep(1000);
                        //   // BoxTaskInfo = SServerManager.GetBoxStatusInfo(config.CID, BoxId);
                        //}

                        ProcessShelfEnter = false;
                        BoxTranverse(logName);
                        LogUtil.info(logName + "   结束");
                    }
                    else
                    {
                        //入口有料串，暂不处理
                        LogUtil.error(logName + "，入口已有料架，暂不处理");
                        //Task.Factory.StartNew(delegate
                        //{
                        //    Thread.Sleep(3000);
                        //    //AgvClient.SetStatus(Config.AgvName, "", ClientAction.None, ClientLevel.High, true);
                        //});
                    }
                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + "  超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + "   出错：", ex);
                }
                finally
                {
                    ProcessShelfEnter = false;
                    recvAGVSig = false;
                }
            });
        }
        public Node AgvNode { get; set; }
        /// <summary>
        /// 是否有空位置
        /// </summary>
        /// <returns></returns>
        public bool HasEmptyPos(int boxT, int boxB)
        {
            return boxT < MaxCntOnSide && boxB < MaxCntOnSide;
        }
        //public bool CanPutIn(out string msg)
        //{
        //    msg = "";
        //    if (InHandlingAGVSig())
        //    {
        //        msg = Name + " 正在进出料，不允许放料";
        //        return false;
        //    }
        //    if (!BoxId.StartsWith("CN"))
        //    {
        //        msg = Name + " 未读到rfid，不允许放料";
        //        return false;
        //    }
        //    bool rtn = CntInSideT < MaxCntOnSide && CntInSideB < MaxCntOnSide;
        //    if (!rtn)
        //    {
        //        msg = Name + $" 格口数量已满，不允许放料。当前数量：【内侧={CntInSideT}】【外侧={CntInSideB}】";
        //        NeedLeave();
        //    }
        //    return rtn;
        //}
        //public bool CheckState(Label_LZ labelInfo, InOutParam param, out BoxTaskInfo boxTaskInfo, out string warnMsg)
        //{
        //    boxTaskInfo = BoxTaskInfo;
        //    warnMsg = "";
        //    bool canOutstore = false;
        //    if (BoxTaskInfo != null)
        //    {
        //        if (!CanPutIn())
        //        {
        //            warnMsg = $"{Name}数量到达极限，不允许放料";
        //            NeedLeave();
        //        }
        //        if (!string.IsNullOrEmpty(BoxTaskInfo.hSerial))
        //        {
        //            if (!BoxTaskInfo.hSerial.Equals(labelInfo.hSerial))
        //            {
        //                warnMsg = ($"{Name}料盘需求单与箱子需求单不符，出库失败：" + param.PosInfo.ToStr());
        //                NeedLeave();
        //            }
        //            else
        //            {
        //                if (labelInfo.side.Equals("T"))
        //                {
        //                    param.ShelfType = Name.Contains("A") ? 1 : 3;
        //                    canOutstore = true;
        //                }
        //                else if (labelInfo.side.Equals("B"))
        //                {
        //                    param.ShelfType = Name.Contains("A") ? 2 : 4;
        //                    canOutstore = true;
        //                }
        //                else
        //                {
        //                    warnMsg = ($"{Name}料盘的面别信息有误:{labelInfo.side}。出库失败：" + param.PosInfo.ToStr());
        //                }
        //            }
        //        }
        //        else//空箱子
        //        {
        //            if (labelInfo.side.Equals("T"))
        //            {
        //                param.ShelfType = Name.Contains("A") ? 1 : 3;
        //                canOutstore = true;
        //            }
        //            else if (labelInfo.side.Equals("B"))
        //            {
        //                param.ShelfType = Name.Contains("A") ? 2 : 4;
        //                canOutstore = true;
        //            }
        //            else
        //            {
        //                warnMsg = ($"{Name}料盘的面别信息有误:{labelInfo.side}。出库失败：" + param.PosInfo.ToStr());
        //            }
        //        }
        //    }

        //    return canOutstore;
        //}
        public void NeedLeave(bool force = false)
        {
            if (force)
            {
                AgvNode.status = NodeStatus.NeedLeave;
                AgvNode.shelf_id = BoxId;
                AgvClient.NeedLeave(AgvNode.id, BoxId);
            }
            else
            {
                if (InHandlingAGVSig())
                {
                    LogUtil.debug(Name + $" 正在进出料，无法设置状态为NeedLeave");
                }
                else
                {
                    AgvClient.NeedLeave(AgvNode.id, BoxId);
                    AgvNode.status = NodeStatus.NeedLeave;
                    AgvNode.shelf_id = BoxId;
                }
            }
        }
        /// <summary>
        /// 正在处理AGV信号
        /// </summary>
        /// <returns></returns>
        bool InHandlingAGVSig()
        {
            return (ProcessShelfOut || ProcessShelfEnter ||
                AgvNode.status.Equals(NodeStatus.RequestEnter) ||
                AgvNode.status.Equals(NodeStatus.RequestLeave) ||
                 AgvNode.status.Equals(NodeStatus.MayEnter) ||
                  AgvNode.status.Equals(NodeStatus.MayLeave) ||
                  recvAGVSig);
        }
        public void SetToNone()
        {
            AgvClient.SetToNone(AgvNode.id, "");
            AgvNode.status = NodeStatus.None;
            AgvNode.shelf_id = BoxId;
        }
        public void MayLeave()
        {
            AgvClient.MayLeave(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.MayLeave;
            AgvNode.shelf_id = BoxId;
        }
        public void MayEnter()
        {
            AgvClient.MayEnter(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.MayEnter;
            AgvNode.shelf_id = BoxId;
        }
        public void FinishEnter()
        {
            AgvClient.FinishEnter(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.FinishEnter;
            AgvNode.shelf_id = BoxId;
        }
        public void FinishLeave()
        {
            AgvClient.FinishLeave(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.FinishLeave;
            AgvNode.shelf_id = BoxId;
        }
        public void Complete()
        {
            AgvClient.SetToComplete(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.Complete;
            AgvNode.shelf_id = BoxId;
        }
        /// <summary>
        /// 格口的最大数量
        /// </summary>
        public int MaxCntOnSide { get; set; } = ConfigAppSettings.GetIntValue(Setting_Init.MaxCntInBox, 15);
        public void PutReelIn(int side)
        {
            WarnMsg = "";
            bool rtn = false;
            //BoxTaskInfo = SServerManager.GetBoxStatusInfo(config.CID, BoxId);
            bool hasRemain = true;
            if (BoxTaskInfo != null)
            {
                rtn = BoxTaskInfo.boxBCount >= MaxCntOnSide || BoxTaskInfo.boxTCount >= MaxCntOnSide;
                hasRemain = (BoxTaskInfo.remainTaskCount > 0 ? true : false);
            }
            if (AutoClearBoxBind)
            {
                ClearBoxInfo();

            }
            else if (InHandlingAGVSig())
            {

            }
            else if (rtn || !hasRemain)
            {
                NeedLeave();
                LogUtil.info($"{Name}已满/无剩余任务，需要离开。{BoxTaskInfo?.ToStr() ?? ""}");
            }

        }
        public void GetBoxTaskInfo()
        {
            if (ReadBoxId())
            {
                List<BoxTaskInfo> boxInfos = SServerManager.GetOutStateInfo();
                UpdateBoxInfo(boxInfos);
            }
        }
        public void UpdateBoxInfo(List<BoxTaskInfo> boxInfos)
        {
            if (boxInfos == null) return;
            BoxTaskInfo = boxInfos.Find(s => outLet.Equals(s.outlet));
        }
        /// <summary>
        /// 任务信息
        /// </summary>
        public BoxTaskInfo BoxTaskInfo { get; set; }

        public void ClearBoxInfo(bool manual = false)
        {
            try
            {
                if (ReadBoxId())
                {
                    SetToNone();
                    SServerManager.BoxTakeAway(BoxId);
                    BoxTaskInfo = SServerManager.GetBoxStatusInfo(config.CID, BoxId);
                    if (manual)
                        LogUtil.info($"手动清除料箱绑定：{BoxId}");
                    else
                    {
                        LogUtil.info($"自动清除料箱绑定：{BoxId}");
                    }
                }
                BoxTaskInfo = new BoxTaskInfo();
            }
            catch { }


        }
        /// <summary>
        /// 读取周转箱编号
        /// </summary>
        /// <returns></returns>
        public bool ReadBoxId()
        {
            try
            {
                //判断料架的编码是否正确
                RFIDData rfidD = RFIDManager.ReadRFID(RFID_IP);
                BoxId = rfidD.NumStr();
                //发送料架信息给调度系统
                // LogUtil.info(Name + "读取RFID：" + BoxId);
                return rfidD.IsValidated();
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "ReadBoxId出错：", ex);
            }
            return false;
        }
        public bool WaitIo(string ioType, IO_VALUE value, int timeOut, string errName = "")
        {
            try
            {
                return WaitUtil.Wait(timeOut, delegate ()
                {
                    return DIValue(ioType, value);
                }, errName);
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "等待" + ioType + "=" + value + "超时：" + ex.ToString());
                return false;
            }
        }

    }
}