using Asa;
using log4net;
using log4net.Repository.Hierarchy;
using log4net.Util;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Security.Cryptography.X509Certificates;
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;
        private System.Timers.Timer serverConnectTimer = new System.Timers.Timer();

        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; }
        public bool UseBuzzer = Setting_Init.UseBuzzer;
        /// <summary>
        /// 入口有料架自动入库
        /// </summary>
        public bool AutoShelfInstore = Setting_Init.AutoShelfInstore;
        List<string> rfidList = new List<string>();
        #region  初始化

        internal 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.DeviceID;

            MoveInfo = new DeviceMoveInfo(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);

                //增加站号名称
                AgvClient.NodeList.Add(config.AgvNodeName);
                AddDeviceName(ioList, config.DIODeviceNameList);
                BoxMap.Add(config.DeviceID, equip);
                BoxConfigMap.Add(config.DeviceID, config);
                rfidList.Add(config.RFID_IP);
            }

            IOManager.Init();
            //先初始化设备
            RFIDManager.Open(rfidList.ToArray());
            //初始化摄像机配置  
            CodeManager.LoadConfig();

            Task.Factory.StartNew(delegate
            {
                //   RFIDManager.RfidReader.Open(rfidList.ToArray());
                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));
                IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                mainTimer.Enabled = true;
                canStart = true;

                serverConnectTimer.Enabled = true;
                //连接AGV调度
                AgvClient.Init();
            });
        }

        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;

            serverConnectTimer = new System.Timers.Timer();
            serverConnectTimer.Interval = 1000;
            serverConnectTimer.AutoReset = true;
            serverConnectTimer.Enabled = false;
            serverConnectTimer.Elapsed += server_connect_timer_Tick;
        }

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

        public override bool StartRun(bool isDebug = false)
        {
            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 + "开始启动，连接agv调度，连接rfid，启动时间：" + StartTime.ToString());
                storeRunStatus = StoreRunStatus.HomeMoving;
                StartTime = DateTime.Now;
                //AgvClient.SetCancelState(false);

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

                foreach (AC_BOX_Bean box in this.BoxMap.Values)
                {
                    box.StartRun();
                }

                serverConnectTimer.Enabled = true;
                ledProcessTimer.Enabled = true;
                mainTimer.Enabled = true;
                return true;
            }
            return false;
        }

        public override void Reset(bool isNeedClearAuto = true)
        {
            mainTimer.Enabled = false;

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

            storeRunStatus = StoreRunStatus.Reset;

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

            foreach (AC_BOX_Bean equip in BoxMap.Values)
            {
                if (!equip.alarmType.Equals(StoreAlarmType.None))
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 需要复位");
                    equip.Reset();
                }
                else
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 正常无报警，不需要复位");
                }
            }
            mainTimer.Enabled = true;
        }


        public override void StopRun()
        {
            mainTimer.Enabled = false;
            ledProcessTimer.Enabled = false;
            AgvClient.SetCancelState(AgvClient.CurrCancelState);           
            //停止运行时，把阻挡气缸上升
            StopMove();
            foreach (AC_BOX_Bean equip in BoxMap.Values)
            {
                equip.StopRun();
            }
            storeRunStatus = StoreRunStatus.Wait;
            // RFIDManager.Close();
            TimeSpan span = DateTime.Now - StartTime;
            LogUtil.info(Name + ",停止运行，关闭rfid，总运行时间：" + span.ToString());
        }

        #region 灯光处理 
        //private void LedProcess(object sender, ElapsedEventArgs e)
        //{
        //    try
        //    {
        //        DateTime time = DateTime.Now;
        //        bool isNeedAlarmLed = false;
        //        bool isInOut = false;
        //        StoreRunStatus runs = StoreRunStatus.Wait;

        //        foreach (AC_BOX_Bean box in BoxMap.Values)
        //        {
        //            if (!box.alarmType.Equals(StoreAlarmType.None))
        //            {
        //                isNeedAlarmLed = true;
        //            }
        //            if (box.MoveInfo.MoveType.Equals(StoreMoveType.InStore) || box.MoveInfo.MoveType.Equals(StoreMoveType.OutStore))
        //            {
        //                isInOut = true;
        //            }
        //            if (box.storeRunStatus > runs)
        //            {
        //                runs = box.storeRunStatus;
        //            }
        //        }

        //        //黄灯
        //        if (runs.Equals(StoreRunStatus.HomeMoving) || runs.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 (isInOut)
        //        {
        //            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);
        //            }
        //        }
        //        if (alarmType.Equals(StoreAlarmType.None).Equals(false) || isNoAirCheck || isInSuddenDown)
        //        {
        //            isNeedAlarmLed = true;
        //        }
        //        //忙碌中，判断是否有移栽在出入库执行 绿灯灭
        //        if (isInOut)
        //        {

        //            IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);

        //        }
        //        else
        //        {
        //            IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
        //        }

        //        //报警中 ，红灯闪烁
        //        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);
        //}
        bool TempOrHumidityIsAlarm = false;
        DateTime TempAlarmTime = DateTime.Now;
        bool isPro = false;
        private void LedProcess(object sender, ElapsedEventArgs e)
        {
            if (isPro)
            {
                return;
            }
            isInPro = true;
            try
            {
                //                机器状态 顶灯显示 
                //                                              绿 黄  红
                //机器复位中                             闪 灭   灭
                //机器待机中                             亮 灭   灭
                //机器出入库中                          闪 闪   灭
                //温湿度超限报警中                   亮 闪   灭
                //温湿度超限报警中超过30分钟  亮 闪   闪
                //机器未启动                             灭 灭   灭
                //机器设备故障(非温湿度)报警    亮   灭 闪
                //报警时只需要亮红灯
                DateTime time = DateTime.Now;
                bool isTemp30M = false;
                if (TempOrHumidityIsAlarm)
                {
                    TimeSpan span = DateTime.Now - TempAlarmTime;
                    if (span.Minutes > 30)
                    {
                        isTemp30M = true;
                    }
                }

                bool isInOut = false;
                bool isNeedAlarmLed = false;
                StoreRunStatus runs = storeRunStatus;

                foreach (AC_BOX_Bean box in BoxMap.Values)
                {
                    if (!box.alarmType.Equals(StoreAlarmType.None))
                    {
                        isNeedAlarmLed = true;
                    }
                    if (box.MoveInfo.MoveType.Equals(StoreMoveType.InStore) || box.MoveInfo.MoveType.Equals(StoreMoveType.OutStore))
                    {
                        isInOut = true;
                    }
                    if (box.storeRunStatus > runs)
                    {
                        runs = box.storeRunStatus;
                    }
                    if (isNeedAlarmLed || isInOut)
                        break;
                }

                //报警灯
                if (!alarmType.Equals(StoreAlarmType.None) || isTemp30M)
                {
                    isNeedAlarmLed = true;
                }
                if (isNeedAlarmLed && IOValue(IO_Type.Alarm_HddLed).Equals(IO_VALUE.LOW))
                {
                    IOMove(IO_Type.Alarm_HddLed, IO_VALUE.HIGH);
                }
                else
                {
                    if (IOValue(IO_Type.Alarm_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                    }
                }
                //报警时绿灯和黄灯灭
                if (isNeedAlarmLed)
                {
                    if (IOValue(IO_Type.AutoRun_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                    }
                    if (IOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                    }
                    return;
                }
                //绿灯闪
                if ((isInOut || runs.Equals(StoreRunStatus.HomeMoving) || runs.Equals(StoreRunStatus.Reset))
                  && IOValue(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);
                }
                //黄灯
                if (isInOut || TempOrHumidityIsAlarm || isTemp30M)
                {
                    if (IOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                    else
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
                    }
                }
                else
                {
                    if (IOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                }
            }
            catch (Exception ex)
            {
                Common.LogUtil.error(Name + "灯处理定时器出错：", ex);
            }
            finally
            {
                isInPro = false;
            }
        }

        private bool IsDoValue(string ioType, IO_VALUE ioValue)
        {
            return IOValue(ioType).Equals(ioValue);
        }
        #endregion 

        private IO_VALUE lastAutoRun = IO_VALUE.LOW;
        protected override void timersTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (storeRunStatus.Equals(StoreRunStatus.Wait))
            {
                //取新的Io状态
                IO_VALUE autoSingle = IOValue(IO_Type.Reset_BTN);
                if (Setting_Init.App_AutoRun)
                {
                    if (autoSingle.Equals(IO_VALUE.HIGH) && lastAutoRun.Equals(IO_VALUE.LOW))
                    {
                        //没有启动时收到复位按钮，相当于启动按钮
                        LogInfo("没有启动时收到复位按钮，相当于启动按钮，开始调用启动方法！");
                        bool result = StartRun();
                        if (result.Equals(false))
                        {
                            LogUtil.error(Name + "料仓启动失败，继续等待下次启动！");
                            mainTimer.Enabled = true;
                        }
                    }
                    lastAutoRun = autoSingle;
                    return;
                }
                lastAutoRun = autoSingle;
            }
            //判断急停 
            else
            {
                BusyMoveProcess();
            }
        }
        public override void StopMove()
        {
            foreach (AC_BOX_Bean equip in this.BoxMap.Values)
            {
                //  if (!equip.IsDebug)
                {
                    equip.StopMove();
                }
            }
            MoveInfo.EndMove();
        }

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

            foreach (AC_BOX_Bean box in this.BoxMap.Values)
            {
                if ((box.storeRunStatus.Equals(StoreRunStatus.HomeMoving) || box.storeRunStatus.Equals(StoreRunStatus.Reset)))
                //if ((box.storeRunStatus.Equals(StoreRunStatus.HomeMoving) || box.storeRunStatus.Equals(StoreRunStatus.Reset)) && box.IsDebug.Equals(false))
                {
                    if (box.alarmType.Equals(StoreAlarmType.None))
                    {
                        isOk = false;
                        break;
                    }
                    else
                    {
                        WarnMsg = box.Name + "在复位过程中报警，需要重新复位";
                    }
                }
            }

            if (isOk)
            {
                //所有原点重置完成
                storeRunStatus = StoreRunStatus.Runing;
                AgvClient.SetCancelState(AgvClient.CurrCancelState);
                LogUtil.info(Name + "所有设备重置完成");
            }
        }

        private void SetWarnMsg(string msg)
        {
            if (String.IsNullOrEmpty(WarnMsg).Equals(false))
            {
                if (WarnMsg.Equals(msg))
                {
                    if (msg.StartsWith(Name))
                    {
                        LogUtil.error(msg, 105);
                    }
                    else
                    {
                        LogUtil.error(Name + msg, 105);
                    }
                }
                else
                {
                    if (msg.StartsWith(Name))
                    {
                        LogUtil.error(msg);
                    }
                    else
                    {
                        LogUtil.error(Name + msg);
                    }
                }
            }

            WarnMsg = msg;
        }

        internal bool AGVProcess(string name, string rfid, ClientAction action)
        {
            foreach (AC_BOX_Bean box in this.BoxMap.Values)
            {
                if (box.Config.AgvNodeName.Equals(name))
                {
                    return box.ProcessAGVAction(name, rfid, action);
                }
            }
            return false;
        }
        public override void Alarm(StoreAlarmType alarmType, string alarmDetial, string alarmMsg, StoreMoveType storeMoveType)
        {

        }
        #region 出库

        public override bool StartOutStoreMove(InOutParam param)
        {

            return true;
        }
        protected override void OutStoreProcess()
        {
        }
        #endregion

        #region 入库 
        public override void StartInStoreMove(InOutParam param)
        {
        }
        protected override void InStoreProcess()
        {
        }

        #endregion




        #region 与服务器通信

        private bool isInProcess = false;
        private DateTime lastConTime = DateTime.Now;
        public void server_connect_timer_Tick(object sender, EventArgs e)
        {
            if (isInProcess)
            {
                TimeSpan span = DateTime.Now - lastConTime;
                if (span.TotalSeconds < 10)
                {
                    return;
                }
                else
                {
                    LogUtil.error($"{Name}server_connect_timer_Tick 已耗时{span.TotalSeconds}秒，重新处理");
                }
            }
            isInProcess = true;
            lastConTime = DateTime.Now;
            try
            {
                foreach (AC_BOX_Bean box in BoxMap.Values)
                {
                    if (box.storeRunStatus.Equals(StoreRunStatus.Wait))
                    {
                        continue;
                    }

                    if ((!box.IsDebug) && StoreManager.IsConnectServer)
                    {
                        try
                        {
                            box.SendLineStatus();
                        }
                        catch (Exception ex)
                        {
                            LogUtil.error(Name + "定时给服务器发送消息出错：" + ex.ToString());
                        }
                    }
                    box.humBean.HumidityProcess(box);
                }

            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "server_connect_timer_Tick出错：" + ex.ToString());
            }
            finally
            {
                isInProcess = false;
            }
        }

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

        #endregion

    }
}