using AutoMapper;
using CapMachine.Core;
using CapMachine.Model;
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.PrismEvent;
using CapMachine.Wpf.Services;
using Ganss.Excel;
using ImTools;
using Microsoft.VisualBasic;
using Microsoft.Win32;
using NPOI.SS.UserModel.Charts;
using Prism.Commands;
using Prism.Events;
using Prism.Regions;
using Prism.Services.Dialogs;
using Syncfusion.Windows.Tools.Controls;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using static CapMachine.Wpf.Models.ComEnum;

namespace CapMachine.Wpf.ViewModels
{
    /// <summary>
    /// CAN配置ViewModel
    /// </summary>
    public class CANConfigViewModel : NavigationViewModel
    {
        public CANConfigViewModel(IDialogService dialogService, IFreeSql freeSql,
            IEventAggregator eventAggregator, IRegionManager regionManager, SysRunService sysRunService,
            ComActionService actionService, LogicRuleService logicRuleService,
            ConfigService configService, CanDriveService canDriveService,
            IMapper mapper, MachineRtDataService machineRtDataService)
        {
            //LogService = logService;
            FreeSql = freeSql;
            EventAggregator = eventAggregator;
            RegionManager = regionManager;
            SysRunService = sysRunService;
            ComActionService = actionService;
            LogicRuleService = logicRuleService;
            ConfigService = configService;
            CanDriveService = canDriveService;
            Mapper = mapper;
            this.MachineRtDataService = machineRtDataService;

            //MachineDataService = machineDataService; 
            DialogService = dialogService;

            EventAggregator.GetEvent<LogicRuleChangeEvent>().Subscribe(LogicRuleChangeEventCall);

            WriteNameCbxItems = new ObservableCollection<CbxItems>()
            {
                new CbxItems(){ Key="转速",Text="转速"},
                new CbxItems(){ Key="功率限制",Text="功率限制"},
                new CbxItems(){ Key="使能",Text="使能"},
                new CbxItems(){ Key="Anti_Sleep",Text="Anti_Sleep"},
            };


            ReadNameCbxItems = new ObservableCollection<CbxItems>()
            {
                new CbxItems(){ Key="通讯转速",Text="通讯转速"},
                new CbxItems(){ Key="通讯母线电压",Text="通讯母线电压"},
                new CbxItems(){ Key="通讯母线电流",Text="通讯母线电流"},
                new CbxItems(){ Key="通讯相电流",Text="通讯相电流"},
                new CbxItems(){ Key="通讯功率",Text="通讯功率"},
                new CbxItems(){ Key="通讯芯片温度",Text="通讯芯片温度"},
            };

            InitLoadCanConfigPro();

            //初始化写规则下拉框
            InitWriteRuleCbx();

        }


        /// <summary>
        /// FreeSQL 实例函数
        /// </summary>
        public IFreeSql FreeSql { get; }
        public IEventAggregator EventAggregator { get; }
        public IRegionManager RegionManager { get; }
        public SysRunService SysRunService { get; }
        public ComActionService ComActionService { get; }
        public LogicRuleService LogicRuleService { get; }
        public ConfigService ConfigService { get; }
        public CanDriveService CanDriveService { get; }
        public IMapper Mapper { get; }
        private MachineRtDataService MachineRtDataService { get; }

        /// <summary>
        /// 弹窗服务
        /// </summary>
        public IDialogService DialogService { get; }

        #region 规则


        /// <summary>
        /// 逻辑更改事件
        /// </summary>
        /// <param name="msg"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void LogicRuleChangeEventCall(string msg)
        {
            //InitWriteRuleCbx();
        }

        /// <summary>
        /// 初始化写规则下拉框
        /// </summary>
        private void InitWriteRuleCbx()
        {
            WriteRuleCbxItems = new ObservableCollection<CbxItems>();
            //选择的读写规则
            foreach (var itemRule in LogicRuleService.LogicRuleDtos)
            {
                WriteRuleCbxItems.Add(new CbxItems()
                {
                    Key = itemRule.Id.ToString(),
                    Text = itemRule.Name
                });
            }
        }


        #endregion


        #region CanConfigPro

        /// <summary>
        /// 初始化j加载执行方法
        /// </summary>
        private void InitLoadCanConfigPro()
        {
            //CAN配置集合数据
            canLinConfigPros = FreeSql.Select<CanLinConfigPro>().Where(a => a.CANLINInfo == CANLIN.CAN)
                .Include(a => a.CANConfigExd)
                .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))//,then=> then.Include(b=>b.LogicRule)
                .ToList();

            ListCanLinConfigPro = new ObservableCollection<CanLinConfigPro>(canLinConfigPros);
            if (SelectCanLinConfigPro != null)
            {
                SelectCanLinConfigPro = canLinConfigPros.Where(a => a.Id == SelectCanLinConfigPro.Id).FirstOrDefault()!;
                //无数据就返回
                if (SelectCanLinConfigPro == null) return;

                SelectedCANConfigExdDto = Mapper.Map<CANConfigExdDto>(SelectCanLinConfigPro!.CANConfigExd);

                //配置信息
                var WirteData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Write).ToList();
                if (WirteData != null && WirteData.Count > 0)
                {
                    ListWriteCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(WirteData));

