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

namespace OnlineStore.DeviceLibrary
{ 
    public partial class BoxEquip : EquipBase
    { 
        /// <summary>
        /// 配置文件
        /// </summary>
        public BoxEquip_Config Config;
        /// <summary>
        /// 轴
        /// </summary>
        public AxisBean MoveAxis = null;
        public AxisBean PullAxis_Inout = null;
        public AxisBean UpdownAxis = null;
        public AxisBean XAxis_A = null;
        public AxisBean MiddleAxis_A = null;
        public AxisBean ComAxis_A = null;
        public AxisBean PullAxis_Updown = null;
        public AxisBean XAxis_B = null;
        public AxisBean MiddleAxis_B = null;
        public AxisBean ComAxis_B = null;
        private AxisBean[] moveAxisArray;
        /// <summary>
        /// A面等待出库的队列
        /// </summary>
        public ConcurrentQueue<InOutParam> waitAOutStoreList = new ConcurrentQueue<InOutParam>();
        /// <summary>
        /// B面等待出库的队列
        /// </summary>
        public ConcurrentQueue<InOutParam> waitBOutStoreList = new ConcurrentQueue<InOutParam>();
        public BoxEquip(string cid, BoxEquip_Config config)
        {
            baseConfig = config;
            this.DeviceID = config.Id;
            this.Config = config;
            IsDebug = config.IsDebug.Equals(1); 
            Name = (" " + "存储机构" +   " ").ToUpper();
            Init();
            ledProcessTimer.Elapsed += LedProcess;
            IoCheckTimer.Elapsed += IoCheckTimerProcess;
            MoveInfo = new DeviceMoveInfo(" 存储机构 "); 

            //MoveZAxis = new AxisBean(StoreManager.Config.Move_Z_Axis, Name);
            //MoveXAxis = new AxisBean(StoreManager.Config.Move_X_Axis, Name);
            //LabelXAxis = new AxisBean(StoreManager.Config.Label_X_Axis, Name);
            //LabelYAxis = new AxisBean(StoreManager.Config.Label_Y_Axis, Name);
            //LabelZAxis = new AxisBean(StoreManager.Config.Label_Z_Axis, Name);
            //LabelRAxis = new AxisBean(StoreManager.Config.Label_R_Axis, Name);
            //BatchAxis = new AxisBean(StoreManager.Config.Out_Batch_Axis,Name);

            //moveAxisArray = new AxisBean[] {MoveXAxis,MoveZAxis };

            //labelAxisArray = new AxisBean[] { LabelXAxis,LabelYAxis,LabelZAxis,LabelRAxis};

            //if (LabelWaitMS < 1000)
            //{
            //    LabelWaitMS = 3000;
            //    ConfigAppSettings.SaveValue(Setting_Init.LabelWaitMS, LabelWaitMS);
            //    LogUtil.info(Name + " 初始化并保存 LabelWaitMS=" + LabelWaitMS);
            //}
        }
         
        public override bool StartRun()
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            if (!OpenAllAxis())
            {
                CloseAllAxis();
                return false;
            }
            SetAllTimer(false);
            MoveInfo.EndMove(); 
            runStatus = RunStatus.HomeMoving;           
            
            MoveInfo.NewMove(MoveType.RHome);  
            LogInfo("开始 原点返回：    ");
            StartReset();
             
            SetAllTimer(true ); 
            return true ;
        }
         
        public override bool Reset()
        {
            StopMove();
            if (!OpenAllAxis())
            {
                CloseAllAxis();
                return false;
            }
            mainTimer.Enabled = false ;
            runStatus = RunStatus.Reset;

            MoveInfo.NewMove(MoveType.Reset); 

            LogInfo("开始重置：  ");
            StartReset();
            mainTimer.Enabled = true ;
            return true;
        }


        #region 复位处理

