using CapMachine.Wpf.Models.Tag;
using CapMachine.Wpf.Services;
using HslCommunication;
using NPOI.OpenXmlFormats.Wordprocessing;
using Prism.Ioc;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Interop;
using static CapMachine.Wpf.CanDrive.USB2CAN;

namespace CapMachine.Wpf.CanDrive
{
    /// <summary>
    /// Toomoss CAN
    /// </summary>
    public class ToomossCan : BindableBase
    {
        private readonly IContainerProvider ContainerProvider;

        /// <summary>
        /// 实例化函数
        /// </summary>
        public ToomossCan(IContainerProvider containerProvider)
        {
            ContainerProvider = containerProvider;
            HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
        }

        /// <summary>
        /// 开始CAN的驱动
        /// </summary>
        public void StartCanDrive()
        {
            IsExistsDllFile();
            ScanDevice();
            OpenDevice();
            GetDeviceInfo();
            GetCANConfig();
            InitCAN();

        }

        /// <summary>
        /// HighSpeedDataService 实例
        /// </summary>
        public HighSpeedDataService HighSpeedDataService { get; set; }

        /// <summary>
        /// 开始Dbc文件写入
        /// </summary>
        public ObservableCollection<CanDbcModel> StartDbc(string DbcPath)
        {
            DBC_Parser(DbcPath);
            return ListCanDbcModel;
        }

        ///// <summary>
        ///// 获取Can DBC数据集合
        ///// </summary>
        //public void LoadCanDbcData(ObservableCollection<CanDbcModel> canDbcModels)
        //{
        //    ListCanDbcModel = canDbcModels;
        //}

        /// <summary>
        /// Dbc消息集合
        /// 包括读取的实时值和数据
        /// </summary>
        public ObservableCollection<CanDbcModel> ListCanDbcModel { get; set; } = new ObservableCollection<CanDbcModel>();


        #region 公共变量

        /// <summary>
        /// 设备固件信息
        /// </summary>
        public USB_DEVICE.DEVICE_INFO DevInfo = new USB_DEVICE.DEVICE_INFO();

        /// <summary>
        /// CAN Config
        /// </summary>
        USB2CAN.CAN_INIT_CONFIG CANConfig = new USB2CAN.CAN_INIT_CONFIG();

        /// <summary>
        /// DBC加载后获取的Handle
        /// DBC Handle
        /// </summary>
        public UInt64 DBCHandle { get; set; }

        /// <summary>
        /// 扫描设备Handle集合
        /// </summary>
        public Int32[] DevHandles { get; set; } = new Int32[20];

        /// <summary>
        /// 扫描设备Handle
        /// </summary>
        public Int32 DevHandle { get; set; } = 0;

        /// <summary>
        /// Write CAN Index
        /// 通道的含义
        /// 描述：
        /// 读取接收到的CAN消息，推荐使用该函数。
        ///原型：
        ///int WINAPI CAN_GetMsgWithSize(int DevHandle, unsigned char CANIndex, CAN_MSG* pCanGetMsg, int BufferSize);
        ///参数：
        ///DevHandle 设备句柄，本质为设备序号的低4字节，可以通过调用USB_ScanDevice函数获得。
        ///CANIndex CAN通道索引号，0-对应CAN1,1-对应CAN2。
        ///pCanGetMsg 存储CAN消息缓冲区首地址。
        ///BufferSize 存储CAN消息缓冲区大小。
        ///返回值：
        //大于等于0表示从CAN适配器内部成功读取到的CAN消息帧数，若返回值小于0则说明调用该函数失败。
        /// </summary>
        public Byte WriteCANIndex { get; set; } = 0;

        /// <summary>
        /// Read CAN Index
        /// 通道的含义
        /// 描述：
        ///读取接收到的CAN消息，推荐使用该函数。
        ///原型：
        ///int WINAPI CAN_GetMsgWithSize(int DevHandle, unsigned char CANIndex, CAN_MSG* pCanGetMsg, int BufferSize);
        ///参数：
        ///DevHandle 设备句柄，本质为设备序号的低4字节，可以通过调用USB_ScanDevice函数获得。
        ///CANIndex CAN通道索引号，0-对应CAN1,1-对应CAN2。
        ///pCanGetMsg 存储CAN消息缓冲区首地址。
        ///BufferSize 存储CAN消息缓冲区大小。
        ///返回值：
        ///大于等于0表示从CAN适配器内部成功读取到的CAN消息帧数，若返回值小于0则说明调用该函数失败。
        /// </summary>
        public Byte ReadCANIndex { get; set; } = 0;


