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

namespace OnlineStore.DeviceLibrary
{
    public partial class InputEquip : EquipBase
    {
        public InputEquip_Config Config;

        public AxisBean MiddleAxis = null;
        public AxisBean UpdownAxis = null;

        private AxisBean[] moveAxisArray;

        public BatchMoveBean BatchMove_A = null;
        public BatchMoveBean BatchMove_B = null;
        public AxisBean BatchAxis_A = null;
        public AxisBean BatchAxis_B = null;
        public ClampJawBean ClampJaw = null;

        public bool AutoInput = ConfigAppSettings.GetIntValue(Setting_Init.AutoInput).Equals(1);
        public int DefautTargetP = 1;

        public InputEquip(string cid, InputEquip_Config config)
        {
            this.DeviceID = config.Id;
            baseConfig = config;
            this.Config = config;
            IsDebug = config.IsDebug.Equals(1);
            Name = (" " + "上料机构" + " ").ToUpper();
            Init();
            ledProcessTimer.Elapsed += LedProcess;
            IoCheckTimer.Elapsed += IoCheckTimerProcess;

            MiddleAxis = new AxisBean(config.TakeAxis_Middle, Name, false);
            UpdownAxis = new AxisBean(config.TakeAxis_Updown, Name, false);

            BatchAxis_A = new AxisBean(config.BatchAxis_A, Name,true);
            BatchAxis_B = new AxisBean(config.BatchAxis_B, Name,true);
            moveAxisArray = new AxisBean[] { MiddleAxis, UpdownAxis };
            if (config.UseClampJaw.Equals(1))
            {
                ClampJaw = new ClampJawBean(StoreManager.Config.CLAW_Input);
            }
            MoveInfo = new DeviceMoveInfo(Name);

            BatchMove_A = new BatchMoveBean(Config, BatchAxis_A, 1);
            BatchMove_B = new BatchMoveBean(config, BatchAxis_B, 2);

            addLastDI(IO_Type.Airpressure_Check, IO_VALUE.LOW);
            addLastDI(IO_Type.SuddenStop_BTN, IO_VALUE.LOW);
            addLastDI(IO_Type.Reset_BTN, IO_VALUE.LOW);
            runStatus = RunStatus.Wait; 
        }

        #region 启动，复位，停止 处理

        public override bool StartRun()
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }

            if (!OpenAllAxis())
            {
                CloseAllAxis();
                return false;
            }
            SetAllTimer(false);
            MoveInfo.EndMove();

            LogInfo("StartRun ： 开始启动 ");
            runStatus = RunStatus.HomeMoving;
            MoveInfo.NewMove(MoveType.RHome,new InOutParam());

            if (!BatchMove_A.Reset())
            {
                runStatus = RunStatus.Wait;
                MoveInfo.EndMove();
                SetWarnMsg("启动失败：A料口启动失败");
                LogUtil.error("复位失败：A料口启动失败");
                return false;
            }
            if (!BatchMove_B.Reset())
            {
                runStatus = RunStatus.Wait;
                MoveInfo.EndMove();
                SetWarnMsg("启动失败：A料口启动失败");
                LogUtil.error("复位失败：B料口启动失败");
                return false;
            }
            StartReset();
            SetAllTimer(true);

