using AutoMapper;
using CapMachine.Core;
using CapMachine.Model;
using CapMachine.Wpf.Models;
using CapMachine.Wpf.Services;
using ImTools;
using NPOI.SS.Formula.Functions;
using Prism.Commands;
using Prism.Services.Dialogs;
using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using System.Windows;

namespace CapMachine.Wpf.ViewModels
{
    public class DialogChartRtConfigViewModel : DialogViewModel
    {
        public DialogChartRtConfigViewModel(IFreeSql freeSql, IMapper mapper, MachineRtDataService machineRtDataService)
        {
            this.Title = "曲线编辑";

            //加载曲线数据源
            ChartSrcDataListViewItems = new ObservableCollection<ChartSrcData>();

            ChartYAxisDataListViewItems = new ObservableCollection<ChartYAxisDto>()
            {
                new ChartYAxisDto(){
                   Name="温度",
                   Max=100,
                   Min=-50,
                   Unit="℃",
                   Index=3,
                },
                new ChartYAxisDto(){
                   Name="湿度",
                   Max=100,
                   Min=0,
                   Unit="%",
                   Index=1,
                },
                new ChartYAxisDto(){
                   Name="压力",
                   Max=100,
                   Min=-50,
                   Unit="Mpa",
                   Index=2,
                },
            };
            FreeSql = freeSql;
            this.Mapper = mapper;
            MachineRtDataService = machineRtDataService;
            LoadChartSourceData();
            //RefreshChartSelectedData();
            RefreshChartYAxisData();
        }

        /// <summary>
        /// FreeSql
        /// </summary>
        public IFreeSql FreeSql { get; }

        /// <summary>
        /// AutoMap映射
        /// </summary>
        public IMapper Mapper { get; }

        /// <summary>
        /// 数据服务
        /// </summary>
        public MachineRtDataService MachineRtDataService { get; }

        /// <summary>
        /// 当前的TabIndex
        /// </summary>
        private int CurGroupTabIndex { get; set; }

        /// <summary>
        /// 当前的Machine
        /// </summary>
        private string CurSelectedMachine { get; set; } = "M1";

        /// <summary>
        /// 加载ChartSourceData
        /// </summary>
        private void LoadChartSourceData()
        {
            foreach (var item in MachineRtDataService.TagManger.DicTags.OrderBy(a=>a.Value.Id))
            {
                ChartSrcDataListViewItems.Add(new ChartSrcData()
                {
                    Index = ChartSrcDataListViewItems.Count + 1,
                    Name = item.Key,
                    Selected = false,
                });
            }
        }

        /// <summary>
        /// 加载数据
        /// </summary>
        private void RefreshChartSourceData()
        {
            //var data = FreeSql.Select<ConfigChartSelect>().ToList();
            //Mapper.Map<List<ChartSelectDto>>(data);
            //ChartSelectDataListViewItems = new ObservableCollection<ChartSelectDto>(Mapper.Map<List<ChartSelectDto>>(data));


        }

        /// <summary>
        /// 加载选择数据
        /// </summary>
        private void RefreshChartSelectedData()
        {
            var ChartSelectedData = FreeSql.Select<ConfigChart>().Where(a => a.Machine == CurSelectedMachine && a.GroupTabIndex == CurGroupTabIndex).Include(a => a.ConfigChartYAxis).ToList();
            ChartSelectDataListViewItems.Clear();
            var Index = 1;
            foreach (var item in ChartSelectedData)
            {
                //序号变成硬编码
                item.Index = Index;
                ChartSelectDataListViewItems.Add(Mapper.Map<ChartSelectDto>(item));

                Index++;
            }

            //选中后源数据状态被选中
            foreach (var item in ChartSelectedData)
            {
                var data = ChartSrcDataListViewItems.FindFirst(a => a.Name == item.Name);
                if (data != null)
                {
                    //选中
                    data.Selected = true;
                }
            }

            //SelectedChartSelectData = null;

            //Mapper.Map<List<ChartSelectDto>>(data);
            //ChartSelectDataListViewItems = new ObservableCollection<ChartSelectDto>(Mapper.Map<List<ChartSelectDto>>(data));

        }

        /// <summary>
        /// 加载Y轴数据信息
        /// </summary>
        private void RefreshChartYAxisData()
        {
            var ChartYAxisData = FreeSql.Select<ConfigChartYAxis>().ToList();
            ChartYAxisDataListViewItems.Clear();
            foreach (var item in ChartYAxisData)
            {
                ChartYAxisDataListViewItems.Add(Mapper.Map<ChartYAxisDto>(item));
            }
        }


        #region 数据源