        private void StartReset()
        {
            //AgvClient.SetStatus(Config.AgvInName);
            //AgvClient.SetStatus(Config.AgvOutName);

            ////TimerMaxSeconds = 10;
            //SetWarnMsg("");
            //alarmType = AlarmType.None;
            //isInSuddenDown = false;
            //isNoAirpressure_Check = false;
            //TimerMaxSeconds = 0;

            //MoveReset();

            //SecMoveReset();

            ShelfMoveReset();
         
            isInPro = false;
        }

        public void ShelfMoveReset()
        {
            //ShelfMoveInfo.NextMoveStep(StepEnum.OBR01_StopUp);
            //ShelfWorkLog("阻挡气缸上升");
            //IOMove(IO_Type.O_ELine_InStop, IO_VALUE.LOW);
            //IOMove(IO_Type.O_WLine_OutStop, IO_VALUE.LOW);
            //IOMove(IO_Type.O_WLine_WorkStop, IO_VALUE.LOW);
            //ShelfMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.O_ELine_InStop, IO_VALUE.LOW));
            //ShelfMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.O_WLine_OutStop, IO_VALUE.LOW));
            //ShelfMoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.O_WLine_WorkStop, IO_VALUE.LOW));
        }
        
        protected override void ResetProcess()
        {
            if (MoveInfo.MoveType.Equals(MoveType.Reset) || MoveInfo.MoveType.Equals(MoveType.RHome))
            {
                MoveResetPro();
            }
        
        }

