using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Data.SqlServerCe;
using System.Runtime.InteropServices;

using BMS_D1000H.BMSConstData;
using BMS_D1000H.DataStructs;
using BMS_D1000H.Utils.Functions;

namespace BMS_D1000H.Utils.Functions
{
    public class AlarmFile
    {
        public string BMS_PASSWORD;
        TAlarmList AlarmList;
        DeviceDataSystem bMainData;
        DeviceDataTray[] bTrayData;

        static readonly string AlarmFilePath = PathHelper.GetFullPath("alarmlist.sdf");
        static readonly string AlarmHistPath = PathHelper.GetFullPath("AlarmHistory.db");
        static readonly string AlarmHistCsvPath = PathHelper.GetFullPath(@"Alarm\");

        static readonly string PasswordFilePath = PathHelper.GetFullPath("password.db");
        static readonly string LoggingFilePath = PathHelper.GetFullPath(@"Log\");
        //static readonly string SdCardPath = @"SD Card\";
        //static readonly string SdLoggingFilePath = @"SD Card\Run\Log\";

        //public static void SystemDataLog(int RackID, CommConfig sConfig, DeviceSystemData sData, DateTime aTime, string AppPath)
        //{
        //    SYSTEMLOG_FILE_DIR = String.Format("{0}\\SHELF{1}\\{2}", "\\log\\systemlog", RackID, String.Format("{0:yyyyMM}", aTime));

        //    FileStream logFile = null;
        //    string path = System.IO.Path.GetDirectoryName(AppPath);
        //    string FileName = String.Format(path + SYSTEMLOG_FILE_DIR + "\\SHELF{0}_LOG_{1}.csv", RackID, String.Format("{0:yyMMdd}", aTime));
        //    byte[] logData;

        //    if (Directory.Exists(path + SYSTEMLOG_FILE_DIR) == false)
        //        Directory.CreateDirectory(path + SYSTEMLOG_FILE_DIR);

        //    if (File.Exists(FileName) == false)
        //    {
        //        logFile = new FileStream(FileName, FileMode.CreateNew, FileAccess.ReadWrite);
        //        logData = WriteDataHeader(aTime);
        //        logFile.Write(logData, 0, logData.Length);
        //        logFile.Close();
        //    }

        //    logFile = null;
        //    //logFile = new FileStream(FileName, FileMode.Open, FileAccess.ReadWrite);
        //    logFile = new FileStream(FileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);

        //    if (logFile != null)
        //    {
        //        logFile.Seek(0, SeekOrigin.End);
        //        logData = WriteData(aTime, sConfig, sData);
        //        logFile.Write(logData, 0, logData.Length);
        //        logFile.Close();
        //    }
        //}

        public AlarmFile()
        {
            bTrayData = new DeviceDataTray[SystemID.MAX_MODULE_SIZE];

            AlarmList = new TAlarmList();
            AlarmList.aData = new TAlarm[1000];

            AlarmList.front = 0;
            AlarmList.rear = 0;
            AlarmList.count = 0;

            LoadAlarmData();
            LoadPasswordData();
        }

        #region WriteDataHeader

        private byte[] WriteDataHeader(DeviceDataSystem sData)
        {
            StringBuilder sb = new StringBuilder();

            sb.Append("DATETIME,OPERATING,ALARM,SYSTEM VOLTAGE,SYSTEM CURRENT,SYSTEM SOC,TRIP,WARNING,");

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("VOLTAGE_{0:00},", i + 1);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("CURRENT_{0:00},", i + 1);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("SOC_{0:00},", i + 1);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("MAX_TEMP_{0:00},", i + 1);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("MIN_TEMP_{0:00},", i + 1);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("MAX_CVOLT_{0:00},", i + 1);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("MIN_CVOLT_{0:00},", i + 1);
            }
            sb.Append("\r\n");

            return new UTF8Encoding(true).GetBytes(sb.ToString());
        }

        #endregion

        #region WriteData

        private byte[] WriteData(DeviceDataSystem sData, DeviceDataTray[] tData)
        {
            StringBuilder sb = new StringBuilder();
            DateTime aLog = DateTime.Now;

            sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss},{1},{2},{3:#0.0},{4:#0.0},{5:#0.0},"
                , aLog
                , StatusStr.operating[sData.OpStatus]
                , StatusStr.alarm[sData.AlarmStatus]
                , Convert.ToDouble(sData.BatVoltage) / 100
                , Convert.ToDouble(sData.Current) / 10
                , Convert.ToDouble(sData.RelativeStateOfCharge) / 10
                );

            sb.AppendFormat("0x{0:X4},", sData.Protection);
            sb.AppendFormat("0x{0:X4},", sData.Warning);

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].BatVoltage) / 100);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].Current) / 10);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0},", Convert.ToDouble(tData[i].RelativeStateOfCharge) / 10);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].MaxTemp) / 10);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0.0},", Convert.ToDouble(tData[i].MinTemp) / 10);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0.000},", Convert.ToDouble(tData[i].MaxCellVoltage) / 1000);
            }

            for (int i = 0; i < sData.ModuleQuantity; i++)
            {
                sb.AppendFormat("{0:#0.000},", Convert.ToDouble(tData[i].MinCellVoltage) / 1000);
            }
            sb.Append("\r\n");

            return new UTF8Encoding(true).GetBytes(sb.ToString());
        }
        #endregion

        public void LoggingData(DeviceDataSystem sData, DeviceDataTray[] tData)
        {
            DateTime aLog = DateTime.Now;
            string filename = String.Format("{0}log{1}.csv", LoggingFilePath, aLog.ToString("yyyyMMdd"));
            string path = System.IO.Path.GetDirectoryName(filename);

            try
            {
                if (Directory.Exists(path) == false)
                    Directory.CreateDirectory(path);

                bool fileExists = File.Exists(filename);
                FileMode mode = fileExists ? FileMode.Open : FileMode.CreateNew;

                using (FileStream fStream = new FileStream(filename, mode, FileAccess.ReadWrite))
                {
                    fStream.Seek(0, SeekOrigin.End);
                    if (!fileExists)
                    {
                        byte[] logHeader = WriteDataHeader(sData);
                        fStream.Write(logHeader, 0, logHeader.Length);
                    }
                    byte[] logData = WriteData(sData, tData);
                    fStream.Write(logData, 0, logData.Length);
                }
            }
            catch (Exception)
            {
            }
        }

        public void InitPasswordData()
        {
            string filepath = PasswordFilePath;
            using (FileStream fStream = new FileStream(filepath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
            {
                BMS_PASSWORD = "0000";
                byte[] bData = Encoding.ASCII.GetBytes(BMS_PASSWORD);

                fStream.Seek(0, SeekOrigin.Begin);
                fStream.Write(bData, 0, bData.Length);
            }
        }

        public void SaveNewPasswordData(string new_password)
        {
            string filepath = PasswordFilePath;
            using (FileStream fStream = new FileStream(filepath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
            {
                BMS_PASSWORD = new_password;
                byte[] bData = Encoding.ASCII.GetBytes(BMS_PASSWORD);

                fStream.Seek(0, SeekOrigin.Begin);
                fStream.Write(bData, 0, bData.Length);
            }
        }

        private void LoadPasswordData()
        {
            string filepath = PasswordFilePath;

            if (File.Exists(filepath))
            {
                using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.Read))
                {
                    long fsize = fStream.Length;
                    byte[] bData = new byte[fsize];

                    fStream.Seek(0, SeekOrigin.Begin);
                    fStream.Read(bData, 0, Convert.ToInt32(fsize));

                    BMS_PASSWORD = Encoding.ASCII.GetString(bData, 0, Convert.ToInt32(fsize));
                }
            }
            else
            {
                using (FileStream fStream = new FileStream(filepath, FileMode.CreateNew, FileAccess.ReadWrite))
                {
                    BMS_PASSWORD = "0000";
                    byte[] bData = Encoding.ASCII.GetBytes(BMS_PASSWORD);

                    fStream.Seek(0, SeekOrigin.Begin);
                    fStream.Write(bData, 0, bData.Length);
                }
            }
        }

        private void LoadAlarmData()
        {
            string filepath = AlarmHistPath;
            byte[] bData = new byte[Marshal.SizeOf(AlarmList)];

            if (File.Exists(AlarmHistPath))
            {
                using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite))
                {
                    long fsize = fStream.Length;

                    if (Marshal.SizeOf(AlarmList) != fsize)
                    {
                        fStream.Close();
                        File.Delete(filepath);

                        using (FileStream newStream = new FileStream(filepath, FileMode.CreateNew, FileAccess.ReadWrite))
                        {
                            newStream.SetLength(Marshal.SizeOf(AlarmList));
                            newStream.Seek(0, SeekOrigin.Begin);
                            newStream.Write(bData, 0, Marshal.SizeOf(AlarmList));

                            newStream.Seek(0, SeekOrigin.Begin);
                            newStream.Read(bData, 0, Marshal.SizeOf(AlarmList));
                            AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
                        }
                    }
                    else
                    {
                        fStream.Read(bData, 0, Marshal.SizeOf(AlarmList));
                        AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
                    }
                }
            }
            else
            {
                using (FileStream fStream = new FileStream(filepath, FileMode.CreateNew, FileAccess.ReadWrite))
                {
                    fStream.SetLength(Marshal.SizeOf(AlarmList));
                    fStream.Seek(0, SeekOrigin.Begin);
                    fStream.Write(bData, 0, Marshal.SizeOf(AlarmList));

                    fStream.Seek(0, SeekOrigin.Begin);
                    fStream.Read(bData, 0, Marshal.SizeOf(AlarmList));
                    AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
                }
            }
            Make_Run_History(EventID.EVENT_INFO, AlarmID.POWER_ON_RESET, 0, 0, 0);
        }

        private void SaveAlarmData()
        {
            long fsize = Marshal.SizeOf(AlarmList);
            string filepath = AlarmHistPath;
            byte[] bData = ConvertTo.StructureToByte(AlarmList);

            using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite))
            {
                fStream.Seek(0, SeekOrigin.Begin);
                fStream.Write(bData, 0, Convert.ToInt32(fsize));
            }
        }

        public void DeleteAlarmData()
        {
            long fsize = Marshal.SizeOf(AlarmList);
            string filepath = AlarmHistPath;
            byte[] bData = new byte[fsize];

            System.Array.Clear(bData, 0, Convert.ToInt32(fsize)); 

            using (FileStream fStream = new FileStream(filepath, FileMode.Open, FileAccess.ReadWrite))
            {
                fStream.Seek(0, SeekOrigin.Begin);
                fStream.Write(bData, 0, Convert.ToInt32(fsize));

                AlarmList = ConvertTo.ByteToStruct<TAlarmList>(bData);
            }

            Make_Run_History(EventID.EVENT_INFO, AlarmID.HIST_DELETE, 0, 0, 0);     // History Delete
        }

        public long GetFileSize(string FilePath)
        {
            long fsize = 0;

            if (File.Exists(FilePath))
            {
                using (FileStream fStream = new FileStream(FilePath, FileMode.Open, FileAccess.ReadWrite))
                {
                    fsize = fStream.Length;
                }
            }
            else
            {
                using (FileStream fStream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                {
                    fsize = fStream.Length;
                }
            }

            return fsize;
        }

        public void CreateDatabase()
        {
            if (File.Exists(AlarmFilePath))
                File.Delete(AlarmFilePath);

            string connstr = @String.Format("Data Source = '{0}'; LCID=1033; Password='1111'; Encrypt = TRUE;", AlarmFilePath);

            SqlCeEngine engine = new SqlCeEngine(connstr);
            engine.CreateDatabase();
            engine.Dispose();

            SqlCeConnection conn = null;


            try
            {
                conn = new SqlCeConnection(connstr);
                conn.Open();

                SqlCeCommand cmd = conn.CreateCommand();
                cmd.CommandText = "CREATE TABLE AlarmList(col1 int, con2 ntext)";
                cmd.ExecuteNonQuery();
            }
            catch
            {
            }
            finally
            {
                conn.Close();
            }
        }

        public bool TableExists(SqlCeConnection connection, string tableName)
        {
            using (var command = new SqlCeCommand())
            {
                command.Connection = connection;
                var sql = String.Format("SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{0}'", tableName);
                command.CommandText = sql;
                var count = Convert.ToInt32(command.ExecuteScalar());

                return (count > 0);
            }
        }

        public int GetAlarmCount()
        {
            return AlarmList.count;
        }

        public TAlarmList GetAlarmList()
        {
            return AlarmList;
        }

        public void Save_History(TAlarm hdata)
        {
            int nFront = AlarmList.front;
            int nRear = AlarmList.rear;
            int nCount = AlarmList.count;

            Save_HistoryCsv(hdata);             // History Save - CSV type

            AlarmList.aData[nFront] = hdata;

            nCount++;

            nFront++;
            nFront %= AlarmID.MAX_ALARM_COUNT;

            if (nFront == nRear)
            {
                nRear++;
                nRear %= AlarmID.MAX_ALARM_COUNT;

                nCount = AlarmID.MAX_ALARM_COUNT;
            }
            if (nCount > AlarmID.MAX_ALARM_COUNT)
                nCount = AlarmID.MAX_ALARM_COUNT;

            AlarmList.front = nFront;
            AlarmList.rear = nRear;
            AlarmList.count = nCount;

            SaveAlarmData();
        }

        public byte[] MakeHistoryCsvHeader()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("DateTime,Event,Alarm Name,Position,Parameter,\r\n");
            return new UTF8Encoding(true).GetBytes(sb.ToString());
        }

        public void Save_HistoryCsv(TAlarm hdata)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss},", hdata.aTime);
            sb.AppendFormat("{0},", EventID.event_name[hdata.aFlag]);
            sb.AppendFormat("{0},", AlarmID.name[hdata.aNameNo]);

            switch (hdata.aNameNo)
            {
                case AlarmID.COV_PROTECTION:
                case AlarmID.COV_WARNING:
                case AlarmID.CUV_PROTECTION:
                case AlarmID.CUV_WARNING:
                    sb.AppendFormat("'{0}-{1},", PosID.pos[hdata.aPos], hdata.ctno);
                    sb.AppendFormat("{0:#0.000},", Convert.ToDouble(hdata.aParam) / 1000);
                    break;
                case AlarmID.OTC_PROTECTION:
                case AlarmID.OTC_WARNING:
                case AlarmID.OTD_PROTECTION:
                case AlarmID.OTD_WARNING:
                    sb.AppendFormat("'{0}-{1},", PosID.pos[hdata.aPos], hdata.ctno);
                    sb.AppendFormat("{0:#0.0},", Convert.ToDouble(hdata.aParam) / 10);
                    break;
                case AlarmID.SOV_PROTECTION:
                case AlarmID.SOV_WARNING:
                case AlarmID.SUV_PROTECTION:
                case AlarmID.SUV_WARNING:
                    sb.AppendFormat("'{0},", PosID.pos[hdata.aPos]);
                    sb.AppendFormat("{0:#0.0},", Convert.ToDouble(hdata.aParam) / 100);
                    break;
                case AlarmID.OCC_PROTECTION:
                case AlarmID.OCC_WARNING:
                case AlarmID.OCD_PROTECTION:
                case AlarmID.OCD_WARNING:
                    sb.AppendFormat("'{0},", PosID.pos[hdata.aPos]);
                    sb.AppendFormat("{0:#0.0},", Convert.ToDouble(hdata.aParam) / 10);
                    break;
                default:
                    sb.AppendFormat("'{0},", PosID.pos[hdata.aPos]);
                    sb.Append(",");
                    break;
            }
            sb.Append("\r\n");

            byte[] bAlm = new UTF8Encoding(true).GetBytes(sb.ToString());

            string filename = String.Format("{0}Alm_{1}.csv", AlarmHistCsvPath, DateTime.Now.ToString("yyyyMMdd"));
            string path = System.IO.Path.GetDirectoryName(filename);

            try
            {
                if (Directory.Exists(path) == false)
                    Directory.CreateDirectory(path);

                bool fileExists = File.Exists(filename);
                FileMode mode = fileExists ? FileMode.Open : FileMode.CreateNew;

                using (FileStream fStream = new FileStream(filename, mode, FileAccess.ReadWrite))
                {
                    fStream.Seek(0, SeekOrigin.End);
                    if (!fileExists)
                    {
                        byte[] hdr = MakeHistoryCsvHeader();
                        fStream.Write(hdr, 0, hdr.Length);
                    }
                    fStream.Write(bAlm, 0, bAlm.Length);
                }
            }
            catch (Exception)
            {
            }
        }

        public void Make_Run_History(int status       // Alarm Status  (0 = Normal, 1 = Alarm) 
                                    , int name_id      // Alarm Name
                                    , int pos          // Tray Number
                                    , int cno          // Temp Number or Cell Number 
                                    , int param         // Alarm Value 
                                     )
        {
            TAlarm his;

            his.aFlag = Convert.ToByte(status);
            his.aTime = DateTime.Now;
            his.aNameNo = Convert.ToByte(name_id);
            his.aPos = Convert.ToByte(pos);
            his.ctno = Convert.ToByte(cno);
            his.aParam = param;

            Save_History(his);
        }

        #region Check Main Alarm History
        public void CheckAlarmHistory(DeviceDataSystem nSys)
        {
            // BMCU Communication Fail Alarm
            if (bMainData.MainCommState != nSys.MainCommState)
            {
                if (nSys.MainCommState != 0)
                    // Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMS_COMM_FAIL, 0, 0, 0);
                else
                    // Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMS_COMM_FAIL, 0, 0, 0);
             
                bMainData.MainCommState = nSys.MainCommState;
            }

            //if (ConvertTo.GetBit(bMainData.TrayCommState, 0) != ConvertTo.GetBit(nSys.TrayCommState, 0))
            //{
            //    if (ConvertTo.GetBit(nSys.TrayCommState, 0))
            //        // Alarm
            //        Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, 1, 0, 0);
            //    else
            //        // Recovery
            //        Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, 1, 0, 0);

            //}
            //if (ConvertTo.GetBit(bMainData.TrayCommState, 1) != ConvertTo.GetBit(nSys.TrayCommState, 1))
            //{
            //    if (ConvertTo.GetBit(nSys.TrayCommState, 1))
            //        // Alarm
            //        Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, 2, 0, 0);
            //    else
            //        // Recovery
            //        Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, 2, 0, 0);

            //}
            //if (ConvertTo.GetBit(bMainData.TrayCommState, 2) != ConvertTo.GetBit(nSys.TrayCommState, 2))
            //{
            //    if (ConvertTo.GetBit(nSys.TrayCommState, 2))
            //        // Alarm
            //        Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, 3, 0, 0);
            //    else
            //        // Recovery
            //        Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, 3, 0, 0);

            //}
            bMainData.TrayCommState = nSys.TrayCommState;

            CheckStatusHistory(nSys);
        }
        #endregion

        #region Check Status History
        public void CheckStatusHistory(DeviceDataSystem nSys)
        {
            if (bMainData.OpStatus != nSys.OpStatus)
            {
                switch (nSys.OpStatus)
                {
                    case 0: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_STAND_BY, 0, 0, 0); break;    // Status Stand by
                    case 1: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_CHARGING, 0, 0, 0); break;    // Status Charging
                    case 2: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_DISCHARGING, 0, 0, 0); break; // Status Stand by
                    case 3: Make_Run_History(EventID.EVENT_INFO, AlarmID.STS_FLOATING, 0, 0, 0); break;    // Status Stand by
                }
                bMainData.OpStatus = nSys.OpStatus;
            }
        }
        #endregion

        public void CheckAlarmHistory(DeviceDataTray nTray, int tno)
        {
            CheckAlarmWarningHistory(nTray, tno);
            CheckAlarmProtectionHistory(nTray, tno);
        }

        #region Check Alarm Warning History
        public void CheckAlarmWarningHistory(DeviceDataTray nTray, int tno)
        {
            int bit_no;

            // Module Commfail Alarm
            if (ConvertTo.GetBit(bTrayData[tno].Commfail, 0) != ConvertTo.GetBit(nTray.Commfail, 0))
            {
                if (ConvertTo.GetBit(nTray.Commfail, 0))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.BMU_COMM_FAIL, tno + 1, 0, 0);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.BMU_COMM_FAIL, tno + 1, 0, 0);

                bTrayData[tno].Commfail = nTray.Commfail;
            }

            // System Over Voltage Warning Check
            if (ConvertTo.GetBit(bTrayData[tno].Warning, 0) != ConvertTo.GetBit(nTray.Warning, 0))
            {
                if (ConvertTo.GetBit(nTray.Warning, 0))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.SOV_WARNING, tno + 1, 0, nTray.BatVoltage);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SOV_WARNING, tno + 1, 0, nTray.BatVoltage);
            }
            // Cell Over Voltage Warning Check
            if (ConvertTo.GetBit(bTrayData[tno].Warning, 1) != ConvertTo.GetBit(nTray.Warning, 1))
            {
                if (ConvertTo.GetBit(nTray.Warning, 1))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
            }
            // System Under Voltage Warning Check
            bit_no = 2;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
            }
            // Cell Under Voltage Warning Check
            bit_no = 3;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
            }
            // Charge Over Current Warning Check
            bit_no = 4;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
            }
            // Discharge Over Current Warning Check
            bit_no = 5;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.OCD_WARNING, tno + 1, 0, nTray.Current);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCD_WARNING, tno + 1, 0, nTray.Current);
            }
            // Charge Over Temperature Warning Check
            bit_no = 8;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
            }
            // Discharge Over Temperature Warning Check
            bit_no = 9;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
            }
            // Charge Low Temperature Warning Check
            bit_no = 10;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
            }
            // Discharge Low Temperature Warning Check
            bit_no = 11;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
            }
            // SOC Low Warning Check
            bit_no = 12;
            if (ConvertTo.GetBit(bTrayData[tno].Warning, bit_no) != ConvertTo.GetBit(nTray.Warning, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Warning, bit_no))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_WARNING, AlarmID.SOC_WARNING, tno + 1, 0, nTray.RelativeStateOfCharge);
                else
                    // Warning Recovery
                    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SOC_WARNING, tno + 1, 0, nTray.RelativeStateOfCharge);
            }
            bTrayData[tno].Warning = nTray.Warning;
        }
        #endregion

        #region Check Alarm Protection History
        public void CheckAlarmProtectionHistory(DeviceDataTray nTray, int tno)
        {
            int bit_no;

            // System Over Voltage Protection Check
            if (ConvertTo.GetBit(bTrayData[tno].Protection, 0) != ConvertTo.GetBit(nTray.Protection, 0))
            {
                if (ConvertTo.GetBit(nTray.Protection, 0))
                    // Warning Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.SOV_PROTECTION, tno + 1, 0, nTray.BatVoltage);
                //else
                //    // Warning Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SOV_PROTECTION, tno + 1, 0, nTray.BatVoltage);
            }
            // Cell Over Voltage Warning Check
            if (ConvertTo.GetBit(bTrayData[tno].Protection, 1) != ConvertTo.GetBit(nTray.Protection, 1))
            {
                if (ConvertTo.GetBit(nTray.Protection, 1))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.COV_WARNING, tno + 1, nTray.MaxCellNo, nTray.MaxCellVoltage);
            }
            // System Under Voltage Protection Check
            bit_no = 2;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.SUV_WARNING, tno + 1, 0, nTray.BatVoltage);
            }
            // Cell Under Voltage Protection Check
            bit_no = 3;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.CUV_WARNING, tno + 1, nTray.MinCellNo, nTray.MinCellVoltage);
            }
            // Charge Over Current Protection Check
            bit_no = 4;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCC_WARNING, tno + 1, 0, nTray.Current);
            }
            // Discharge Over Current Protection Check
            bit_no = 5;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OCD_WARNING, tno + 1, 0, nTray.Current);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OCD_WARNING, tno + 1, 0, bTrayData[tno].Current);
            }
            // Charge Over Temperature Protection Check
            bit_no = 8;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTC_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
            }
            // Discharge Over Temperature Protection Check
            bit_no = 9;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.OTD_WARNING, tno + 1, nTray.MaxTempNo, nTray.MaxTemp);
            }
            // Charge Low Temperature Protection Check
            bit_no = 10;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTC_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
            }
            // Discharge Low Temperature Protection Check
            bit_no = 11;
            if (ConvertTo.GetBit(bTrayData[tno].Protection, bit_no) != ConvertTo.GetBit(nTray.Protection, bit_no))
            {
                if (ConvertTo.GetBit(nTray.Protection, bit_no))
                    // Protection Alarm
                    Make_Run_History(EventID.EVENT_PROTECTION, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
                //else
                //    // Protection Recovery
                //    Make_Run_History(EventID.EVENT_RECOVERY, AlarmID.LTD_WARNING, tno + 1, nTray.MinTempNo, nTray.MinTemp);
            }
            bTrayData[tno].Protection = nTray.Protection;
        }
        #endregion
    }
}