        private DelegateCommand<object> _SelectionChartSourceCmd;
        /// <summary>
        /// 选中Chart数据源命令
        /// </summary>
        public DelegateCommand<object> SelectionChartSourceCmd
        {
            set
            {
                _SelectionChartSourceCmd = value;
            }
            get
            {
                if (_SelectionChartSourceCmd == null)
                {
                    _SelectionChartSourceCmd = new DelegateCommand<object>((str) => SelectionChartSourceCmdMethod(str));
                }
                return _SelectionChartSourceCmd;
            }
        }
        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void SelectionChartSourceCmdMethod(object par)
        {
            var data = par as ChartSrcData;
            //如果不是ProgramSeg则退出，因为刷新数据源的时候，会触发这个选择器
            if (data == null) return;

            SelectedChartSrcData = data;

        }

        private ChartSrcData _SelectedChartSrcData;
        /// <summary>
        /// 当前选中Chart数据源
        /// </summary>
        public ChartSrcData SelectedChartSrcData
        {
            get { return _SelectedChartSrcData; }
            set { _SelectedChartSrcData = value; RaisePropertyChanged(); }
        }


        private ObservableCollection<ChartSrcData> _ChartSrcDataListViewItems;
        /// <summary>
        /// 数据源控件 数据集合
        /// </summary>
        public ObservableCollection<ChartSrcData> ChartSrcDataListViewItems
        {
            get { return _ChartSrcDataListViewItems; }
            set { _ChartSrcDataListViewItems = value; RaisePropertyChanged(); }
        }

        ///// <summary>
        ///// 加载最新的数据
        ///// </summary>
        ///// <returns></returns>
        //private List<ProgramSeg> RefreshProSeg()
        //{

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

        //    return ListProgramSeg;
        //}

        #endregion

        #region 数据操作


        private DelegateCommand<string> _ChartSourceCmd;
        /// <summary>
        /// Chart数据 匹配操作命令
        /// </summary>
        public DelegateCommand<string> ChartSourceCmd
        {
            set
            {
                _ChartSourceCmd = value;
            }
            get
            {
                if (_ChartSourceCmd == null)
                {
                    _ChartSourceCmd = new DelegateCommand<string>((str) => ChartSourceCmdMethod(str));
                }
                return _ChartSourceCmd;
            }
        }
        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void ChartSourceCmdMethod(string par)
        {
            if (par == "Selected")//选中的操作
            {
                if (SelectedChartSrcData == null)
                {
                    MessageBox.Show("请选择后再操作");
                    return;
                }
                if (ChartSelectDataListViewItems.Where(a => a.Name == SelectedChartSrcData.Name).Count() > 0)
                {
                    MessageBox.Show("已经选择这条曲线");
                    return;
                }

                //数据库增加
                FreeSql.Insert<ConfigChart>(new ConfigChart()
                {
                    Name = SelectedChartSrcData.Name,
                    Machine = CurSelectedMachine,
                    GroupTabIndex = CurGroupTabIndex,
                    Index = ChartSelectDataListViewItems.Count + 1,
                    ConfigChartYAxis = GetDefaultYAxis(SelectedChartSrcData.Name),
                    ConfigChartYAxisId = GetDefaultYAxis(SelectedChartSrcData.Name).Id,
                }).ExecuteAffrows();

                //刷新图表
                RefreshChartSelectedData();

                //更改数据源状态
                ChartSrcDataListViewItems.FindFirst(a => a.Name == SelectedChartSrcData.Name).Selected = true;

            }
            else//删除的操作
            {
                if (SelectedChartSelectData != null)
                {
                    //数据库删除
                    FreeSql.Delete<ConfigChart>()
                        .Where(a => a.Name == SelectedChartSelectData.Name && a.Machine == CurSelectedMachine && a.GroupTabIndex == CurGroupTabIndex)
                        .ExecuteAffrows();

                    //刷新图表
                    RefreshChartSelectedData();

                    //ChartSelectDataListViewItems.Remove(SelectedChartSelectData);

                    //更改状态
                    ChartSrcDataListViewItems.FindFirst(a => a.Name == SelectedChartSelectData.Name).Selected = false;
                }
                else
                {
                    MessageBox.Show("请选择后再操作");

                }
            }
        }


        /// <summary>
        /// 获取默认的Y轴设置
        /// </summary>
        /// <returns></returns>
        private ConfigChartYAxis GetDefaultYAxis()
        {
            var Default = ChartYAxisDataListViewItems.ToList().FirstOrDefault()!;

            return new ConfigChartYAxis()
            {
                Index = Default.Index,
                Id = Default.Id,
                Max = Default.Max,
                Min = Default.Min,
                Name = Default.Name,
                Unit = Default.Unit,
            };
        }

