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 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);
            UpdownAxis = new AxisBean(config.TakeAxis_Updown, Name); 

            AxisBean LeftBatchAxis = new AxisBean(config.BatchAxis_A, Name);
            AxisBean RightBatchAxis = new AxisBean(config.BatchAxis_B, Name);
            moveAxisArray = new AxisBean[] { MiddleAxis, UpdownAxis  };

            MoveInfo = new DeviceMoveInfo(Name); 

            BatchMove_A = new BatchMoveBean(Config, LeftBatchAxis, 1);
            BatchMove_B = new BatchMoveBean(config, RightBatchAxis, 2);
        }


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

            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); 
            StartReset();
            SetAllTimer(true);
            return true;

        }

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

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

        internal override void StopMove()
        {
            //StopMove时设置状态为none
            AgvClient.SetStatus(Config.AgvName_A);
            AgvClient.SetStatus(Config.AgvName_B);

            MoveInfo.EndMove(); 

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

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

            CloseAllAxis();
        }

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


        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return;
            }
         
            BatchMove_A.TimerProcess();
            BatchMove_B.TimerProcess();

            if (NoErrorAlarm())
            {
                CheckAxisAlarm();
            } 
        }


        internal bool CanStartWork()
        {
            //是否可以开始新的料串入料
            if (BatchMove_A.MoveInfo.MoveType.Equals(MoveType.Working))
            {
                StepEnum step = BatchMove_A.MoveInfo.MoveStep; 
                if (step < StepEnum.IB21_BatchToP1)
                {
                    return false;
                }
            }
            else if (BatchMove_B.MoveInfo.MoveType.Equals(MoveType.Working))
            {
                StepEnum step = BatchMove_B.MoveInfo.MoveStep; 
                if (step < StepEnum.IB21_BatchToP1)
                {
                    return false;
                }
            }
            return true ;
        }
  
        private DateTime checkAlarmTime = DateTime.Now;
        public 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)
        { 
            return false;
        }

        public void CloseAllAxis()
        { 
          
        } 
       
    }
    
}