using Asa;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    partial class BatchMoveBean
    {
        public ShelfInfo CurrShelf = new ShelfInfo();
        #region 入库

        private List<string> LastCodeList = new List<string>();
        private List<string> NextCodeList = new List<string>();

        public bool StartInstore(InOutParam param)
        {
            if (ProcessShelfOut || ProcessShelfEnter)
            {
                return false;
            }
            if (!Robot.CanStartWork())
            {
                return false;
            }
            if (AgvClient.GetAction(Config.AgvName) == ClientAction.NeedLeave || AgvClient.GetAction(Config.AgvName) == ClientAction.MayLeave)
            {
                //WorkLog("料串入料 ：等待AGV来取空料串1");
                return false; ;
            }
            UpdateShelf(1);
            if (CurrShelf.ShelfState.Equals(3))
            {
                bool agvcallresult = AgvClient.NeedLeave(Config.AgvName, CurrShelf.ShelfRfid, ClientLevel.High);
                LogUtil.info(Name + "StartInstore 失败，料串" + CurrShelf.ToStr() + "需要离开，NeedLeave:" + Config.AgvName + "," + CurrShelf.ShelfRfid + ",agvcallresult:" + agvcallresult.ToString());
                return false;
            }
            //if (Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH) && Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
            //{
            //    MoveInfo.NewMove(MoveType.InStore);
            //    MoveInfo.MoveParam = new InOutParam();
            //    //判断是哪个工位有料串

            //    IB05_StopUp();
            //}
            else if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH) )
            {
                MoveInfo.NewMove(MoveType.InStore);
                IB03_LineStart();
            }
            else if(Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
            {
                MoveInfo.NewMove(MoveType.InStore);
                IB04_LineWait();
            }
            else
            {
                LineStop();
                MoveInfo.EndMove();
            }
            return true;
        }

        internal InOutParam GetInstoreParam()
        {
            string code = MoveInfo.MoveParam.PosInfo.barcode;
            InOutPosInfo posInfo = new InOutPosInfo(code, "");
            posInfo.NgMsg = MoveInfo.MoveParam.PosInfo.NgMsg;
            posInfo.IsNG = MoveInfo.MoveParam.PosInfo.IsNG;
            posInfo.rfid = MoveInfo.MoveParam.PosInfo.rfid;
            InOutParam param = new InOutParam(posInfo);
            param.ShelfType = ShelfType;
            return param;
        }

        private void IB05_StopUp()
        {
            //   定位工位有料串，等待1秒后再次检测
            MoveInfo.NextMoveStep(StepEnum.IB05_StopUp);
            WorkLog("定位工位检测到料串： 链条转动，阻挡气缸上升， 3秒再次检测");
            LineRun();
            StopUp(MoveInfo);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
        }
        private void IB02_BatchAxisToP1()
        {
            WorkLog("料串入料 ：提升伺服移动到P1,阻挡气缸下降");
            MoveInfo.NextMoveStep(StepEnum.IB02_BatchAxisToP1);
            BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Robot.Config.BatchAxis_P1Speed);
            StopDown();
        }
        private void IB03_LineStart()
        {
            WorkLog("料串入料 ：入口有料串，转动料串到位");
            MoveInfo.NextMoveStep(StepEnum.IB03_LineStart);
            LineRun(MoveInfo); 
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineIn_Check, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineEnd_Check, IO_VALUE.HIGH));
        }
        private void IB04_LineWait()
        {
            WorkLog("料串入料 ：料串已到位，在转动3秒");
            MoveInfo.NextMoveStep(StepEnum.IB04_LineWait);
            LineRun(MoveInfo);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineEnd_Check, IO_VALUE.HIGH));
        }
        private void IB07_AxisUpMove()
        {
            MoveInfo.ShelfNoTray = false;
            AgvClient.SetToNone(Config.AgvName);
            MoveInfo.NextMoveStep(StepEnum.IB07_AxisUpMove);

            WorkLog("料串入料 ：上料轴开始慢速上升到P2点，等待检测到料盘");
            LastCodeList = new List<string>();
            NextCodeList = new List<string>();
            MoveInfo.ShelfNoTray = false;
            BatchAxisToP2(true);
        }
        protected void InstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            #region 入料：料串进入并开始检测托盘
            if (MoveInfo.IsStep(StepEnum.IB01_Wait))
            {
                IB02_BatchAxisToP1();
            }
            if (MoveInfo.IsStep(StepEnum.IB02_BatchAxisToP1))
            {
                //MoveInfo.NextMoveStep(StepEnum.IB03_LineStart);
                //WorkLog("料串入料 ：开始转动链条");
                //LineRun(MoveInfo);
                ////等待指定时间
                //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                IB03_LineStart();
            }
            else if (MoveInfo.IsStep(StepEnum.IB03_LineStart))
            {
                //if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH) && Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                //{
                //    IB05_StopUp();
                //}
                //else 
                if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
                {
                    //MoveInfo.NextMoveStep(StepEnum.IB03_LineStart);
                    //WorkLog(" 入口检测到料串，流水线转动 6000，等待料串完全进入轨道");
                    //LineRun(MoveInfo);
                    //MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(6000));
                    IB03_LineStart();
                }
                else if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
                {
                    IB04_LineWait();
                }
                else
                {
                    LineStop();
                    MoveInfo.EndMove();
                    LogUtil.info(" 未检测到料串，入料结束");
                }
            }else if (MoveInfo.IsStep(StepEnum.IB04_LineWait))
            {
                IB05_StopUp();
            }
            else if (MoveInfo.IsStep(StepEnum.IB06_WaitTime))
            {
                LineStop();
                if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH) && Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                {
                    if (CurrShelf.ShelfState.Equals(2))
                    {
                        SendInShelfLeave(" 料串【" + CurrShelf.ToStr() + "】为出库中料串，不需要入库 ");
                    }
                    else
                    {
                        UpdateShelf(1);
                        if (CurrShelf.ShelfRfid.EndsWith("00"))
                        {
                            SendInShelfLeave(" 料串号【" + CurrShelf.ShelfRfid + "】无效 ");
                        }
                        else
                        {
                            IB07_AxisUpMove();
                        }
                    }

                }
                else
                {
                    LineStop();
                    MoveInfo.EndMove();
                    WorkLog(" 未检测到料串，链条停止转动，入料结束");
                }
            }


            #endregion

            #region 检测到托盘，扫码，取料并放入托盘 
            else if (MoveInfo.IsStep(StepEnum.IB07_AxisUpMove))
            {
                CheckHasTray();
            }

            else if (MoveInfo.IsStep(StepEnum.IB09_ScanCode))
            {
                WorkLog("IB09_ScanCode");
                MoveInfo.MoveParam = new InOutParam(new InOutPosInfo("", ""));
                string code = CodeManager.ProcessCode(LastCodeList);
                MoveInfo.MoveParam.PosInfo.barcode = code;
                MoveInfo.MoveParam.PosInfo.rfid = CurrShelf.ShelfRfid;
                if (String.IsNullOrEmpty(code))
                {
                    MoveInfo.MoveParam.PosInfo.IsNG = true;
                    MoveInfo.MoveParam.PosInfo.NgMsg = "无有效条码NG";
                    WorkLog(" 无有效条码NG，需要放入NG箱：" + MoveInfo.MoveParam.PosInfo.ToStr());
                }

                MoveInfo.NextMoveStep(StepEnum.IB10_ScanOK);
                var span = DateTime.Now - MoveInfo.LastSetpTime;
                WorkLog("料串入料 ：扫码结束【" + code + "】，等待取料机构来取料," + MoveInfo.MoveParam.PosInfo.ToStr());
            }
            else if (MoveInfo.IsStep(StepEnum.IB11_WaitReelLeave))
            {
                MoveInfo.NextMoveStep(StepEnum.IB12_BatchAxisToP2);
                WorkLog("料串入料 ：料盘已拿走，批量轴到P2,测盘高 ");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                BatchAxisToP2();
            }
            else if (MoveInfo.IsStep(StepEnum.IB12_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(StepEnum.IB13_SaveHight);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                LastHeight = GetHeight();
                CheckHasTray();
            }

            #endregion

            #region 未检测到托盘或放料完成

            else if (MoveInfo.IsStep(StepEnum.IB21_BatchToP1))
            {
                //TODO 判断是否有空料串，没有的话直接准备出库

                MoveInfo.NextMoveStep(StepEnum.IB22_StopDown);
                WorkLog("上料完成 ：阻挡气缸下降");
                StopDown(MoveInfo);
            }
            else if (MoveInfo.IsStep(StepEnum.IB22_StopDown))
            {
                MoveInfo.NextMoveStep(StepEnum.IB23_ShelfOut);
                MoveInfo.TimeOutSeconds = 40;
                MoveInfo.OneWaitCanEndStep = true;

                bool agvcallresult = AgvClient.NeedLeave(Config.AgvName, CurrShelf.ShelfRfid, ClientLevel.High);
                WorkLog("上料完成 ：通知agv来取料串，等待料串离开Config.AgvName:" + Config.AgvName + ",CurrShelfId:" + CurrShelf.ShelfRfid + ",agvcallresult:" + agvcallresult.ToString());
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(60000));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineIn_Check, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(StepEnum.IB23_ShelfOut))
            {
                WarnMsg = "";
                alarmType = AlarmType.None;
                WorkLog("上料结束");
                MoveInfo.EndMove();
            }

            #endregion
        }

        private void IB09_ScanCode()
        {
            MoveInfo.NextMoveStep(StepEnum.IB09_ScanCode);
            bool isScan = ConfigAppSettings.GetIntValue(Setting_Init.NeedScanCode).Equals(1);

            LastCodeList = new List<string>();

            if (NextCodeList.Count > 0)
            {
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(300));
                LastCodeList = new List<string>(NextCodeList);
                NextCodeList = new List<string>();
                MoveInfo.MoveParam.PosInfo.barcode = CodeManager.ProcessCode(LastCodeList);
                MoveInfo.NextMoveStep(StepEnum.IB10_ScanOK);
                WorkLog("料盘移栽 ：使用预扫码【" + MoveInfo.MoveParam.PosInfo.barcode + "】，等待取料机构来取料");

            }
            else if (isScan)
            {
                WorkLog("料盘移栽 ：开始扫码");
                MoveInfo.OneWaitCanEndStep = true;
                MoveInfo.WaitList.Add(WaitResultInfo.WaitFeedScanCode());
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(6000));
                try
                {
                    Task<List<string>> scanTask = Task.Factory.StartNew(delegate
                    {
                        Robot.IOMove(IO_Type.CameraLed, IO_VALUE.HIGH);

                        LastCodeList = CodeManager.CameraScan(Config.CameraName, Name);
                        if (LastCodeList.Count <= 0)
                        {
                            LastCodeList = CodeManager.CameraScan(Config.CameraName, Name);
                        }
                        Robot.IOMove(IO_Type.CameraLed, IO_VALUE.LOW);
                        return LastCodeList;
                    });
                }
                catch (Exception ex)
                {
                    LogUtil.error(" IB09_ScanCode 扫码出错：", ex);
                }
            }
            else
            {
                WorkLog("料盘移栽 ：不需要扫码");
            }

        }

        private void CheckHasTray()
        {
            WarnMsg = "";
            if (Robot.IOValue(Config.IO_ReelCheck).Equals(IO_VALUE.HIGH) && MoveInfo.ShelfNoTray.Equals(false))
            {
                IB09_ScanCode();
            }
            else
            {
                if (MoveInfo.ShelfNoTray.Equals(false))
                {
                    //判断当前位置是否在指定的位置
                    int currP = BatchAxis.GetAclPosition();
                    int chaz = Math.Abs(currP - Config.BatchAxisP2);
                    if (chaz > BatchAxis.Config.CanErrorCountMax)
                    {
                        MoveInfo.NextMoveStep(StepEnum.IB07_AxisUpMove);
                        WorkLog("料串入料 ：CheckHasTray：上料轴开始慢速上升到P2点，等待检测到料盘。currP" + currP.ToString());
                        MoveInfo.ShelfNoTray = false;
                        BatchAxisToP2();
                        return;
                    }
                }
                //无料盘
                MoveInfo.ShelfNoTray = true;
                SendInShelfLeave(" 未检测到料盘 ");
            }
        }
        private void SendInShelfLeave(string msg = "")
        { 
            bool needLeave = true;
            //入料完成直接开始出库
            if (ShelfAutoOut || CurrShelf.ShelfState.Equals(2))
            {
                needLeave = false;
            }
            else  if (ShelfType.Equals(1) && Robot.BatchMove_B.ShelfReadyOut())
            {
                needLeave = true;
            }
            //如果已经有一个出库料串，这个直接离开
            else if (ShelfType.Equals(2) && Robot.BatchMove_A.ShelfReadyOut())
            {
                needLeave = true;
            }
            else
            {
                needLeave = false;
            }

            if (needLeave)
            {
                UpdateShelf(3);
                MoveInfo.NextMoveStep(StepEnum.IB21_BatchToP1);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                WorkLog("送出料串 ：" + msg + "，提升伺服到P1点");
                BatchAxis.SuddenStop();
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Robot.Config.BatchAxis_P1Speed);
            }
            else
            {
                MoveInfo.NextMoveStep(StepEnum.IB20_InStoreEnd);
                StartOutstore();
            }
        }
        #endregion


        #region 获取料盘高度
        public int StartMovePosition = 0;
        public int EndMovePosition = 0;
        internal int LastHeight = 0;
        public int GetHeight()
        {
            LastHeight = 0;
            int AxisChangeValue = Robot.Config.Height_ChangeValue;
            //计算高度
            EndMovePosition = BatchAxis.GetAclPosition();
            bool isLast = false;
            int chaz = Math.Abs(EndMovePosition - Config.BatchAxisP2);
            if (chaz < BatchAxis.Config.CanErrorCountMax)
            {
                isLast = true;
            }
            float height = (float)Math.Ceiling(1F * Math.Abs(EndMovePosition - StartMovePosition) / AxisChangeValue);
            string buchongStr = "";
            if (isLast)
            {
                buchongStr = "(最后一盘料已补充5)";
                height += 5;
            }

            //如果检测出<=15,都按照8计算
            if (height <= 15)
            {
                LastHeight = 8;
            }
            else
            {
                List<int> heightList = StoreManager.GetTrayList();
                heightList = (from m in heightList orderby m descending select m).ToList<int>();
                float minCha = height;
                foreach (int h in heightList)
                {
                    //取差值最小的接近值
                    float cha = Math.Abs(h - (height - 4));
                    if (cha < minCha)
                    {
                        LastHeight = h;
                        minCha = cha;
                    }
                }
            }
            if (LastHeight <= 8) { LastHeight = 8; }
            string code = CodeManager.ProcessCode(LastCodeList);
            string msg = Name + " 计算盘高：上升前 [" + StartMovePosition + "]实时[ " + EndMovePosition + "]差值[" + (EndMovePosition - StartMovePosition) + "]系数[" + AxisChangeValue + "] 计算后" + buchongStr + "[" + height + "]" + ",归类为【" + LastHeight + "mm】条码【" + code + "】";
            LogUtil.info(msg);
            return LastHeight;
        }
        #endregion


        #region 出库
        /// <summary>
        /// 入库完成的料串直接开始出库
        /// </summary>
        /// <returns></returns>
        public bool StartOutstore()
        {
            if (MoveInfo.MoveType.Equals(MoveType.InStore) && MoveInfo.IsStep(StepEnum.IB20_InStoreEnd))
            {
                MoveInfo.NewMove(MoveType.OutStore);
                //如果已经在P2位置 或者伺服检测信号亮，直接开始
                if (BatchAxis.IsInPosition(Config.BatchAxisP2) || Robot.IOValue(Config.IO_ReelCheck).Equals(IO_VALUE.LOW))
                {
                    ShelfToReady();
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IS07_AxisUpMove);
                    WorkLog("料串入库完成，料串上升到P2或检测到料盘");
                    BatchAxisToP2();
                }
            }
            return true;
        }
        protected void OutstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }

            if (MoveInfo.IsStep(StepEnum.IS07_AxisUpMove))
            {
                CheckShelfIsFull();
            }
            else if (MoveInfo.IsStep(StepEnum.IS11_ShelfReady))
            {
                if (ShelfNeedLeave)
                {
                    SendOutShelfLeave("手动送料串离开");
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IS11_ShelfReady);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IS12_AxisDown))
            {
                MoveInfo.NextMoveStep(StepEnum.IS13_WaitReel);
                WorkLog($"出库{MoveInfo.SLog} 伺服下降完成，等待放料盘");
            }
            else if (MoveInfo.IsStep(StepEnum.IS13_WaitReel))
            {

            }
            else if (MoveInfo.IsStep(StepEnum.IS14_ReelOK))
            {

            }

            #region 送料串离开

            else if (MoveInfo.IsStep(StepEnum.IS21_BatchToP1))
            {
                MoveInfo.NextMoveStep(StepEnum.IB22_StopDown);
                WorkLog("送出出库料串 ：阻挡气缸下降");
                StopDown(MoveInfo);
            }
            else if (MoveInfo.IsStep(StepEnum.IB22_StopDown))
            {
                MoveInfo.NextMoveStep(StepEnum.IS23_ShelfOut);
                MoveInfo.TimeOutSeconds = 40;
                MoveInfo.OneWaitCanEndStep = true;

                bool agvcallresult = AgvClient.NeedLeave(Config.AgvName, CurrShelf.ShelfRfid, ClientLevel.High);
                WorkLog("送出出库料串 ：通知agv来取料串，等待料串离开Config.AgvName:" + Config.AgvName + ",CurrShelfId:" + CurrShelf.ShelfRfid + ",agvcallresult:" + agvcallresult.ToString());
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(60000));
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineIn_Check, IO_VALUE.LOW));
            }
            else if (MoveInfo.IsStep(StepEnum.IS23_ShelfOut))
            {
                WarnMsg = "";
                alarmType = AlarmType.None;
                WorkLog("上料结束");
                MoveInfo.EndMove();
            }

            #endregion
        }

        internal void NewReelOut(InOutPosInfo posInfo, string xnRfid = "")
        {
            if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.IsStep(StepEnum.IS11_ShelfReady))
            {
                UpdateShelf(2, xnRfid);
                MoveInfo.NextMoveStep(StepEnum.IS12_AxisDown);
                MoveInfo.MoveParam.PosInfo = posInfo;
                int currPositon = BatchAxis.GetAclPosition();
                int downValue = Robot.Config.Height_ChangeValue * (posInfo.PlateH + 2);
                int batchTP = currPositon - downValue;
                if (batchTP <= Config.BatchAxisP1)
                {
                    batchTP = Config.BatchAxisP1;
                }
                WorkLog($"出库{MoveInfo.SLog}新料盘：{posInfo.ToStr()}，提升轴下降{posInfo.PlateH + 2}mm，目标位置{batchTP}");
                BatchAxis.AbsMove(MoveInfo, batchTP, Robot.Config.BatchAxis_P1Speed);
            }
            else
            {

                LogUtil.error(Name + "NewReelOut ,料串不在 IS11_ShelfReady 中，跳过暂不处理");
            }
        }

        internal void ReelPutOk()
        { 
            if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.IsStep(StepEnum.IS13_WaitReel))
            { 
                MoveInfo.NextMoveStep(StepEnum.IS14_ReelOK);
                WorkLog($"出库{MoveInfo.SLog} 放料完成");
                CheckShelfIsFull();
            }
            else
            {
                LogUtil.error(Name + "ReelPutOk ,料串不在等待放料 IS13_WaitReel 中，跳过暂不处理");
            }
        }

        private void CheckShelfIsFull()
        {
            int currPositon = BatchAxis.GetAclPosition();
            int nextP = currPositon - Robot.Config.Height_ChangeValue * (8 + 2);
            if (nextP <= Config.BatchAxisP1)
            {
                if (Robot.IOValue(Config.IO_ReelCheck).Equals(IO_VALUE.HIGH))
                {
                    SendOutShelfLeave("料串出满需离开");
                }
                else if (MoveInfo.IsStep(StepEnum.IB07_AxisUpMove))
                {
                    SendOutShelfLeave("料串出满需离开");
                }
                else
                {
                    MoveInfo.NextMoveStep(StepEnum.IS07_AxisUpMove);
                    WorkLog("料串入库完成，料串上升到P2或检测到料盘");
                    BatchAxisToP2();
                }
            }
            else
            {
                ShelfToReady();
            }
        }
        private void SendOutShelfLeave(string log)
        {
            MoveInfo.NewMove(MoveType.OutStore);
            MoveInfo.NextMoveStep(StepEnum.IS21_BatchToP1);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
            WorkLog($"送出料串{MoveInfo.SLog} ：" + log + "，提升伺服到P1点");
            UpdateShelf(3);
            BatchAxis.SuddenStop();
            BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Robot.Config.BatchAxis_P1Speed);
        }
        private void ShelfToReady()
        {
            UpdateShelf(2);
            MoveInfo.NextMoveStep(StepEnum.IS11_ShelfReady);
            WorkLog($"出库{MoveInfo.SLog}料串{CurrShelf.ToStr()}准备完成");
            ShelfNeedLeave = false;
        }
        #endregion



        #region AGV 处理
        internal bool ProcessShelfOut = false;
        internal bool ProcessShelfEnter = false;
        internal void AgvReady(string nodeId, string rfid, ClientAction clientaction)
        {
            if (clientaction == ClientAction.MayLeave)
            {
                ShelfOutProcess(nodeId, rfid);
            }
            else
            {
                ShelfEnterProcess(nodeId, rfid);
            }
        }
        internal void ShelfEnterProcess(string nodeId, string rfid)
        {
            Task.Factory.StartNew(delegate
            {
                UpdateShelf();
                string logName = Name + "料串 " + rfid + " [AGV->" + Config.AgvName + "] ";
                try
                {
                    if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.LOW) && Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.LOW))
                    {
                        LogUtil.info(logName + "   开始转动线体");
                        ProcessShelfEnter = true;
                        LineRun();

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

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待{ Config.IO_LineIn_Check}=High 超时， 等待 {Config.IO_LineEnd_Check } 信号");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {Config.IO_LineIn_Check}=High ， 等待 { Config.IO_LineEnd_Check} 信号");
                        }
                        result = Robot.WaitIo(Config.IO_LineEnd_Check, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待 {Config.IO_LineEnd_Check} =High 超时，等待3000后停止转动，发送  FinishEnter");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {Config.IO_LineEnd_Check} =High ，等待3000后停止转动，发送   FinishEnter");
                        }
                        //等待200毫秒后停止转动
                        Thread.Sleep(3000);

                        LogUtil.info(logName + "等待3000后，停止链条转动");
                        LineStop();

                        //料串可离开
                        AgvClient.SetStatus(Config.AgvName, "", ClientAction.FinishEnter, ClientLevel.High, true);
                        Task.Factory.StartNew(delegate
                        {
                            Thread.Sleep(10000);
                            AgvClient.SetStatus(Config.AgvName, "", ClientAction.None, ClientLevel.High, true);
                        });
                        ProcessShelfEnter = false;
                        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;
                }
            });
        }

        internal void ShelfOutProcess(string nodeId, string rfid)
        {
            //AGV已到达，将料串送入AGV中
            Task.Factory.StartNew(delegate
            {
                string logName = Name + "料串" + rfid + "[" + Config.AgvName + "->AGV ]  ";
                try
                {
                    //AgvClient.SetStatus(Config.AgvName, CurrShelfId, ClientAction.None, ClientLevel.High, true);
                    if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH) || Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                    {
                        ProcessShelfOut = true;
                        LineBack();
                        bool result = Robot.WaitIo(Config.IO_LineIn_Check, IO_VALUE.LOW, 60000);
                        if (!result)
                        {
                            LogUtil.error(logName + $"  等待 { Config.IO_LineIn_Check}=LOW超时，等待8000后停止转动，发送FinishLeave");
                        }
                        else
                        {
                            LogUtil.info(logName + $"  已收到 {Config.IO_LineIn_Check}=LOW ，等待8000后停止转动，发送FinishLeave");
                        }
                        //再转动2000
                        Thread.Sleep(8000);
                        LineStop();
                        AgvClient.SetStatus(Config.AgvName, CurrShelf.ShelfRfid, ClientAction.FinishLeave, ClientLevel.High, true);
                        Task.Factory.StartNew(delegate
                        {
                            Thread.Sleep(10000);
                            AgvClient.SetStatus(Config.AgvName, "", ClientAction.None, ClientLevel.High, true);
                        });
                        ProcessShelfOut = false;
                        LogUtil.info(logName + "结束,停止转动，清空料串[" + CurrShelf.ShelfRfid + "] ");
                        UpdateShelf();
                    }
                    else
                    {
                        LogUtil.info(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
                {
                    LineStop();
                    ProcessShelfOut = false;
                }
            });
        }

        #endregion


        public void GetTrayOK()
        {
            if (MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                MoveInfo.NextMoveStep(StepEnum.IB11_WaitReelLeave);
                WorkLog("当前料盘已离开，清理高度，准备开始测高");
                LastHeight = 0;
            }
            else
            {
                LogUtil.error(Name + "当前状态：" + MoveInfo.MoveType + ",GetTrayOK暂不处理");
            }
        }

        private bool isFastLoad = false;
        private bool UpdateShelf(int state = 0, string xnRfid = "")
        {
            try
            {
                string configStr = "";
                if (ShelfType.Equals(1))
                {
                    configStr = Setting_Init.AShelfInfo;
                }
                else
                {
                    configStr = Setting_Init.BShelfInfo;
                }
                if (state.Equals(0))
                {
                    CurrShelf = new ShelfInfo();
                }
                else
                {
                    if (isFastLoad)
                    {
                        CurrShelf = BufferDataManager.LoadData<ShelfInfo>(configStr);
                        isFastLoad = true;
                        LogUtil.info(Name + "当前料串信息：" + CurrShelf.ToStr());
                        return false;
                    }
                    else
                    {
                        RFIDData rfidD = RFIDManager.ReadRFID(Config.RfidIP);
                        CurrShelf = new ShelfInfo(rfidD.StrData, state, xnRfid);
                        BufferDataManager.SaveData<ShelfInfo>(configStr, CurrShelf);
                        LogUtil.info(Name + "当前料串信息：" + CurrShelf.ToStr());
                    }
                }


            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "UpdateShelfId出错：", ex);
            }
            return true;
        }
    }

    public class ShelfInfo
    {

        public ShelfInfo(string rfid = "", int state = 0, string xnrfid = "")
        {
            this.ShelfRfid = rfid;
            this.ShelfState = state;
            this.XuniRfid = xnrfid;
        }
        /// <summary>
        /// 料串RFID
        /// </summary>
        public string ShelfRfid = "";
        /// <summary>
        /// 料串状态，0=未开始，1=入库，2=出库中,3=需要离开
        /// </summary>
        public int ShelfState = 0;

        public string XuniRfid = "";

        public string ToStr()
        {
            if (ShelfState.Equals(1))
            {
                return "料串：" + ShelfRfid + "_入库中";
            }
            else if (ShelfState.Equals(2))
            {
                return "料串：" + ShelfRfid + "_出库中";
            }
            else if (ShelfState.Equals(3))
            {
                return "料串：" + ShelfRfid + "_需离开";
            }
            else
            {
                return ShelfRfid;
            }
        }
    }

}