        private bool _OpenState;
        /// <summary>
        /// 打开设备的状态
        /// </summary>
        public bool OpenState
        {
            get { return _OpenState; }
            set { _OpenState = value; RaisePropertyChanged(); }
        }


        /// <summary>
        /// 扫描到设备个数
        /// </summary>
        public Int32 DevNum { get; set; }

        public Int32 ret { get; set; }

        public string dllFilePath { get; set; } = "USB2XXX.dll";


        /// <summary>
        /// 消息值Pt
        /// </summary>
        public IntPtr msgPt { get; set; }

        #endregion

        /// <summary>
        /// ******************【1】*********************
        /// 是否存在Dll文件
        /// </summary>
        /// <returns></returns>
        public bool IsExistsDllFile()
        {
            if (!File.Exists(dllFilePath))
            {
                Console.WriteLine("请先将USB2XXX.dll和libusb-1.0.dll文件复制到exe程序文件输出目录下!");
                Console.WriteLine("dll文件在‘usb2can_lin_pwm_example/sdk/libs/windows’目录下！");
                Console.WriteLine("程序是32位的就复制‘x86’目录下文件，程序是64位的就复制‘x86_64’目录下文件！");
                return false;
            }
            return true;
        }

        /// <summary>
        /// ******************【2】*********************
        /// 扫描查找设备，并将每个设备的唯一设备号存放到数组中，后面的函数需要用到
        /// </summary>
        /// <returns></returns>
        public bool ScanDevice()
        {
            DevNum = USB_DEVICE.USB_ScanDevice(DevHandles);
            if (DevNum <= 0)
            {
                Console.WriteLine("No device connected!");

                return false;
            }
            else
            {
                Console.WriteLine("Have {0} device connected!", DevNum);
                DevHandle = DevHandles[0];//获取第一个设备的设备号
                return true;
            }
        }

        /// <summary>
        /// ******************【3】*********************
        /// 打开设备
        /// </summary>
        /// <returns></returns>
        public bool OpenDevice()
        {
            //打开设备
            OpenState = USB_DEVICE.USB_OpenDevice(DevHandle);
            if (!OpenState)
            {
                Console.WriteLine("Open device error!");
                return false;
            }
            else
            {
                Console.WriteLine("Open device success!");
                return true;
            }
        }

        /// <summary>
        /// ******************【4】*********************
        /// 获取设备的固件信息
        /// </summary>
        /// <returns></returns>
        public bool GetDeviceInfo()
        {
            //获取固件信息
            StringBuilder FuncStr = new StringBuilder(256);
            OpenState = USB_DEVICE.DEV_GetDeviceInfo(DevHandle, ref DevInfo, FuncStr);
            if (!OpenState)
            {
                Console.WriteLine("Get device infomation error!");
                return false;
            }
            else
            {
                Console.WriteLine("Firmware Info:");
                Console.WriteLine("    Name:" + Encoding.Default.GetString(DevInfo.FirmwareName));
                Console.WriteLine("    Build Date:" + Encoding.Default.GetString(DevInfo.BuildDate));
                Console.WriteLine("    Firmware Version:v{0}.{1}.{2}", (DevInfo.FirmwareVersion >> 24) & 0xFF, (DevInfo.FirmwareVersion >> 16) & 0xFF, DevInfo.FirmwareVersion & 0xFFFF);
                Console.WriteLine("    Hardware Version:v{0}.{1}.{2}", (DevInfo.HardwareVersion >> 24) & 0xFF, (DevInfo.HardwareVersion >> 16) & 0xFF, DevInfo.HardwareVersion & 0xFFFF);
                Console.WriteLine("    Functions:" + DevInfo.Functions.ToString("X8"));
                Console.WriteLine("    Functions String:" + FuncStr);
                StringBuilder DLLBuildDate = new StringBuilder(256);
                USB_DEVICE.DEV_GetDllBuildTime(DLLBuildDate);
                Console.WriteLine("    DLL Build Date:" + DLLBuildDate);

                return true;
            }
        }

        /// <summary>
        /// ******************【5】*********************
        /// 获取设备Config配置
        /// </summary>
        public void GetCANConfig()
        {
            CANConfig.CAN_Mode = 0x80;//正常模式并接入终端电阻
            //获取CAN波特率参数
            ret = USB2CAN.CAN_GetCANSpeedArg(DevHandle, ref CANConfig, 500000);
            if (ret != USB2CAN.CAN_SUCCESS)
            {
                Console.WriteLine("Get CAN Speed failed!");
                return;
            }
            else
            {
                Console.WriteLine("Get CAN Speed Success!");
            }

        }