        /// <summary>
        /// 根据名称获取Y轴设置
        /// </summary>
        /// <returns></returns>
        private ConfigChartYAxis GetDefaultYAxis(string Name)
        {
            foreach (var item in ChartYAxisDataListViewItems)
            {
                //匹配单位
                if (Name.Contains("[") && Name.Contains("]"))
                {
                    var Unit = MidStrEx(Name, "[", "]");
                    //匹配单位
                    if (Unit == item.Unit)
                    {
                        return new ConfigChartYAxis()
                        {
                            Index = item.Index,
                            Id = item.Id,
                            Max = item.Max,
                            Min = item.Min,
                            Name = item.Name,
                            Unit = item.Unit,
                        };
                    }
                }

                //匹配名称
                if (Name.Contains(item.Name))
                {
                    return new ConfigChartYAxis()
                    {
                        Index = item.Index,
                        Id = item.Id,
                        Max = item.Max,
                        Min = item.Min,
                        Name = item.Name,
                        Unit = item.Unit,
                    };
                }
            }

            //如果都没有的话，就选择第一个
            var Default = ChartYAxisDataListViewItems.ToList().FirstOrDefault()!;
            return new ConfigChartYAxis()
            {
                Index = Default.Index,
                Id = Default.Id,
                Max = Default.Max,
                Min = Default.Min,
                Name = Default.Name,
                Unit = Default.Unit,
            };
        }

        /// <summary>
        /// 截取中间的字符串
        /// </summary>
        /// <param name="sourse"></param>
        /// <param name="startstr"></param>
        /// <param name="endstr"></param>
        /// <returns></returns>
        private string MidStrEx(string sourse, string startstr, string endstr)
        {
            string result = string.Empty;
            int startindex, endindex;
            try
            {
                startindex = sourse.IndexOf(startstr);
                if (startindex == -1)
                    return result;
                string tmpstr = sourse.Substring(startindex + startstr.Length);
                endindex = tmpstr.IndexOf(endstr);
                if (endindex == -1)
                    return result;
                result = tmpstr.Remove(endindex);
            }
            catch (Exception ex)
            {
                //Log.WriteLog("MidStrEx Err:" + ex.Message);
            }
            return result;
        }

        private DelegateCommand<string> _ChartYAxisSelectCmd;
        /// <summary>
        /// Chart 标尺数据的操作命令
        /// </summary>
        public DelegateCommand<string> ChartYAxisSelectCmd
        {
            set
            {
                _ChartYAxisSelectCmd = value;
            }
            get
            {
                if (_ChartYAxisSelectCmd == null)
                {
                    _ChartYAxisSelectCmd = new DelegateCommand<string>((str) => ChartYAxisSelectCmdMethod(str));
                }
                return _ChartYAxisSelectCmd;
            }
        }

        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void ChartYAxisSelectCmdMethod(string par)
        {
            if (par == "Selected")//选中的操作
            {
                if (SelectedChartYAxisData == null)
                {
                    MessageBox.Show("请选择后再操作");
                    return;
                }
                if (SelectedChartSelectData == null)
                {
                    MessageBox.Show("请选择中间的【已选择曲线】后再操作");
                    return;
                }

                //数据库保存
                FreeSql.Update<ConfigChart>()
                    .Where(a => a.Id == SelectedChartSelectData.Id)
                    .Set(a => a.ConfigChartYAxisId, SelectedChartYAxisData.Id)
                    .ExecuteAffrows();

                //刷新图表
                RefreshChartSelectedData();

                //SelectedChartSelectData.YAxis = SelectedChartYAxisData;
            }

        }

        #endregion

        #region 数据选中操作

        private DelegateCommand<object> _SelectedChartConfigCmd;
        /// <summary>
        /// 选中Chart数据源命令
        /// </summary>
        public DelegateCommand<object> SelectedChartConfigCmd
        {
            set
            {
                _SelectedChartConfigCmd = value;
            }
            get
            {
                if (_SelectedChartConfigCmd == null)
                {
                    _SelectedChartConfigCmd = new DelegateCommand<object>((str) => SelectedChartConfigCmdMethod(str));
                }
                return _SelectedChartConfigCmd;
            }
        }
        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void SelectedChartConfigCmdMethod(object par)
        {
            var data = par as ChartSelectDto;
            //如果不是ProgramSeg则退出，因为刷新数据源的时候，会触发这个选择器
            if (data == null) return;

            SelectedChartSelectData = data;

        }

