using log4net;
using SmartShelf.Common; 
using SmartShelf.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq; 
using System.Windows.Forms;

namespace SmartShelf.DeviceLibrary
{
    public partial class BOXManager
    {
        public static string BoxName = " Shelf  ";
        public static string CID = "";

        private static System.Timers.Timer timersTimer;
        private static System.Timers.Timer serverConTimer;
        private static bool isInit = false;
        public static string WarnMsg = "";
        public static Dictionary<string, BoxPosition> PositionMap = null;
        public static int BoxCount = 1;

        private static Dictionary<string, string> PosIdColorMap = new Dictionary<string, string>();


        /// <summary>
        /// 指示灯颜色记录，key= IP_DmxID, value=颜色
        /// </summary>
        private static Dictionary<string, string> StatusLedColorMap = new Dictionary<string, string>();
        public static bool IsRun = false;
        public static string GetPosIdColor(string posId)
        {
            if (PosIdColorMap.ContainsKey(posId))
            {
                return PosIdColorMap[posId];
            }
            return "";
        }
        public static void UpdatePosIdColor(string posId, string color = "")
        {
            if (PosIdColorMap.ContainsKey(posId))
            {
                PosIdColorMap[posId] = color;
            }
            else
            {
                PosIdColorMap.Add(posId, color);
            }
        }
        public static bool StartInit()
        {
            try
            {
                BoxCount = ConfigAppSettings.GetIntValue(Setting_Init.BoxCount);
                string appPath = Application.StartupPath;
                //加载位置
                string positionConfigFile = appPath + ConfigAppSettings.GetValue(Setting_Init.Store_Position_Config);
                if (BoxCount > 1)
                {
                    string fileSub = System.IO.Path.GetExtension(positionConfigFile);
                    for (int i = 1; i <= BoxCount; i++)
                    {
                        string fileName = positionConfigFile.Substring(0, positionConfigFile.Length - fileSub.Length) + "_" + i + fileSub;
                        CSVPositionReader<BoxPosition>.AddCSVFile(fileName);
                    }
                }
                else
                {
                    CSVPositionReader<BoxPosition>.AddCSVFile(positionConfigFile);
                }
                PositionMap = CSVPositionReader<BoxPosition>.allPositionMap;
                if (PositionMap == null || PositionMap.Count <= 0)
                {
                    return false;
                }
                CID = ConfigAppSettings.GetValue(Setting_Init.Store_CID); 
                LEDManager.Init();
                LEDManager.deviceMap = new Dictionary<string, LEDBaseModule>();
                PosIdColorMap = new Dictionary<string, string>();
                StatusLedColorMap = new Dictionary<string, string>();
                foreach (BoxPosition box in PositionMap.Values)
                {
                    if (!LEDManager.deviceMap.ContainsKey(box.DeviceIp))
                    {
                        LEDManager.deviceMap.Add(box.DeviceIp, LEDBaseModule.GetModule(box.DeviceIp));
                        foreach (int dmx in LEDManager.StatusLedDmx)
                        {
                            string ledStr = box.DeviceIp + "_" + dmx;
                            if (!StatusLedColorMap.ContainsKey(ledStr))
                            {
                                StatusLedColorMap.Add(ledStr, "");
                            }
                        }
                    }
                    PosIdColorMap.Add(box.PositionNum, "");

                    if (box.GetStatusLedDmxId() >= 0)
                    {
                        string ledStr = box.DeviceIp + "_" + box.GetStatusLedDmxId();
                        if (!StatusLedColorMap.ContainsKey(ledStr))
                        {
                            StatusLedColorMap.Add(ledStr, "");
                        }
                    }
                }


                LogUtil.info(BoxName + "加载完成！");

                Init();
                return true;
            }
            catch (Exception ex)
            {
                LogUtil.error(BoxName + "加载配置出错：" + ex.ToString());
            }
            return false;
        }

        protected static void Init()
        {
            if (!isInit)
            {
                timersTimer = new System.Timers.Timer();
                timersTimer.Enabled = false;
                timersTimer.Interval = 1500;
                timersTimer.Elapsed += timersTimer_Elapsed;
                timersTimer.AutoReset = true;

                serverConTimer = new System.Timers.Timer();

                serverConTimer.Enabled = false;
                serverConTimer.Interval = 1000;
                serverConTimer.Elapsed += server_connect_timer;
                serverConTimer.AutoReset = true;

                isInit = true;
            }
        }

        public static bool StartRun()
        {
            LogUtil.info(BoxName + "开始启动：" + DateTime.Now.ToString() + "！");
            timersTimer.Enabled = true;
            IsRun = true;
            OpenStatusLights();

            ServerPort = ConfigAppSettings.GetIntValue(Setting_Init.ServerPort);
            string host = ConfigAppSettings.GetValue(Setting_Init.HttpServerAddr);
            if (ServerPort > 0)
            {
                PosId_SpiltChar = ';';
                PosId_Color_SpiltChar = '@';
                HttpServer.Start(ServerOnReceived, ServerPort);
                LogUtil.info("启动HttpServer接口服务完成，[ " + PosId_SpiltChar + "][" + PosId_Color_SpiltChar + "]，端口号【" + ServerPort + "】");
            }
            else if (!String.IsNullOrEmpty(host))
            {
                PosId_SpiltChar = '|';
                PosId_Color_SpiltChar = '=';
                serverConTimer.Start();
                LogUtil.info("启动与服务器连接定时器完成，[ " + PosId_SpiltChar + "][" + PosId_Color_SpiltChar + "]，地址 【" + host + "】");
            }
            else
            {
                LogUtil.info("未配置 ServerPort 或 HttpServerAddr");
            }
            return true;
        }