        private void MoveResetPro()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            
        }
         
 
          
        #endregion
        private bool  moveInPro=false;
        private bool secInPro = false;
        private bool shelfInPro = false;
        private DateTime moveLastTime = DateTime.Now;
        private DateTime secLastTime = DateTime.Now;
        private DateTime shelfLastTime = DateTime.Now;
        object worklock = new object();
        protected override void OnTimerProcess()
        {
            if (MoveStop)
            {
                return;
            }
            int seconds = 3;
            TimeSpan shelfSpan = DateTime.Now - shelfLastTime;
            if (!shelfInPro || shelfSpan.TotalSeconds > seconds)
            {
                shelfInPro = true;
                shelfLastTime = DateTime.Now;
                try
                {
                    //if (ShelfMoveInfo.MoveType.Equals(MoveType.ShelfPro))
                    //{
                    //    ShelfMoveProcess();
                    //}
                    //else if (ShelfMoveInfo.MoveType.Equals(MoveType.Reset) || ShelfMoveInfo.MoveType.Equals(MoveType.RHome))
                    //{
                    //    BatchResetMovePro();
                    //}
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + " OnTimerProcess 出错：", ex);
                }
                finally
                {
                    shelfInPro = false;
                }
            }
            TimeSpan secSpan = DateTime.Now - secLastTime;
            if (!secInPro || secSpan.TotalSeconds > seconds)
            {
                secInPro = true;
                secLastTime = DateTime.Now;
                try
                {
                    //if (SecMoveInfo.MoveType.Equals(MoveType.Labelling))
                    //{
                    //    LabellingProcess();
                    //}
                    //else if (SecMoveInfo.MoveType.Equals(MoveType.Reset) || SecMoveInfo.MoveType.Equals(MoveType.RHome))
                    //{
                    //    SecMoveResetPro();
                    //}
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "TimerProcess出错：", ex);
                }
                finally
                {
                    secInPro = false;
                }
            }

            TimeSpan moveSpan = DateTime.Now - moveLastTime ;
            if (!moveInPro || moveSpan.TotalSeconds > seconds)
            {
                moveInPro = true;
                moveLastTime = DateTime.Now;
                try
                {
                    if (MoveInfo.MoveType.Equals(MoveType.Working))
                    {
                        if (Monitor.TryEnter(worklock))
                        {
                            try
                            {
                                InstoreProcess();
                            }
                            catch (Exception ex)
                            {
                                LogUtil.error(Name + "WorkingProcess出错：", ex);
                            }
                            finally
                            {
                                Monitor.Exit(worklock);
                            }
                        }
                    }
                    else if (MoveInfo.MoveType.Equals(MoveType.Reset) || MoveInfo.MoveType.Equals(MoveType.RHome))
                    {
                        MoveResetPro();
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "TimerProcess出错：", ex);
                }
                finally
                {
                    moveInPro = false;
                }
            }

        }
        //protected override void BusyMoveProcess()
        //{
        //    if (MoveStop)
        //    {
        //        return;
        //    }

        //    if (runStatus.Equals(RobotRunStatus.HomeMoving) || runStatus.Equals(RobotRunStatus.Reset))
        //    {
        //        ResetProcess();
        //    }
        //    else
        //    {
        //        if (ShelfMoveInfo.MoveType.Equals(RobotMoveType.ShelfPro))
        //        {
        //            ShelfMoveProcess();
        //        }
        //        if (SecMoveInfo.MoveType.Equals(RobotMoveType.Labelling))
        //        {
        //            LabellingProcess();
        //        }

        //        if (MoveInfo.MoveType.Equals(RobotMoveType.Working))
        //        {
        //            WorkingProcess();
        //        }
        //    }
        //}

        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return;
            }
            //BusyMoveProcess();

          


            //if (ShelfMoveInfo.MoveType.Equals(MoveType.None))
            //{
            //    if (IOValue(IO_Type.O_WLine_WorkOutCheck).Equals(IO_VALUE.LOW) && NoErrorAlarm())
            //    {
            //        if (IOValue(IO_Type.O_WLine_WorkCheck).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.O_WLine_InCheck).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.O_ELine_InCheck).Equals(IO_VALUE.HIGH))
            //        {
            //            StartShelfMove();
            //        }
            //    }
            //}

            //if (MoveInfo.MoveType.Equals(MoveType.None))
            //{
            //    if (NoErrorAlarm() && IOValue(IO_Type.Out_TrayCheck).Equals(IO_VALUE.HIGH) && IOValue(IO_Type.X_OLine_Run).Equals(IO_VALUE.LOW))
            //    {
            //        //料串准备好才能取料
            //        if (OutReelCount >= 0)
            //        //if (OutReelCount >= 0 && SecMoveInfo.MoveType.Equals(RobotMoveType.None))
            //        {
            //            StartWorking(new WorkParam());
            //        }
            //    }
            //}



           

            if (NoErrorAlarm())
            {
                CheckAxisAlarm();
            } 
        }
        protected override void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 3 && alarmType.Equals(AlarmType.IoSingleTimeOut))
                {
                    preIoTimerOutTime = DateTime.Now;

                    if (runStatus < RunStatus.Runing || isInSuddenDown || isNoAirpressure_Check)
                    {
                        return;
                    }
                    ////若BOX和出料都没有在等待Io的过程中则此Io超时异常可能已经处理过
                    //if ( MoveInfo.IsInWait.Equals(false) && SecMoveInfo.IsInWait.Equals(false)&&ShelfMoveInfo.IsInWait.Equals(false) && StoreManager.LastPrintStatus != Asa.PrintLabel.PrinterStatus.Printing)
                    //{
                    //    LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                    //    alarmType = AlarmType.None;
                    //    SetWarnMsg("");
                    //}
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("IOTimeOutProcess出错：", ex);
            }
        }
        internal override void StopMove()
        {
           
         
            MoveInfo.EndMove(); 

            PullAxis_Updown.SuddenStop();
            MoveAxis.SuddenStop();
            PullAxis_Inout.SuddenStop();

            MiddleAxis_A.SuddenStop();
            UpdownAxis.SuddenStop();
            XAxis_A.SuddenStop();
            ComAxis_A.SuddenStop();

            CloseAllAxis();
             

        }

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

        public override string GetMoveStr()
        {
            string msg = "";
            int tLength = 15;

            msg += "runS：  " + runStatus + "\n";
            msg += "alarm：  " + alarmType + "\n";
 

           
            return msg;
        }

        #region 轴运动

        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(PullAxis_Updown))
            {
                return;
            }
        }


        public bool OpenAllAxis(bool isCheck = true)
        { 
            return false;
        }

        public void CloseAllAxis()
        {
           
        }


        #endregion

         

      
    }
}