using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using LFP_Manager.DataStructure;

namespace LFP_Manager.Utils
{
    static class csUtils
    {
        public static readonly byte[] auchCRCHi = {
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
            0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
            0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,0x40
        };

        public static readonly byte[] auchCRCLo = {
            0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
            0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
            0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
            0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
            0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
            0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
            0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
            0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
            0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
            0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
            0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
            0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
            0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
            0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
            0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
            0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,0x40
        };

        #region CRC Calculation
        /// <summary>
        /// Modbus CRC-16 계산
        /// </summary>
        public static byte[] CalculateCRC(byte[] data, int length)
        {
            if (data == null || length <= 0 || length > data.Length)
                throw new ArgumentException("Invalid data or length");

            ushort crc = 0xFFFF;

            for (int i = 0; i < length; i++)
            {
                crc ^= data[i];
                for (int j = 0; j < 8; j++)
                {
                    if ((crc & 1) == 1)
                        crc = (ushort)((crc >> 1) ^ 0xA001);
                    else
                        crc >>= 1;
                }
            }

            return new byte[] { (byte)(crc & 0xFF), (byte)(crc >> 8) };
        }
        #endregion

        public static int GetModuleQty(CommConfig aConfig)
        {
            int mQty = 0;

            switch (aConfig.CommType)
            {
                case csConstData.CommType.COMM_UART:
                    mQty = 1;
                    break;
                case csConstData.CommType.COMM_RS485:
                    mQty = aConfig.ModuleQty;
                    break;
                case csConstData.CommType.COMM_SNMP:
                    mQty = 1;
                    break;
                default:
                    mQty = 0;
                    break;
            }
            return mQty;
        }

        public static void TypingOnlyNumber(object sender, KeyPressEventArgs e, bool includePoint, bool includeMinus)  
        {
            bool isValidInput = false;  
            if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar))  
            {  
                if (includePoint == true) { if (e.KeyChar == '.') isValidInput = true; }  
                if (includeMinus == true) { if (e.KeyChar == '-') isValidInput = true; }  
 
                if (isValidInput == false) e.Handled = true;  
            }

