using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using log4net;
using log4net.Appender;
using log4net.Layout;
using log4net.Repository.Hierarchy;
using DIT.SharedMemory;

namespace SHARP_CLAS_UI
{
    public class Alarm_Manager:IDisposable
    {
        #region Define
        readonly string file_name = "Alarm_List.csv";
        #endregion

        #region Logger
        /// <summary>
        /// Alarm Log
        /// </summary>
        private ILog Alarm_Log = LogManager.GetLogger("Alarm");

        /// <summary>
        /// Alarm Log Write
        /// </summary>
        /// <param name="Methodname">Method name of exception that occurred</param>
        /// <param name="ex">exception</param>
        private void Write_Alarm_Log(string message)
        {
            if (Alarm_Log != null) Alarm_Log.Debug($"{message}");
        }

        /// <summary>
        /// Create excepton logger
        /// </summary>
        private void Create_Alarm_logger()
        {
            Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
            RollingFileAppender rollingAppender = new RollingFileAppender();

            PatternLayout layout = new PatternLayout();
            hierarchy.Configured = true;

            rollingAppender.Name = "Alarm_RoolingFile";
            rollingAppender.LockingModel = new RollingFileAppender.MinimalLock();
            rollingAppender.File = @"D:\Logger\Alarm\";
            rollingAppender.AppendToFile = true;
            rollingAppender.DatePattern = "yyyy\\\\MM\\\\'Alarm_'dd'.csv'";
            rollingAppender.RollingStyle = RollingFileAppender.RollingMode.Composite;
            rollingAppender.MaxSizeRollBackups = 10;
            rollingAppender.MaximumFileSize = "100MB";
            rollingAppender.StaticLogFileName = false;
            rollingAppender.Encoding = Encoding.UTF8;
            rollingAppender.PreserveLogFileNameExtension = true;
            layout = new PatternLayout("%d{yyyy/MM/dd HH:mm:ss.fff},%m%n");
            layout.ActivateOptions();
            rollingAppender.Layout = layout;
            rollingAppender.ActivateOptions();

            hierarchy.GetLogger("Alarm");
            ILog log = LogManager.GetLogger("Alarm");
            Logger l = (Logger)log.Logger;
            l.Level = log4net.Core.Level.Debug;
            l.AddAppender(rollingAppender);

            Alarm_Log = LogManager.GetLogger("Alarm");
        }
        #endregion

        #region Property
        private static readonly Lazy<Alarm_Manager> _instatnce = new Lazy<Alarm_Manager>(() => new Alarm_Manager());

        public static Alarm_Manager Instance
        {
            get
            {
                return _instatnce.Value;
            }
        }

        public List<Alarm_Occurred> Occured_List { get; private set; }
        #endregion

        #region Field
        bool IsDisposed;
        string file_path;

        public SortedList<En_Alarm_List, Alarm> Alarm_List;
        public En_Alarm_Status Alarm_Status;
        public Queue<Alarm_Occurred> Occured_Alarm = new Queue<Alarm_Occurred>();
        public SharedMemory sm;
        List<SharedmemoryAddressInfo> lst_alarm_memory = new List<SharedmemoryAddressInfo>();
        #endregion

        #region Construct
        public Alarm_Manager()
        {
            sm = new SharedMemory("SHARP_CLAS", 10000, true);
            sm.Open();
            Create_Alarm_logger();

            IsDisposed = false;
            Alarm_Status = En_Alarm_Status.NONE;

            Get_File_Path();

            Initialize_Alarm_List();

            Occured_List = new List<Alarm_Occurred>();
            Occured_List.Clear();
        }
        #endregion

