using Asa;
using BLL;
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;

namespace OnlineStore.DeviceLibrary
{
    public partial class RobotBean : RobotBase
    {


        #region  初始化 
        public bool IsDebug = false;

        public InputEquip inputEquip;
        public X_RAY_Equip XrayBean;
        public OutputEquip outputEquip;
        public Dictionary<int, EquipBase> equipsMap = new Dictionary<int, EquipBase>();
        
        public Robot_Config Config = null;
        private bool canStart = false;
        public SQLite sQLite = null;
        public bool LoadSuccess = false;
        public bool SafeStop = false;
        public RobotBean(Robot_Config lineConfig, InputEquip_Config fconfig, XRay_Config xconfig, OutputEquip_Config pconfig)
        {
            equipsMap = new Dictionary<int, EquipBase>();
            if (lineConfig.IOSingle_TimerOut <= 0)
            {
                lineConfig.IOSingle_TimerOut = 5000;
            }
            Init();
            baseConfig = lineConfig;
            this.Config = lineConfig;
            this.DeviceID = lineConfig.Id;

            Name = (" 自动点料机_" + " ").ToUpper();
            MoveInfo = new RobotMoveInfo(Name);

            IsDebug = Config.IsDebug.Equals(1);

            ledProcessTimer.Elapsed += LedProcessTimer_Elapsed;

            
            List<string> ioList = new List<string>();
            ioList = new List<string>(DeviceConfig.ProIOIpMap.Values);

            inputEquip = new InputEquip("1", fconfig);
            XrayBean = new X_RAY_Equip("2", xconfig);
            outputEquip = new OutputEquip("3", pconfig);

            equipsMap.Add(1, inputEquip);
            equipsMap.Add(2, XrayBean);
            equipsMap.Add(3, outputEquip);
            IOManager.Init();
            CodeManager.LoadConfig();

            AgvClient.NodeList.Add(outputEquip.Config.AgvInName);
            AgvClient.NodeList.Add(outputEquip.Config.AgvOutName);
            AgvClient.NodeList.Add(inputEquip.Config.RightAgvName);
            AgvClient.NodeList.Add(inputEquip.Config.LeftAgvName);




            EyemManager.record = true;
            outputEquip.Out_TrayCheck_Test(outputEquip.Config.CameraName, IO_VALUE.HIGH);
            EyemManager.record = false;
            /*var carerayImage = new CarerayImage();
            if (carerayImage.Open())
            {
                carerayImage.Close();
            }
            else {
                LogUtil.info(Name + "图像平板打开失败！ 系统不允许启动。");
                return;
            }
            */
            ParamManager.Init();
            OldPNList.init();
            Task.Factory.StartNew(delegate
            {
                LogUtil.info(Name + "开始连接IO模块 ");
                IOManager.instance.ConnectionIOList(ioList);
                Thread.Sleep(3000);
                mainTimer.Enabled = true;
                //ledProcessTimer.Enabled = true;
                canStart = true;
                var MaxNopaperCount = ConfigAppSettings.GetIntValue("NopaperCount");
                LogUtil.info("MaxNopaperCount:"+ MaxNopaperCount);
                var loadsuccess = XrayBean.XPlateUP();
                
                AgvClient.Init();
                string dataFile =Application.StartupPath+ ConfigAppSettings.GetValue(Setting_Init.DataPath);
                sQLite = new SQLite(dataFile);
                bool result = sQLite.Connect();
                LogUtil.info(Name + "连接【" + dataFile + "】结果: " + result+","+sQLite.ErrInfo);
                LoadSuccess = loadsuccess;
            });
        }

        private void LedProcessTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                //DateTime time = DateTime.Now;
                if (runStatus <= RobotRunStatus.Wait)
                {
                    CloseLed();
                    return;
                }
                bool isNeedAlarmLed = false;
                bool isInOut = false;
                bool yellowMove = true;
                // {inputEquip,XrayBean,outputEquip};


                bool NeedAlarm = inputEquip.NeedAlarm || XrayBean.NeedAlarm || outputEquip.NeedAlarm;
                if (!NeedAlarm) {
                    if (outputEquip.WarnMsg.IndexOf("OS_") > 0) {
                        NeedAlarm = true;
                    }
                }
                isInOut = inputEquip.MoveInfo.MoveType == RobotMoveType.Working
                    || XrayBean.MoveInfo.MoveType == RobotMoveType.Working
                    || outputEquip.ShelfMoveInfo.MoveType == RobotMoveType.ShelfPro
                    || outputEquip.MoveInfo.MoveType == RobotMoveType.Working
                    || outputEquip.SecMoveInfo.MoveType == RobotMoveType.Labelling
                    ;
                if (!NeedAlarm)
                {
                    NeedAlarm = inputEquip.alarmType >= AlarmType.AxisAlarm
                    || XrayBean.alarmType >= AlarmType.AxisAlarm
                    || outputEquip.alarmType >= AlarmType.AxisAlarm
                    ;
                }
                //if (inputEquip.runStatus<3)
                //{
                //    yellowMove = true;
                ////}

                if (isNoAirCheck || isInSuddenDown || NeedAlarm)
                {
                    isNeedAlarmLed = true;
                }