                    //加载把当前的配置信息给指令
                    CanDriveService.CmdData.Clear();
                    foreach (var item in WirteData)
                    {
                        CanDriveService.AddCmdData(new CanCmdData()
                        {
                            ConfigName = item.Name,
                            MsgName = item.MsgFrameName,
                            SignalName = item.SignalName,
                            SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
                            LogicRuleDto = Mapper.Map<LogicRuleDto>(item.LogicRule),
                        });

                        //CanDriveService.CmdData.Add(new CanCmdData()
                        //{
                        //    ConfigName = item.Name,
                        //    MsgName = item.MsgFrameName,
                        //    SignalName = item.SignalName,
                        //    SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
                        //});
                    }
                }
                var ReadData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Read).ToList();
                if (ReadData != null && ReadData.Count > 0)
                {
                    ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(ReadData));
                }

                //匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListCanDbcModel
                MatchSeletedAndCanDbcModel();
            }
        }

        /// <summary>
        /// 匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListCanDbcModel
        /// 为了标注和着色使用
        /// </summary>
        private void MatchSeletedAndCanDbcModel()
        {
            //通过CanLinConfigContents标注ListCanDbcModel的选中状态属性,方便着色
            if (ListCanDbcModel != null && ListCanDbcModel!.Count() > 0 && SelectCanLinConfigPro.CanLinConfigContents != null && SelectCanLinConfigPro.CanLinConfigContents.Count() > 0)
            {
                foreach (var itemCanDbcModel in ListCanDbcModel)
                {
                    var FindData = SelectCanLinConfigPro.CanLinConfigContents.FindFirst(a => a.SignalName == itemCanDbcModel.SignalName);
                    if (FindData != null)//找到了就标注
                    {
                        switch (FindData.RWInfo)
                        {
                            case RW.Write:
                                itemCanDbcModel.IsSeletedInfo = 1;
                                break;
                            case RW.Read:
                                itemCanDbcModel.IsSeletedInfo = 2;
                                break;
                            default:
                                break;
                        }
                    }
                    else
                    {
                        //没有找到了就标注为0
                        itemCanDbcModel.IsSeletedInfo = 0;
                    }
                }
            }
        }



        private bool _IsCanConfigProActive = false;
        /// <summary>
        /// CAN 配置是否被激活
        /// </summary>
        public bool IsCanConfigProActive
        {
            get { return _IsCanConfigProActive; }
            set { _IsCanConfigProActive = value; RaisePropertyChanged(); }
        }

        private bool _IsCANConfigDatagridActive = true;
        /// <summary>
        /// CANConfigDatagrid是否被触控
        /// 关联IsCanConfigProActive 取反
        /// </summary>
        public bool IsCANConfigDatagridActive
        {
            get { return _IsCANConfigDatagridActive; }
            set { _IsCANConfigDatagridActive = value; RaisePropertyChanged(); }
        }

        private string _SelectCanLinConfigProConfigName;
        /// <summary>
        /// 选中的 CanLinConfigPro 名称
        /// </summary>
        public string SelectCanLinConfigProConfigName
        {
            get { return _SelectCanLinConfigProConfigName; }
            set { _SelectCanLinConfigProConfigName = value; RaisePropertyChanged(); }
        }


        private DelegateCommand<string> _CanLinConfigPromdCmd;
        /// <summary>
        /// CanConfigPro操作的指令
        /// </summary>
        public DelegateCommand<string> CanLinConfigPromdCmd
        {
            set
            {
                _CanLinConfigPromdCmd = value;
            }
            get
            {
                if (_CanLinConfigPromdCmd == null)
                {
                    _CanLinConfigPromdCmd = new DelegateCommand<string>((Par) => CanLinConfigPromdCmdMethod(Par));
                }
                return _CanLinConfigPromdCmd;
            }
        }
        /// <summary>
        /// CanConfigPro操作的指令方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void CanLinConfigPromdCmdMethod(string Par)
        {
            switch (Par)
            {
                case "Add":
                    //弹窗
                    DialogService.ShowDialog("DialogCanLinConfigCreateView", new DialogParameters() { { "Name", "" } }, (par) =>
                    {
                        if (par.Result == ButtonResult.OK)
                        {
                            //程序名称
                            var ReturnValue = par.Parameters.GetValue<string>("Name");

                            //加载默认的数据 CANConfigExd
                            var InsertCANConfigExd = FreeSql.Insert<CANConfigExd>(new CANConfigExd()
                            {
                                BaudRate = 250,
                                DbcPath = "请配置DBC路径",
                                Cycle = 100,
                            }).ExecuteInserted();

                            //返回数据，刷新Chart
                            var InsertData = FreeSql.Insert<CanLinConfigPro>(new CanLinConfigPro()
                            {
                                ConfigName = ReturnValue,
                                CANLINInfo = CANLIN.CAN,
                                CANConfigExdId = InsertCANConfigExd.FirstOrDefault()!.Id
                            }).ExecuteInserted();
                            if (InsertData != null)
                            {
                                //加载默认的数据 CanLinRWConfig
                                FreeSql.Insert<CanLinRWConfig>(new CanLinRWConfig()
                                {
                                    SignalName = "Speed",
                                    DefautValue = "0",
                                    Name = "转速",
                                    RWInfo = RW.Write,
                                    CanLinConfigProId = InsertData.FirstOrDefault().Id
                                }).ExecuteInserted();

                                FreeSql.Insert<CanLinRWConfig>(new CanLinRWConfig()
                                {
                                    SignalName = "Vol",
                                    DefautValue = "0",
                                    Name = "电压",
                                    RWInfo = RW.Read,
                                    CanLinConfigProId = InsertData.FirstOrDefault().Id

                                }).ExecuteInserted();
                            }

                            InitLoadCanConfigPro();

                            SelectCanLinConfigPro = canLinConfigPros!.Find(a => a.Id == InsertData.FirstOrDefault()!.Id);
                        }
                        else if (par.Result == ButtonResult.Cancel)
                        {
                            //取消

                        }

                    });

                    break;
                case "Edit":
                    if (SelectCanLinConfigPro != null)
                    {
                        //弹窗
                        DialogService.ShowDialog("DialogCanLinConfigCreateView", new DialogParameters() { { "Name", SelectCanLinConfigPro.ConfigName } }, (par) =>
                        {
                            if (par.Result == ButtonResult.OK)
                            {
                                //程序名称
                                var ReturnValue = par.Parameters.GetValue<string>("Name");

                                FreeSql.Update<CanLinConfigPro>()
                                .Set(a => a.ConfigName, ReturnValue)
                                .Where(a => a.Id == SelectCanLinConfigPro.Id)
                                .ExecuteAffrows();

                                InitLoadCanConfigPro();

                                SelectCanLinConfigPro = null;
                            }
                            else if (par.Result == ButtonResult.Cancel)
                            {
                                //取消

                            }

                        });
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("选中后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }
                    break;

                case "Save":

                case "Delete":
                    if (SelectCanLinConfigPro != null)
                    {
                        var repo = FreeSql.GetRepository<CanLinConfigPro>();
                        repo.DbContextOptions.EnableCascadeSave = true; //关键设置

                        var DeleteData = repo.Select
                             .Include(a => a.CANConfigExd)
                             .IncludeMany(a => a.CanLinConfigContents)
                             .Where(a => a.Id == SelectCanLinConfigPro.Id)
                             .ToList();

                        repo.Delete(DeleteData);
                        foreach (var item in DeleteData)
                        {
                            FreeSql.Delete<CANConfigExd>(item.CANConfigExdId).ExecuteAffrows();
                        }
                        InitLoadCanConfigPro();
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("选中后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }
                    break;
                case "Active":

                    //激活到取消的状态的判断
                    if (IsCanConfigProActive == true)
                    {
                        //控件的激活
                        IsCanConfigProActive = !IsCanConfigProActive;
                        //控件的激活配置信息
                        IsCANConfigDatagridActive = !IsCanConfigProActive;

                        return;
                    }

                    if ((CanDriveService.ToomossCanDrive.OpenState == true && CanDriveService.ToomossCanDrive.DbcParserState == true))
                    {
                        if (SelectCanLinConfigPro != null)
                        {
                            //控件的激活
                            IsCanConfigProActive = !IsCanConfigProActive;
                            //控件的激活配置信息
                            IsCANConfigDatagridActive = !IsCanConfigProActive;

                            //当前使用的CAN 配置信息
                            CanDriveService.InitCanConfig(SelectCanLinConfigPro);

                            InitLoadCanConfigPro();
                        }
                        else
                        {
                            System.Windows.MessageBox.Show("选中后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                        }

                    }
                    else
                    {
                        System.Windows.MessageBox.Show("请确保CAN连接打开和Dbc解析成功后再激活", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// CAN List集合信息
        /// </summary>
        private List<CanLinConfigPro> canLinConfigPros = new List<CanLinConfigPro>();


        private ObservableCollection<CanLinConfigPro> _ListCanLinConfigPro;
        /// <summary>
        /// CAN 配置程序集合 ObservableCollection
        /// </summary>
        public ObservableCollection<CanLinConfigPro> ListCanLinConfigPro
        {
            get { return _ListCanLinConfigPro; }
            set { _ListCanLinConfigPro = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 选中的CanLinConfigPro
        /// </summary>
        public CanLinConfigPro SelectCanLinConfigPro { get; set; }

        private DelegateCommand<object> _CanConfigProGridSelectionChangedCmd;
        /// <summary>
        /// CAN 配置程序 选中行数据命令
        /// </summary>
        public DelegateCommand<object> CanConfigProGridSelectionChangedCmd
        {
            set
            {
                _CanConfigProGridSelectionChangedCmd = value;
            }
            get
            {
                if (_CanConfigProGridSelectionChangedCmd == null)
                {
                    _CanConfigProGridSelectionChangedCmd = new DelegateCommand<object>((par) => CanConfigProGridSelectionChangedCmdMethod(par));
                }
                return _CanConfigProGridSelectionChangedCmd;
            }
        }
        private void CanConfigProGridSelectionChangedCmdMethod(object par)
        {
            if (par == null)
            {
                return;
            }
            if (par is SelectionChangedEventArgs)
            {
                return;
            }

            if (par is CanLinConfigPro)
            {
                SelectCanLinConfigPro = par as CanLinConfigPro;

                //CANConfigExdDto 数据
                SelectedCANConfigExdDto = Mapper.Map<CANConfigExdDto>(SelectCanLinConfigPro!.CANConfigExd);

                var WirteData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Write).ToList();
                if (WirteData != null && WirteData.Count > 0)
                {
                    ListWriteCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(WirteData));

                    //加载把当前的配置信息给指令
                    CanDriveService.CmdData.Clear();
                    foreach (var item in WirteData)
                    {
                        CanDriveService.AddCmdData(new CanCmdData()
                        {
                            ConfigName = item.Name,
                            MsgName = item.MsgFrameName,
                            SignalName = item.SignalName,
                            SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
                        });

                        //CanDriveService.CmdData.Add(new CanCmdData()
                        //{
                        //    ConfigName = item.Name,
                        //    MsgName = item.MsgFrameName,
                        //    SignalName = item.SignalName,
                        //    SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
                        //});
                    }

                }
                var ReadData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Read).ToList();
                if (ReadData != null && ReadData.Count > 0)
                {
                    ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(ReadData));
                }

                SelectCanLinConfigProConfigName = SelectCanLinConfigPro.ConfigName;

                return;
            }
            //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
            var Selecteddata = (par as SelectionChangedEventArgs)!.AddedItems[0] as CanLinConfigPro;

            if (Selecteddata != null)
            {
                SelectCanLinConfigPro = Selecteddata;

                SelectCanLinConfigProConfigName = SelectCanLinConfigPro.ConfigName;

            }


        }


        private DelegateCommand<object> _CanConfigProGridPreviewMouseLeftButtonDownCmd;
        /// <summary>
        /// CAN 配置程序 选中行之前的数据命令 Preview
        /// 防止CAN 打开后没有关闭就开始切换CAN 配置程序信息
        /// 要关闭后再切换
        /// </summary>
        public DelegateCommand<object> CanConfigProGridPreviewMouseLeftButtonDownCmd
        {
            set
            {
                _CanConfigProGridPreviewMouseLeftButtonDownCmd = value;
            }
            get
            {
                if (_CanConfigProGridPreviewMouseLeftButtonDownCmd == null)
                {
                    _CanConfigProGridPreviewMouseLeftButtonDownCmd = new DelegateCommand<object>((par) => CanConfigProGridPreviewMouseLeftButtonDownCmdMethod(par));
                }
                return _CanConfigProGridPreviewMouseLeftButtonDownCmd;
            }
        }
        /// <summary>
        /// 防止CAN 打开后没有关闭就开始切换CAN 配置程序信息
        /// 要关闭后再切换
        /// </summary>
        /// <param name="par"></param>
        private void CanConfigProGridPreviewMouseLeftButtonDownCmdMethod(object par)
        {
            if (par == null)
            {
                return;
            }
            if (par is System.Windows.Input.MouseButtonEventArgs)
            {
                var handler = par as System.Windows.Input.MouseButtonEventArgs;

                if (!CanDriveService.ToomossCanDrive.OpenState)
                {
                    // 防止默认的行选择行为发生
                    handler.Handled = false;
                }
                else
                {
                    System.Windows.MessageBox.Show("关闭CAN连接后再点击切换CAN配置", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    handler.Handled = true;
                }
            }
        }


        #endregion

        #region Dbc操作

        private ObservableCollection<CanDbcModel> _ListCanDbcModel;
        /// <summary>
        /// Dbc消息集合
        /// </summary>
        public ObservableCollection<CanDbcModel> ListCanDbcModel
        {
            get { return _ListCanDbcModel; }
            set { _ListCanDbcModel = value; RaisePropertyChanged(); }
        }

        //private string _DbcFilePath;
        ///// <summary>
        ///// Dbc文件路径
        ///// </summary>
        //public string DbcFilePath
        //{
        //    get { return _DbcFilePath; }
        //    set { _DbcFilePath = value; RaisePropertyChanged(); }
        //}


        private DelegateCommand _LoadDbcCmd;
        /// <summary>
        /// 下载Dbc文件指令
        /// </summary>
        public DelegateCommand LoadDbcCmd
        {
            set
            {
                _LoadDbcCmd = value;
            }
            get
            {
                if (_LoadDbcCmd == null)
                {
                    _LoadDbcCmd = new DelegateCommand(() => LoadDbcCmdMethod());
                }
                return _LoadDbcCmd;
            }
        }
        /// <summary>
        /// 加载Dbc文件信息
        /// </summary>
        private void LoadDbcCmdMethod()
        {
            //DbcFilePath
            try
            {
                //var dd = ListQuickMeterStepDto;

                if (SelectCanLinConfigPro != null && SelectedCANConfigExdDto != null)
                {
                    OpenFileDialog OpenFileDialogInfo = new OpenFileDialog(); //new一个方法
                    OpenFileDialogInfo.Filter = "(*.dbc;*.dbc)|*.dbc;*.dbc|all|*.*"; //删选、设定文件显示类型
                    OpenFileDialogInfo.CheckFileExists = true;
                    OpenFileDialogInfo.CheckPathExists = true;

                    OpenFileDialogInfo.ShowDialog(); //显示打开文件的窗口
                    string fileName = OpenFileDialogInfo.FileName; //获得选择的文件路径

                    SelectedCANConfigExdDto.DbcPath = fileName;
                }
                else
                {
                    System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                }




                //System.Diagnostics.Process.Start(fileName);//打开指定路径下的文件
            }
            catch (Exception ex)
            {
                System.Windows.MessageBox.Show("可能未选择信息", "提示", System.Windows.MessageBoxButton.OKCancel, System.Windows.MessageBoxImage.Hand);
            }
        }


        /// <summary>
        /// 选中的CanDbcModel
        /// </summary>
        public CanDbcModel SelectedCanDbcModel { get; set; }

        private DelegateCommand<object> _DbcGridSelectionChangedCmd;
        /// <summary>
        /// Dbc选中行数据命令
        /// </summary>
        public DelegateCommand<object> DbcGridSelectionChangedCmd
        {
            set
            {
                _DbcGridSelectionChangedCmd = value;
            }
            get
            {
                if (_DbcGridSelectionChangedCmd == null)
                {
                    _DbcGridSelectionChangedCmd = new DelegateCommand<object>((par) => DbcGridSelectionChangedCmdMethod(par));
                }
                return _DbcGridSelectionChangedCmd;
            }
        }
        private void DbcGridSelectionChangedCmdMethod(object par)
        {
            if (par == null)
            {
                return;
            }
            if (par is CanDbcModel)
            {
                SelectedCanDbcModel = par as CanDbcModel;
                return;
            }

            //(par as SelectionChangedEventArgs)!.AddedItems[0] == null
            if ((par as SelectionChangedEventArgs)!.AddedItems.Count == 0)
            {
                return;
            }
            //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
            var Selecteddata = (par as SelectionChangedEventArgs)!.AddedItems[0] as CanDbcModel;

            if (Selecteddata != null)
            {
                SelectedCanDbcModel = Selecteddata;

            }
        }


        private DelegateCommand<string> _DataGridMenuCmd;
        /// <summary>
        /// DataGridMenu 操作的指令
        /// </summary>
        public DelegateCommand<string> DataGridMenuCmd
        {
            set
            {
                _DataGridMenuCmd = value;
            }
            get
            {
                if (_DataGridMenuCmd == null)
                {
                    _DataGridMenuCmd = new DelegateCommand<string>((Par) => DataGridMenuCmdMethod(Par));
                }
                return _DataGridMenuCmd;
            }
        }
        /// <summary>
        /// DataGridMenu 操作的指令
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void DataGridMenuCmdMethod(string Par)
        {
            switch (Par)
            {
                case "Write":
                    if (SelectedCanDbcModel != null && SelectCanLinConfigPro != null)
                    {
                        FreeSql.Insert<CanLinRWConfig>(new CanLinRWConfig()
                        {
                            Name = "",
                            SignalName = SelectedCanDbcModel.SignalName,
                            MsgFrameName = SelectedCanDbcModel.MsgName,
                            CanLinConfigProId = SelectCanLinConfigPro.Id,
                            DefautValue = "",
                            RWInfo = RW.Write,
                        }).ExecuteInserted();

                        InitLoadCanConfigPro();
                    }
                    break;
                case "Read":
                    if (SelectedCanDbcModel != null && SelectCanLinConfigPro != null)
                    {
                        FreeSql.Insert<CanLinRWConfig>(new CanLinRWConfig()
                        {
                            Name = "",
                            SignalName = SelectedCanDbcModel.SignalName,
                            MsgFrameName = SelectedCanDbcModel.MsgName,
                            CanLinConfigProId = SelectCanLinConfigPro.Id,
                            DefautValue = "",
                            RWInfo = RW.Read,
                        }).ExecuteInserted();

                        InitLoadCanConfigPro();
                    }
                    break;
                default:
                    break;
            }
        }



        #endregion

        #region CAN操作 

        private CANConfigExdDto _SelectedCANConfigExdDto;
        /// <summary>
        /// 选中的CAN操作
        /// </summary>
        public CANConfigExdDto SelectedCANConfigExdDto
        {
            get { return _SelectedCANConfigExdDto; }
            set { _SelectedCANConfigExdDto = value; RaisePropertyChanged(); }
        }

        private DelegateCommand<string> _CanOpCmd;
        /// <summary>
        /// CAN操作的指令
        /// </summary>
        public DelegateCommand<string> CanOpCmd
        {
            set
            {
                _CanOpCmd = value;
            }
            get
            {
                if (_CanOpCmd == null)
                {
                    _CanOpCmd = new DelegateCommand<string>((Par) => CanOpCmdMethod(Par));
                }
                return _CanOpCmd;
            }
        }
        /// <summary>
        /// CAN操作的指令方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void CanOpCmdMethod(string Par)
        {
            switch (Par)
            {
                case "Open":
                    if (ComActionService.IsCanToDoWork() == false)
                    {
                        System.Windows.MessageBox.Show("请关闭LIN连接后才能开启CAN，同一个时刻只能有一个通信驱动压缩机", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                        return;
                    }
                    if (SelectCanLinConfigPro != null && SelectedCANConfigExdDto != null)
                    {
                        //打开连接
                        CanDriveService.ToomossCanDrive.StartCanDrive();
                        //成功后状态显示
                        if (CanDriveService.ToomossCanDrive.OpenState)
                        {
                            //系统使用了CAN
                            ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = CanLinEnum.Can;
                        }

                        //CAN DBC配置 有DBC配置的话，则直接加载DBC信息
                        if (!string.IsNullOrEmpty(SelectCanLinConfigPro.CANConfigExd.DbcPath))
                        {
                            var DbcData = CanDriveService.StartDbc(SelectedCANConfigExdDto.DbcPath);
                            ListCanDbcModel = DbcData;

                            //ListCanDbcModel有数据后就要看看是否有配置信息，有的话就要标注
                            //匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListCanDbcModel
                            MatchSeletedAndCanDbcModel();

                        }

                    }
                    else
                    {
                        System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }

                    break;
                case "Close":
                    if (SelectCanLinConfigPro != null && SelectedCANConfigExdDto != null)
                    {

                        CanDriveService.ToomossCanDrive.CloseDevice();
                        //系统取消使用了CAN
                        ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = CanLinEnum.No;
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }

                    break;
                case "Save":
                    if (SelectCanLinConfigPro != null && SelectedCANConfigExdDto != null)
                    {
                        //保存Can 配置
                        if (!string.IsNullOrEmpty(SelectedCANConfigExdDto.DbcPath))
                        {
                            var Update = FreeSql.Update<CANConfigExd>()
                             .Set(a => a.DbcPath, SelectedCANConfigExdDto.DbcPath)
                             .Set(a => a.Cycle, SelectedCANConfigExdDto.Cycle)
                             .Set(a => a.BaudRate, SelectedCANConfigExdDto.BaudRate)
                             .Where(a => a.Id == SelectedCANConfigExdDto.Id)
                             .ExecuteUpdated();
                        }

                        InitLoadCanConfigPro();
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }

                    break;
                case "Parse":
                    if (SelectCanLinConfigPro != null && SelectedCANConfigExdDto != null)
                    {
                        //打开之后连接
                        if (CanDriveService.ToomossCanDrive.OpenState)
                        {
                            //CAN DBC配置 有DBC配置的话，则加载DBC信息
                            if (!string.IsNullOrEmpty(SelectedCANConfigExdDto.DbcPath))
                            {
                                var DbcData = CanDriveService.StartDbc(SelectedCANConfigExdDto.DbcPath);

                                ListCanDbcModel = DbcData;
                            }
                            else
                            {
                                System.Windows.MessageBox.Show("请选择DBC文件后再操作", "提示", System.Windows.MessageBoxButton.OKCancel, System.Windows.MessageBoxImage.Hand);
                            }
                        }
                        //    ListCanDbcModel = new ObservableCollection<CanDbcModel>()
                        //{
                        //    new CanDbcModel(){ MsgName="DSDF1",SignalName="FASDFA11",Publisher="DFAD1",SignalDesc="ASDFASD1"},
                        //    new CanDbcModel(){ MsgName="DSDF2",SignalName="FASDFA22",Publisher="DFAD2",SignalDesc="ASDFASD2"},
                        //    new CanDbcModel(){ MsgName="DSDF3",SignalName="FASDFA33",Publisher="DFAD3",SignalDesc="ASDFASD3"},
                        //    new CanDbcModel(){ MsgName="DSDF4",SignalName="FASDFA44",Publisher="DFAD4",SignalDesc="ASDFASD4"},
                        //    new CanDbcModel(){ MsgName="DSDF5",SignalName="FASDFA55",Publisher="DFAD5",SignalDesc="ASDFASD5"},
                        //};
                        //    return;

                    }
                    else
                    {
                        System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }

                    break;

                case "HandSend"://手动发送

                    //手动发送数据
                    CanDriveService.SendMsgToCanDrive(HandSpeed);

                    //CanDriveService.ToomossCanDrive.SendCanMsg(new List<CanCmdData>()
                    //{
                    //    new CanCmdData(){ MsgName="TX1",SignalName="COM_current_Power",SignalCmdValue=12},
                    //    new CanCmdData(){ MsgName="TX1",SignalName="COM_Curr_dc",SignalCmdValue=12},
                    //});

                    break;
                case "CycleSend"://循环发送你
                    //循环发送数据
                    CanDriveService.CycleSendMsg();

                    //Listen
                    break;
                case "CycleRecive":
                    CanDriveService.CycleReciveMsg();

                    //Listen
                    break;
                default:
                    break;
            }
        }


        private double _HandSpeed;
        /// <summary>
        /// 手动转速数据
        /// </summary>
        public double HandSpeed
        {
            get { return _HandSpeed; }
            set { _HandSpeed = value; RaisePropertyChanged(); }
        }


        #endregion


        #region 写入和读取操作

        private ObservableCollection<CbxItems> _WriteNameCbxItems;
        /// <summary>
        /// 写入的Name
        /// </summary>
        public ObservableCollection<CbxItems> WriteNameCbxItems
        {
            get { return _WriteNameCbxItems; }
            set { _WriteNameCbxItems = value; RaisePropertyChanged(); }
        }

        private ObservableCollection<CbxItems> _WriteRuleCbxItems;
        /// <summary>
        /// 写入的规格集合
        /// </summary>
        public ObservableCollection<CbxItems> WriteRuleCbxItems
        {
            get { return _WriteRuleCbxItems; }
            set { _WriteRuleCbxItems = value; RaisePropertyChanged(); }
        }


        private ObservableCollection<CbxItems> _ReadNameCbxItems;
        /// <summary>
        /// 写入的Name
        /// </summary>
        public ObservableCollection<CbxItems> ReadNameCbxItems
        {
            get { return _ReadNameCbxItems; }
            set { _ReadNameCbxItems = value; RaisePropertyChanged(); }
        }

        private ObservableCollection<CbxItems> _ReadRuleCbxItems;
        /// <summary>
        /// 读取的规格集合
        /// </summary>
        public ObservableCollection<CbxItems> ReadRuleCbxItems
        {
            get { return _ReadRuleCbxItems; }
            set { _ReadRuleCbxItems = value; RaisePropertyChanged(); }
        }

        //private string _SelectedWriteName;
        ///// <summary>
        ///// 选中的写入的Name
        ///// </summary>
        //public string SelectedWriteName
        //{
        //    get { return _SelectedWriteName; }
        //    set { _SelectedWriteName = value; RaisePropertyChanged(); }
        //}

        //private string _SelectedReadName;
        ///// <summary>
        ///// 选中的读取的Name
        ///// </summary>
        //public string SelectedReadName
        //{
        //    get { return _SelectedReadName; }
        //    set { _SelectedReadName = value; RaisePropertyChanged(); }
        //}


        private ObservableCollection<CanLinRWConfigDto> _ListWriteCanLinRWConfigDto;
        /// <summary>
        ///  CAN写入集合数据
        /// </summary>
        public ObservableCollection<CanLinRWConfigDto> ListWriteCanLinRWConfigDto
        {
            get { return _ListWriteCanLinRWConfigDto; }
            set { _ListWriteCanLinRWConfigDto = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 选中的CanLinRWConfigDto行 Write
        /// </summary>
        private CanLinRWConfigDto SelectedWriteCanLinRWConfigDto { get; set; }

        private DelegateCommand<object> _WriteGridSelectionChangedCmd;
        /// <summary>
        /// 写入CAN的选中行的命令
        /// </summary>
        public DelegateCommand<object> WriteGridSelectionChangedCmd
        {
            set
            {
                _WriteGridSelectionChangedCmd = value;
            }
            get
            {
                if (_WriteGridSelectionChangedCmd == null)
                {
                    _WriteGridSelectionChangedCmd = new DelegateCommand<object>((Par) => WriteGridSelectionChangedCmdMethod(Par));
                }
                return _WriteGridSelectionChangedCmd;
            }
        }
        /// <summary>
        /// 写入CAN的选中行执行方法
        /// </summary>
        /// <param name="par"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void WriteGridSelectionChangedCmdMethod(object par)
        {
            if (par is CanLinRWConfigDto)
            {
                SelectedWriteCanLinRWConfigDto = par as CanLinRWConfigDto;
            }
        }

        private DelegateCommand<string> _WriteCmd;
        /// <summary>
        /// 写入操作的指令
        /// </summary>
        public DelegateCommand<string> WriteCmd
        {
            set
            {
                _WriteCmd = value;
            }
            get
            {
                if (_WriteCmd == null)
                {
                    _WriteCmd = new DelegateCommand<string>((Par) => WriteCmdMethod(Par));
                }
                return _WriteCmd;
            }
        }
        /// <summary>
        /// 写入操作的指令方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void WriteCmdMethod(string Par)
        {
            if (SelectCanLinConfigPro == null)
            {
                System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                return;
            }
            if (CanDriveService.ToomossCanDrive.IsCycleSend)
            {
                System.Windows.MessageBox.Show("正在循环发送中，此时编辑可能会出现错误，请关闭循环发送后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                return;
            }

            switch (Par)
            {
                case "Add":
                    //由右侧的右键DBC目录增加

                    break;
                case "Edit":
                    if (ListWriteCanLinRWConfigDto != null && ListWriteCanLinRWConfigDto.Count() > 0)
                    {
                        foreach (var item in ListWriteCanLinRWConfigDto)
                        {
                            //直接修改
                            FreeSql.Update<CanLinRWConfig>(item.Id)
                                .Set(a => a.Name, item.Name)
                                .Set(a => a.LogicRuleId, item.LogicRuleId)
                                .Set(a => a.DefautValue, item.DefautValue)
                                .ExecuteAffrows();
                            //ListWriteCanLinRWConfigDto.Remove(SelectedWriteCanLinRWConfigDto);

                            //SelectedWriteCanLinRWConfigDto = null;

                        }

                        InitLoadCanConfigPro();
                    }



                    break;
                case "Delete":
                    if (SelectedWriteCanLinRWConfigDto != null)
                    {
                        //直接删除掉
                        FreeSql.Delete<CanLinRWConfig>(SelectedWriteCanLinRWConfigDto.Id).ExecuteAffrows();
                        ListWriteCanLinRWConfigDto.Remove(SelectedWriteCanLinRWConfigDto);

                        SelectedWriteCanLinRWConfigDto = null;

                        InitLoadCanConfigPro();
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("请选中后再进行【删除】操作？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }

                    break;
                default:
                    break;
            }
        }





        private ObservableCollection<CanLinRWConfigDto> _ListReadCanLinRWConfigDto;
        /// <summary>
        /// CAN读取集合数据
        /// </summary>
        public ObservableCollection<CanLinRWConfigDto> ListReadCanLinRWConfigDto
        {
            get { return _ListReadCanLinRWConfigDto; }
            set { _ListReadCanLinRWConfigDto = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 选中的CanLinRWConfigDto行 Read
        /// </summary>
        private CanLinRWConfigDto SelectedReadCanLinRWConfigDto { get; set; }

        private DelegateCommand<object> _ReadGridSelectionChangedCmd;
        /// <summary>
        /// 写入CAN的选中行的命令
        /// </summary>
        public DelegateCommand<object> ReadGridSelectionChangedCmd
        {
            set
            {
                _ReadGridSelectionChangedCmd = value;
            }
            get
            {
                if (_ReadGridSelectionChangedCmd == null)
                {
                    _ReadGridSelectionChangedCmd = new DelegateCommand<object>((Par) => ReadGridSelectionChangedCmdMethod(Par));
                }
                return _ReadGridSelectionChangedCmd;
            }
        }
        /// <summary>
        /// 读取CAN的选中行执行方法
        /// </summary>
        /// <param name="par"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void ReadGridSelectionChangedCmdMethod(object par)
        {
            if (par is CanLinRWConfigDto)
            {
                SelectedReadCanLinRWConfigDto = par as CanLinRWConfigDto;
            }
        }



        private DelegateCommand<string> _ReadCmd;
        /// <summary>
        /// 读取操作的指令
        /// </summary>
        public DelegateCommand<string> ReadCmd
        {
            set
            {
                _ReadCmd = value;
            }
            get
            {
                if (_ReadCmd == null)
                {
                    _ReadCmd = new DelegateCommand<string>((Par) => ReadCmdMethod(Par));
                }
                return _ReadCmd;
            }
        }
        /// <summary>
        /// 读取操作的指令方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void ReadCmdMethod(string Par)
        {
            if (SelectCanLinConfigPro == null)
            {
                System.Windows.MessageBox.Show("选中CAN配置名称后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                return;
            }
            if (CanDriveService.ToomossCanDrive.IsCycleRevice)
            {
                System.Windows.MessageBox.Show("正在循环接受中，此时编辑可能会出现错误，请关闭循环发送后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                return;
            }

            switch (Par)
            {
                case "Add":
                    //由右侧的右键DBC目录增加

                    break;
                case "Edit":
                    if (ListReadCanLinRWConfigDto != null && ListReadCanLinRWConfigDto.Count() > 0)
                    {
                        foreach (var item in ListReadCanLinRWConfigDto)
                        {
                            //直接修改
                            FreeSql.Update<CanLinRWConfig>(item.Id)
                                .Set(a => a.Name, item.Name)
                                .Set(a => a.DefautValue, item.DefautValue)
                                .ExecuteAffrows();
                            //ListReadCanLinRWConfigDto.Remove(SelectedReadCanLinRWConfigDto);

                            //SelectedReadCanLinRWConfigDto = null;

                        }

                        InitLoadCanConfigPro();
                    }



                    break;
                case "Delete":
                    if (SelectedReadCanLinRWConfigDto != null)
                    {
                        //直接删除掉
                        FreeSql.Delete<CanLinRWConfig>(SelectedReadCanLinRWConfigDto.Id).ExecuteAffrows();
                        ListReadCanLinRWConfigDto.Remove(SelectedReadCanLinRWConfigDto);

                        SelectedReadCanLinRWConfigDto = null;

                        InitLoadCanConfigPro();
                    }
                    else
                    {
                        System.Windows.MessageBox.Show("请选中后再进行【删除】操作？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                    }

                    break;
                default:
                    break;
            }
        }

        #endregion
    }
}