using CapMachine.Model.CANLIN;
using CapMachine.Wpf.CanDrive;
using ImTools;
using Prism.Ioc;
using Prism.Mvvm;
using SharpDX;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CapMachine.Wpf.Services
{
    /// <summary>
    /// Can驱动服务
    /// </summary>
    public class CanDriveService : BindableBase
    {

        public HighSpeedDataService HighSpeedDataService { get; }
        public LogicRuleService LogicRuleService { get; }

        /// <summary>
        /// 实例化函数
        /// </summary>
        public CanDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService)
        {
            ToomossCanDrive = new ToomossCan(containerProvider);
            //高速数据服务
            HighSpeedDataService = highSpeedDataService;
            LogicRuleService = logicRuleService;

            //ToomossCanDrive.StartCanDrive();
        }

        /// <summary>
        /// 当前选中的CanLinConfigPro 程序
        /// </summary>
        public CanLinConfigPro SelectedCanLinConfigPro { get; set; }


        /// <summary>
        /// 图莫斯 CAN Drive
        /// ToomossCanDrive
        /// </summary>
        public ToomossCan ToomossCanDrive { get; set; }

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

        /// <summary>
        /// 初始化CAN的配置信息
        /// </summary>
        public void InitCanConfig(CanLinConfigPro selectedCanLinConfigPro)
        {
            //赋值配置数据
            SelectedCanLinConfigPro = selectedCanLinConfigPro;
            //为DBC实时数据关联配置的名称
            foreach (var item in SelectedCanLinConfigPro.CanLinConfigContents)
            {
                var FindData = ListCanDbcModel.FindFirst(a => a.SignalName == item.SignalName);
                if (FindData != null)
                {
                    FindData.Name = item.Name;
                }
            }
        }

        /// <summary>
        /// 开始DBC 配置文件 加载
        /// </summary>
        /// <returns></returns>
        public ObservableCollection<CanDbcModel> StartDbc(string Path)
        {
            ListCanDbcModel = ToomossCanDrive.StartDbc(Path);
            return ListCanDbcModel;
        }


        #region 程序驱动CAN



        private bool _CanAutoHand;
        /// <summary>
        /// CAN 手自动 模式，自动代表接受程序步骤的数据，手动代表接受手动输入的数据
        /// True代表自动，False代表手动
        /// </summary>
        public bool CanAutoHand
        {
            get { return _CanAutoHand; }
            set
            {
                if (_CanAutoHand != value)
                {
                    RaisePropertyChanged();
                    _CanAutoHand = value;
                }
            }
        }


        private bool _CanHandEnable;
        /// <summary>
        /// CAN 手动 模式，是否使能，用于报文的使能和非使能的数据
        /// True代表使能，False代表禁用
        /// </summary>
        public bool CanHandEnable
        {
            get { return _CanHandEnable; }
            set
            {
                if (_CanHandEnable != value)
                {
                    RaisePropertyChanged();
                    _CanHandEnable = value;
                }
            }
        }


        private int _AutoSpeedSv;
        /// <summary>
        /// 转速SV
        /// </summary>
        public int AutoSpeedSv
        {
            get { return _AutoSpeedSv; }
            set
            {
                if (value != _AutoSpeedSv)
                {
                    _AutoSpeedSv = value;
                    RaisePropertyChanged();
                }

            }
        }


        /// <summary>
        /// 转速 指令数据 实例
        /// </summary>
        private CanCmdData SpeedCanCmdData { get; set; }

        /// <summary>
        /// 功率限制 指令数据 实例
        /// </summary>
        private CanCmdData PwLimitCanCmdData { get; set; }

        /// <summary>
        /// 使能 指令数据 实例
        /// </summary>
        private CanCmdData EnableCanCmdData { get; set; }

        /// <summary>
        /// 要发送的CAN指令数据
        /// 在程序配置好后就确定要发送哪些数据
        /// </summary>
        public List<CanCmdData> CmdData { get; set; } = new List<CanCmdData>();

        /// <summary>
        /// 增加发送的指令数据
        /// </summary>
        /// <param name="canCmdData"></param>
        public void AddCmdData(CanCmdData SendCanCmdData)
        {
            //提取常用的实例数据
            switch (SendCanCmdData.ConfigName)
            {
                case "转速":
                    SpeedCanCmdData = SendCanCmdData;
                    break;
                case "功率限制":
                    PwLimitCanCmdData = SendCanCmdData;
                    break;
                case "使能":
                    EnableCanCmdData = SendCanCmdData;
                    break;
                case "Anti_Sleep":
                    //SpeedCanCmdData = SendCanCmdData;
                    break;
                default:
                    break;
            }
            //添加到发送数据集合
            CmdData.Add(SendCanCmdData);
        }

        /// <summary>
        /// 更新速度信息
        /// 默认是启动
        /// </summary>
        /// <param name="canCmdData"></param>
        public void UpdateSpeedCmdData(double SpeedData)
        {
            if (SpeedCanCmdData != null)
            {
                AutoSpeedSv = (int)SpeedData;

                //首先是否判断是有斜率
                if (SpeedCanCmdData.LogicRuleDto == null)
                {
                    //没有启动逻辑规则处理
                    SpeedCanCmdData.SignalCmdValue = SpeedData;
                }
                else
                {
                    //LogicRuleService.ApplyExpressionFast(SpeedData, SpeedCanCmdData.LogicRuleDto);
                    SpeedCanCmdData.SignalCmdValue = LogicRuleService.ApplyExpressionFast(SpeedData, SpeedCanCmdData.LogicRuleDto);
                    //Console.WriteLine($"实时转换后转速值：{SpeedCanCmdData.SignalCmdValue}-SV值:{SpeedData}");
                }

            }
            //if (EnableCanCmdData != null)
            //{
            //    EnableCanCmdData.SignalCmdValue = 1;
            //}
        }

        /// <summary>
        /// 更新压缩机使能数据 自动时的赋值数据
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapEnableCmdData(bool IsEnable)
        {
            if (!ToomossCanDrive.IsCycleSend) return;
            if (CanAutoHand)
            {
                if (EnableCanCmdData != null)
                {
                    EnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0;
                }
            }
        }

        /// <summary>
        /// 更新压缩机使能数据 手动时的赋值数据
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapEnableCmdDataByHand(bool IsEnable)
        {
            if (EnableCanCmdData != null)
            {
                EnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0;
                Console.WriteLine("压缩机使能:" + IsEnable);
            }
        }

        /// <summary>
        /// 发送消息给CAN 驱动
        /// 手动发送时使用
        /// </summary>
        public void SendMsgToCanDrive(double SpeedData)
        {
            if (ToomossCanDrive.OpenState)
            {
                if (CmdData.Count > 0)
                {
                    //更新速度信息
                    UpdateSpeedCmdData(SpeedData);

                    ToomossCanDrive.SendCanMsg(CmdData);
                }
                else
                {
                    System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                }
            }
            else
            {
                System.Windows.MessageBox.Show("未打开CAN通信，无法发送数据", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
            }
        }


        /// <summary>
        /// 循环发送数据到CAN 
        /// </summary>
        public void CycleSendMsg()
        {
            if (ToomossCanDrive.OpenState)
            {
                if (ToomossCanDrive.IsCycleSend == false)//要防止多次启动导致的问题，来回转换
                {
                    if (CmdData.Count > 0)
                    {
                        ToomossCanDrive.IsCycleSend = true;
                        ToomossCanDrive.CmdData = CmdData;
                        //ToomossCanDrive.StartCycleSendMsg();
                        ToomossCanDrive.StartPrecisionCycleSendMsg();
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }
                }
                else
                {
                    ToomossCanDrive.IsCycleSend = false;
                }

            }
        }



        /// <summary>
        ///循环接收数据
        /// </summary>
        public void CycleReciveMsg()
        {
            if (ToomossCanDrive.OpenState)
            {
                if (ToomossCanDrive.IsCycleRevice == false)
                {
                    if (ListCanDbcModel.Count > 0)
                    {
                        ToomossCanDrive.IsCycleRevice = true;
                        ToomossCanDrive.StartCycleReviceCanMsg();
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }
                }
                else
                {
                    ToomossCanDrive.IsCycleRevice = false;
                }
            }
        }


        /// <summary>
        /// 获取数据值
        /// 从DBC中获取数据给数据中心集合
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public double GetDbcValueByName(string Name)
        {
            if (!ToomossCanDrive.IsCycleRevice) return 0;

            if (ListCanDbcModel.Any(a => a.Name == Name))
            {
                //double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1);
                //return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
                return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result) == true ? Result : 0;
            }
            return 0;
        }

        /// <summary>
        /// 速度的数据的获取
        /// 获取速度数据值
        /// 从DBC中获取Speed数据给数据中心集合
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public double GetDbcSpeedValueBySpeedName(string Name)
        {
            if (!ToomossCanDrive.IsCycleRevice) return 0;

            if (ListCanDbcModel.Any(a => a.Name == Name))
            {
                //double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1);  
                //return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
                return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result) == true ? Result : 0;
            }
            return 0;
        }

        #endregion


    }
}