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;

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 流水线自动料仓-流水线类
    /// </summary>
    public partial class PackingStoreBean : KTK_Store
    {
        
        /// <summary>
        /// 灯闪烁定时器
        /// </summary>
        private System.Timers.Timer ledProcessTimer = null; 
        /// <summary>
        /// 分出一个线程，专门处理急停，报警，气压检测，工单信号检测等处理
        /// </summary>
        private System.Timers.Timer IoCheckTimer = null;
      
        public Dictionary<int, AC_BOX_Config> BoxConfigMap { get; set; }
        public Dictionary<int, AC_BOX_Bean> BoxMap = new Dictionary<int, AC_BOX_Bean>();
     
        public Store_Config Config { get; set; }

        #region  初始化

        private bool canStart = false;
        public PackingStoreBean(Store_Config lineConfig, Dictionary<int, AC_BOX_Config> configList)
        {
            BoxConfigMap = new Dictionary<int, AC_BOX_Config>();
            BoxMap = new Dictionary<int, AC_BOX_Bean>();
            if (lineConfig.IOSingle_TimerOut <= 0)
            {
                lineConfig.IOSingle_TimerOut = 5000;
            }
            Init();
            InitTimer();
            baseConfig = lineConfig;
            this.Config = lineConfig;
            this.DeviceID = lineConfig.Id;

            MoveInfo = new StoreMoveInfo(DeviceID);
            Name = (" Store_" + Config.CID + " ").ToUpper();
            List<string> ioList = new List<string>();

            AddDeviceName(ioList, Config.DIODeviceNameList);
            foreach (AC_BOX_Config config in configList.Values)
            {
                AC_BOX_Bean equip = new AC_BOX_Bean(config);

                AddDeviceName(ioList, config.DIODeviceNameList);
                BoxMap.Add(config.Id, equip);
                BoxConfigMap.Add(config.Id, config);
            }

            IOManager.Init();
            //先初始化设备

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

            Task.Factory.StartNew(delegate
            {
                IOManager.instance.ConnectionIOList(ioList);
                addLastDI(IO_Type.Airpressure_Check, IOValue(IO_Type.Airpressure_Check));
                addLastDI(IO_Type.SuddenStop_BTN, IOValue(IO_Type.SuddenStop_BTN));
                addLastDI(IO_Type.Reset_BTN, IOValue(IO_Type.Reset_BTN));

                mainTimer.Enabled = true;
                IoCheckTimer.Enabled = true;
                canStart = true;
            });
        }


        private void AddDeviceName(List<string> targetList, List<string> list)
        {
            foreach (string str in list)
            {
                if (!targetList.Contains(str))
                {
                    targetList.Add(str);
                }
            }
        }
        public void InitTimer()
        {

            ledProcessTimer = new System.Timers.Timer();
            ledProcessTimer.Interval = 1000;
            ledProcessTimer.Elapsed += LedProcess;
            ledProcessTimer.AutoReset = true;
            ledProcessTimer.Enabled = false;

            IoCheckTimer = new System.Timers.Timer();
            IoCheckTimer.Interval = 200;
            IoCheckTimer.Elapsed += IoCheckTimerProcess;
            IoCheckTimer.AutoReset = true;
            IoCheckTimer.Enabled = false;
        }

        private void IoCheckTimerProcess(object sender, ElapsedEventArgs e)
        {
           
        }

        #endregion

        public override bool StartRun( )
        { 
            if (!canStart)
            {
                SetWarnMsg("启动失败：设备未初始化完成");
                return false;
            }
            if (BoxConfigMap == null)
            {
                SetWarnMsg("启动失败：未加载到料仓配置");
                return false;
            }
            if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg("启动失败：急停未开"); 
            }
            else if (IOValue(IO_Type.Airpressure_Check).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg("启动失败：没有气压信号"); 
            }
            else
            {
                LogUtil.info( Name + "开始启动，启动时间：" + StartTime.ToString());
                storeRunStatus = StoreRunStatus.HomeMoving;
                StartTime = DateTime.Now;

                mainTimer.Enabled = false;
                IoCheckTimer.Enabled = false;
                isInSuddenDown = false;
                isNoAirCheck = false;
                alarmType = StoreAlarmType.None;
                WarnMsg = "";

                foreach (AC_BOX_Bean moveEquip in this.BoxMap.Values)
                {
                    if (!moveEquip.IsDebug)
                    {
                        moveEquip.StartRun();
                    } 
                }
               
                ledProcessTimer.Enabled = true;
                IoCheckTimer.Enabled = true;
                mainTimer.Enabled = true;
                return true;
            }
            return false;
        }  

        public override void Reset(bool isNeedClearAuto = true) 
        {
            mainTimer.Enabled = false;
            IoCheckTimer.Enabled = false; 
           
            //停止运动
            MoveInfo.EndMove(); 

            storeRunStatus = StoreRunStatus.Reset;

            mainTimer.Enabled = false;
            IoCheckTimer.Enabled = false;
            isInSuddenDown = false;
            isNoAirCheck = false;
            alarmType = StoreAlarmType.None;
            WarnMsg = "";
             
            foreach (AC_BOX_Bean equip in BoxMap.Values)
            {
                //调试状态不再重置
                if (!equip.IsDebug)
                {
                    if (!equip.alarmType.Equals(StoreAlarmType.None))
                    {
                        LogUtil.info(Name + "收到复位信号，" + equip.Name + " 需要复位");
                        equip.Reset();
                    }
                    else
                    {
                        LogUtil.info(Name + "收到复位信号，" + equip.Name + " 正常无报警，不需要复位");
                    }
                } 
            }
            
            IoCheckTimer.Enabled = true;
            mainTimer.Enabled = true; 
        }
       

        public override void StopRun()
        {
            IoCheckTimer.Enabled = false; 
            mainTimer.Enabled = false;
            ledProcessTimer.Enabled = false;
             
            //停止运行时，把阻挡气缸上升
            StopMove();
            storeRunStatus = StoreRunStatus.Wait;
             
            TimeSpan span = DateTime.Now - StartTime;
            LogUtil.info( Name + ",停止运行，总运行时间：" + span.ToString());
        }

      

      

        #region 灯光处理 
        private void LedProcess(object sender, ElapsedEventArgs e)
        {
            //try
            //{
            //    DateTime time = DateTime.Now; 
            //    //黄灯
            //    if (  storeRunStatus.Equals(StoreRunStatus.HomeMoving) || storeRunStatus.Equals(StoreRunStatus.Reset))
            //    {
            //        //开机执行中时黄灯闪烁
            //        if (IsDoValue(IO_Type.RunSign_HddLed, IO_VALUE.HIGH))
            //        {
            //            IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            //        }
            //        else
            //        {
            //            IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
            //        }
            //    }
            //    //休眠状态黄灯常亮
            //    else if (IsSleep)
            //    {
            //        if (IsDoValue(IO_Type.RunSign_HddLed, IO_VALUE.LOW))
            //        {
            //            IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
            //        }
            //    }
            //    else
            //    {
            //        if (IsDoValue(IO_Type.RunSign_HddLed, IO_VALUE.HIGH))
            //        {
            //            IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            //        }
            //    }

            //    bool isNeedAlarmLed = false;
            //    bool isInOut = false;
            //    if (alarmType.Equals(StoreAlarmType.None).Equals(false) || isNoAirCheck || isInSuddenDown || TrayManager.TrayErrorMsg != "")
            //    {
            //        isNeedAlarmLed = true;
            //    }

            //    foreach (AC_Packing_Box moveEquip in BoxConfigMap.Values)
            //    {
            //        if (!moveEquip.alarmType.Equals(StoreAlarmType.None))
            //        {
            //            isNeedAlarmLed = true;
            //        }
            //        if (moveEquip.MoveInfo.MoveType.Equals(LineMoveType.InStore) || moveEquip.MoveInfo.MoveType.Equals(LineMoveType.OutStore))
            //        {
            //            isInOut = true;
            //        }
            //    }

            //    //忙碌中，判断是否有移栽在出入库执行，绿灯闪烁
            //    if (isInOut)
            //    {
            //        if (IsDoValue(IO_Type.AutoRun_HddLed, IO_VALUE.LOW))
            //        {
            //            IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
            //        }
            //        else
            //        {
            //            IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
            //        }
            //    }
            //    else if (IsDoValue(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH))
            //    {
            //        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
            //    }

            //    //报警中 ，红灯闪烁
            //    if (isNeedAlarmLed)
            //    {
            //        if (IsDoValue(IO_Type.Alarm_HddLed, IO_VALUE.LOW))
            //        {
            //            IOMove(IO_Type.Alarm_HddLed, IO_VALUE.HIGH);
            //        }
            //        else
            //        {
            //            IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            //        }
            //    }
            //    else if (IsDoValue(IO_Type.Alarm_HddLed, IO_VALUE.HIGH))
            //    {
            //        IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            //    }

            //}
            //catch (Exception ex)
            //{
            //    LogUtil.error(Name + "灯处理定时器出错："+ ex.ToString());
            //}
            //Thread.Sleep(5);
        } 
        #endregion

      
        /// <summary>
        /// 定时处理，监听信号，监听IO
        /// </summary> 
        protected override void timersTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                DateTime time = DateTime.Now;
                if (storeRunStatus.Equals(StoreRunStatus.Wait))
                {
                    //取新的Io状态
                    IO_VALUE fuweiValue = IOValue(IO_Type.Reset_BTN);
                    IO_VALUE lastFuwei = DILastValueMap[IO_Type.Reset_BTN];
                    addLastDI(IO_Type.Reset_BTN, fuweiValue);
                    bool isAutoStart = ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun) == 1;

                    //收到复位信号后启动
                    if (isAutoStart && fuweiValue.Equals(IO_VALUE.HIGH) && lastFuwei.Equals(IO_VALUE.LOW))
                    {
                        //没有启动时收到复位按钮，相当于启动按钮
                        LogUtil.info( Name + "没有启动时收到复位按钮，相当于启动按钮，开始调用启动方法！");
                        bool isOk = StartRun();
                        if (!isOk)
                        {
                            LogUtil.error("启动失败，等待下次启动");
                            mainTimer.Enabled = true;
                        }
                    }
                    return;
                }
                //判断急停 
                else if (this.storeRunStatus >= StoreRunStatus.HomeMoving)
                {
                    foreach (AC_BOX_Bean moveEquip in this.BoxMap.Values)
                    {
                        if (!moveEquip.IsDebug)
                        {
                            moveEquip.TimerProcess();
                        }
                    } 
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "主定时器出错：" + ex.ToString());
            }
            Thread.Sleep(1);
        } 
        /// <summary>
        /// 气压检测处理
        /// </summary> 
        private IO_VALUE CheckAir(IO_VALUE airCheck, IO_VALUE lastAir)
        {
            IO_VALUE airValue = IO_VALUE.HIGH;
            if (airCheck == IO_VALUE.LOW && (!isInSuddenDown))
            {
                //判断是否持续了3秒
                if (lastAir == IO_VALUE.LOW)
                {
                    if ((DateTime.Now - lastAirCloseTime).TotalSeconds > Config.AirCheckSeconds)
                    {
                        SetWarnMsg("持续"+Config.AirCheckSeconds+"秒未检测到气压信号");
                        //SendAlarmCode(0, LineAlarm.NoAirCheck);
                        airValue = IO_VALUE.LOW;
                      
                    }
                }
                else
                {
                    lastAirCloseTime = DateTime.Now;
                    isNoAirCheck = false;
                }
            }
            else
            {
                isNoAirCheck = false;
            }
            return airValue;
        }
 


        public override void StopMove()
        {
          
            foreach (AC_BOX_Bean equip in this.BoxMap.Values)
            {
                if (!equip.IsDebug)
                {
                    equip.StopRun();
                } 
            }
            MoveInfo.EndMove();
 
        }

        protected override void ResetProcess()
        {
            bool isOk = true;
            //判断是否所有的已经返回完成

            foreach (AC_BOX_Bean moveEquip in this.BoxMap.Values)
            {
                if ((moveEquip.storeRunStatus.Equals(StoreRunStatus.HomeMoving) || moveEquip.storeRunStatus.Equals(StoreRunStatus.Reset)) && moveEquip.IsDebug.Equals(false))
                {
                    if (moveEquip.alarmType.Equals(StoreAlarmType.None))
                    {
                        isOk = false;
                        break;
                    }
                    else
                    {
                        WarnMsg = moveEquip.Name + "在复位过程中报警，需要重新复位";
                    }
                }
            }
         
            if (isOk)
            { 
                //所有原点重置完成
                storeRunStatus = StoreRunStatus.Runing;
                LogUtil.info( Name + "所有设备重置完成");
            }
        }
     
        private void SetWarnMsg(string msg)
        {
            WarnMsg = msg;
            LogUtil.error(Name + WarnMsg);
        }

        public override void Alarm(StoreAlarmType alarmType, string alarmDetial, string alarmMsg, StoreMoveType storeMoveType)
        {
            throw new NotImplementedException();
        }

        protected override void ReturnHomeProcess()
        {
            throw new NotImplementedException();
        } 
    }
}