using Asa;
using HuichuanLibrary;
using log4net;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using System.Windows.Forms;
using System.Xml.Linq;

namespace OnlineStore.DeviceLibrary
{
    public partial class XLRStoreBean : DeviceBase
    {


        #region  初始化 
        public bool IsDebug = false;

        public InputEquip inputEquip;
        public BoxEquip boxEquip;
        public Dictionary<int, EquipBase> equipsMap = new Dictionary<int, EquipBase>();

        public XLRStore_Config Config = null;
        private bool canStart = false;
        //public SQLite sQLite = null;
        string title = ConfigAppSettings.GetValue(Setting_Init.App_Title);
        public XLRStoreBean(XLRStore_Config config, InputEquip_Config inputConfig, BoxEquip_Config boxConfig)
        {
            equipsMap = new Dictionary<int, EquipBase>();
            if (config.IOSingle_TimerOut <= 0)
            {
                config.IOSingle_TimerOut = 5000;
            }
            Init();
            baseConfig = config;
            this.Config = config;
            this.DeviceID = config.Id;

            Name = ($" {title}_" + " ").ToUpper();
            MoveInfo = new DeviceMoveInfo(Name);


            List<string> ioList = new List<string>();
            ioList = new List<string>(DeviceConfig.ProIOIpMap.Values);
            string[] boxA = inputConfig.AgvName_A.Split('#');
            string[] boxB = inputConfig.AgvName_B.Split('#');
            AgvClient.NodeList.Add(new AGVLib.Node() { id = int.Parse(boxA[0]), name = boxA[1] });
            AgvClient.NodeList.Add(new AGVLib.Node() { id = int.Parse(boxB[0]), name = boxB[1] });
            AgvClient.Init();
            inputEquip = new InputEquip("1", inputConfig);
            inputEquip.BoxA.AgvNode = new AGVLib.Node(int.Parse(boxA[0]), boxA[1]);
             AgvClient.RecvServerInfo+=inputEquip.BoxA.RecvMsgFromServer;
            inputEquip.BoxB.AgvNode = new AGVLib.Node(int.Parse(boxB[0]), boxB[1]);
            AgvClient.RecvServerInfo += inputEquip.BoxB.RecvMsgFromServer;
            boxEquip = new BoxEquip("2", boxConfig);

            equipsMap.Add(1, inputEquip);
            equipsMap.Add(2, boxEquip);
            //先初始化设备
            HCBoardManager.InitConfig();
            IOManager.Init();
            AxisManager.Init();
            AxisManager.instance.OpenCard();

            //初始化摄像机配置  
            CodeManager.LoadConfig();

            BufferDataManager.InitData();
            IPCameraHelper.InstallService();
            mainTimer.Enabled = true;
            canStart = true;
        }
         
        ~XLRStoreBean()
        {
            AgvClient.Dispose();
        }
        #endregion

        public string CanStart()
        {
            if (!canStart)
            {
                return "启动失败：设备未初始化完成";
            }
            return "";
        }
        #region 启动和复位

        public override bool StartRun()
        {
            string result = CanStart();
            if (String.IsNullOrEmpty(result).Equals(false))
            {
                SetWarnMsg(result);
                return false;
            }
            else if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg("启动失败：急停未开");
                return false;
            }
            else
            {
                mainTimer.Enabled = false;
                //lineStatus = LineStatus.ResetMove;
                runStatus = RunStatus.HomeMoving;
                StartTime = DateTime.Now;
                LogUtil.info(Name + "开始启动，启动时间：" + StartTime.ToString() + "");

                Thread.Sleep(5);

                mainTimer.Interval = 1000;
                maxSeconds = 10;
                alarmType = AlarmType.None;
                mainTimer.Enabled = false;
                isInSuddenDown = false;
                isNoAirpressure_Check = false;
                SetWarnMsg("");
                MoveInfo.NewMove(MoveType.Reset);
                MoveInfo.NextMoveStep(StepEnum.Wait);

                foreach (EquipBase moveEquip in this.equipsMap.Values)
                {
                    if (runStatus.Equals(RunStatus.Wait))
                    {
                        LogUtil.error(Name + "启动过程中发现 runStatus=Wait，中断启动");
                        return false;
                    }

                    EquipStartRun(moveEquip);
                }
                if (runStatus.Equals(RunStatus.Wait))
                {
                    return false;
                }
                //RFIDManager.Open(new string[] { });
                mainTimer.Enabled = true;
                return true;
            }
        }
        private void EquipStartRun(EquipBase moveEquip)
        {
            if (moveEquip.IsDebug)
            {
                LogUtil.info(moveEquip.Name + "调试状态，暂不启动");
            }
            else
            {
                bool result = moveEquip.StartRun();
                Thread.Sleep(60);
            }
        }