            return true;
        }

        public override bool Reset()
        {
            SetAllTimer(false);
            StopMove();

            if (!OpenAllAxis())
            {
                CloseAllAxis();
                SetAllTimer(true);
                return false;
            }
            LogInfo("Reset  开始重置  ");
            runStatus = RunStatus.Reset;
            MoveInfo.NewMove(MoveType.Reset,new InOutParam());
            if (!BatchMove_A.Reset())
            {
                SetWarnMsg("复位失败：A料口复位失败");
                MoveInfo.EndMove();
                LogUtil.error("复位失败：A料口复位失败");
                return false;
            }
            if (!BatchMove_B.Reset())
            {
                SetWarnMsg("复位失败：B料口复位失败");
                MoveInfo.EndMove();
                LogUtil.error("复位失败：B料口复位失败");
                return false;
            }
            StartReset();
            SetAllTimer(true);
            return true;

        }

        private void StartReset()
        {
            //复位时设置状态为none
            AgvClient.SetStatus(Config.AgvName_B);
            AgvClient.SetStatus(Config.AgvName_A);

            SetWarnMsg("");
            alarmType = AlarmType.None;
            isInSuddenDown = false;
            isNoAirpressure_Check = false;
            MoveInfo.NextMoveStep(StepEnum.IR01_Wait);

            LogInfo($"复位 {MoveInfo.SLog} ：批量轴开始复位");
        }


        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            if (MoveInfo.IsStep(StepEnum.IR01_Wait))
            {

                // 1，处于A,B,NG料口是，可以直接回取料升降轴。
                // 2，处于A, B两个暂存区时，升降轴先运动到该暂存区的取放料高点，旋转轴再回原点或待机点。
                //验证旋转轴位置 TODO

                int updownP = UpdownAxis.GetAclPosition();
                int middleP = MiddleAxis.GetAclPosition();

                // if (UpdownAxis.IsInPosition(Config.Updown_P5_AUpperL))
                //{
                //    MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                //    LogInfo($"复位 {MoveInfo.SLog}：当前升降轴在 A上暂存区低点 {Config.Updown_P5_AUpperL}，升降轴先到P4:{Config.Updown_P4_AUpperH}");
                //    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P4_AUpperH, Config.Updown_P4_Speed);
                //}
                //else if (UpdownAxis.IsInPosition(Config.Updown_P7_AUnderL))
                //{
                //    MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                //    LogInfo($"复位{MoveInfo.SLog}：当前升降轴在 A下暂存区低点 {Config.Updown_P7_AUnderL}，升降轴先到P6:{Config.Updown_P6_AUnderH}");
                //    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P6_AUnderH, Config.Updown_P6_Speed);
                //}
                //else if (UpdownAxis.IsInPosition(Config.Updown_P11_BUpperL))
                //{
                //    MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                //    LogInfo($"复位{MoveInfo.SLog}：当前升降轴在 B上暂存区低点{Config.Updown_P11_BUpperL}，升降轴先到P10:{Config.Updown_P10_BUpperH}");
                //    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P10_BUpperH, Config.Updown_P10_Speed);
                //}
                //else if (UpdownAxis.IsInPosition(Config.Updown_P13_BUnderL))
                //{
                //    MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                //    LogInfo($"复位{MoveInfo.SLog}：当前升降轴在 B下暂存区低点 {Config.Updown_P13_BUnderL}，升降轴先到P12{Config.Updown_P12_BUnderH}");
                //    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P12_BUnderH, Config.Updown_P12_Speed);
                //}
                 //旋转轴在A暂存区
                  if (MiddleAxis.IsInPosition(Config.Middle_P4_AUpper) || MiddleAxis.IsInPosition(Config.Middle_P7_AUnder))
                {
                    //如果升降轴<下方高点
                    if(updownP< Config.Updown_P6_AUnderH+10000)
                    { 
                        MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                        LogInfo($"复位 {MoveInfo.SLog}：当前旋转轴在 A侧暂存区{middleP}，升降轴当前位置{updownP}，低于下方高点，升降轴先到P4:{Config.Updown_P6_AUnderH}");
                        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P6_AUnderH, Config.Updown_P6_Speed);
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                        LogInfo($"复位 {MoveInfo.SLog}：当前旋转轴在 A侧暂存区{middleP}，升降轴当前位置{updownP}，在上方暂存区，升降轴先回待机点:{Config.Updown_P1}");
                        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);

                    }
                } 
                else if (MiddleAxis.IsInPosition(Config.Middle_P5_BUpper)|| MiddleAxis.IsInPosition(Config.Middle_P8_BUnder))
                {
                    if (updownP < Config.Updown_P12_BUnderH + 10000)
                    { 
                        MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                        LogInfo($"复位 {MoveInfo.SLog}：当前旋转轴在 B侧暂存区{middleP}，升降轴当前位置{updownP}，低于下方高点，升降轴先到P4:{Config.Updown_P12_BUnderH}");
                        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P12_BUnderH, Config.Updown_P12_BUnderH);
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.IR02_UpdownUpMove);
                        LogInfo($"复位 {MoveInfo.SLog}：当前旋转轴在 B侧暂存区{middleP}，升降轴当前位置{updownP}，在上方暂存区，升降轴先回待机点:{Config.Updown_P1}");
                        UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                    } 
                } 
                else
                {
                    if (MiddleAxis.IsNeedHome)
                    {
                        MoveInfo.NextMoveStep(StepEnum.IR03_MiddleHome);
                        LogInfo($"复位{MoveInfo.SLog}：旋转轴回原点");
                        MiddleAxis.HomeMove(MoveInfo);
                    }
                    else
                    {
                        IR04_MiddleToP1();
                    }
                }

            }
            else if (MoveInfo.IsStep(StepEnum.IR02_UpdownUpMove))
            {
                if (MiddleAxis.IsNeedHome)
                {
                    MoveInfo.NextMoveStep(StepEnum.IR03_MiddleHome);
                    LogInfo($"复位{MoveInfo.SLog}：旋转轴回原点");
                    MiddleAxis.HomeMove(MoveInfo);
                }
                else
                {
                    IR04_MiddleToP1();
                }
            }
            else if (MoveInfo.IsStep(StepEnum.IR03_MiddleHome))
            {
                IR04_MiddleToP1();
            }
            else if (MoveInfo.IsStep(StepEnum.IR04_MiddleToP1))
            {
                if (UpdownAxis.IsNeedHome)
                {
                    MoveInfo.NextMoveStep(StepEnum.IR05_UpdownHome);
                    LogInfo($"复位{MoveInfo.SLog}：升降轴原点返回");
                    UpdownAxis.HomeMove(MoveInfo);
                }
                else
                {
                    IR06_UpdownToP1();
                }
            }

            else if (MoveInfo.IsStep(StepEnum.IR05_UpdownHome))
            {
                IR06_UpdownToP1();
            }
            else if (MoveInfo.IsStep(StepEnum.IR06_UpdownToP1))
            {
                MoveInfo.NextMoveStep(StepEnum.IR07_ClampRelax);
                LogInfo($"复位{MoveInfo.SLog}：夹爪气缸放松");
                ClampRelax(MoveInfo, MoveInfo.MoveParam.PosInfo.barcode);
            }
            else if (MoveInfo.IsStep(StepEnum.IR07_ClampRelax))
            {
                MoveInfo.NextMoveStep(StepEnum.IR08_WaitBatchMove);
                LogInfo($"复位{MoveInfo.SLog}：等待左右批量轴模块复位完成");

            }

            else if (MoveInfo.IsStep(StepEnum.IR08_WaitBatchMove))
            {
                if ((BatchMove_A.MoveInfo.MoveType.Equals(MoveType.Reset).Equals(false))
                    && (BatchMove_B.MoveInfo.MoveType.Equals(MoveType.Reset).Equals(false)))
                {
                    LogInfo("复位完成");
                    runStatus = RunStatus.Runing;
                    MoveInfo.EndMove();
                }
                else if (MoveInfo.IsTimeOut(180))
                {
                    if (BatchMove_A.MoveInfo.MoveType.Equals(MoveType.Reset))
                    {
                        WarnMsg = Name + "等待" + BatchMove_A.Name + "复位完成超时[" + MoveInfo.TimeOutSeconds + "]秒";
                        LogUtil.error(WarnMsg, MoveInfo.ErrorLogType, MoveInfo.logSeconds());
                        Alarm(AlarmType.IoSingleTimeOut);
                    }
                    else
                    {
                        WarnMsg = Name + "等待" + BatchMove_B.Name + "复位完成超时[" + MoveInfo.TimeOutSeconds + "]秒";
                        LogUtil.error(WarnMsg);
                        Alarm(AlarmType.IoSingleTimeOut);
                    }
                }
            }
        }

        private void IR06_UpdownToP1()
        {
            MoveInfo.NextMoveStep(StepEnum.IR06_UpdownToP1);
            LogInfo($"复位{MoveInfo.SLog}：升降轴到P1：" + Config.Updown_P1 + "，夹爪原点返回");
            UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
            if (Config.UseClampJaw.Equals(1))
            {
                ClampJaw.GoHome(MoveInfo);
            }
        }

        private void IR04_MiddleToP1()
        {

            MoveInfo.NextMoveStep(StepEnum.IR04_MiddleToP1);
            LogInfo($"复位{MoveInfo.SLog}：旋转轴到待机点：" + Config.Middle_P1);
            MiddleAxis.AbsMove(MoveInfo, Config.Middle_P1, Config.Middle_P1_Speed);
        }
        internal override void StopMove()
        {
            //StopMove时设置状态为none
            AgvClient.SetStatus(Config.AgvName_A);
            AgvClient.SetStatus(Config.AgvName_B);

            runStatus = RunStatus.Wait;
            MoveInfo.EndMove();

            BatchMove_A.StopMove();
            BatchMove_B.StopMove();

            UpdownAxis.SuddenStop();
            MiddleAxis.SuddenStop();

            CloseAllAxis();
        }

        public override void StopRun()
        {
            SetAllTimer(false);
            runStatus = RunStatus.Wait;
            StopMove();
        }

        #endregion

        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return;
            }
            BusyMoveProcess();
            IOTimeOutProcess();
            //判断流水线打开了才可以运行  
            List<BatchMoveBean> BatchMoveList = new List<BatchMoveBean>() { BatchMove_A, BatchMove_B };
            if (MoveInfo.MoveType.Equals(MoveType.None) && NoErrorAlarm())
            {
                //若左侧或右侧在等待扫码结束的状态，需要开始去取料 
                foreach (BatchMoveBean moveBean in BatchMoveList)
                {
                    if (moveBean.MoveInfo.MoveType.Equals(MoveType.InStore) && moveBean.MoveInfo.IsStep(StepEnum.IB10_ScanOK))
                    {
                        LogInfo(moveBean.Name + "开始取料");
                        StartInstore(moveBean.GetInstoreParam());
                        break;
                    }
                }
            }
            if (MoveInfo.MoveType.Equals(MoveType.None) && NoErrorAlarm())
            {
                if (CheckStartOutPos("A下暂存区", BufferDataManager.AOutStoreInfo, BatchMoveList))
                {

                }
                else if (CheckStartOutPos("B下暂存区", BufferDataManager.BOutStoreInfo, BatchMoveList))
                {

                }
                else
                {
                    //如果有物料且不能放料，需要送一个料串离开
                    if (BufferDataManager.AOutStoreInfo != null)
                    {
                        CheckStartOutPos("A下暂存区", BufferDataManager.AOutStoreInfo, BatchMoveList, true);
                    }
                    else if (BufferDataManager.BOutStoreInfo != null)
                    {
                        CheckStartOutPos("B下暂存区", BufferDataManager.BOutStoreInfo, BatchMoveList, true);
                    }
                }

            }


            foreach (BatchMoveBean moveBean in BatchMoveList)
            {
                moveBean.TimerProcess();
            }
            if (NoErrorAlarm())
            {
                CheckAxisAlarm();
            }
        }
        private bool CheckStartOutPos(string posType, InOutPosInfo posInfo, List<BatchMoveBean> BatchMoveList, bool shelfAutoLeave = false)
        {
            if (posInfo != null)
            {
                foreach (BatchMoveBean moveBean in BatchMoveList)
                {
                    if (moveBean.ShelfReadyOut(BufferDataManager.AOutStoreInfo, shelfAutoLeave))
                    {
                        InOutParam param = new InOutParam(BufferDataManager.AOutStoreInfo.ToCopy());
                        param.ShelfType = moveBean.ShelfType;
                        LogInfo($"{posType}物料{param.PosInfo.ToStr()}，准备出库到料串{param.ShelfType}");
                        StartOutstore(param);
                        return true;
                        break;
                    }
                }

            }
            return false;
        }

        internal bool CanStartWork()
        {
            //是否可以开始新的料串入料
            if (BatchMove_A.MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                StepEnum step = BatchMove_A.MoveInfo.MoveStep;
                if (step < StepEnum.IB21_BatchToP1)
                {
                    return false;
                }
            }
            else if (BatchMove_B.MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                StepEnum step = BatchMove_B.MoveInfo.MoveStep;
                if (step < StepEnum.IB21_BatchToP1)
                {
                    return false;
                }
            }
            return true;
        }

        private DateTime checkAlarmTime = DateTime.Now;
        private void CheckAxisAlarm()
        {
            if (alarmType.Equals(AlarmType.AxisAlarm) || alarmType.Equals(AlarmType.AxisMoveError))
            {
                return;
            }
            TimeSpan span = DateTime.Now - checkAlarmTime;
            //在回原点，复位，出入库时，检测报警间隔减小
            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                if (span.TotalSeconds < 5)
                {
                    return;
                }
            }
            else if (span.TotalSeconds < 1)
            {
                return;
            }

            checkAlarmTime = DateTime.Now;
            foreach (AxisBean axisInfo in moveAxisArray)
            {
                if (AxisIsAlarm(axisInfo))
                {
                    return;
                }
            }
            if (AxisIsAlarm(BatchMove_A.BatchAxis, false))
            {
                BatchMove_A.WarnMsg = WarnMsg;
                BatchMove_A.Alarm(AlarmType.AxisAlarm);
                return;
            }
            if (AxisIsAlarm(BatchMove_B.BatchAxis, false))
            {
                BatchMove_B.WarnMsg = WarnMsg;
                BatchMove_B.Alarm(AlarmType.AxisAlarm);
                return;
            }
        }


        public bool OpenAllAxis(bool isCheck = true)
        {
            foreach (AxisBean axis in moveAxisArray)
            {
                string outMsg = "";
                if (!axis.Open(true, out outMsg))
                {
                    LogUtil.info(outMsg);
                    return false;
                }
            }
            return true;
        }

        public void CloseAllAxis()
        {
            foreach (AxisBean axis in moveAxisArray)
            {
                axis.SuddenStop();
                axis.ServoOff();
            }
        }

        private void ClampWork(DeviceMoveInfo moveInfo, bool isCheck, params string[] codes)
        {
            if (Config.UseClampJaw.Equals(1))
            {
                ClampJaw.Push(moveInfo, isCheck, codes);
            }
            else
            {

            }
        }

        private void ClampRelax(DeviceMoveInfo moveInfo, params string[] codes)
        {
            if (Config.UseClampJaw.Equals(1))
            {
                ClampJaw.Relax(moveInfo, codes);
            }
            else
            {

            }
        }

        public  bool IsNoReelAlarm()
        {
            if (runStatus.Equals(RunStatus.Busy) && alarmType.Equals(AlarmType.IoSingleTimeOut))
            { 
                if (MoveInfo.MoveType.Equals(MoveType.InStore) && MoveInfo.MoveStep.Equals(StepEnum.II08_ClampWork))
                {
                    return true;
                }
                else if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.MoveStep.Equals(StepEnum.IO05_ClampWork))
                {
                    return true;
                }
                else if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.MoveStep.Equals(StepEnum.IO15_ClampWork))
                {
                    return true;
                }
            }
            return false;
        }

    }

}