        private ChartSelectDto _SelectedChartSelectData;
        /// <summary>
        /// 当前选中Chart数据源
        /// </summary>
        public ChartSelectDto SelectedChartSelectData
        {
            get { return _SelectedChartSelectData; }
            set { _SelectedChartSelectData = value; RaisePropertyChanged(); }
        }


        private ObservableCollection<ChartSelectDto> _ChartSelectDataListViewItems = new ObservableCollection<ChartSelectDto>();
        /// <summary>
        /// 数据源控件 数据集合
        /// </summary>
        public ObservableCollection<ChartSelectDto> ChartSelectDataListViewItems
        {
            get { return _ChartSelectDataListViewItems; }
            set { _ChartSelectDataListViewItems = value; RaisePropertyChanged(); }
        }

        ///// <summary>
        ///// 加载最新的数据
        ///// </summary>
        ///// <returns></returns>
        //private List<ProgramSeg> RefreshProSeg()
        //{

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

        //    return ListProgramSeg;
        //}

        #endregion


        #region Y轴设置

        private DelegateCommand<object> _ChartYAxisDataConfigCmd;
        /// <summary>
        /// 选中Chart数据源命令
        /// </summary>
        public DelegateCommand<object> ChartYAxisDataConfigCmd
        {
            set
            {
                _ChartYAxisDataConfigCmd = value;
            }
            get
            {
                if (_ChartYAxisDataConfigCmd == null)
                {
                    _ChartYAxisDataConfigCmd = new DelegateCommand<object>((str) => ChartYAxisDataConfigCmdMethod(str));
                }
                return _ChartYAxisDataConfigCmd;
            }
        }
        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="str"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void ChartYAxisDataConfigCmdMethod(object par)
        {
            var data = par as ChartYAxisDto;
            //如果不是ProgramSeg则退出，因为刷新数据源的时候，会触发这个选择器
            if (data == null) return;

            SelectedChartYAxisData = data;

        }

        private ChartYAxisDto _SelectedChartYAxisData;
        /// <summary>
        /// 当前选中Chart数据源
        /// </summary>
        public ChartYAxisDto SelectedChartYAxisData
        {
            get { return _SelectedChartYAxisData; }
            set { _SelectedChartYAxisData = value; RaisePropertyChanged(); }
        }


        private ObservableCollection<ChartYAxisDto> _ChartYAxisDataListViewItems = new ObservableCollection<ChartYAxisDto>();
        /// <summary>
        /// 数据源控件 数据集合
        /// </summary>
        public ObservableCollection<ChartYAxisDto> ChartYAxisDataListViewItems
        {
            get { return _ChartYAxisDataListViewItems; }
            set { _ChartYAxisDataListViewItems = value; RaisePropertyChanged(); }
        }

        ///// <summary>
        ///// 加载最新的数据
        ///// </summary>
        ///// <returns></returns>
        //private List<ProgramSeg> RefreshProSeg()
        //{

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

        //    return ListProgramSeg;
        //}

        #endregion



        private string name;
        /// <summary>
        /// 名称
        /// </summary>
        public string Name
        {
            get { return name; }
            set { name = value; RaisePropertyChanged(); }
        }

        private DelegateCommand saveCmd;
        /// <summary>
        /// 保存命令
        /// </summary>
        public DelegateCommand SaveCmd
        {
            set
            {
                saveCmd = value;
            }
            get
            {
                if (saveCmd == null)
                {
                    saveCmd = new DelegateCommand(() => SaveCmdMethod());
                }
                return saveCmd;
            }
        }

        /// <summary>
        /// 保存命令方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void SaveCmdMethod()
        {


            DialogParameters pars = new DialogParameters
             {
                 { "Name", Name }
             };

            RaiseRequestClose(new DialogResult(ButtonResult.OK, pars));
        }

        private DelegateCommand cancelCmd;
        /// <summary>
        /// 取消命令
        /// </summary>
        public DelegateCommand CancelCmd
        {
            set
            {
                cancelCmd = value;
            }
            get
            {
                if (cancelCmd == null)
                {
                    cancelCmd = new DelegateCommand(() => CancelCmdMethod());
                }
                return cancelCmd;
            }
        }



        /// <summary>
        /// 取消命令方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void CancelCmdMethod()
        {
            RaiseRequestClose(new DialogResult(ButtonResult.Cancel));
        }


        /// <summary>
        /// 窗口打开时的传递的参数
        /// </summary>
        /// <param name="parameters"></param>
        public override void OnDialogOpened(IDialogParameters parameters)
        {
            CurGroupTabIndex = parameters.GetValue<int>("TabIndex");
            RefreshChartSelectedData();
        }
    }
}