            if (includePoint == true)
            {
                if (e.KeyChar == '.' && (string.IsNullOrEmpty((sender as DevExpress.XtraEditors.TextEdit).Text.Trim()) || (sender as DevExpress.XtraEditors.TextEdit).Text.IndexOf('.') > -1)) e.Handled = true;
            }
            if (includeMinus == true)
            {
                if (e.KeyChar == '-' && (!string.IsNullOrEmpty((sender as DevExpress.XtraEditors.TextEdit).Text.Trim()) || (sender as DevExpress.XtraEditors.TextEdit).Text.IndexOf('-') > -1)) e.Handled = true;
            }  
        }

        public static bool[] Int16ToBitArray(Int16 data)
        {
            bool[] result = new bool[16];

            for (int i = 0; i < 16; i++)
            {
                result[i] = (((data >> i) & 0x0001) == 0x0001) ? true : false;
            }

            return result;
        }

        public static byte[] GetCRC(byte[] pby, UInt16 nSize)
        {
            byte[] result = new byte[2];
            UInt16 uIndex, i;
            UInt16 crc;
            byte uchCRCHi = 0xff;
            byte uchCRCLo = 0xff;

            for (i = 0; i < nSize; i++)
            {
                uIndex = (UInt16)(uchCRCHi ^ pby[i]);
                uchCRCHi = (byte)(uchCRCLo ^ csConstData.CRC_Data.auchCRCHi[uIndex]);
                uchCRCLo = csConstData.CRC_Data.auchCRCLo[uIndex];
            }
            crc = (UInt16)(((UInt16)uchCRCHi << 8) | uchCRCLo);

            result[1] = (byte)(crc / 256);
            result[0] = (byte)(crc % 256);

            return result;
        }

        public static byte StrByte2toByte(byte a, byte b)
        {
            byte result = 0;
            byte a1 = 0, b1 = 0;

            if ((a >= (byte)'0')&&(a <= (byte)'9'))
            {
                a1 = (byte)(a - (byte)'0');
            }
            else if ((a >= (byte)'a')&&(a <= (byte)'f'))
            {
                a1 = (byte)(a - (byte)'a');
            }
            else if ((a >= (byte)'A')&&(a <= (byte)'F'))
            {
                a1 = (byte)((a - (byte)'A') + 0x0A);
            }

            if ((b >= (byte)'0') && (b <= (byte)'9'))
            {
                b1 = (byte)(b - (byte)'0');
            }
            else if ((b >= (byte)'a') && (b <= (byte)'f'))
            {
                b1 = (byte)(b - (byte)'a');
            }
            else if ((b >= (byte)'A') && (b <= (byte)'F'))
            {
                b1 = (byte)((b - (byte)'A') + 0x0A);
            }

            result = (byte)((b1 << 4) | a1);

            return result;
        }

        public static byte[] StrToByteArray(byte[] rData, int offset, int rlen)
        {
            int len = (rlen - 2) / 2;
            byte[] result = new byte[len];

            for (int i = 0; i < len; i++)
            {
                result[i] = StrByte2toByte(rData[(i * 2) + offset + 2], rData[(i * 2) + offset + 1]);
            }

            return result;
        }

        public static byte[] StringToByte(string str)
        {
            byte[] StrByte = Encoding.UTF8.GetBytes(str); return StrByte;
        }

        #region OPERATING WARNING FUCTION

        public static bool BitCheck(short rData, int pos)
        {
            if (((rData >> pos) & 0x0001) == 0x0001)
                return true;
            else
                return false;
        }

        #endregion

        #region TIMESTAMP FUNCTION
        public static UInt32 CalcKKTimeStamp(DateTime tDate)
        {
            //Time of test and calibration. Local time in seconds since 2000.
            //Ex:
            //Epoch time offset (1 January 2000 00:00:00) = 946684800
            //Current epoch time (1 October 2019 12:00:00) = 1569931200
            //Timestamp = 1569931200 - 946684800 = 623246400
            //(Used 'https://www.epochconverter.com/' for conversion)
            DateTime baseDate = new DateTime(2000, 1, 1, 0, 0, 0);

            int bDate = ConvertToUnixTimestamp(baseDate);
            int nDate = ConvertToUnixTimestamp(tDate);

            return (UInt32)(nDate - bDate);
        }

        public static DateTime ConvertTimeStampToDateTime(UInt32 tStamp)
        {
            DateTime result = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);

            result = result.AddSeconds(tStamp);

            // DateTimeOffset.Now.ToUnixTimeSeconds()  // (.NET Framework 4.6 +/.NET Core), 
            // older versions: 
            //var epoch = (DateTime.UtcNow - new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

            return result;
        }

        public static int ConvertToUnixTimestamp(DateTime date)
        {
            DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0);
            TimeSpan diff = date - origin;
            return (int)Math.Floor(diff.TotalSeconds);
        }
        #endregion

        #region DateTime Format Methods
        /// <summary>
        /// DateTime을 기본 형식으로 변환합니다. (yyyy-MM-dd HH:mm:ss)
        /// </summary>
        public static string FormatDateTime(DateTime dateTime)
        {
            return dateTime.ToString("yyyy-MM-dd HH:mm:ss");
        }
        #endregion

        #region DATA INIT

        public static void DataInit(CommConfig aConfig, ref DeviceSystemData aSystemData)
        {
            aSystemData.ShelfCommFail = true;

            switch (aConfig.CommType)
            {
                case csConstData.CommType.COMM_UART:
                case csConstData.CommType.COMM_RS485:
                    switch (aConfig.UartModelIndex)
                    {
                        case csConstData.MODEL_INDEX.LFPM_48100D:
                        case csConstData.MODEL_INDEX.LFPM_48150D:
                        case csConstData.MODEL_INDEX.LFPM_48200D:
                        case csConstData.MODEL_INDEX.LFPM_48250D:
                        case csConstData.MODEL_INDEX.LFPM_48300D:
                            aSystemData.cellQty = 15;
                            aSystemData.tempQty = 4;
                            break;
                        case csConstData.MODEL_INDEX.LFPM_124050D:
                            aSystemData.cellQty = csConstData.SystemInfo.MAX_MODULE_CELL_SIZE;
                            aSystemData.tempQty = csConstData.SystemInfo.MAX_MODULE_TEMP_SIZE;
                            break;
                        default:
                            aSystemData.cellQty = 15;
                            aSystemData.tempQty = 4;
                            break;
                    }
                    break;
                case csConstData.CommType.COMM_SNMP:
                    switch (aConfig.SnmpModelIndex)
                    {
                        case csConstData.MODEL_INDEX.LFPM_48100D:
                        case csConstData.MODEL_INDEX.LFPM_48150D:
                        case csConstData.MODEL_INDEX.LFPM_48200D:
                        case csConstData.MODEL_INDEX.LFPM_48250D:
                        case csConstData.MODEL_INDEX.LFPM_48300D:
                            aSystemData.cellQty = 15;
                            aSystemData.tempQty = 4;
                            break;
                        case csConstData.MODEL_INDEX.LFPM_124050D:
                            aSystemData.cellQty = csConstData.SystemInfo.MAX_MODULE_CELL_SIZE;
                            aSystemData.tempQty = csConstData.SystemInfo.MAX_MODULE_TEMP_SIZE;
                            break;
                        default:
                            aSystemData.cellQty = 15;
                            aSystemData.tempQty = 4;
                            break;
                    }
                    break;
                default:
                    aSystemData.cellQty = 15;
                    aSystemData.tempQty = 4;
                    break;
            }

            for (int j = 0; j < aSystemData.ValueData.CellVoltage.Length; j++)
            {
                aSystemData.ValueData.CellVoltage[j] = 0;
            }
            for (int j = 0; j < aSystemData.ValueData.CellTemperature.Length; j++)
            {
                aSystemData.ValueData.CellTemperature[j] = 0;
            }
            aSystemData.ValueData.voltageOfPack = 0;
            aSystemData.ValueData.current = 0;
            aSystemData.ValueData.rSOC = 0;
            aSystemData.AvgData.maxCellVoltage = 0;
            aSystemData.AvgData.minCellVoltage = 0;
            aSystemData.AvgData.avgCellVoltage = 0;
            aSystemData.AvgData.maxTemp = 0;
            aSystemData.AvgData.minTemp = 0;
            aSystemData.AvgData.avgTemp = 0;
            aSystemData.heatbeat = 0;
            aSystemData.StatusData.warning = 0;
            aSystemData.StatusData.protection = 0;

            for (int j = 0; j < aSystemData.Information.BMS_SN.Length; j++)
            {
                aSystemData.Information.BMS_SN[j] = 0;
            }
            for (int j = 0; j < aSystemData.Information.Module_SN.Length; j++)
            {
                aSystemData.Information.Module_SN[j] = 0;
            }

            aSystemData.CalibrationData.Battery.Capacity = 0;
            aSystemData.CalibrationData.Current.ChaAndDchSelect = 0;
            aSystemData.CalibrationData.Current.ChgCalibration_K = 0;
            aSystemData.CalibrationData.Current.DchCalibration_K = 0;
        }

        #endregion

        #region MAKE AVERAGE VALUE
        public static void MakeMaxAvgMinCellVoltage(ref DeviceSystemData rSystemData, int cellQty)
        {
            int Max, Avg, Min, Sum;
            int MaxNo, MinNo;

            Max = Avg = Min = Sum = 0;
            MaxNo = MinNo = 0;
            for (int i = 0; i < cellQty; i++)
            {
                if (i == 0)
                {
                    Max = Min = rSystemData.ValueData.CellVoltage[i];
                }
                Sum += rSystemData.ValueData.CellVoltage[i];

                if (Max < rSystemData.ValueData.CellVoltage[i])
                {
                    Max = rSystemData.ValueData.CellVoltage[i];
                    MaxNo = i;
                }
                if (Min > rSystemData.ValueData.CellVoltage[i])
                {
                    Min = rSystemData.ValueData.CellVoltage[i];
                    MinNo = i;
                }
            }
            Avg = Sum / cellQty;

            rSystemData.AvgData.avgCellVoltage = (short)Avg;
            rSystemData.AvgData.maxCellVoltage = (short)Max;
            rSystemData.AvgData.maxCellNum = (short)(MaxNo + 1);
            rSystemData.AvgData.minCellVoltage = (short)Min;
            rSystemData.AvgData.minCellNum = (short)(MinNo + 1);
            rSystemData.AvgData.diffCellVoltage = (short)(Max - Min);
        }

        public static void MakeMaxAvgMinTemperature(ref DeviceSystemData rSystemData, int tempQty)
        {
            int Max, Avg, Min, Sum;
            int MaxNo, MinNo;

            Max = Avg = Min = Sum = 0;
            MaxNo = MinNo = 0;

            for (int i = 0; i < tempQty; i++)
            {
                if (i == 0)
                {
                    Max = Min = rSystemData.ValueData.CellTemperature[i];
                }
                Sum += rSystemData.ValueData.CellTemperature[i];

                if (Max < rSystemData.ValueData.CellTemperature[i])
                {
                    Max = rSystemData.ValueData.CellTemperature[i];
                    MaxNo = i;
                }
                if (Min > rSystemData.ValueData.CellTemperature[i])
                {
                    Min = rSystemData.ValueData.CellTemperature[i];
                    MinNo = i;
                }
            }
            Avg = Sum / tempQty;

            rSystemData.AvgData.avgTemp = (short)Avg;
            rSystemData.AvgData.maxTemp = (short)Max;
            rSystemData.AvgData.maxTempNum = (short)(MaxNo + 1);
            rSystemData.AvgData.minTemp = (short)Min;
            rSystemData.AvgData.minTempNum = (short)(MinNo + 1);
            rSystemData.AvgData.diffTemp = (short)(Max - Min);
        }

        #endregion
    }
}