        public static void StopRun()
        {
            //关闭串口
            timersTimer.Enabled = false;
            foreach (LEDBaseModule led in LEDManager.deviceMap.Values)
            {
                led.AllLightOff();
            }
            //LEDManager.CloseStatusLights(new List<string>(StatusLedColorMap.Keys));
            CloseStatusLights();
            HttpServer.Stop();
            serverConTimer.Stop();
            IsRun = false;
            LogUtil.info(BoxName + "停止运行，时间" + DateTime.Now.ToShortTimeString() + "！");
        }
        private static  bool InProcess = false; 
        private static  Stopwatch stopwatch = new Stopwatch();
        protected static void timersTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (InProcess)
            {
                //TimeSpan span = DateTime.Now - preProcessTime;
                if (stopwatch.Elapsed.TotalMinutes < 1)
                {
                    return;
                }
                else
                {
                    LogUtil.error("主定时器：InProcess已等待" + stopwatch.Elapsed.ToString() + "重新处理"); 
                }
            }
            try
            {
                InProcess = true;
                //判断是否需要亮黄灯
                List<string> openLeds = new List<string>();

                List<string> shanShuoLed = new List<string>();
                foreach (string key in PosIdColorMap.Keys)
                {
                    string color = GetPosIdColor(key);
                    if (!String.IsNullOrEmpty(color))
                    {
                        openLeds.Add(key);

                        if (PositionMap.ContainsKey(key))
                        {
                            BoxPosition box = PositionMap[key];
                            if (box.GetStatusLedDmxId() >= 0)
                            {
                                string statusStr = box.DeviceIp + "_" + box.GetStatusLedDmxId();
                                if (!shanShuoLed.Contains(statusStr))
                                {
                                    shanShuoLed.Add(statusStr);
                                }
                            }
                        }
                        //break;
                    }
                }


                List<string> keys = new List<string>(StatusLedColorMap.Keys);

                foreach(string key in keys)
                {
                    if (shanShuoLed.Contains(key))
                    {
                        if (StatusLedColorMap[key].EndsWith("yellow"))
                        {
                            StatusLedColorMap[key] = "";
                        }
                        else
                        {

                            StatusLedColorMap[key] = "yellow";
                        }
                    }
                    else
                    {
                        StatusLedColorMap[key] = "green";
                    }
                }

                LEDManager.UpdateStatusLights(StatusLedColorMap);

            }
            catch (Exception ex)
            {
                LogUtil.error("timersTimer_Elapsed出错：" + ex.ToString());
            }
            InProcess = false ;
        }

        public static string StrMsg = "";


        public static bool ProcessOpenAll(string proMsg = "Revice ", string ip = "")
        {
            LogUtil.info(BoxName + proMsg + " closeAll命令：");
            List<string> posIdList = new List<string>(PositionMap.Keys);
            foreach (LEDBaseModule led in LEDManager.deviceMap.Values)
            {
                if (String.IsNullOrEmpty(ip) || led.ModuleIP.Equals(ip))
                {
                    led.AllLightOn();
                }
            }
            foreach (string key in posIdList)
            {
                string pIP = "";
                if (PositionMap.ContainsKey(key))
                {
                    pIP = PositionMap[key].DeviceIp;
                }
                if (String.IsNullOrEmpty(ip) || pIP.Equals(ip))
                {
                    UpdatePosIdColor(key, Light.defaultColor);
                }
            }
            return true;
        }
        public static bool ProcessCloseAll(string proMsg = "Revice ", string ip = "")
        {
            LogUtil.info(BoxName + proMsg + " closeAll命令：");
            List<string> posIdList = new List<string>(PositionMap.Keys);
            foreach (LEDBaseModule led in LEDManager.deviceMap.Values)
            {
                if (String.IsNullOrEmpty(ip) || led.ModuleIP.Equals(ip))
                {
                    led.AllLightOff();
                }
            }
            foreach (string key in posIdList)
            {
                string pIP = "";
                if (PositionMap.ContainsKey(key))
                {
                    pIP = PositionMap[key].DeviceIp;
                }
                if (String.IsNullOrEmpty(ip) || pIP.Equals(ip))
                {
                    UpdatePosIdColor(key);
                }
            }
            return true;
        }