        /// <summary>
        /// ******************【6】*********************
        /// 初始化CAN
        /// </summary>
        public void InitCAN()
        {
            //初始化CAN

            ret = USB2CAN.CAN_Init(DevHandle, WriteCANIndex, ref CANConfig);
            if (ret != USB2CAN.CAN_SUCCESS)
            {
                Console.WriteLine("Config CAN failed!");
                return;
            }
            else
            {
                Console.WriteLine("WriteCANIndex Config CAN Success!");
            }

            ret = USB2CAN.CAN_Init(DevHandle, ReadCANIndex, ref CANConfig);
            if (ret != USB2CAN.CAN_SUCCESS)
            {
                Console.WriteLine("Config CAN failed!");
                return;
            }
            else
            {
                Console.WriteLine("ReadCANIndex Config CAN Success!");
            }
            Console.WriteLine("");
        }

        /// <summary>
        /// ******************【7】*********************
        /// DBC解析
        /// </summary>
        public void DBC_Parser(string Path)
        {
            //解析DBC文件
            DBCHandle = CAN_DBCParser.DBC_ParserFile(DevHandle, new StringBuilder(Path));
            if (DBCHandle == 0)
            {
                Console.WriteLine("Parser DBC File error!");
                return;
            }
            else
            {
                Console.WriteLine("Parser DBC File success!");
            }

            ListCanDbcModel.Clear();

            //打印DBC里面报文和信号相关信息
            int DBCMsgNum = CAN_DBCParser.DBC_GetMsgQuantity(DBCHandle);
            for (int i = 0; i < DBCMsgNum; i++)
            {
                StringBuilder MsgName = new StringBuilder(32);
                CAN_DBCParser.DBC_GetMsgName(DBCHandle, i, MsgName);
                Console.WriteLine("Msg.Name = {0}", MsgName);
                int DBCSigNum = CAN_DBCParser.DBC_GetMsgSignalQuantity(DBCHandle, MsgName);
                StringBuilder Publisher = new StringBuilder(32);
                CAN_DBCParser.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher);
                long MsgId;
                MsgId = CAN_DBCParser.DBC_GetMsgIDByName(DBCHandle, MsgName);

                Console.Write("Signals:");
                for (int j = 0; j < DBCSigNum; j++)
                {
                    StringBuilder SigName = new StringBuilder(32);
                    CAN_DBCParser.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName);
                    Console.Write("{0} ", SigName);

                    //增加信息数据
                    ListCanDbcModel.Add(new CanDbcModel()
                    {
                        MsgName = MsgName.ToString(),
                        MsgId = "0x" + MsgId.ToString("X8"),
                        SignalName = SigName.ToString(),
                        SignalDesc = "",
                        SignalUnit = "",
                        SignalRtValue = "",
                        Publisher = Publisher.ToString()
                    });
                }
                Console.WriteLine("");
            }
        }

        /// <summary>
        /// 发送CAN数据
        /// </summary>
        public void SendCanMsg(List<CanCmdData> CmdData)
        {
            var GroupMsg = CmdData.GroupBy(x => x.MsgName);
            USB2CAN.CAN_MSG[] CanMsg = new USB2CAN.CAN_MSG[GroupMsg.Count()];
            for (int i = 0; i < GroupMsg.Count(); i++)
            {
                CanMsg[i] = new USB2CAN.CAN_MSG();
                CanMsg[i].Data = new Byte[64];
            }

            IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
            int Index = 0;
            //循环给MSG赋值数据
            foreach (var itemMsg in GroupMsg)
            {
                foreach (var itemSignal in itemMsg)
                {
                    CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
                }
                CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt);
                CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CAN.CAN_MSG));
                Index++;
            }

            //设置信号值
            //DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), 2412);
            //DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), 980);
            //DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), 120);

            //通过DBC写入数据后生成CanMsg
            //将信号值填入CAN消息里面


            //释放申请的临时缓冲区
            Marshal.FreeHGlobal(msgPt);
            Console.WriteLine("");
            //发送CAN数据
            int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length);
            if (SendedNum >= 0)
            {
                Console.WriteLine("Success send frames:{0}", SendedNum);
            }
            else
            {
                Console.WriteLine("Send CAN data failed! {0}", SendedNum);
            }
        }

        /// <summary>
        /// 是否循环接收数据
        /// </summary>
        public bool IsCycleRevice { get; set; }

        /// <summary>
        /// CycleRevice扫描Task
        /// </summary>
        private static Task CycleReviceTask { get; set; }

        StringBuilder ValueSb = new StringBuilder(16);

        /// <summary>
        /// 循环获取CAN消息
        /// </summary>
        public void StartCycleReviceCanMsg()
        {
            CycleReviceTask = Task.Run(async () =>
            {
                while (IsCycleRevice)
                {
                    await Task.Delay(500);
                    try
                    {
                        //另外一个CAN通道读取数据
                        USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[10];
                        msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length);
                        int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
                        if (CanNum > 0)
                        {
                            Console.WriteLine("Read CanMsgNum = {0}", CanNum);
                            for (int i = 0; i < CanNum; i++)
                            {
                                //CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG)); //有溢出报错
                                CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)(msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG));

                                Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8"));
                                //Console.WriteLine("CanMsg[{0}].TimeStamp = {1}",i,CanMsgBuffer[i].TimeStamp);
                                Console.Write("CanMsg[{0}].Data = ", i);
                                for (int j = 0; j < CanMsgBuffer[i].DataLen; j++)
                                {
                                    Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2"));
                                }
                                Console.WriteLine("");

                                HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg()
                                {
                                    Category="CAN",
                                    MsgInfo="0x"+CanMsgBuffer[i].ID.ToString("X8"),
                                    MsgData= CanMsgBuffer[i].Data.ToArrayString(),
                                    Time=DateTime.Now.ToString()
                                });
                            }
                        }
                        else if (CanNum == 0)
                        {
                            Console.WriteLine("No CAN data!");
                        }
                        else
                        {
                            Console.WriteLine("Get CAN data error!");
                        }
                        Console.WriteLine("");

                        //将CAN消息数据填充到信号里面，用DBC解析数据
                        CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPt, CanNum);

                        //循环获取消息的数据
                        foreach (var item in ListCanDbcModel)
                        {
                            //有配置的名称的，认为是有用的，则需要读取数据
                            //if (!string.IsNullOrEmpty(item.Name))
                            //{
                            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb);
                            item.SignalRtValueSb = ValueSb;

                            //}
                        }

                        ////获取信号值并打印出来
                        //StringBuilder ValueStr = new StringBuilder(32);
                        //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
                        //Console.WriteLine("moto_speed = {0}", ValueStr);
                        //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
                        //Console.WriteLine("oil_pressure = {0}", ValueStr);
                        //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
                        //Console.WriteLine("speed_can = {0}", ValueStr);
                    }
                    catch (Exception ex)
                    {
                        //LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
                    }
                }
            });
        }

        /// <summary>
        /// 接受CAN消息
        /// </summary>
        public void ReciveCanMsg()
        {
            //另外一个CAN通道读取数据
            USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[10];
            msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length);
            int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
            if (CanNum > 0)
            {
                Console.WriteLine("Read CanMsgNum = {0}", CanNum);
                for (int i = 0; i < CanNum; i++)
                {
                    CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG));
                    Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8"));
                    //Console.WriteLine("CanMsg[{0}].TimeStamp = {1}",i,CanMsgBuffer[i].TimeStamp);
                    Console.Write("CanMsg[{0}].Data = ", i);
                    for (int j = 0; j < CanMsgBuffer[i].DataLen; j++)
                    {
                        Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2"));
                    }
                    Console.WriteLine("");
                }
            }
            else if (CanNum == 0)
            {
                Console.WriteLine("No CAN data!");
            }
            else
            {
                Console.WriteLine("Get CAN data error!");
            }
            Console.WriteLine("");

            //将CAN消息数据填充到信号里面
            CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPt, CanNum);
            //获取信号值并打印出来
            StringBuilder ValueStr = new StringBuilder(32);
            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
            Console.WriteLine("moto_speed = {0}", ValueStr);
            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
            Console.WriteLine("oil_pressure = {0}", ValueStr);
            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
            Console.WriteLine("speed_can = {0}", ValueStr);
        }


        /// <summary>
        /// 关闭设备
        /// </summary>
        public void CloseDevice()
        {
            //关闭设备
            USB_DEVICE.USB_CloseDevice(DevHandle);
            OpenState = false;
        }

    }
}