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 bool MoveStop = false;
        public ShelfInfo CurrShelf = new ShelfInfo();
        #region 入库
        /// <summary>
        /// 扫码前是否到了P4点
        /// </summary>
        private bool toBatchP4 = false;
        /// <summary>
        /// 扫门前料盘位置
        /// </summary>
        private int batchAxisReelPosition = 0;
        private List<string> preCodeList = new List<string>();
        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;
            }
            else if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
            {
                MoveInfo.NewMove(MoveType.InStore, new InOutParam());
                IB03_LineStart();
            }
            else if (Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
            {
                MoveInfo.NewMove(MoveType.InStore, new InOutParam());
                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("定位工位检测到料串： 链条停止，阻挡气缸上升");
            LineStop();
            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点，等待检测到料盘");
            preCodeList = new List<string>(LastCodeList);
            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))
            {
                IB03_LineStart();
            }
            else if (MoveInfo.IsStep(StepEnum.IB03_LineStart))
            {
                if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
                {
                    IB03_LineStart();
                }
                else if (Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                {
                    IB04_LineWait();
                }
                else
                {
                    LineStop();
                    MoveInfo.EndMove();
                    LogUtil.info(" 未检测到料串，入料结束");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IB04_LineWait))
            {
                if (Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                {
                    IB05_StopUp();
                }
                else
                {
                    LineStop();
                    MoveInfo.EndMove();
                    LogUtil.info(" 未检测到料串，入料结束");
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IB05_StopUp))
            {
                LineStop();
                if (Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                {
                    if (CurrShelf != null && 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.IB08_BatchAxisToP4))
            {
                if (Robot.AxisIsInShelfUp(ShelfType))
                {
                    MoveInfo.NextMoveStep(StepEnum.IB09_WaitCanScan);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                    WorkLog("旋转轴在料串上方，暂不能扫码，等待旋转轴离开");
                }
                else
                {
                    IB11_ScanCode();
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IB09_WaitCanScan))
            {
                if (!Robot.AxisIsInShelfUp(ShelfType))
                {
                    IB11_ScanCode();
                }
                else if (MoveInfo.IsTimeOut(10))
                {
                    WarnMsg = Name + "[" + MoveInfo.MoveStep + "] " + "等待旋转轴离开料串超时" + "[" + FormUtil.GetSpanStr(MoveInfo.StepSpan()) + "]";
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IB11_ScanCode))
            {

                if (scanTask == null || scanTask.IsCompleted)
                {
                    ClearWarnMsg("扫码超时");
                    //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());
                    }


                    //如果之前走到了扫码点，需要下降
                    if (toBatchP4)
                    {
                        MoveInfo.NextMoveStep(StepEnum.IB12_BatchAxisToReelPosition);
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                        BatchAxis.AbsMove(MoveInfo, batchAxisReelPosition, Robot.Config.BatchAxis_P4Speed);
                        WorkLog("扫码结束，扫码前走到了扫码点【" + Config.BatchAxisP4 + "】，批量轴需要返回之前位置【" + batchAxisReelPosition + "】");
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.IB13_ScanOK);
                        var span = DateTime.Now - MoveInfo.LastSetpTime;
                        WorkLog("料串入料 ：扫码结束【" + code + "】，等待取料机构来取料," + MoveInfo.MoveParam.PosInfo.ToStr());
                    }
                }
                else
                {
                    WarnMsg = Name + "[" + MoveInfo.MoveStep + "]  扫码超时  [" + FormUtil.GetSpanStr(MoveInfo.StepSpan()) + "]";
                    LogUtil.error(WarnMsg, 999);
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IB12_BatchAxisToReelPosition))
            {
                string code = CodeManager.ProcessCode(LastCodeList);
                MoveInfo.NextMoveStep(StepEnum.IB13_ScanOK);
                var span = DateTime.Now - MoveInfo.LastSetpTime;
                WorkLog("料串入料 ：扫码结束【" + code + "】，等待取料机构来取料," + MoveInfo.MoveParam.PosInfo.ToStr());
            }
            else if (MoveInfo.IsStep(StepEnum.IB14_ReelLeave))
            {
                MoveInfo.NextMoveStep(StepEnum.IB15_BatchAxisToP2);
                WorkLog("料串入料 ：料盘已拿走，批量轴到P2,测盘高 ");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                BatchAxisToP2();
            }
            else if (MoveInfo.IsStep(StepEnum.IB15_BatchAxisToP2))
            {
                MoveInfo.NextMoveStep(StepEnum.IB16_SaveHight);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                LastHeight = GetHeight();
            }
            else if (MoveInfo.IsStep(StepEnum.IB17_WaitReelLeave))
            {
                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
        }

        public bool IsInScanCode()
        {
            if (MoveInfo.MoveType.Equals(MoveType.InStore) && MoveInfo.IsStep(StepEnum.IB11_ScanCode))
            {
                return true;
            }
            return false;
        }
        bool isScan = ConfigAppSettings.GetIntValue(Setting_Init.NeedScanCode).Equals(1);
        private Task<List<string>> scanTask = null;
        private void IB11_ScanCode()
        {
            ClearWarnMsg("等待旋转轴离开料串超时");
            MoveInfo.NextMoveStep(StepEnum.IB11_ScanCode);
            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
                    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);

                      //TODO 需要判断是否和上次的条码重复，重复的条码不可用
                      bool isCanUse = true;
                      //判断是否可用
                      foreach (string nC in LastCodeList)
                      {
                          foreach (string n in preCodeList)
                          {
                              //if(CodeManager.HasRightCode(nC))
                              if (nC.Length > 15 && nC.Equals(n))
                              {
                                  LogUtil.error(Name + "扫码结果【" + nC + "】与上个条码【" + n + "】重复，扫码结果不可用");
                                  isCanUse = false;
                                  break;
                              }
                          }
                      }
                      if (!isCanUse)
                      {
                          LastCodeList = new List<string>();
                      }

                      return LastCodeList;
                  });
                }
                catch (Exception ex)
                {
                    LogUtil.error(" IB09_ScanCode 扫码出错：", ex);
                }
            }
            else
            {
                scanTask = null;
                WorkLog("料盘移栽 ：不需要扫码");
            }

        }

        private void CheckHasTray()
        {
            WarnMsg = "";
            if (Robot.IOValue(Config.IO_ReelCheck).Equals(IO_VALUE.HIGH) && MoveInfo.ShelfNoTray.Equals(false))
            {

                toBatchP4 = false;

                //判断扫码点是否可用，可用，运动到扫码点
                int currP = BatchAxis.GetAclPosition();
                int targetPosition = currP + Config.BatchAxisP4;
                if (Config.BatchAxisP4 > 0 && (targetPosition < Config.BatchAxisP2))
                {
                    batchAxisReelPosition = currP;
                    toBatchP4 = true;
                    MoveInfo.NextMoveStep(StepEnum.IB08_BatchAxisToP4);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
                    BatchAxis.AbsMove(MoveInfo, targetPosition, Robot.Config.BatchAxis_P4Speed);
                    WorkLog("料盘已到位，批量轴当前位置【" + currP + "】，扫码上升高度P4【" + Config.BatchAxisP4 + "】可用，批量轴走到扫码点【" + targetPosition + "】");
                }
                else
                {
                    LogUtil.info(Name + "料盘已到位，批量轴当前位置【" + currP + "】扫码上升高度P4【" + Config.BatchAxisP4 + "】扫码点【" + targetPosition + "】P2【" + Config.BatchAxisP2 + "】,可直接扫码");
                    if (Robot.AxisIsInShelfUp(ShelfType))
                    {
                        MoveInfo.NextMoveStep(StepEnum.IB09_WaitCanScan);
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                        WorkLog("旋转轴在料串上方，暂不能扫码，等待旋转轴离开");
                    }
                    else
                    {
                        IB11_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 = "")
        {
            WorkLog(" SendInShelfLeave :" + msg + ",清空条码");
            LastCodeList = new List<string>();
            preCodeList = new List<string>();
            bool needLeave = true;
            //入料完成直接开始出库
            if (ShelfAutoOut || CurrShelf.ShelfState.Equals(2))
            {
                needLeave = false;
            }
            else if (ShelfType.Equals(1) && Robot.BatchMove_B.ShelfIsOut())
            {
                needLeave = true;
            }
            //如果已经有一个出库料串，这个直接离开
            else if (ShelfType.Equals(2) && Robot.BatchMove_A.ShelfIsOut())
            {
                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计算
            int heightLimit = ConfigAppSettings.GetIntValue(Setting_Init.HeightLimit, 13);
            if (height <= heightLimit)
            {
                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));
                    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.HIGH))
                {
                    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
                {
                    if (SServerManager.GetOutTaskCount(MoveInfo.MoveParam.PosInfo.hSerial) == 0)
                    {
                        SendOutShelfLeave("检测到工单已结束:" + MoveInfo.MoveParam.PosInfo.hSerial);
                    }
                    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))
            {

            }
            else if (MoveInfo.IsStep(StepEnum.IS15_CheckShelfNeedLeave))
            {
                CheckShelfIsFull();
            }

            #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;

                //如果料盘检测信号亮或者是上料目标位置，需要多下降20mm
                int downValueMM = 4;
                if (Robot.IOValue(Config.IO_ReelCheck).Equals(IO_VALUE.HIGH) || BatchAxis.IsInPosition(Config.BatchAxisP2))
                {
                    downValueMM = 20;
                }

                int currPositon = BatchAxis.GetAclPosition();
                int downValue = Robot.Config.Height_ChangeValue * (posInfo.PlateH + downValueMM);
                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);
                int remain=SServerManager.GetOutTaskCount(MoveInfo.MoveParam.PosInfo.hSerial);
                WorkLog($"出库{MoveInfo.SLog} 放料完成 【{MoveInfo.MoveParam.PosInfo.hSerial}】【remain={remain}】");
                if (remain == 0)
                {
                    SendOutShelfLeave("工单已结束:" + MoveInfo.MoveParam.PosInfo.hSerial);

                }
                else
                    CheckShelfIsFull();
            }
            else
            {
                LogUtil.error(Name + "ReelPutOk ,料串不在等待放料 IS13_WaitReel 中，跳过暂不处理");
            }
        }

        private void CheckShelfIsFull()
        {
            int currPositon = BatchAxis.GetAclPosition();
            int nextP = currPositon - Robot.Config.Height_ChangeValue * (8 + 20);
            if (nextP <= Config.BatchAxisP1)
            {
                if (Robot.IOValue(Config.IO_ReelCheck).Equals(IO_VALUE.HIGH))
                {
                    //IS14_ReelOK
                    //如果是刚刚放料结束的判断，需要等1500再次判断
                    if (MoveInfo.IsStep(StepEnum.IS14_ReelOK))
                    {
                        MoveInfo.NextMoveStep(StepEnum.IS15_CheckShelfNeedLeave);
                        WorkLog($"出库{MoveInfo.SLog} 放料完成，检测到料串出满需离开(信号到位)，等待1500后再次判断");
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1500));
                    }
                    else
                    {
                        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.IB14_ReelLeave);
                WorkLog("当前料盘已离开，清理高度，准备开始测高");
                LastHeight = 0;
            }
            else
            {
                LogUtil.error(Name + "当前状态：" + MoveInfo.MoveType + ",GetTrayOK暂不处理");
            }
        }

        public void GetTrayStartLeave()
        {
            if (MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                if (MoveInfo.IsStep(StepEnum.IB16_SaveHight))
                {
                    MoveInfo.NextMoveStep(StepEnum.IB17_WaitReelLeave);
                    WorkLog("当前料盘已离开,开始判断是否有下一盘，开始扫码");
                    LastHeight = 0;
                }
            }
            else
            {
                LogUtil.error(Name + "当前状态：" + MoveInfo.MoveType + ",GetTrayLeave暂不处理");
            }
        }

        private bool isFastLoad = true;
        public 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();
                    AgvClient.SetStatus(Config.AgvName);
                }
                else
                {
                    if (isFastLoad)
                    {
                        CurrShelf = BufferDataManager.LoadData<ShelfInfo>(configStr);
                        isFastLoad = false;
                        LogUtil.info(Name + "首次初始化料串，从配置中加载到当前料串信息：" + CurrShelf.ToStr());
                        return false;
                    }
                    else
                    {
                        RFIDData rfidD = RFIDManager.ReadRFID(Config.RfidIP);
                        CurrShelf = new ShelfInfo(rfidD.StrData, state, xnRfid);
                        LogUtil.info(Name + "读取到当前料串信息：" + CurrShelf.ToStr());
                        BufferDataManager.SaveData<ShelfInfo>(configStr, CurrShelf);
                    }
                }


            }
            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;
            }
        }
    }

}