using CapMachine.Model.CANLIN;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.LinDrive;
using ImTools;
using Prism.Ioc;
using Prism.Mvvm;
using System.Collections.ObjectModel;

namespace CapMachine.Wpf.Services
{
    /// <summary>
    /// Lin驱动服务
    /// </summary>
    public class LinDriveService : BindableBase
    {
        public HighSpeedDataService HighSpeedDataService { get; }

        public LogicRuleService LogicRuleService { get; }

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

            LogicRuleService = logicRuleService;

            //ToomossLinDrive.StartLinDrive();
        }

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


        /// <summary>
        /// 图莫斯 CAN Drive
        /// ToomossLinDrive
        /// </summary>
        public ToomossLin ToomossLinDrive { get; set; }

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

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

        /// <summary>
        /// 开始DBC 配置文件 加载
        /// </summary>
        /// <returns></returns>
        public ObservableCollection<LinLdfModel> StartLdf(string Path)
        {
            ListLinLdfModel = ToomossLinDrive.StartLdf(Path);
            return ListLinLdfModel;
        }


        #region 程序驱动CAN

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

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

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

        /// <summary>
        /// PTC使能 指令数据 实例
        /// </summary>
        private LinCmdData PTCEnableCanCmdData { get; set; }

        /// <summary>
        /// PTC功率 指令数据 实例
        /// </summary>
        private LinCmdData PTCPwCanCmdData { get; set; }

        /// <summary>
        /// PTC水流量 指令数据 实例
        /// </summary>
        private LinCmdData PTCFlowCanCmdData { get; set; }

        /// <summary>
        /// PTC水温 指令数据 实例
        /// </summary>
        private LinCmdData PTCWaterTempCanCmdData { get; set; }


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

        /// <summary>
        /// 调度表LIN配置信息
        /// </summary>
        public List<LINScheduleConfigDto> ListLINScheduleConfig { get; set; } = new List<LINScheduleConfigDto>();

        /// <summary>
        /// 增加发送的指令数据
        /// </summary>
        /// <param name="canCmdData"></param>
        public void AddCmdData(LinCmdData SendLinCmdData)
        {
            //提取常用的实例数据
            switch (SendLinCmdData.ConfigName)
            {
                case "转速":
                    SpeedLinCmdData = SendLinCmdData;
                    break;
                case "功率限制":
                    PwLimitLinCmdData = SendLinCmdData;
                    break;
                case "使能":
                    EnableLinCmdData = SendLinCmdData;
                    break;
                case "Anti_Sleep":
                    //SpeedLinCmdData = SendLinCmdData;
                    break;
                case "PTC使能":
                    PTCEnableCanCmdData = SendLinCmdData;
                    break;
                case "PTC功率":
                    PTCPwCanCmdData = SendLinCmdData;
                    break;
                case "PTC水流量":
                    PTCFlowCanCmdData = SendLinCmdData;
                    break;
                case "PTC水温":
                    PTCWaterTempCanCmdData = SendLinCmdData;
                    break;
                default:
                    break;
            }
            //添加到发送数据集合
            CmdData.Add(SendLinCmdData);
        }


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

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

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

        /// <summary>
        /// 更新压缩机使能数据
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapEnableCmdData(bool IsEnable)
        {
            if (EnableLinCmdData != null)
            {
                EnableLinCmdData.SignalCmdValue = IsEnable ? 1 : 0;
            }
        }


        /// <summary>
        /// 更新压缩机的功率限制
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapPwLimitCmdData(double PwLimit)
        {
            if (PwLimitLinCmdData != null)
            {
                PwLimitLinCmdData.SignalCmdValue = PwLimit;
            }
        }

        /// <summary>
        /// 更新 PTC使能信号
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapPTCEnableCmdData(bool IsEnable)
        {
            if (PTCEnableCanCmdData != null)
            {
                PTCEnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0;
            }
        }

        /// <summary>
        /// 更新 PTC功率 信号
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapPTCPwCmdData(double PTCPw)
        {
            //if (PTCPwCanCmdData != null)
            //{
            //    PTCPwCanCmdData.SignalCmdValue = PTCPw;
            //}

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

        /// <summary>
        /// 更新 PTC水流量 信号
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapPTCFlowCmdData(double Flow)
        {
            //if (PTCFlowCanCmdData != null)
            //{
            //    PTCFlowCanCmdData.SignalCmdValue = Flow;
            //}

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

        }

        /// <summary>
        /// 更新 PTC水温 信号
        /// </summary>
        /// <param name="IsEnable"></param>
        public void UpdateCapPTCWaterTempCmdData(double WaterTemp)
        {
            //if (PTCWaterTempCanCmdData != null)
            //{
            //    PTCWaterTempCanCmdData.SignalCmdValue = WaterTemp;
            //}

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

        }

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

                    ToomossLinDrive.SendLinMsg(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 (ToomossLinDrive.OpenState)
            {
                if (ToomossLinDrive.IsCycleSend == false)
                {
                    if (CmdData.Count > 0)
                    {
                        //ToomossLinDrive.IsCycleSend = true;
                        ToomossLinDrive.CmdData = CmdData;
                        //ToomossLinDrive.StartPrecisionCycleSendMsg();
                        //ToomossLinDrive.StartCycleSendMsg();

                        if (ToomossLinDrive.SchEnable)
                        {
                            //使用调度表的话，需要在调度表中配置信息后才可以进行操作
                            var GroupMsg = ToomossLinDrive.CmdData.GroupBy(a => a.MsgName).ToList();
                            foreach (var itemMsg in GroupMsg)
                            {
                                if (!ListLINScheduleConfig.ToList().Any(a => a.MsgName == itemMsg.Key))
                                {
                                    System.Windows.MessageBox.Show($"你使能了调度表，但是调度表中没有设置【{itemMsg.Key}】信息，请设置后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                                    return;
                                }
                            }

                            if (ListLINScheduleConfig == null && ListLINScheduleConfig!.Count() == 0)
                            {
                                System.Windows.MessageBox.Show("调度表配置为空数据，请检查！将无法发送数据", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                                return;
                            }

                            ToomossLinDrive.ListLINScheduleConfig = ListLINScheduleConfig!;
                            ToomossLinDrive.StartSchedule();
                            ToomossLinDrive.StartCycleUpdateCmd();
                        }
                        else
                        {
                            ToomossLinDrive.StartPrecisionCycleSendMsg();
                            //ToomossCanDrive.StartCycleSendMsg();
                        }

                        ToomossLinDrive.IsCycleSend = true;

                    }
                    else
                    {
                        System.Windows.MessageBox.Show("未发现配置的数据内容", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }
                }
                else
                {
                    ToomossLinDrive.IsCycleSend = false;
                }

            }
        }



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


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

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

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

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

        #endregion
    }
}