using CapMachine.Core;
using CapMachine.Model;
using Prism.Commands;
using Prism.Services.Dialogs;
using System.Collections.ObjectModel;
using System.Text;
using System.Windows;

namespace CapMachine.Wpf.ViewModels
{
    public class ProConfigViewModel : NavigationViewModel
    {
        public ProConfigViewModel(IDialogService dialogService, IFreeSql freeSql)
        {
            //LogService = logService;
            FreeSql = freeSql;
            //MachineDataService = machineDataService;
            DialogService = dialogService;

            ListMeterSpeedItems = new ObservableCollection<MeterSpeed>();
            ListMeterPsItems = new ObservableCollection<MeterPs>();

            ListProStepDtoItems = new ObservableCollection<ProStepDto>();
            ListProStep = new List<ProStep>();

            ProSegListViewItems = new ObservableCollection<ProgramSeg>();
            RefreshProSeg();

            //各个单独仪表的初始化
            SelectedMeterSpeed = new MeterSpeed();
            SelectedPs = new MeterPs();
        }

        /// <summary>
        /// FreeSQL 实例函数
        /// </summary>
        public IFreeSql FreeSql { get; }

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



        #region 速度表操作

        private ObservableCollection<MeterSpeed> _ListMeterSpeedItems;
        /// <summary>
        /// MeterSpeedp数据集合
        /// </summary>
        public ObservableCollection<MeterSpeed> ListMeterSpeedItems
        {
            get { return _ListMeterSpeedItems; }
            set { _ListMeterSpeedItems = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// MeterSpeed集合数据
        /// </summary>
        public List<MeterSpeed> ListMeterSpeed { get; set; }

        private MeterSpeed _SelectedMeterSpeed;
        /// <summary>
        /// 当前选中的程序速度
        /// </summary>
        public MeterSpeed SelectedMeterSpeed
        {
            get { return _SelectedMeterSpeed; }
            set { _SelectedMeterSpeed = value; RaisePropertyChanged(); }
        }




        private DelegateCommand<object> _MeterSpeedSelectedChangedCmd;
        /// <summary>
        /// 刷新数据命令
        /// </summary>
        public DelegateCommand<object> MeterSpeedSelectedChangedCmd
        {
            set
            {
                _MeterSpeedSelectedChangedCmd = value;
            }
            get
            {
                if (_MeterSpeedSelectedChangedCmd == null)
                {
                    _MeterSpeedSelectedChangedCmd = new DelegateCommand<object>((str) => MeterSpeedSelectedChangedCmdMethod(str));
                }
                return _MeterSpeedSelectedChangedCmd;
            }
        }


        /// <summary>
        /// 速度表选中行的执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void MeterSpeedSelectedChangedCmdMethod(object par)
        {
            var SelectedData = par as MeterSpeed;
            if (SelectedData != null)
            {
                SelectedMeterSpeed = SelectedData;
            }

        }



        private DelegateCommand _ProStepSpeedAddCmd;
        /// <summary>
        /// 新增速度命令
        /// </summary>
        public DelegateCommand ProStepSpeedAddCmd
        {
            set
            {
                _ProStepSpeedAddCmd = value;
            }
            get
            {
                if (_ProStepSpeedAddCmd == null)
                {
                    _ProStepSpeedAddCmd = new DelegateCommand(() => ProStepSpeedAddCmdMethod());
                }
                return _ProStepSpeedAddCmd;
            }
        }

        /// <summary>
        /// 新增速度命令执行方法
        /// </summary>
        private void ProStepSpeedAddCmdMethod()
        {
            if (SelectedProStepDto == null)
            {
                MessageBox.Show("未发现选中要操作的数据！", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
                return;
            }

            //当前的速度表集合数据
            var MeterSpeeds = ListMeterSpeedItems.ToList();

            var MeterSpeedData = new MeterSpeed()
            {
                StartValue = SelectedMeterSpeed.StartValue,
                EndValue = SelectedMeterSpeed.EndValue,
                KeepTime = SelectedMeterSpeed.KeepTime,
                ProStepId = SelectedProStepDto.Id,
                StepNo = AutoGetMeterSpeedStepNo(),
            };

            //增加数据
            var getdata = FreeSql.Insert<MeterSpeed>(MeterSpeedData).ExecuteIdentity();

            //更新界面数据
            ListProgramSeg = RefreshProSeg();
            RefreshProStepData();
            RefreshMeterSpeed();
        }


        private DelegateCommand _ProStepSpeedEditCmd;
        /// <summary>
        /// 修改速度命令
        /// </summary>
        public DelegateCommand ProStepSpeedEditCmd
        {
            set
            {
                _ProStepSpeedEditCmd = value;
            }
            get
            {
                if (_ProStepSpeedEditCmd == null)
                {
                    _ProStepSpeedEditCmd = new DelegateCommand(() => ProStepSpeedEditCmdMethod());
                }
                return _ProStepSpeedEditCmd;
            }
        }

        /// <summary>
        /// 新增速度命令执行方法
        /// </summary>
        private void ProStepSpeedEditCmdMethod()
        {
            if (SelectedProStepDto == null || SelectedMeterSpeed == null)
            {
                MessageBox.Show("未发现选中要操作的数据！", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
                return;
            }

            FreeSql.Update<MeterSpeed>()
                .Set(a => a.StartValue, SelectedMeterSpeed.StartValue)
                .Set(a => a.EndValue, SelectedMeterSpeed.EndValue)
                .Set(a => a.KeepTime, SelectedMeterSpeed.KeepTime)
                .Where(a => a.Id == SelectedMeterSpeed.Id)
                .ExecuteAffrows();

            //更新界面数据
            ListProgramSeg = RefreshProSeg();
            RefreshProStepData();
            RefreshMeterSpeed();
        }


        private DelegateCommand _ProStepSpeedDeleteCmd;
        /// <summary>
        /// 修改速度命令
        /// </summary>
        public DelegateCommand ProStepSpeedDeleteCmd
        {
            set
            {
                _ProStepSpeedDeleteCmd = value;
            }
            get
            {
                if (_ProStepSpeedDeleteCmd == null)
                {
                    _ProStepSpeedDeleteCmd = new DelegateCommand(() => ProStepSpeedDeleteCmdMethod());
                }
                return _ProStepSpeedDeleteCmd;
            }
        }

        /// <summary>
        /// 删除速度命令执行方法
        /// </summary>
        private void ProStepSpeedDeleteCmdMethod()
        {
            if (SelectedProStepDto != null || SelectedMeterSpeed.Id != 0)
            {
                MessageBoxResult dialogResult = MessageBox.Show("你确定要删除当前的数据吗？", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand);
                if (dialogResult == MessageBoxResult.OK)
                {
                    FreeSql.Delete<MeterSpeed>(SelectedMeterSpeed.Id).ExecuteAffrows();

                    //更新界面数据
                    ListProgramSeg = RefreshProSeg();
                    RefreshProStepData();
                    RefreshMeterSpeed();
                }

            }
            else
            {
                MessageBox.Show("未发现选中要删除的数据！", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
            }

        }






        /// <summary>
        /// 更新速度表信息
        /// </summary>
        private void RefreshMeterSpeed()
        {
            ListMeterSpeed = ListProgramSeg.Where(a => a.Id == SelectedProgramSeg.Id).FirstOrDefault()!.ProSteps!.Where(a => a.Id == SelectedProStepDto.Id)!
                .FirstOrDefault()!.MeterSpeeds!.ToList();

            ListMeterSpeedItems.Clear();

            ListMeterSpeedItems = new ObservableCollection<MeterSpeed>(ListMeterSpeed!);

        }

        #endregion

        #region Ps表

        private ObservableCollection<MeterPs> _ListMeterPsItems;
        /// <summary>
        /// Meter Ps数据集合
        /// </summary>
        public ObservableCollection<MeterPs> ListMeterPsItems
        {
            get { return _ListMeterPsItems; }
            set { _ListMeterPsItems = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// MeterSpeed集合数据
        /// </summary>
        public List<MeterPs> ListMeterPs { get; set; }


        private MeterPs _SelectedPs;
        /// <summary>
        /// 当前选中的程序速度 
        /// </summary>
        public MeterPs SelectedPs
        {
            get { return _SelectedPs; }
            set { _SelectedPs = value; RaisePropertyChanged(); }
        }

        private DelegateCommand<object> _MeterPsSelectedChangedCmd;
        /// <summary>
        /// 刷新数据命令
        /// </summary>
        public DelegateCommand<object> MeterPsSelectedChangedCmd
        {
            set
            {
                _MeterPsSelectedChangedCmd = value;
            }
            get
            {
                if (_MeterPsSelectedChangedCmd == null)
                {
                    _MeterPsSelectedChangedCmd = new DelegateCommand<object>((str) => MeterPsSelectedChangedCmdMethod(str));
                }
                return _MeterPsSelectedChangedCmd;
            }
        }


        /// <summary>
        /// 速度表选中行的执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void MeterPsSelectedChangedCmdMethod(object par)
        {
            var SelectedData = par as MeterPs;
            if (SelectedData != null)
            {
                SelectedPs = SelectedData;
            }
        }

        private DelegateCommand _ProStepPsAddCmd;
        /// <summary>
        /// 新增PS命令
        /// </summary>
        public DelegateCommand ProStepPsAddCmd
        {
            set
            {
                _ProStepPsAddCmd = value;
            }
            get
            {
                if (_ProStepPsAddCmd == null)
                {
                    _ProStepPsAddCmd = new DelegateCommand(() => ProStepPsAddCmdMethod());
                }
                return _ProStepPsAddCmd;
            }
        }

        /// <summary>
        /// 增加Ps命令执行方法
        /// </summary>
        private void ProStepPsAddCmdMethod()
        {
            if (SelectedProStepDto == null)
            {
                MessageBox.Show("未发现选中要操作的数据！", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
                return;
            }

            //当前的速度表集合数据
            var MeterPss = ListMeterPsItems.ToList();

            var MeterPsData = new MeterPs()
            {
                StartValue = SelectedPs.StartValue,
                EndValue = SelectedPs.EndValue,
                KeepTime = SelectedPs.KeepTime,
                ProStepId = SelectedProStepDto.Id,
                StepNo = AutoGetMeterPsStepNo(),
            };

            //增加数据
            var getdata = FreeSql.Insert<MeterPs>(MeterPsData).ExecuteIdentity();

            //更新界面数据
            ListProgramSeg = RefreshProSeg();
            RefreshProStepData();
            RefreshMeterPs();
        }


        private DelegateCommand _ProStepPsEditCmd;
        /// <summary>
        /// 新增PS命令
        /// </summary>
        public DelegateCommand ProStepPsEditCmd
        {
            set
            {
                _ProStepPsEditCmd = value;
            }
            get
            {
                if (_ProStepPsEditCmd == null)
                {
                    _ProStepPsEditCmd = new DelegateCommand(() => ProStepPsEditCmdMethod());
                }
                return _ProStepPsEditCmd;
            }
        }

        /// <summary>
        /// 编辑Ps命令执行方法
        /// </summary>
        private void ProStepPsEditCmdMethod()
        {
            if (SelectedProStepDto == null || SelectedPs == null)
            {
                MessageBox.Show("未发现选中要操作的数据！", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
                return;
            }

            FreeSql.Update<MeterPs>()
                .Set(a => a.StartValue, SelectedPs.StartValue)
                .Set(a => a.EndValue, SelectedPs.EndValue)
                .Set(a => a.KeepTime, SelectedPs.KeepTime)
                .Where(a => a.Id == SelectedPs.Id)
                .ExecuteAffrows();

            //更新界面数据
            ListProgramSeg = RefreshProSeg();
            RefreshProStepData();
            RefreshMeterPs();
        }

        private DelegateCommand _ProStepPsDeleteCmd;
        /// <summary>
        /// 新增PS命令
        /// </summary>
        public DelegateCommand ProStepPsDeleteCmd
        {
            set
            {
                _ProStepPsDeleteCmd = value;
            }
            get
            {
                if (_ProStepPsDeleteCmd == null)
                {
                    _ProStepPsDeleteCmd = new DelegateCommand(() => ProStepPsDeleteCmdMethod());
                }
                return _ProStepPsDeleteCmd;
            }
        }

        /// <summary>
        /// 增加Ps命令执行方法
        /// </summary>
        private void ProStepPsDeleteCmdMethod()
        {
            if (SelectedProStepDto != null || SelectedPs.Id != 0)
            {
                MessageBoxResult dialogResult = MessageBox.Show("你确定要删除当前的数据吗？", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand);
                if (dialogResult == MessageBoxResult.OK)
                {
                    FreeSql.Delete<MeterPs>(SelectedPs.Id).ExecuteAffrows();

                    //更新界面数据
                    ListProgramSeg = RefreshProSeg();
                    RefreshProStepData();
                    RefreshMeterPs();
                }

            }
            else
            {
                MessageBox.Show("未发现选中要删除的数据！", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
            }
        }



        /// <summary>
        /// 更新速度表信息
        /// </summary>
        private void RefreshMeterPs()
        {
            ListMeterPs = ListProgramSeg.Where(a => a.Id == SelectedProgramSeg.Id).FirstOrDefault()!.ProSteps!.Where(a => a.Id == SelectedProStepDto.Id)!
                .FirstOrDefault()!.MeterPss!.ToList();

            ListMeterPsItems.Clear();

            ListMeterPsItems = new ObservableCollection<MeterPs>(ListMeterPs!);



        }
        #endregion


        #region ProStep操作

        private int _ProStepCycleCount;
        /// <summary>
        /// ProStep 循环次数
        /// </summary>
        public int ProStepCycleCount
        {
            get { return _ProStepCycleCount; }
            set { _ProStepCycleCount = value; RaisePropertyChanged(); }
        }


        private ProStepDto _SelectedProStepDto;
        /// <summary>
        /// 当前选中的程序步骤
        /// </summary>
        public ProStepDto SelectedProStepDto
        {
            get { return _SelectedProStepDto; }
            set { _SelectedProStepDto = value; RaisePropertyChanged(); }
        }



        private ObservableCollection<ProStepDto> _ListProStepDtoItems;
        /// <summary>
        /// ProStep数据集合
        /// </summary>
        public ObservableCollection<ProStepDto> ListProStepDtoItems
        {
            get { return _ListProStepDtoItems; }
            set { _ListProStepDtoItems = value; RaisePropertyChanged(); }
        }

        private List<ProStep> _ListProStep;
        /// <summary>
        /// ProStep数据集合
        /// </summary>
        public List<ProStep> ListProStep
        {
            get { return _ListProStep; }
            set { _ListProStep = value; }
        }


        private string MeterSpeedToString(List<MeterSpeed> data)
        {
            var strInfo = new StringBuilder();
            var Count = data.Count;
            foreach (var item in data)
            {
                Count--;
                strInfo.Append(item.StartValue);
                strInfo.Append("-");
                strInfo.Append(item.EndValue);
                strInfo.Append("-");
                strInfo.Append(item.KeepTime);
                if (Count != 0)
                {
                    strInfo.Append(Environment.NewLine);
                }
            }

            return strInfo.ToString();
            //return @"&lt; ASDFA-ADFA-FASD-ADF "+ Environment.NewLine+" ASDFA-ADFA-FASD-ADF  &#x0A; ASDFA-ADFA-FASD-ADF  &#10;";

        }

        private DelegateCommand<object> _GridSelectionChangedCmd;
        /// <summary>
        /// 刷新数据命令
        /// </summary>
        public DelegateCommand<object> GridSelectionChangedCmd
        {
            set
            {
                _GridSelectionChangedCmd = value;
            }
            get
            {
                if (_GridSelectionChangedCmd == null)
                {
                    _GridSelectionChangedCmd = new DelegateCommand<object>((par) => GridSelectionChangedCmdMethod(par));
                }
                return _GridSelectionChangedCmd;
            }
        }


        private void GridSelectionChangedCmdMethod(object par)
        {
            //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
            var Selecteddata = par as ProStepDto;
            //SelectedProStepDto = par as ProStepDto;
            if (Selecteddata != null)
            {
                SelectedProStepDto = Selecteddata;
                ProStepCycleCount = SelectedProStepDto.StepRepeat;

                ListMeterSpeed = ListProStep.Where(a => a.Id == SelectedProStepDto.Id).FirstOrDefault()!.MeterSpeeds!.ToList();
                ListMeterPs = ListProStep.Where(a => a.Id == SelectedProStepDto.Id).FirstOrDefault()!.MeterPss!.ToList();

                ListMeterSpeedItems = new ObservableCollection<MeterSpeed>(ListMeterSpeed);
                ListMeterPsItems = new ObservableCollection<MeterPs>(ListMeterPs);
            }
        }



        private DelegateCommand _ProStepAddCmd;
        /// <summary>
        /// 新增命令
        /// </summary>
        public DelegateCommand ProStepAddCmd
        {
            set
            {
                _ProStepAddCmd = value;
            }
            get
            {
                if (_ProStepAddCmd == null)
                {
                    _ProStepAddCmd = new DelegateCommand(() => ProStepAddCmdMethod());
                }
                return _ProStepAddCmd;
            }
        }

        /// <summary>
        /// 新增命令执行方法
        /// </summary>
        private void ProStepAddCmdMethod()
        {
            //当前的速度表集合数据
            var MeterSpeeds = ListMeterSpeedItems.ToList();

            var NewData = new ProStep()
            {
                StepNo = AutoGetProStepNo(),
                StepRepeat = ProStepCycleCount,
                ProgramSegId = SelectedProgramSeg.Id,
                Remark = "",
            };

            var getdata = FreeSql.Insert<ProStep>(NewData).ExecuteIdentity();

            //var repo = FreeSql.GetRepository<ProStep>();
            //var getdata = repo.Insert(NewData);

            //更新Id
            foreach (var item in MeterSpeeds)
            {
                item.ProStepId = getdata;
            }

            NewData.MeterSpeeds = MeterSpeeds;
            //repo.SaveMany(NewData, "MeterSpeeds");

            FreeSql.Insert<MeterSpeed>(MeterSpeeds).ExecuteAffrows();

            //更新界面数据
            ListProgramSeg = RefreshProSeg();
            RefreshProStepData();
        }



        private DelegateCommand _ProStepEditCmd;
        /// <summary>
        /// 编辑命令
        /// </summary>
        public DelegateCommand ProStepEditCmd
        {
            set
            {
                _ProStepEditCmd = value;
            }
            get
            {
                if (_ProStepEditCmd == null)
                {
                    _ProStepEditCmd = new DelegateCommand(() => ProStepEditCmdMethod());
                }
                return _ProStepEditCmd;
            }
        }

        /// <summary>
        /// 编辑命令执行方法
        /// </summary>
        private void ProStepEditCmdMethod()
        {
            if (SelectedProStepDto == null)
            {
                MessageBox.Show("请选择后再进行编辑");
                return;
            }

            FreeSql.Update<ProStep>()
                .Set(a => a.StepRepeat, ProStepCycleCount)
                //.Set(a=>a.StepRepeat, ProStepCycleCount)
                .Where(a => a.Id == SelectedProStepDto.Id)
                .ExecuteAffrows();

            //更新界面数据
            ListProgramSeg = RefreshProSeg();
            RefreshProStepData();
        }

        private DelegateCommand _ProStepDeleteCmd;
        /// <summary>
        /// 删除命令
        /// </summary>
        public DelegateCommand ProStepDeleteCmd
        {
            set
            {
                _ProStepDeleteCmd = value;
            }
            get
            {
                if (_ProStepDeleteCmd == null)
                {
                    _ProStepDeleteCmd = new DelegateCommand(() => ProStepDeleteCmdMethod());
                }
                return _ProStepDeleteCmd;
            }
        }

        /// <summary>
        /// 删除命令执行方法
        /// </summary>
        private void ProStepDeleteCmdMethod()
        {
            if (SelectedProStepDto == null)
            {
                MessageBox.Show("请选择后再进行删除");
                return;
            }

            MessageBoxResult dialogResult = MessageBox.Show("你确定要删除当前的数据吗？", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand);
            if (dialogResult == MessageBoxResult.OK)
            {
                FreeSql.Delete<ProStep>()
                  .Where(a => a.Id == SelectedProStepDto.Id)
                  .ExecuteAffrows();

                //更新界面数据
                ListProgramSeg = RefreshProSeg();
                RefreshProStepData();
            }

        }



        private void RefreshProStepData()
        {
            ListProStep = ListProgramSeg.Where(a => a.Id == SelectedProgramSeg.Id).FirstOrDefault()!.ProSteps!.ToList();
            ListProStepDtoItems.Clear();
            foreach (var item in ListProStep)
            {
                ListProStepDtoItems.Add(new ProStepDto()
                {
                    Id = item.Id,
                    StepNo = item.StepNo,
                    StepRepeat = item.StepRepeat,
                    SpeedInfo = MeterSpeedToString(item.MeterSpeeds!.ToList())
                });
            }
        }

        #endregion



        //private ObservableCollection<ProStep> GetProStep(List<ProStep> data)
        //{

        //}

        #region ProgramSeg操作

        private DelegateCommand<object> _ProSelectedChangedCmd;
        /// <summary>
        /// 刷新数据命令
        /// </summary>
        public DelegateCommand<object> ProSelectedChangedCmd
        {
            set
            {
                _ProSelectedChangedCmd = value;
            }
            get
            {
                if (_ProSelectedChangedCmd == null)
                {
                    _ProSelectedChangedCmd = new DelegateCommand<object>((str) => ProListSelectionChangedCmdMethod(str));
                }
                return _ProSelectedChangedCmd;
            }
        }


        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void ProListSelectionChangedCmdMethod(object par)
        {
            var data = par as ProgramSeg;
            //如果不是ProgramSeg则退出，因为刷新数据源的时候，会触发这个选择器
            if (data == null) return;

            ListProStep = data!.ProSteps!.ToList();

            SelectedProgramSeg = data;

            ListProStepDtoItems.Clear();
            foreach (var item in ListProStep)
            {
                ListProStepDtoItems.Add(new ProStepDto()
                {
                    Id = item.Id,
                    StepNo = item.StepNo,
                    StepRepeat = item.StepRepeat,
                    SpeedInfo = MeterSpeedToString(item.MeterSpeeds!.ToList())
                });
            }
        }


        private ObservableCollection<ProgramSeg> _ProSegListViewItems;
        /// <summary>
        /// ProgramSeg 数据集合
        /// </summary>
        public ObservableCollection<ProgramSeg> ProSegListViewItems
        {
            get { return _ProSegListViewItems; }
            set { _ProSegListViewItems = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 程序集合数据
        /// </summary>
        public List<ProgramSeg> ListProgramSeg { get; set; }


        private ProgramSeg _SelectedProgramSeg;
        /// <summary>
        /// 当前选中的程序名称
        /// </summary>
        public ProgramSeg SelectedProgramSeg
        {
            get { return _SelectedProgramSeg; }
            set { _SelectedProgramSeg = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 加载最新的数据
        /// </summary>
        /// <returns></returns>
        private List<ProgramSeg> RefreshProSeg()
        {
            ListProgramSeg = FreeSql.Select<ProgramSeg>()
                .IncludeMany(a => a.ProSteps,
                then => then.IncludeMany(b => b.MeterSpeeds).IncludeMany(b => b.MeterPss).IncludeMany(b => b.MeterPds)).ToList();

            ProSegListViewItems.Clear();
            foreach (var item in ListProgramSeg)
            {
                ProSegListViewItems.Add(item);
            }

            return ListProgramSeg;
        }


        private DelegateCommand _ProAddCmd;
        /// <summary>
        /// 新增命令
        /// </summary>
        public DelegateCommand ProAddCmd
        {
            set
            {
                _ProAddCmd = value;
            }
            get
            {
                if (_ProAddCmd == null)
                {
                    _ProAddCmd = new DelegateCommand(() => ProAddCmdMethod());
                }
                return _ProAddCmd;
            }
        }

        /// <summary>
        /// 新增命令执行方法
        /// </summary>
        private void ProAddCmdMethod()
        {
            //弹窗
            DialogService.ShowDialog("DialogCreateProView", new DialogParameters() { { "Name", "" } }, (par) =>
            {
                if (par.Result == ButtonResult.OK)
                {
                    //程序名称
                    var ReturnValue = par.Parameters.GetValue<string>("Name");
                    //查询是否重复
                    var count = FreeSql.Select<ProgramSeg>().Where(a => a.Name == ReturnValue).Count();
                    if (count > 0)
                    {
                        MessageBox.Show("名称已经存在了");
                        return;
                    }

                    //开始新增
                    var InsertedData = FreeSql.Insert<ProgramSeg>(new ProgramSeg()
                    {
                        Name = ReturnValue,
                        Remark = "",
                    }).ExecuteAffrows();

                    //获取全部的数据
                    RefreshProSeg();

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

                }

            });
        }


        private DelegateCommand _ProEditCmd;
        /// <summary>
        /// 编辑命令
        /// </summary>
        public DelegateCommand ProEditCmd
        {
            set
            {
                _ProEditCmd = value;
            }
            get
            {
                if (_ProEditCmd == null)
                {
                    _ProEditCmd = new DelegateCommand(() => ProEditCmdMethod());
                }
                return _ProEditCmd;
            }
        }

        /// <summary>
        /// 编辑命令执行方法
        /// </summary>
        private void ProEditCmdMethod()
        {

            if (SelectedProgramSeg == null)
            {
                MessageBox.Show("未选中工况程序");
                return;
            }

            //弹窗
            DialogService.ShowDialog("DialogEditProView", new DialogParameters() { { "Name", SelectedProgramSeg.Name } }, (par) =>
            {
                if (par.Result == ButtonResult.OK)
                {
                    //程序名称
                    var ReturnValue = par.Parameters.GetValue<string>("Name");
                    //查询是否重复
                    var count = FreeSql.Select<ProgramSeg>().Where(a => a.Name == ReturnValue).Count();
                    if (count > 0)
                    {
                        MessageBox.Show("名称已经存在了");
                        return;
                    }

                    //开始修改
                    var InsertedData = FreeSql.Update<ProgramSeg>()
                    .Set(a => a.Name, ReturnValue)
                    .Where(a => a.Id == SelectedProgramSeg.Id)
                    .ExecuteAffrows();

                    //获取全部的数据
                    RefreshProSeg();

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

                }

            });
        }


        private DelegateCommand _ProDeleteCmd;
        /// <summary>
        /// 删除命令
        /// </summary>
        public DelegateCommand ProDeleteCmd
        {
            set
            {
                _ProDeleteCmd = value;
            }
            get
            {
                if (_ProDeleteCmd == null)
                {
                    _ProDeleteCmd = new DelegateCommand(() => ProDeleteCmdMethod());
                }
                return _ProDeleteCmd;
            }
        }

        /// <summary>
        /// 删除命令执行方法
        /// </summary>
        private void ProDeleteCmdMethod()
        {
            if (SelectedProgramSeg == null)
            {
                MessageBox.Show("未选中工况程序");
                return;
            }

            MessageBoxResult dialogResult = MessageBox.Show("你确定要删除当前的数据吗？", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand);
            if (dialogResult == MessageBoxResult.OK)
            {
                //联级别删除
                var repo = FreeSql.GetRepository<ProgramSeg>();
                repo.DbContextOptions.EnableCascadeSave = true; //关键设置

                var data = repo.Select.Where(a => a.Id == SelectedProgramSeg.Id)
                    .IncludeMany(a => a.ProSteps, then => then.IncludeMany(b => b.MeterSpeeds).IncludeMany(b => b.MeterPss).IncludeMany(b => b.MeterPds))
                    //.IncludeMany(a => a.QuickClutchStepCells)
                    //.IncludeMany(a => a.QuickVoltageStepCells)
                    .ToList();
                repo.Delete(data);

                ////开始删除
                //var InsertedData = FreeSql.Delete<ProgramSeg>(SelectedProgramSeg.Id).ExecuteAffrows();

                //获取全部的数据
                RefreshProSeg();
            }
        }


        #endregion


        #region 公共库

        /// <summary>
        /// 获取当前的步骤的数据信息
        /// </summary>
        private int AutoGetProStepNo()
        {
            var StepInfo = FreeSql.Select<ProStep>().Where(a => a.ProgramSegId == SelectedProgramSeg.Id).ToList();
            if (StepInfo != null && StepInfo.Count > 0)
            {
                var MaxStep = StepInfo.Max(a => a.StepNo);
                return MaxStep + 1;
            }
            else
            {
                return 1;
            }

        }

        /// <summary>
        /// 获取MeterSpeed当前的步骤的数据信息
        /// </summary>
        private int AutoGetMeterSpeedStepNo()
        {
            var StepInfo = FreeSql.Select<MeterSpeed>().Where(a => a.ProStepId == SelectedProStepDto.Id).ToList();
            if (StepInfo != null && StepInfo.Count > 0)
            {
                var MaxStep = StepInfo.Max(a => a.StepNo);
                return MaxStep + 1;
            }
            else
            {
                return 1;
            }

        }

        /// <summary>
        /// 获取MeterSpeed当前的步骤的数据信息
        /// </summary>
        private int AutoGetMeterPsStepNo()
        {
            var StepInfo = FreeSql.Select<MeterPs>().Where(a => a.ProStepId == SelectedProStepDto.Id).ToList();
            if (StepInfo != null && StepInfo.Count > 0)
            {
                var MaxStep = StepInfo.Max(a => a.StepNo);
                return MaxStep + 1;
            }
            else
            {
                return 1;
            }

        }

        #endregion


    }
}