        public override bool Reset()
        { 
            bool isNeedAllReset = false;
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                //TrayManager.LineNeedEmptyTrayNum = 0;
                isNeedAllReset = true;
                LogUtil.error(Name + "收到复位信号，急停中或没有气压报警中，强制所有设备复位~");
            }
            else if ((runStatus == RunStatus.HomeMoving || runStatus == RunStatus.Reset) && NoAlarm())
            {
                LogUtil.error(Name + "收到复位信号，已经在复位或原点返回中，且当前无报警，不处理复位"); 
                return false;
            }

            //停止运动
            MoveInfo.EndMove();

            runStatus = RunStatus.Reset;

            //重置通用处理
            mainTimer.Interval = 1000;
           // maxSeconds = 10;
            alarmType = AlarmType.None;
            mainTimer.Enabled = false;
            isInSuddenDown = false;
            isNoAirpressure_Check = false;
            SetWarnMsg("");
            MoveInfo.NewMove(MoveType.Reset);
            MoveInfo.NextMoveStep(StepEnum.Wait);

            foreach (EquipBase equip in equipsMap.Values)
            {
                if (runStatus.Equals(RunStatus.Wait))
                {
                    LogUtil.error(Name + "复位过程中发现 runStatus=Wait，中断启动");
                    return false;
                }
                EquipReset(equip, isNeedAllReset);
            }
            if (runStatus.Equals(RunStatus.Wait))
            {
                return false;
            }
            mainTimer.Enabled = true;
            return true;
        }
        private void EquipReset(EquipBase equip, bool isNeedAllReset)
        {
            //调试状态不再重置
            if (!equip.IsDebug)
            {
                if (isNeedAllReset || (!equip.NoAlarm()))
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 需要复位");
                    equip.Reset();
                    Thread.Sleep(60);
                }
                else
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 正常无报警，不需要复位");
                }
            }
        }


        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (!MoveInfo.IsInWait)
            {
                bool isOk = true;
                string msg = "";
                //判断是否所有的已经返回完成
                TimeSpan span = DateTime.Now - MoveInfo.LastSetpTime;
                foreach (EquipBase moveEquip in this.equipsMap.Values)
                {
                    if (moveEquip.runStatus.Equals(RunStatus.HomeMoving) || moveEquip.runStatus.Equals(RunStatus.Reset) || moveEquip.runStatus.Equals(RunStatus.Wait))
                    {
                        if (moveEquip.NoAlarm())
                        {
                            msg = moveEquip.Name + "复位结束";
                            isOk = false;
                            break;
                        }
                     
                    }
                }

                if (isOk)
                {
                    runStatus = RunStatus.Runing;
                    MoveInfo.EndMove();
                    mainTimer.Interval = 300;
                    maxSeconds = 3;
                    AgvClient.SetCancelState(AgvClient.CurrCancelState);
                    LogUtil.info(Name + "复位完成 [" + FormUtil.GetSpanStr(span) + "]");
                }
                else if (span.TotalSeconds > 120)
                {
                    WarnMsg = Name + "[" + MoveInfo.MoveStep + "][" + msg + "]已等待[" + Math.Round(span.TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, MoveInfo.ErrorLogType);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
        } 
        #endregion

        private bool busyPro = false;
        private DateTime busyProTime = DateTime.Now;
        private int maxSeconds = 3;
        protected override void mainTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            try
            {
                TimeSpan span = DateTime.Now - busyProTime;
                if (busyPro && span.TotalSeconds < maxSeconds)
                {
                    return;
                }
                try
                {
                    busyPro = true;
                    busyProTime = DateTime.Now;
                    switch (runStatus)
                    {
                        case RunStatus.HomeMoving:
                            ResetProcess();
                            break;
                        case RunStatus.Reset:
                            ResetProcess();
                            break;
                        case RunStatus.Runing:
                            if ((isInSuddenDown.Equals(false) && isNoAirpressure_Check.Equals(false)))
                            {
                                //清理超时异常
                                IOTimeOutProcess();
                            }
                            break;
                        default: break;
                    }

                    inputEquip.AutoStartProcess();
                    boxEquip.AutoStartProcess();
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "LineTimerPro 出错：", ex);
                } 
                busyPro = false;
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "主定时器出错：" + ex.ToString());
            }
            Thread.Sleep(1);
        }
   

        #region 停止运动

        internal override void StopMove()
        {
            MoveInfo.EndMove();
            foreach (EquipBase equip in this.equipsMap.Values)
            {
                if (!equip.IsDebug)
                {
                    equip.StopRun();
                }
            }
        }
        public override void StopRun()
        {
            mainTimer.Enabled = false;
            StopMove();
            AgvClient.SetCancelState(false);
            runStatus = RunStatus.Wait;
            TimeSpan span = DateTime.Now - StartTime;
            LogUtil.info(Name + ",停止运行，总运行时间：" + span.ToString());
        }

        #endregion

        #region IOTimeOutProcess     

        private DateTime preIoTimerOutTime = DateTime.Now;
        private void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 1 && alarmType.Equals(AlarmType.IoSingleTimeOut))
                {
                    preIoTimerOutTime = DateTime.Now;

                    if (runStatus < RunStatus.Runing || isInSuddenDown || isNoAirpressure_Check)
                    {
                        return;
                    }

                    //若BOX和移栽都没有在等待Io的过程中则此Io超时异常可能已经处理过
                    //     if (MoveInfo.IsInWait.Equals(false) && SW41_MoveInfo.IsInWait.Equals(false) && SW23_MoveInfo.IsInWait.Equals(false))
                    {
                        LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                        alarmType = AlarmType.None;
                        SetWarnMsg("");
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("IOTimeOutProcess出错：", ex);
            }
        }
        #endregion

        #region    CheckWait  
        private DateTime preRWTime = DateTime.Now;
        private void CheckWait(DeviceMoveInfo checkWaitInfo)
        {
            try
            {
                List<WaitResultInfo> list = checkWaitInfo.WaitList;
                if (list.Count <= 0)
                {
                    checkWaitInfo.EndStepWait();
                    return;
                }

                //当等待超过一分钟时，需要打印提示 
                TimeSpan span = DateTime.Now - checkWaitInfo.LastSetpTime;
                string NotOkMsg = "";
                bool isOk = true;
                if (checkWaitInfo.OneWaitCanEndStep)
                {
                    isOk = false;
                }
                foreach (WaitResultInfo wait in list)
                {
                    if (wait == null || wait.IsEnd)
                    {
                        continue;
                    }
                    NotOkMsg = " [" + wait.ToStr() + "] ";
                    if (wait.WaitType.Equals(WaitEnum.W002_IOValue))
                    {
                        NotOkMsg = " [" + IOManager.GetIO(wait.IoType, DeviceID).DisplayStr + "=" + wait.IoValue + "] ";
                        wait.IsEnd = IOValue(wait.IoType).Equals(wait.IoValue);

                        if (!wait.IsEnd)
                        {
                            TimeSpan rwSpan = DateTime.Now - preRWTime;
                            //一分钟还未检测到
                            if (span.TotalSeconds > StoreManager.Config.IOSingle_TimerOut && NoAlarm())
                            {
                                ConfigIO io = baseConfig.getWaitIO(wait.IoType);
                                WarnMsg = Name + "[" + checkWaitInfo.MoveStep + "]等待" + NotOkMsg + " 超时";
                                Alarm(AlarmType.IoSingleTimeOut);
                                LogUtil.error(  WarnMsg, checkWaitInfo.ErrorLogType);
                            }
                            //超过报警时长
                            else if (rwSpan.TotalSeconds > 5 && span.TotalSeconds > 6 && span.TotalSeconds < StoreManager.Config.IOSingle_TimerOut * 2)
                            {
                                preRWTime = DateTime.Now;
                                string msg = checkWaitInfo.Name + "  " + NotOkMsg + "已等待 " + Math.Round(span.TotalSeconds, 1) + "秒，重写DO：";
                                bool isLog = false;
                                foreach (WaitResultInfo ww in list)
                                {
                                    if (ww != null && ww.WaitType.Equals(2) && baseConfig.DOList.ContainsKey(ww.IoType))
                                    {
                                        if (IOManager.DOValue(ww.IoType, baseConfig.Id).Equals(ww.IoValue).Equals(false))
                                        {
                                            isLog = true;
                                            IOMove(ww.IoType, ww.IoValue);
                                            msg += ww.ToStr() + "，";
                                        }
                                    }
                                }
                                if (isLog)
                                {
                                    LogUtil.error(msg);
                                }
                            }
                            if (!checkWaitInfo.OneWaitCanEndStep)
                            {
                                isOk = false;
                                break;
                            }
                        }
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W003_Time))
                    {
                        wait.IsEnd = (span.TotalMilliseconds >= wait.TimeMSeconds);
                    }

                    if (wait.IsEnd)
                    {
                        if (checkWaitInfo.OneWaitCanEndStep)
                        {
                            isOk = true;
                            break;
                        }
                    }
                    else
                    {
                        if (!checkWaitInfo.OneWaitCanEndStep)
                        {
                            isOk = false;
                            break;
                        }
                    }
                }
                if (isOk)
                {
                    checkWaitInfo.EndStepWait();
                }
                else if (span.TotalSeconds > checkWaitInfo.TimeOutSeconds)
                {
                    WarnMsg = checkWaitInfo.Name + "[" + checkWaitInfo.MoveStep + "][" + NotOkMsg + "]已等待[" + Math.Round(span.TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, checkWaitInfo.ErrorLogType);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(checkWaitInfo.Name + " [" + checkWaitInfo.MoveStep + "] CheckWait 出错：", ex);
            }
        }
        #endregion

        #region 忙碌处理
      
         
        public override bool StartInstore(InOutParam param)
        {
            return true;

        }
        protected override void InstoreProcess()
        {
        }

        public override bool StartOutstore(InOutParam param)
        {
            return false;
        }

        protected override void OutstoreProcess()
        {
        }
        private void InOutLog(string msg)
        {
            LogUtil.debug(Name + msg);
        }

        #endregion


        public override void Alarm(AlarmType alarmType)
        {
            if (alarmType.Equals(AlarmType.None).Equals(false))
            {
                LastAlarmTime = DateTime.Now;
            }
            if (this.alarmType.Equals(alarmType))
            {
                return;
            }
            if (alarmType.Equals(AlarmType.SuddenStop))
            {
                isInSuddenDown = true;
            }
            else if (alarmType.Equals(AlarmType.NoAirpressure_Check))
            {
                isNoAirpressure_Check = true;
            }
            this.alarmType = alarmType;
            if (alarmType.Equals(AlarmType.SuddenStop) || alarmType.Equals(AlarmType.NoAirpressure_Check) || alarmType.Equals(AlarmType.AxisAlarm))
            {
                StopMove();
            }
        }

      
    }
}