        public static bool ProcessCloseByParam(string color, string shelf, string proMsg = "Revice ", string ip = "")
        {
            LogUtil.info(BoxName + proMsg + " ProcessCloseByColor 命令：" + color);
            List<string> posIdList = new List<string>(PositionMap.Keys);

            Dictionary<string, List<Light>> lightsMap = new Dictionary<string, List<Light>>();
            foreach (string key in posIdList)
            {
                string shelfStr = shelf + "_";
                if (String.IsNullOrEmpty(shelf) || key.StartsWith(shelfStr))
                {

                    string status = GetPosIdColor(key);
                    if (String.IsNullOrEmpty(status))
                    {
                        continue;
                    }
                    if (String.IsNullOrEmpty(color) || status.ToLower().Equals(color.ToLower()))
                    {
                        BoxPosition position = PositionMap[key];
                        Light[] lightArray = Light.GetLights(position.DmxId, position.GetLedList(), 0);
                        LEDManager.SaveLightToMap(lightsMap, position.DeviceIp, lightArray);
                        //     LEDManager.GetLedModule(position.DeviceIp).LightOff(Light.GetLights(position.DmxId, position.GetLedList(), 0));
                        UpdatePosIdColor(key);
                    }
                }
            }
            foreach (string dip in lightsMap.Keys)
            {
                List<Light> lights = lightsMap[dip];
                if (lights.Count > 0)
                {
                    LEDManager.GetLedModule(dip).LightOff(lights.ToArray());
                }
            }
            return true;
        }

        public static bool ProcessOpenLed(string posids, string proMsg = "Revice ")
        {
            LogUtil.info(BoxName + proMsg + " open命令：" + posids);
            string[] posArray = posids.Split(PosId_SpiltChar);

            Dictionary<string, List<Light>> lightsMap = new Dictionary<string, List<Light>>();
            foreach (string posStr in posArray)
            {
                if (String.IsNullOrEmpty(posStr))
                {
                    continue;
                }
                string posid = posStr;
                string color = Light.defaultColor;
                if (posStr.Contains(PosId_Color_SpiltChar))
                {
                    string[] posInfos = posStr.Split(PosId_Color_SpiltChar);
                    posid = posInfos[0];
                    color = posInfos[1];
                }
                color = color.ToLower();
                if (PositionMap.ContainsKey(posid))
                {
                    BoxPosition position = PositionMap[posid];
                    Light[] lightArray = Light.GetLights(position.DmxId, color, position.GetLedList().ToArray());
                    LEDManager.SaveLightToMap(lightsMap, position.DeviceIp, lightArray);

                    //    LEDManager.GetLedModule(position.DeviceIp).LightOn(lights);

                    UpdatePosIdColor(posid, color);
                }
                else
                {
                    if (posid.ToLower().Equals("statuslight"))
                    {
                        LogUtil.info("状态灯指令：" + posid + "=" + color);
                    }
                    else
                    {
                        LogUtil.error(BoxName + "打开灯失败，未找到库位号：" + posid);
                    }
                }
            }
            LEDManager.UpdateLightMap(lightsMap);
            //foreach (string dip in lightsMap.Keys)
            //{
            //    List<Light> lights = lightsMap[dip];
            //    if (lights.Count > 0)
            //    {
            //        LEDManager.GetLedModule(dip).LightOn(lights.ToArray());
            //    }
            //}
            return true;
        }


        public static bool ProcessCloseLed(string posids, string proMsg = "Revice ")
        {
            LogUtil.info(BoxName + proMsg + " close命令：" + posids);
            string[] posArray = posids.Split(PosId_SpiltChar);
            Dictionary<string, List<Light>> lightsMap = new Dictionary<string, List<Light>>();
            foreach (string posid in posArray)
            {
                string posName = posid;
                if (posid.Contains(PosId_Color_SpiltChar))
                {
                    posName = posid.Split(PosId_Color_SpiltChar)[0];
                }

                if (PositionMap.ContainsKey(posName))
                {
                    BoxPosition position = PositionMap[posName];
                    Light[] lightArray = Light.GetLights(position.DmxId, position.GetLedList());
                    LEDManager.SaveLightToMap(lightsMap, position.DeviceIp, lightArray);
                    //    LEDManager.GetLedModule(position.DeviceIp).LightOff(Light.GetLights(position.DmxId, position.GetLedList(), 0)); 
                    UpdatePosIdColor(posName);
                }
                else
                {
                    LogUtil.error(BoxName + "关闭灯败，未找到库位号：" + posName);
                }
            }
            LEDManager.UpdateLightMap(lightsMap);
            //foreach (string dip in lightsMap.Keys)
            //{
            //    List<Light> lights = lightsMap[dip];
            //    if (lights.Count > 0)
            //    {
            //        LEDManager.GetLedModule(dip).LightOff(lights.ToArray());
            //    }
            //}
            return true;
        }



        public static void  OpenStatusLights(string color="green")
        {
            List<string> keys = new List<string>(StatusLedColorMap.Keys);
            foreach(string key in keys)
            {
                StatusLedColorMap[key] = color;
            }
            LEDManager.UpdateStatusLights(StatusLedColorMap);
        }
        public static void CloseStatusLights()
        {
            List<string> keys = new List<string>(StatusLedColorMap.Keys);
            foreach (string key in keys)
            {
                StatusLedColorMap[key] = "";
            }
            LEDManager.UpdateStatusLights(StatusLedColorMap);
        }

    }
}