                //黄灯
                if (yellowMove)
                {
                    //开机执行中时黄灯闪烁
                    if (DOValue(IO_Type.AutoRun_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                    }
                    else
                    {
                        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
                    }
                }
                else if (DOValue(IO_Type.AutoRun_HddLed).Equals(IO_VALUE.HIGH))
                {
                    IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                }
                //忙碌中，判断是否有移栽在出入库执行，绿灯闪烁
                if (isInOut)
                {
                    if (DOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.LOW))
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
                    }
                    else
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                }
                else if (DOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.LOW))
                {
                    //平常常亮绿灯
                    IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
                }

                //严重报警中 ，红灯闪烁
                if (isNeedAlarmLed)
                {
                    if (DOValue(IO_Type.Alarm_HddLed).Equals(IO_VALUE.LOW))
                    {
                        IOMove(IO_Type.Alarm_HddLed, IO_VALUE.HIGH);
                    }
                    else
                    {
                        IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                    }
                }
                else if (DOValue(IO_Type.Alarm_HddLed).Equals(IO_VALUE.HIGH))
                {
                    IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                }
                if (isNeedAlarmLed && RobotManager.UseBuzzer)
                {
                    CheckAndMove(IO_Type.Alarm_Buzzer, IO_VALUE.HIGH);
                }
                else
                {
                    CheckAndMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
                }
                //Thread.Sleep(900);
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "灯处理定时器出错：", ex);
            }
        }
        protected void CloseLed()
        {
            CheckAndMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
            CheckAndMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            CheckAndMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            CheckAndMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
        }
        #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
            {
                SafeStop = false;

                mainTimer.Enabled = false;
                //lineStatus = LineStatus.ResetMove;
                runStatus = RobotRunStatus.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;
                isNoAirCheck = false;
                SetWarnMsg("");
                MoveInfo.NewMove(RobotMoveType.Reset);
                MoveInfo.NextMoveStep(StepEnum.Wait);

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

                    EquipStartRun(moveEquip);
                }
                if (runStatus.Equals(RobotRunStatus.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()
        {
            SafeStop = false;

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

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

            runStatus = RobotRunStatus.Reset;

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

            foreach (EquipBase equip in equipsMap.Values)
            {
                if (runStatus.Equals(RobotRunStatus.Wait))
                {
                    LogUtil.error(Name + "复位过程中发现 runStatus=Wait，中断启动");
                    return false;
                }
                EquipReset(equip, isNeedAllReset);
            }
            if (runStatus.Equals(RobotRunStatus.Wait))
            {
                return false;
            }
            mainTimer.Enabled = true;
            return true;
        }
        private void EquipReset(EquipBase equip, bool isNeedAllReset)
        {
            //调试状态不再重置
            if (!equip.IsDebug)
            {
                if (isNeedAllReset || (!equip.NoAlarm()))
                {
                    SafeStop = false;

                    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)
            {
                SafeStop = false;

                bool isOk = true;
                string msg = "";
                //判断是否所有的已经返回完成
                TimeSpan span = DateTime.Now - MoveInfo.LastSetpTime;
                foreach (EquipBase moveEquip in this.equipsMap.Values)
                {
                    if (moveEquip.runStatus.Equals(RobotRunStatus.HomeMoving) || moveEquip.runStatus.Equals(RobotRunStatus.Reset) || moveEquip.runStatus.Equals(RobotRunStatus.Wait))
                    {
                        if (moveEquip.NoAlarm())
                        {
                            msg = moveEquip.Name + "复位结束";
                            isOk = false;
                            break;
                        }
                        else
                        {
                            //LogUtil.error(Name + " " + moveEquip.Name + "在复位过程中报警，需要重新复位，调用 moveEquip.Reset();");
                            //moveEquip.Reset();
                            ////如果小于80秒，继续等待
                            //if (span.TotalSeconds < 80)
                            //{
                            //    isOk = false;
                            //    break;
                            //}
                        }
                    }
                }

                if (isOk)
                {
                    runStatus = RobotRunStatus.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 RobotRunStatus.HomeMoving:
                            ResetProcess();
                            break;
                        case RobotRunStatus.Reset:
                            ResetProcess();
                            break;
                        case RobotRunStatus.Runing:
                            if ((isInSuddenDown.Equals(false) && isNoAirCheck.Equals(false)))
                            {
                                //清理超时异常
                                IOTimeOutProcess();
                            }
                            break;
                        default: break;
                    }
                }
                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);
            RFIDManager.Close();
            runStatus = RobotRunStatus.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 < RobotRunStatus.Runing || isInSuddenDown || isNoAirCheck)
                    {
                        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(RobotMoveInfo 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.GetDI(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 > RobotManager.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 < RobotManager.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 StartLabelling(WorkParam param)
        {
            return true;
        }
        protected override void LabellingProcess()
        {
        }
         
        public override bool StartWorking(WorkParam param)
        {
            return true;

        }
        protected override void WorkingProcess()
        {
        }


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

        #endregion


        public DateTime LastAlarmTime = DateTime.Now;
        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.NoAirCheck))
            {
                isNoAirCheck = true;
            }
            this.alarmType = alarmType;
            if (alarmType.Equals(AlarmType.SuddenStop) || alarmType.Equals(AlarmType.NoAirCheck) || alarmType.Equals(AlarmType.AxisAlarm))
            {
                StopMove();
            }
        }


    }
}