using DeviceLibrary;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    public partial class BatchMoveBean
    {
        public bool ShelfAutoOut = false;
        public bool ShelfNeedLeave = false;
        public string Name = "料口";
        public AxisBean BatchAxis = null;
        public int ShelfType = 1;//1=左侧A，2=右侧B
        public DeviceMoveInfo MoveInfo;
        public string WarnMsg = "";
        public BatchMoveConfig Config = null;
        public DoorInfo doorInfo;
        private InputEquip Robot
        {
            get { return StoreManager.XLRStore.inputEquip; }
        }
        public BatchMoveBean(InputEquip_Config config, AxisBean axis, int inType = 1)
        {
            Config = new BatchMoveConfig();
            this.ShelfType = inType;
            this.BatchAxis = axis;
            string ioAdd = "_A";
            if (ShelfType.Equals(1))
            {
                doorInfo = new DoorInfo(doorIndexE.XLR_1);
                ioAdd = "_A";
                Name = "A料口 ";
                Config.BatchAxisP1 = config.BatchAxisP1_A;
                Config.BatchAxisP2 = config.BatchAxisP2_A;
                Config.BatchAxisP4 = config.BatchAxisP4_A;

                Config.AgvName = config.AgvName_A;
                Config.CameraName = config.CameraNameList_A;
                Config.RfidIP = config.PRO_RFIP_A;
            }
            else
            {
                doorInfo = new DoorInfo(doorIndexE.XLR_2);
                ioAdd = "_B";
                Name = "B料口 ";
                Config.BatchAxisP1 = config.BatchAxisP1_B;
                Config.BatchAxisP2 = config.BatchAxisP2_B;
                Config.BatchAxisP4 = config.BatchAxisP4_B;

                Config.AgvName = config.AgvName_B;
                Config.CameraName = config.CameraNameList_B;
                Config.RfidIP = config.PRO_RFIP_B;
            }

            Config.LoadIO(ioAdd);
            MoveInfo = new DeviceMoveInfo(Name);
            cames = ConfigHelper.Config.Get<string[]>($"{Name}_HeightCams");
            lineInSigMonitor = new SignalMonitor(false);
        }
        DeviceLibrary.SignalMonitor lineInSigMonitor;
        DateTime LineIn_Check_ONTime = DateTime.MaxValue;

        //出料口线体料盘检测，true：有料盘
        public bool CameraCheck(string deviceName, out string ngList)
        {
            return ReelCheckCamera.AOICheck(deviceName, $"AOI.data", Name, out ngList);
        }
        public void TimerProcess()
        {
            //如果急停，不再处理
            if (Robot.alarmType.Equals(AlarmType.SuddenStop) || Robot.alarmType.Equals(AlarmType.NoAirpressure_Check))
            {
                return;
            }
            lineInSigMonitor.UpdateSignalState(Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH));
            if (!MoveStop)
            {
                if (MoveInfo.MoveType.Equals(MoveType.None))
                {
                    WarnMsg = "";
                    if (Robot.MoveInfo.MoveType.Equals(MoveType.Reset) || Robot.MoveInfo.MoveType.Equals(MoveType.RHome))
                    {
                    }
                    else
                    {
                        LogUtil.debug($"{Name} 处理1");
                        if (Robot.IOValue(Config.IO_AGV_RequestIn).Equals(IO_VALUE.HIGH))
                        {
                            ShelfEnterProcess("", "");
                        }
                        else if (Robot.AutoInput && Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH))
                        {
                            if(lineInSigMonitor.GetCurrentOnDuration().TotalMilliseconds > 500)
                            {
                                ResetShelf = false;
                                LogUtil.debug($"{Name} 处理2");
                                WorkLog("前端信号亮，开始入库");
                                StartInstore(new InOutParam());
                            }
                        }
                        else if (Robot.AutoInput && Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH))
                        {
                            if(!ResetShelf)
                            {
                                WorkLog("末端信号亮，开始入库");
                                LogUtil.debug($"{Name} 处理3");
                                StartInstore(new InOutParam());
                            }

                        }
                    }
                }
                else if (MoveInfo.MoveType.Equals(MoveType.Reset))
                {
                    ResetProcess();
                }
                else if (MoveInfo.MoveType.Equals(MoveType.InStore))
                {
                    InstoreProcess();
                }
                else if (MoveInfo.MoveType.Equals(MoveType.OutStore))
                {
                    OutstoreProcess();
                }
            }


            //判断是否无料串
            if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.LOW)
                && Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.LOW)
                && Robot.CylinderIsOk(Config.IO_Shelf_StopUp, Config.IO_Shelf_StopDown))
            {


                if (StoreManager.checkWatch(shelfWatch, 10000, true))
                {

                    //doorInfo.hSerial = MoveInfo.MoveParam.hSerial;
                    doorInfo.status = doorStatusE.free;
                    doorInfo.hasContainer = false;
                    WorkLog($"无料串,：通知agv来送料串 ShelfType:{ShelfType},{doorInfo.doorIndex},hasContainer:{doorInfo.hasContainer}");
                    //Asa.ClientAction action= AgvClient.GetAction(Config.AgvName);
                    //var agvcallresult = AgvClient.NeedEnter(Config.AgvName, "", Asa.ClientLevel.High);
                    //if (!action.Equals(Asa.ClientAction.NeedEnter))
                    //{ 
                    //    WorkLog("无料串,：通知agv来送料串AgvName:" + Config.AgvName + ",send NeedEnter=:" + agvcallresult.ToString());
                    //}
                }
            }
            else if (Robot.IOValue(Config.IO_LineIn_Check).Equals(IO_VALUE.HIGH) && Robot.IOValue(Config.IO_LineEnd_Check).Equals(IO_VALUE.HIGH)
                && AgvClient.GetAction(Config.AgvName) != Asa.ClientAction.NeedLeave && AgvClient.GetAction(Config.AgvName) != Asa.ClientAction.MayLeave && AgvClient.GetAction(Config.AgvName) != Asa.ClientAction.FinishLeave)
            {
                shelfWatch.Stop();

                //doorInfo.status = doorStatusE.inStore;
                //doorInfo.hasContainer = true;
                //AgvClient.SetToNone(Config.AgvName);
            }
        }
        private Stopwatch shelfWatch = new Stopwatch();
        public bool ResetShelf = false;
        public bool Reset(bool needStop = false, bool resetShelf = false)
        {
            WarnMsg = "";
            if (Robot.CanStartRun())
            {
                if (Robot.runStatus >= RunStatus.HomeMoving)
                {
                    if (needStop)
                    {
                        StopMove();
                    }
                    string msg = "";
                    bool axisOpen = BatchAxis.Open(true, out msg);
                    //   WorkLog("批量轴打开结果：" + axisOpen);
                    if (!axisOpen)
                    {
                        BatchAxis.SuddenStop();
                        BatchAxis.ServoOff();

                        WarnMsg = Name + "复位失败：批量轴打开失败:" + msg;
                        return false;
                    }
                    if (resetShelf)
                    {
                        WorkLog("复位前重置料串状态");
                        UpdateShelf();
                    }
                    ResetShelf = resetShelf;
                    preCodeList = new List<string>();
                    WarnMsg = "";
                    alarmType = AlarmType.None;
                    MoveInfo.NewMove(MoveType.Reset, new InOutParam());
                    MoveInfo.NextMoveStep(StepEnum.IBR01_StopDown);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
                    WorkLog("开始复位，定位气缸下降");
                    StopDown(MoveInfo);
                    return true;
                }
                else
                {
                    WarnMsg = Name + "复位失败：入料机构未启动";
                }
            }
            else
            {
                WarnMsg = Name + "复位失败";
            }
            return false;
        }


        private void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }

            if (MoveInfo.IsStep(StepEnum.IBR01_StopDown))
            {
                MoveInfo.NextMoveStep(StepEnum.IBR02_LineRun);
                WorkLog("复位：链条正转3秒");
                LineRun(MoveInfo);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
            }
            else if (MoveInfo.IsStep(StepEnum.IBR02_LineRun))
            {
                LineStop();
                MoveInfo.NextMoveStep(StepEnum.IBR03_BatchToP1);
                WorkLog("复位：批量轴走到待机点");
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Robot.Config.BatchAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IBR03_BatchToP1))
            {
                MoveInfo.NextMoveStep(StepEnum.IBR04_BatchHome);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000));
                WorkLog("复位：批量轴开始回原点");
                BatchAxis.HomeMove(MoveInfo);
            }
            else if (MoveInfo.IsStep(StepEnum.IBR04_BatchHome))
            {
                MoveInfo.NextMoveStep(StepEnum.IBR05_WaitTime);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(100));
            }
            else if (MoveInfo.IsStep(StepEnum.IBR05_WaitTime))
            {
                MoveInfo.NextMoveStep(StepEnum.IBR06_BatchToP1);
                WorkLog("复位：批量轴走到待机点");
                BatchAxis.AbsMove(MoveInfo, Config.BatchAxisP1, Robot.Config.BatchAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StepEnum.IBR06_BatchToP1))
            {
                //Robot.IOMove(IO_Type.CameraLed, IO_VALUE.HIGH);
                WorkLog("复位完成");
                MoveInfo.EndMove();
            }
        }

        internal void StopMove()
        {
            LogUtil.info(Name + " Stop Move ");
            MoveInfo.EndMove();
            BatchAxis.AxisStopCheckMove();
            BatchAxis.SuddenStop();
        }

        public DateTime LastAlarmTime = DateTime.Now;
        public AlarmType alarmType = AlarmType.None;
        internal void Alarm(AlarmType alarmType)
        {
            if (alarmType.Equals(AlarmType.None).Equals(false))
            {
                LastAlarmTime = DateTime.Now;
            }
            if (this.alarmType.Equals(alarmType))
            {
                return;
            }
            this.alarmType = alarmType;
            if (alarmType.Equals(AlarmType.SuddenStop) || alarmType.Equals(AlarmType.NoAirpressure_Check) || alarmType.Equals(AlarmType.AxisAlarm))
            {
                StopMove();
            }
        }
        #region 气缸操作

        public void LineRun(DeviceMoveInfo moveInfo = null)
        {
            Robot.IOMove(Config.IO_LineBack, IO_VALUE.LOW);
            Robot.IOMove(Config.IO_LineStart, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineBack, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineStart, IO_VALUE.HIGH));
            }
        }
        public void LineBack(DeviceMoveInfo moveInfo = null)
        {
            Robot.IOMove(Config.IO_LineStart, IO_VALUE.LOW);
            Robot.IOMove(Config.IO_LineBack, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineStart, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineBack, IO_VALUE.HIGH));
            }
        }
        public void LineStop(DeviceMoveInfo moveInfo = null)
        {
            Robot.IOMove(Config.IO_LineBack, IO_VALUE.LOW);
            Robot.IOMove(Config.IO_LineStart, IO_VALUE.LOW);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineBack, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_LineStart, IO_VALUE.LOW));
            }
        }
        public void StopDown(DeviceMoveInfo moveInfo = null)
        {
            Robot.IOMove(Config.IO_Shelf_StopUp, IO_VALUE.LOW);
            Robot.IOMove(Config.IO_Shelf_StopDown, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_Shelf_StopUp, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_Shelf_StopDown, IO_VALUE.HIGH));
            }
        }
        public void StopUp(DeviceMoveInfo moveInfo = null)
        {
            Robot.IOMove(Config.IO_Shelf_StopDown, IO_VALUE.LOW);
            Robot.IOMove(Config.IO_Shelf_StopUp, IO_VALUE.HIGH);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_Shelf_StopDown, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(Config.IO_Shelf_StopUp, IO_VALUE.HIGH));
            }
        }
        #endregion


        #region 提升轴匀速上升处理 
        public bool LastMoveIsTest = true;

        public void BatchAxisToP2(bool isFirstMove = true, bool isWait = true, bool IsTest = false)
        {
            int targetP2 = Config.BatchAxisP2;
            int targetSpeed = Robot.Config.BatchAxis_P2Speed;
            if (!isFirstMove)
            {
                int currPosition = BatchAxis.GetAclPosition();
                if (currPosition != -1)
                {
                    targetP2 = currPosition + Robot.Config.Height_ChangeValue * 80;
                    if (targetP2 > Config.BatchAxisP2)
                    {
                        targetP2 = Config.BatchAxisP2;
                    }
                }
                targetSpeed = Robot.Config.BatchAxis_P3Speed;
            }
            else
            {
                targetSpeed = Robot.Config.BatchAxis_P1Speed;
            }
            //  需要增加定时器，获取验证信号并停止伺服
            StartMovePosition = BatchAxis.GetAclPosition();
            if (isWait)
            {
                MoveInfo.TimeOutSeconds = 200;
                MoveInfo.CanWhileCount = 0;
                MoveInfo.WaitList.Add(WaitResultInfo.WaitBatchAxis(BatchAxis.Config, targetP2, targetSpeed));
            }
            BatchAxis.Config.TargetPosition = targetP2;
            BatchAxis.AbsMove(null, targetP2, targetSpeed);
            //开始检测信号
            BatchAxis.BatchAxisStartCheck(Config.IO_ReelCheck, IO_VALUE.HIGH);
            LastMoveIsTest = IsTest;
            LogUtil.info(Name + " BatchAxisToP2 目标P2: " + targetP2 + "(" + targetSpeed + ")");
        }
        public void BatchAxisDown()
        {
            int targetP1 = Config.BatchAxisP1;
            int targetSpeed = Robot.Config.BatchAxis_P1Speed;
            {
                MoveInfo.TimeOutSeconds = 200;
                MoveInfo.CanWhileCount = 0;
                MoveInfo.WaitList.Add(WaitResultInfo.WaitBatchAxis(BatchAxis.Config, targetP1, targetSpeed));
            }
            BatchAxis.Config.TargetPosition = targetP1;
            BatchAxis.AbsMove(null, targetP1, targetSpeed);
            //开始检测信号
            BatchAxis.BatchAxisStartCheck(Config.IO_ReelCheck, IO_VALUE.LOW);
            LogUtil.info(Name + " 向P1点运行，直到料盘检测信号灭: " + targetP1 + "(" + targetSpeed + ")");
        }
        #endregion

        private DateTime preCheckAxisTime = DateTime.Now;
        protected DateTime preRWTime = DateTime.Now;
        internal void CheckWait(DeviceMoveInfo moveInfo)
        {
            int DeviceID = 10 + ShelfType;
            try
            {
                List<WaitResultInfo> list = moveInfo.WaitList;
                if (list.Count <= 0)
                {
                    moveInfo.EndStepWait();
                    return;
                }

                //当等待超过一分钟时，需要打印提示 
                TimeSpan span = DateTime.Now - moveInfo.LastSetpTime;
                if (span.TotalMilliseconds < 300)
                {
                    return;
                }
                string NotOkMsg = "";
                bool isOk = !moveInfo.OneWaitCanEndStep;
                foreach (WaitResultInfo wait in list)
                {
                    if (wait.IsEnd)
                    {
                        continue;
                    }
                    NotOkMsg = " [" + wait.ToStr() + "] ";
                    if (wait.WaitType.Equals(WaitEnum.W001_AxisMove))
                    {
                        TimeSpan axisSpan = DateTime.Now - preCheckAxisTime;
                        if (axisSpan.TotalSeconds > 1)
                        {
                            preCheckAxisTime = DateTime.Now;
                            string msg = "";
                            if (wait.IsHomeMove)
                            {
                                wait.IsEnd = AxisBean.HomeMoveIsEnd(moveInfo, wait.AxisInfo, out msg);
                            }
                            else
                            {
                                wait.IsEnd = AxisBean.ACAxisMoveIsEnd(moveInfo, wait.AxisInfo, wait.TargetPosition, wait.TargetSpeed, out msg);
                            }
                            if (!msg.Equals(""))
                            {
                                isOk = false;
                                WarnMsg = Name + msg;
                                Alarm(AlarmType.AxisMoveError);
                                LogUtil.error(WarnMsg, moveInfo.ErrorLogType, moveInfo.logSeconds());
                                break;
                            }
                        }
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W002_IOValue))
                    {
                        NotOkMsg = " [" + IOManager.GetIO(wait.IoType, Robot.DeviceID).DisplayStr + "=" + wait.IoValue + "]";
                        wait.IsEnd = Robot.IOValue(wait.IoType).Equals(wait.IoValue);

                        if (!wait.IsEnd && (!moveInfo.IsStep(StepEnum.IB23_ShelfOut)))
                        {
                            TimeSpan rwSpan = DateTime.Now - preRWTime;
                            //一分钟还未检测到
                            if (span.TotalSeconds > StoreManager.Config.IOSingle_TimerOut && alarmType <= AlarmType.IoSingleTimeOut)
                            {
                                ConfigIO io = Robot.Config.getWaitIO(wait.IoType);
                                WarnMsg = moveInfo.Name + "[" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "] 等待" + NotOkMsg + " 超时 " + Math.Round(span.TotalSeconds, 1) + "秒";

                                LogUtil.error(WarnMsg, moveInfo.ErrorLogType, moveInfo.logSeconds());
                                if (alarmType.Equals(AlarmType.None))
                                {
                                    Alarm(AlarmType.IoSingleTimeOut);
                                }
                            }
                            else if (rwSpan.TotalSeconds > 5 && span.TotalSeconds > 6 && span.TotalSeconds < StoreManager.Config.IOSingle_TimerOut * 2)
                            {
                                preRWTime = DateTime.Now;
                                string msg = moveInfo.Name + " [" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "] " + NotOkMsg + "已等待 " + Math.Round(span.TotalSeconds, 1) + "秒，重写DO：";
                                bool isLog = false;
                                foreach (WaitResultInfo ww in list)
                                {
                                    if (ww != null && ww.WaitType.Equals(2) && Robot.Config.DOList.ContainsKey(ww.IoType))
                                    {
                                        if (IOManager.DOValue(ww.IoType, Robot.Config.Id).Equals(ww.IoValue).Equals(false))
                                        {
                                            isLog = true;
                                            Robot.IOMove(ww.IoType, ww.IoValue);
                                            msg += ww.ToStr() + "，";
                                        }
                                    }
                                }
                                if (isLog)
                                {
                                    LogUtil.error(msg);
                                }
                            }
                        }
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W003_Time))
                    {
                        wait.IsEnd = (span.TotalMilliseconds >= wait.TimeMSeconds);
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W101_BatchAxisMove))
                    {
                        //等待信号亮或者走到绝对位置才停止
                        if (Robot.IOValue(BatchAxis.TargetIoType).Equals(BatchAxis.TargetIoValue))
                        {
                            WorkLog(Name + "CheckWaitResult 检测到" + BatchAxis.TargetIoType + "=" + BatchAxis.TargetIoValue + ",停止运行");
                            BatchAxis.AxisStopCheckMove();
                            if (AxisManager.instance.GetBusyStatus(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(1))
                            {
                                BatchAxis.SuddenStop();
                            }
                            wait.IsEnd = true;
                        }
                        else
                        {
                            if (AxisManager.instance.GetBusyStatus(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(0))
                            {
                                BatchAxis.AxisStopCheckMove();
                                wait.IsEnd = true;
                            }
                        }
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W102_FeedScanCode))
                    {
                        if (LastCodeList.Count > 0)
                        {
                            wait.IsEnd = true;
                        }
                    }
                    else
                    {
                        LogUtil.error(Name + "未找到WaitType=" + wait.WaitType + "的处理");
                    }
                    if (wait.IsEnd)
                    {
                        if (moveInfo.OneWaitCanEndStep)
                        {
                            isOk = true;
                            break;
                        }
                    }
                    else
                    {
                        if (!moveInfo.OneWaitCanEndStep)
                        {
                            isOk = false;
                            break;
                        }
                    }
                }
                if (isOk)
                {
                    moveInfo.EndStepWait();
                }
                else if (span.TotalSeconds > moveInfo.TimeOutSeconds)
                {
                    WarnMsg = moveInfo.Name + "[" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "]等待" + NotOkMsg + "超时[" + Math.Round(span.TotalSeconds, 1) + "]秒";
                    //int second = 10;

                    //second = (int)(span.TotalSeconds/ moveInfo.TimeOutSeconds) * 10;
                    //if (second > 120)
                    //{
                    //    second = 120;
                    //}
                    //else if (second < 10)
                    //{
                    //    second = 10;
                    //}
                    LogUtil.error(WarnMsg, moveInfo.ErrorLogType, moveInfo.logSeconds());
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(moveInfo.Name + " [" + moveInfo.MoveStep + "] CheckWait 出错：", ex);
            }
        }

        internal bool ShelfReadyOut(InOutPosInfo posInfo = null, bool SendShelfOut = false, ShelfInfo otherBatchShelf = null)
        {
            if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.IsStep(StepEnum.IS11_ShelfReady))
            {
                if (posInfo == null)
                {
                    return true;
                }

                //TODO 验证料串是否同一个，不是同一个直接送出料串
                if (String.IsNullOrEmpty(CurrShelf.XuniRfid))
                {
                    return true;
                }
                else if (posInfo.rfid.Equals(CurrShelf.XuniRfid))
                {
                    return true;
                }
                else if (SendShelfOut)
                {
                    LogUtil.error($"当前料串【{CurrShelf.ToStr()}】出库料盘【{posInfo.ToStr()}】料串不一致，送出当前料串");
                    SendOutShelfLeave($"料串{CurrShelf.XuniRfid}与{posInfo.rfid}不一致");
                }
            }
            return false;
        }

        internal bool ShelfIsOut()
        {
            if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.MoveStep < StepEnum.IS21_BatchToP1)
            {
                return true;
            }
            return false;
        }


        public string GetMoveStr()
        {
            if (MoveInfo.MoveType.Equals(MoveType.OutStore))
            {
                string code = MoveInfo.MoveParam != null ? MoveInfo.MoveParam.PosInfo.ToStr() : "";
                return CurrShelf.ToStr() + "， 出料：" + "   " + MoveInfo.MoveStep + " \r\n" + code + "\n";
            }
            else if (MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                string code = MoveInfo.MoveParam != null ? MoveInfo.MoveParam.PosInfo.ToStr() : "";
                return CurrShelf.ToStr() + "， 入料：" + "   " + MoveInfo.MoveStep + " \r\n" + code + "\n";
            }
            else
            {
                if (!String.IsNullOrEmpty(CurrShelf.ShelfRfid))
                {
                    return "空闲中";
                }
                else
                {
                    return CurrShelf.ToStr();
                }
            }
        }

        public Color GetShowColor()
        {
            Color color = Robot.GetShowColor();

            if (Robot.runStatus > RunStatus.Wait)
            {
                if (alarmType.Equals(AlarmType.IoSingleTimeOut))
                {
                    color = Color.LightCoral;
                }
                else if (alarmType.Equals(AlarmType.None).Equals(false))
                {
                    color = Color.Red;
                }
                else if (MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore))
                {
                    color = Color.LimeGreen;
                }
            }
            return color;
        }


        protected void WorkLog(string msg)
        {
            LogUtil.info(Name + " [" + MoveInfo.MoveStep + "]" + msg);
        }
        protected void ClearWarnMsg(string msg)
        {
            if (WarnMsg.Contains(msg))
            {
                WarnMsg = "";
            }
        }
    }

    public class BatchMoveConfig
    {

        internal List<string> DIList = new List<string>();
        internal List<string> DOList = new List<string>();
        public string CameraName = "";
        public string AgvName = "";
        public int BatchAxisP1 = 0;
        public int BatchAxisP2 = 0;
        public int BatchAxisP4 = 0;
        internal string RfidIP = "";
        #region 左右入料口共有IO  
        //伺服料盘检测
        internal string IO_ReelCheck = "ReelCheck";
        //料串前端检测
        internal string IO_LineIn_Check = "LineIn_Check";
        //料串到位检测
        internal string IO_LineEnd_Check = "LineEnd_Check";
        //料串阻挡上升
        internal string IO_Shelf_StopUp = "Shelf_StopUp";
        //料串阻挡下降
        internal string IO_Shelf_StopDown = "Shelf_StopDown";
        //线体正转
        internal string IO_LineStart = "LineStart";
        //线体反转
        internal string IO_LineBack = "LineBack";
        //AGV上料请求
        internal string IO_AGV_RequestIn = "AGV_RequestIn";
        /// <summary>
        /// AGV下料请求
        /// </summary>
        internal string IO_AGV_RequestOut = "AGV_RequestOut";
        //AGV应答
        internal string IO_AGV_Response = "AGV_Response";
        internal void LoadIO(string ioAdd)
        {
            IO_ReelCheck = IO_ReelCheck + ioAdd;
            IO_LineIn_Check = IO_LineIn_Check + ioAdd;
            IO_LineEnd_Check = IO_LineEnd_Check + ioAdd;
            IO_Shelf_StopUp = IO_Shelf_StopUp + ioAdd;
            IO_Shelf_StopDown = IO_Shelf_StopDown + ioAdd;
            IO_LineStart = IO_LineStart + ioAdd;
            IO_LineBack = IO_LineBack + ioAdd;
            IO_AGV_RequestIn += ioAdd;
            IO_AGV_RequestOut += ioAdd;
            IO_AGV_Response += ioAdd;

            DIList.Add(IO_ReelCheck);
            DIList.Add(IO_LineIn_Check);
            DIList.Add(IO_LineEnd_Check);
            DIList.Add(IO_Shelf_StopUp);
            DIList.Add(IO_Shelf_StopDown);
            DIList.Add(IO_AGV_RequestIn);
            DIList.Add(IO_AGV_RequestOut);

            DOList.Add(IO_Shelf_StopUp);
            DOList.Add(IO_Shelf_StopDown);
            DOList.Add(IO_LineStart);
            DOList.Add(IO_LineBack);
            DOList.Add(IO_AGV_Response);
        }

        #endregion
    }
}