using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OrpaonEMS.App.CANDrive
{
    /// <summary>
    /// 液冷AC数据解析
    /// CAN 解析解析数据
    /// 协议数据执行Motorola LSB格式；数据类型= Unsigned；
    ///协议内基于CAN2.0B的扩展帧。
    ///CAN 2.0B的29bit扩展ID帧标识符进行的分段定义
    /// </summary>
    public class ACCANParsData
    {
        public static Msg_0x18008040 msg_0X18008040 { get; set; } = new Msg_0x18008040();
        public static Msg_0x18018040 msg_0X18018040 { get; set; } = new Msg_0x18018040();

        /// <summary>
        /// 获取0x18008040
        /// </summary>
        /// <returns></returns>
        public static void Load_0x18008040_Msg(CAN_FRAME_INFO srData)
        {
            msg_0X18008040.WorkState = (int)GetMotorolaSignalValue(srData.data, 0, 8, 1, 0);

            msg_0X18008040.OutTemp = GetMotorolaSignalValue(srData.data, 8, 8, 1, -40);
            msg_0X18008040.InTemp = GetMotorolaSignalValue(srData.data, 16, 8, 1, -40);
            msg_0X18008040.SysEnvTemp = GetMotorolaSignalValue(srData.data, 24, 8, 1, -40);

            msg_0X18008040.InPress = GetMotorolaSignalValue(srData.data, 32, 8, 0.1, 0);
            msg_0X18008040.OutPress = GetMotorolaSignalValue(srData.data, 40, 8, 0.1, 0);

            msg_0X18008040.InverterErrCode = (int)GetMotorolaSignalValue(srData.data, 48, 8, 1, 0);
            msg_0X18008040.ErrCode = (int)GetMotorolaSignalValue(srData.data, 56, 6, 1, 0);
            msg_0X18008040.ErrLevel = (int)GetMotorolaSignalValue(srData.data, 62, 2, 1, 0);
        }

        /// <summary>
        /// 获取0x18018040
        /// </summary>
        /// <returns></returns>
        public static void Load_0x18018040_Msg(CAN_FRAME_INFO srData)
        {
            msg_0X18018040.CompressorState = (int)GetMotorolaSignalValue(srData.data, 0, 1, 1, 0);
            msg_0X18018040.CompressorHeatStripState = (int)GetMotorolaSignalValue(srData.data, 1, 1, 1, 0);
            msg_0X18018040.EleHeatState = (int)GetMotorolaSignalValue(srData.data, 2, 1, 1, 0);
            msg_0X18018040.WaterPumpState = (int)GetMotorolaSignalValue(srData.data, 3, 1, 1, 0);
            msg_0X18018040.FanState1 = (int)GetMotorolaSignalValue(srData.data, 4, 1, 1, 0);
            msg_0X18018040.FanState2 = (int)GetMotorolaSignalValue(srData.data, 5, 1, 1, 0);
            msg_0X18018040.FanState3 = (int)GetMotorolaSignalValue(srData.data, 6, 1, 1, 0);

            msg_0X18018040.CompressorSpeed = GetMotorolaSignalValue(srData.data, 8, 8, 100, 0);
            msg_0X18018040.PumpSpeed = GetMotorolaSignalValue(srData.data, 16, 8, 100, 0);

        }

        ///// <summary>
        ///// 获取交流 电流 电压 测量 值
        ///// </summary>
        ///// <returns></returns>
        //public static void Load_AC_Sense_Msg(AC_Sense_Msg aC_Sense_Msg, VCI_CAN_OBJ srData)
        //{
        //    aC_Sense_Msg.A_Vol = GetIntelSignalValue(srData.Data, 0, 10, 1, -512);
        //    aC_Sense_Msg.B_Vol = GetIntelSignalValue(srData.Data, 10, 10, 1, -512);
        //    aC_Sense_Msg.C_Vol = GetIntelSignalValue(srData.Data, 20, 10, 1, -512);

        //    aC_Sense_Msg.A_Cur = GetIntelSignalValue(srData.Data, 30, 10, 1, -512);
        //    aC_Sense_Msg.B_Cur = GetIntelSignalValue(srData.Data, 40, 10, 1, -512);
        //    aC_Sense_Msg.C_Cur = GetIntelSignalValue(srData.Data, 50, 10, 1, -512);
        //}

        ///// <summary>
        ///// 获取 直流 电流 电压 和交直流 交直流 功率 测量 值
        ///// </summary>
        ///// <returns></returns>
        //public static void Load_DC_Power_Sense_Msg(DC_Power_Sense_Msg value, VCI_CAN_OBJ srData)
        //{
        //    value.Vbus_Ave = GetIntelSignalValue(srData.Data, 0, 11, 1, 0);
        //    value.Ibat_Ave = GetIntelSignalValue(srData.Data, 11, 10, 1, -512);
        //    value.PwrAC = GetIntelSignalValue(srData.Data, 21, 19, 1, -256000);
        //    value.PwrDC = GetIntelSignalValue(srData.Data, 40, 19, 1, -256000);

        //}

        ///// <summary>
        ///// 获取 状态 帧
        ///// </summary>
        ///// <returns></returns>
        //public static void Load_State_Sense_Msg(State_Sense_Msg value, VCI_CAN_OBJ srData)
        //{
        //    //冷却液进口温度测量值
        //    value.Coolant_Tin_Sense = GetIntelSignalValue(srData.Data, 0, 8, 1, -64);

        //    value.Coolant_Tout_Sense = GetIntelSignalValue(srData.Data, 8, 8, 1, -64);

        //    value.IGBT_Tmax_Sense = GetIntelSignalValue(srData.Data, 16, 8, 1, -64);

        //    value.Vac_Freq_Sense = GetIntelSignalValue(srData.Data, 24, 8, 0.25, 0);


        //    value.DrvCtrlModel = GetIntelSignalValue(srData.Data, 32, 4, 1, 0);
        //    switch (value.DrvCtrlModel)
        //    {
        //        case 0:
        //            value.DrvCtrlModel_State = PCSDriveCtrlMode.NotActive;
        //            break;
        //        case 1:
        //            value.DrvCtrlModel_State = PCSDriveCtrlMode.Init;
        //            break;
        //        case 2:
        //            value.DrvCtrlModel_State = PCSDriveCtrlMode.PreCharge;
        //            break;
        //        case 3:
        //            value.DrvCtrlModel_State = PCSDriveCtrlMode.Standby;
        //            break;
        //        case 5:
        //            value.DrvCtrlModel_State = PCSDriveCtrlMode.GridDisChg;
        //            break;
        //        case 8:
        //            value.DrvCtrlModel_State = PCSDriveCtrlMode.Failure;
        //            break;
        //        default:
        //            break;
        //    }

        //    value.GateDrvModel = GetIntelSignalValue(srData.Data, 36, 2, 1, 0);
        //    switch (value.GateDrvModel)
        //    {
        //        case 0:
        //            value.GateDrvModel_State = PCSGateDriveMode.Freewheel;
        //            break;
        //        case 1:
        //            value.GateDrvModel_State = PCSGateDriveMode.ShortCircuit;
        //            break;
        //        case 2:
        //            value.GateDrvModel_State = PCSGateDriveMode.PWNRun;
        //            break;
        //        default:
        //            break;
        //    }

        //    value.flgTColantDerat = GetIntelSignalValue(srData.Data, 38, 1, 1, 0);
        //    switch (value.flgTColantDerat)
        //    {
        //        case 0:
        //            value.flgTColantDerat_State = PCSFlgColantDeratModel.Off;
        //            break;
        //        case 1:
        //            value.flgTColantDerat_State = PCSFlgColantDeratModel.On;
        //            break;
        //        default:
        //            break;
        //    }
        //    value.Runcrnd = GetIntelSignalValue(srData.Data, 39, 1, 1, 0);
        //    switch (value.Runcrnd)
        //    {
        //        case 0:
        //            value.Runcrnd_State = PCSRuncmdModel.Stop;
        //            break;
        //        case 1:
        //            value.Runcrnd_State = PCSRuncmdModel.Run;
        //            break;
        //        default:
        //            break;
        //    }
        //}


        //public static void Load_Fault_T_F_Sense_Msg(Fault_T_F_Sense_Msg value, VCI_CAN_OBJ srData)
        //{

        //    value.HW_Fault = GetIntelSignalValue(srData.Data, 0, 16, 1, 0);
        //    value.Env_Fault = GetIntelSignalValue(srData.Data, 16, 32, 1, 0);
        //}


        /// <summary>
        /// 当前发送的Intel的数据
        /// </summary>
        private byte[] CurrentSendIntelSignal { get; set; } = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };


        /// <summary>
        /// intel格式CAN报文 转 数值
        /// </summary>
        /// <param name="data">CAN报文</param>
        /// <param name="startBit">信号起始bit</param>
        /// <param name="bitLength">信号总长度</param>
        /// <param name="factor">精度值</param>
        /// <param name="offset">偏移值</param>
        /// <returns>数值</returns>
        public static double GetIntelSignalValue(byte[] data, int startBit, int bitLength, double factor, double offset)
        {
            ulong canSignalValue = 0;
            for (int i = data.Length - 1; i >= 0; i--)
            {
                canSignalValue += (ulong)data[i] << i * 8;
            }
            int x = startBit / 8;
            int y = startBit % 8;
            int rightMoveCount = x * 8 + y;
            canSignalValue >>= rightMoveCount;
            canSignalValue = canSignalValue & ulong.MaxValue >> 64 - bitLength;
            double values = canSignalValue * factor + offset;
            return values;
        }


        /// <summary>
        /// 数值 转 intel格式CAN报文
        /// </summary>
        /// <param name="values">物理信号值</param>
        /// <param name="startBit">信号起始bit</param>
        /// <param name="bitLength">信号总长度</param>
        /// <param name="factor">精度值</param>
        /// <param name="offset">偏移值</param>
        /// <returns>intel格式CAN报文</returns>
        public static byte[] ValueToIntelSignal(double values, int startBit, int bitLength, double factor, double offset)
        {
            byte[] IntelSignal = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            ulong data = Convert.ToUInt64((values - offset) / factor);
            int dataLength = bitLength / 8 + (bitLength / 4) % 2;
            int IntelSignal_pos = startBit / 8;
            for (int Count = 0; Count < dataLength; Count++, IntelSignal_pos++)
            {
                ulong lowBit = (data >> (8 * Count)) & 0xFF;                // 将数据移至低8位并取出
                IntelSignal[IntelSignal_pos] = Convert.ToByte(lowBit);
            }
            return IntelSignal;
        }

        /// <summary>
        /// 数值 转 intel格式CAN报文
        /// </summary>
        /// <param name="values">物理信号值</param>
        /// <param name="startBit">信号起始bit</param>
        /// <param name="bitLength">信号总长度</param>
        /// <param name="factor">精度值</param>
        /// <param name="offset">偏移值</param>
        /// <returns>intel格式CAN报文</returns>
        public static byte[] ValueToIntelSignal(byte[] IntelSignal, double values, int startBit, int bitLength, double factor, double offset)
        {
            //byte[] IntelSignal = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            ulong data = Convert.ToUInt64((values - offset) / factor);
            int dataLength = bitLength / 8 + (bitLength / 4) % 2;
            int IntelSignal_pos = startBit / 8;
            for (int Count = 0; Count < dataLength; Count++, IntelSignal_pos++)
            {
                ulong lowBit = (data >> (8 * Count)) & 0xFF;                // 将数据移至低8位并取出
                IntelSignal[IntelSignal_pos] = Convert.ToByte(lowBit);
            }
            return IntelSignal;
        }

        /// <summary>
        /// Motorola格式CAN报文 转 数值
        /// </summary>
        /// <param name="data">CAN报文</param>
        /// <param name="startBit">信号起始bit</param>
        /// <param name="bitLength">信号总长度</param>
        /// <param name="factor">精度值</param>
        /// <param name="offset">偏移值</param>
        /// <returns>物理信号值</returns>
        public static double GetMotorolaSignalValue(byte[] data, int startBit, int bitLength, double factor, double offset)
        {
            ulong canSignalValue = 0;
            for (int i = data.Length - 1, j = 0; i >= 0; i--, j++)
            {
                canSignalValue += (ulong)data[j] << i * 8;
            }
            int x = startBit / 8;
            int y = startBit % 8;
            int z = x * 8 + bitLength - y;
            int rightMoveCount = data.Length * 8 - z;
            canSignalValue >>= rightMoveCount;
            canSignalValue = canSignalValue & ulong.MaxValue >> 64 - bitLength;

            double values = canSignalValue * factor + offset;
            return values;
        }

        /// <summary>
        /// 数值 转 Motorola格式CAN报文
        /// </summary>
        /// <param name="MotorolaSignal">CAN报文</param>
        /// <param name="values">物理信号值</param>
        /// <param name="startBit">信号起始bit</param>
        /// <param name="bitLength">信号总长度</param>
        /// <param name="factor">精度值</param>
        /// <param name="offset">偏移值</param>
        /// <returns>Motorola格式CAN报文</returns>
        public static byte[] ValueToMotorolaSignal_Part(byte[] MotorolaSignal, double values, int startBit, int bitLength, double factor, double offset)
        {
            // = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            ulong data = Convert.ToUInt64((values - offset) / factor);
            int dataLength = bitLength / 8 + (bitLength / 4) % 2;
            int str_length = data.ToString().Length;
            int MotorolaSignal_pos = startBit / 8;
            data = str_length % 2 != 0 ? data << 4 : data;
            for (int Count = dataLength - 1; Count >= 0; Count--, MotorolaSignal_pos++)
            {
                ulong newBit = (data >> (8 * Count)) & 0xFF;
                ulong newBit2 = ((newBit << 4) & 0xF0) + ((newBit >> 4) & 0x0F);
                ulong Bit = (data > 0x0F & bitLength > 8) ? newBit2 : newBit;
                MotorolaSignal[MotorolaSignal_pos] = Convert.ToByte(Bit);
            }
            return MotorolaSignal;
        }

    }
}