        #region Function
        private void Get_File_Path()
        {
            RegistryKey rkk = Registry.CurrentUser.OpenSubKey(Equipment.Registry_Path, true);

            try
            {
                if (rkk == null)
                {
                    rkk = Registry.CurrentUser.CreateSubKey(Equipment.Registry_Path);

                    rkk.SetValue("ALARM_INFO_PATH", @"C:\SHARP_CLAS\Config\SETTING\");
                    file_path = @"C:\SHARP_CLAS\Config\SETTING\";
                }
                else
                {
                    object value = rkk.GetValue("ALARM_INFO_PATH");
                    if (value == null)
                    {
                        rkk.SetValue("ALARM_INFO_PATH", @"C:\SHARP_CLAS\Config\SETTING\");
                        file_path = @"C:\SHARP_CLAS\Config\SETTING\";
                    }
                    else
                    {
                        file_path = value.ToString();
                    }
                }

                if (!Directory.Exists(file_path))
                {
                    Directory.CreateDirectory(file_path);
                }
            }
            finally
            {
                rkk.Close();
            }
        }

        private void Initialize_Alarm_List()
        {
            Alarm_List = new SortedList<En_Alarm_List, Alarm>();
            Alarm_List.Clear();

            SortedList<En_Alarm_List, Alarm> alarm_datas = Get_Alarm_Info();

            foreach (En_Alarm_List list in Enum.GetValues(typeof(En_Alarm_List)))
            {
                if(alarm_datas.ContainsKey(list))
                {
                    Alarm_List.Add(list, alarm_datas[list]);
                }
                else
                {
                    Alarm_List.Add(list, new Alarm(list));
                }
            }

            Save_Alarm_List();
            lst_alarm_memory.AddRange(Alarm_Memory_Address.Get_Address_Infos());
        }

        private SortedList<En_Alarm_List, Alarm> Get_Alarm_Info()
        {
            string file = file_path + file_name;

            SortedList<En_Alarm_List, Alarm> alarm_list = new SortedList<En_Alarm_List, Alarm>();

            alarm_list.Clear();

            if (File.Exists(file))
            {
                foreach(string line in File.ReadAllLines(file))
                {
                    if (line == "") continue;

                    string[] items = line.Split(',');

                    if (items.Length < 4) continue;
                    En_Alarm_List list;
                    if (Enum.TryParse(items[0], out list))
                    {
                        if(!alarm_list.ContainsKey(list))
                        {
                            Alarm alarm = new Alarm(list);

                            alarm.Set_Heavy(items[1]);
                            alarm.Set_Discription(items[2]);
                            alarm.Set_Use(items[3]);

                            alarm_list.Add(list, alarm);
                        }
                    }
                }
            }
            else
            {
                File.Create(file);

                foreach (En_Alarm_List list in Enum.GetValues(typeof(En_Alarm_List)))
                {
                    Alarm alarm = new Alarm(list);
                    alarm_list.Add(list, alarm);
                }
            }

            return alarm_list;
        }
        
        public void Save_Alarm_List()
        {
            string file = file_path + file_name;
            if (Alarm_List == null) return;

            StringBuilder sb = new StringBuilder();

            string[] lines = new string[Alarm_List.Count];
            
            foreach(Alarm data in Alarm_List.Values)
            {
                sb.AppendLine($"{data.Code},{data.Heavy},{data.Description},{data.Use}");
            }
            
            File.WriteAllText(file, sb.ToString());
        }

        public bool Get_Alarm_Info(int Code, out Alarm info)
        {
            info = null;

            En_Alarm_List eCode = (En_Alarm_List)Code;
            
            if (Alarm_List.Count <= 0) return false;

            if (Code < 0 || Alarm_List.Count < Code)
                return false;

            if (Alarm_List[eCode].Code == eCode)
            {
                info = Alarm_List[eCode];
                return true;
            }
            else
            {
                foreach (Alarm ainfo in Alarm_List.Values)
                {
                    if (ainfo.Code == eCode)
                    {
                        info = ainfo;
                        return true;
                    }
                }
            }

            return false;
        }

        public SortedList<En_Alarm_List, Alarm> Clone()
        {
            SortedList<En_Alarm_List, Alarm> list = new SortedList<En_Alarm_List, Alarm>();

            foreach(Alarm alarm in Alarm_List.Values)
            {
                Alarm data = alarm.Clone();
                list.Add(data.Code, data);
            }

            return list;
        }

        public List<Alarm_Occurred> Clone_Occurred()
        {
            List<Alarm_Occurred> list = new List<Alarm_Occurred>();
            list.Clear();

            foreach (Alarm_Occurred alarm in Occured_List)
            {
                list.Add(alarm);
            }

            return list;
        }

        public void Occurred(En_Alarm_List list)
        {
            Alarm alarm = Alarm_List[list].Clone();

            if(alarm.Use)
            {
                if(!Occured_List.Exists(x => x.Code == alarm.Code))
                {
                    Write_Alarm_Log($"{alarm.Code.ToString()},{alarm.Description}");
                    if ((int)list < lst_alarm_memory.Count)
                    {
                        sm.Set_Bit(lst_alarm_memory[(int)list], true);
                    }
                    
                    Occured_Alarm.Enqueue(new Alarm_Occurred(alarm));
                    Occured_List.Add(new Alarm_Occurred(alarm));
                }

                if(Occured_List.Exists(x => x.Heavy))
                {
                    Alarm_Status = En_Alarm_Status.HEAVY;
                }
                else
                {
                    Alarm_Status = En_Alarm_Status.LIGHT;
                }
            }
        }

        public void Alarm_Clear()
        {
            foreach(SharedmemoryAddressInfo sa in lst_alarm_memory)
            {
                sm.Set_Bit(sa, false);
            }
            
            Occured_List.Clear();
            Alarm_Status = En_Alarm_Status.NONE;
        }

        public void Alarm_Clear(En_Alarm_List list)
        {
            if(Occured_List.Exists(x => x.Code == list))
            {
                foreach(Alarm_Occurred alarm in Occured_List)
                {
                    if (alarm.Code == list)
                    {
                        Occured_List.Remove(alarm);
                        return;
                    }
                }
            }
        }

        public void Dispose()
        {
            IsDisposed = true;
            sm.Close();
        }
        #endregion
    }
}