using Aspose.Cells;
using Prism.Events;
using Prism.Ioc;
using Prism.Services.Dialogs;
using SWS.CAD.Event;
using SWS.CAD.ViewModels.myViewModelBase;
using SWS.CAD.Views;
using SWS.CAD.Views.CustomControl;
using SWS.Commons;
using SWS.Model;
using SWS.Service;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using Telerik.Windows.Controls;
using Unity;

namespace SWS.CAD.ViewModels
{
    /// <summary>
    /// 信号预分配页面的模型类
    /// </summary>
    public class DialogSignalPredistributionViewModel : DialogBase, IDialogAware
    {
        #region 字段
        private ObservableCollection<Model.TreeModel> _PanelTreels = new ObservableCollection<Model.TreeModel>();
        /// <summary>
        /// 页面左侧树形结构数据
        /// </summary>
        public ObservableCollection<Model.TreeModel> PanelTreels
        {
            get { return _PanelTreels; }
            set { _PanelTreels = value; RaisePropertyChanged(nameof(PanelTreels)); }
        }

        private Model.TreeModel _SelectedTreeNode;
        /// <summary>
        /// 当前选中的树形节点
        /// </summary>
        public Model.TreeModel SelectedTreeNode
        {
            get { return _SelectedTreeNode; }
            set
            {
                _SelectedTreeNode = value;
                RaisePropertyChanged(nameof(SelectedTreeNode));
                var path= FindNodePath(PanelTreels, _SelectedTreeNode);
                _eventAggregator.GetEvent<ScrollToItemEvent>().Publish(path);
            }
        }

        private ObservableCollection<SignalPredistributionInfo> _SignalPredistributionInfos = new ObservableCollection<SignalPredistributionInfo>();
        /// <summary>
        /// 表格数据
        /// </summary>
        public ObservableCollection<SignalPredistributionInfo> SignalPredistributionInfos
        {
            get { return _SignalPredistributionInfos; }
            set
            {
                _SignalPredistributionInfos = value;
                RaisePropertyChanged(nameof(SignalPredistributionInfos));
            }
        }


        private string _SelectedOption1;
        /// <summary>
        /// 是否通讯母线
        /// </summary>
        public string SelectedOption1
        {
            get { return _SelectedOption1; }
            set
            {
                _SelectedOption1 = value;
                RaisePropertyChanged(nameof(SelectedOption1));
            }
        }

        private string _SelectedOption2;
        /// <summary>
        /// 选择的信号类型
        /// </summary>
        public string SelectedOption2
        {
            get { return _SelectedOption2; }
            set
            {
                _SelectedOption2 = value;
                SignalColumnName = value;
                RaisePropertyChanged(nameof(SelectedOption2));
            }
        }

        private string _SignalColumnName;
        /// <summary>
        /// 信号类型列的列名
        /// </summary>
        public string SignalColumnName
        {
            get { return _SignalColumnName; }
            set
            {
                _SignalColumnName = value;
                RaisePropertyChanged(nameof(SignalColumnName));
                if (value.Equals("Digital"))
                {
                    //判断是否输入输出是否有值，有值下拉可选项需要设置为已有值
                    string tempIntorOut= SignalPredistributionInfos.Where(s => !string.IsNullOrEmpty(s.InorOut)).Select(s => s.InorOut).FirstOrDefault();
                    if (string.IsNullOrEmpty(tempIntorOut))
                    {
                        InorOuts = new List<string>() { "输出", "输入" };
                    }
                    else
                    {
                        InorOuts = new List<string>() { tempIntorOut };
                    }
                    
                    SignalTypeColumn = new ObservableCollection<string>() { "无公共端接线(断开报警NC)", "无公共端接线(闭合报警NO)", "带公共端接线(断开报警NC)", "带公共端接线(闭合报警NO)" };
                }
                else if (value.Equals("4-20mA"))
                {
                    InorOuts= new List<string>() { "输出", "输入" };
                    SignalTypeColumn = new ObservableCollection<string>() { "无源", "有源" };
                }
                else if (value.Equals("-10V-10V"))
                {
                    InorOuts = new List<string>() { "输出", "输入" };
                    SignalTypeColumn = new ObservableCollection<string>() { "无源", "有源" };
                }
                else if (value.Equals("PT100"))
                {
                    InorOuts = new List<string>() { "输出", "输入" };
                    SignalTypeColumn = new ObservableCollection<string>() { "量程100", "量程150", "量程200", "量程600" };
                }
                else if (value.Equals("Pulse"))
                {
                    InorOuts = new List<string>() { "输出", "输入" };
                    SignalTypeColumn = new ObservableCollection<string>() { "脉冲信号" };
                }
            }
        }



        private List<string> _CommunicationFormats = new List<string>() { "RS485", "RS482", "TCP/IP", "MQTT" };
        /// <summary>
        /// 通讯格式集合
        /// </summary>
        public List<string> CommunicationFormats
        {
            get { return _CommunicationFormats; }
            set
            {
                _CommunicationFormats = value;
                RaisePropertyChanged(nameof(CommunicationFormats));
            }
        }

        private string _CommunicationFormat = "RS485";
        /// <summary>
        /// 通讯格式
        /// </summary>
        public string CommunicationFormat
        {
            get { return _CommunicationFormat; }
            set
            {
                _CommunicationFormat = value;
                RaisePropertyChanged(nameof(CommunicationFormat));
            }
        }

        private ObservableCollection<string> _SignalTypeColumn;
        /// <summary>
        /// 信号类型列的下拉列表
        /// </summary>
        public ObservableCollection<string> SignalTypeColumn
        {
            get { return _SignalTypeColumn; }
            set
            {
                _SignalTypeColumn = value;
                RaisePropertyChanged(nameof(SignalTypeColumn));
                if (SignalPredistributionInfos != null)
                {
                    foreach (var item in SignalPredistributionInfos)
                    {
                        item.SignalType = _SignalTypeColumn.FirstOrDefault();
                    }
                }
            }
        }
        private List<string> _InorOuts = new List<string>() { "输出", "输入" };
        /// <summary>
        /// 输入/输出列的下拉列表
        /// </summary>
        public List<string> InorOuts
        {
            get { return _InorOuts; }
            set
            {
                _InorOuts = value;
                RaisePropertyChanged(nameof(InorOuts));
            }
        }

        #endregion

        IOModuleService _iOModuleService;
        IEventAggregator _eventAggregator;

        public DialogSignalPredistributionViewModel()
        {
            _iOModuleService = GlobalObject.container.Resolve<IOModuleService>();
            _eventAggregator = GlobalObject.container.Resolve<IEventAggregator>();

        }
        public string Title => "";

        public event Action<IDialogResult> RequestClose;

        public bool CanCloseDialog()
        {
            return true;
        }

        public void OnDialogClosed()
        {

        }

        private ec_Cable CableBy;
        public async void OnDialogOpened(IDialogParameters parameters)
        {
            title = $"电缆信号({parameters.GetValue<string>(GlobalObject.dialogPar.para2.ToString())})预分配";
            //树形结构数据
            PanelTreels.AddRange(await _iOModuleService.GetPanelTree());
            //电缆信息
            CableBy = parameters.GetValue<ec_Cable>(GlobalObject.dialogPar.para1.ToString());
            //是否母线
            if (CableBy.CableClass.Equals("homerun"))
            {
                SelectedOption1 = "是";
            }
            else if (CableBy.CableClass.Equals("conventional") || CableBy.CableClass.Equals(""))
            {
                SelectedOption1 = "否";

            }
            //设置默认信号类型
            if (string.IsNullOrEmpty(CableBy.PreAssignIOType))
            {
                SelectedOption2 = "Digital";
            }
            else
            {
                SelectedOption2 = CableBy.PreAssignIOType;
            }

            //设置表格数据
            int index = 0;
            foreach (var Set in CableBy.Sets)
            {
                SignalPredistributionInfo predistributionInfo = new SignalPredistributionInfo();
                predistributionInfo.CablePair = Set.CableSetName;
                foreach (var Wire in Set.Wires)
                {
                    index++;
                    predistributionInfo.Index.Add(index.ToString());
                    predistributionInfo.CableWires.Add(Wire);
                    predistributionInfo.Polaritys.Add(Wire);
                }
                if (string.IsNullOrEmpty(Set.PreAssignIOTypeDetail))
                {
                    predistributionInfo.SignalType = SignalTypeColumn.FirstOrDefault();
                }
                else
                {
                    predistributionInfo.SignalType = Set.PreAssignIOTypeDetail;
                }
                predistributionInfo.ChineseDescription = Set.PreAssignGroup_Desc;
                predistributionInfo.EnglishDescription = Set.PreAssignGroup_Desc_EN;

                if (string.IsNullOrEmpty(Set.PreAssignInOrOut))
                {
                    //predistributionInfo.InorOut = InorOuts.FirstOrDefault();
                }
                else
                {
                    predistributionInfo.InorOut = Set.PreAssignInOrOut;
                }
                predistributionInfo.SensorCode = Set.PreAssignSensorCode;

                //给每一行添加委托事件
                predistributionInfo.UpdateInorOutsChanged += (sender, e) => UpdateInorOuts((SignalPredistributionInfo)sender);

                SignalPredistributionInfos.Add(predistributionInfo);
            }
            //是否预关联，有则选中节点
            foreach (var Panel in PanelTreels)
            {
                if (!string.IsNullOrEmpty(Panel.ID))
                {
                    if (Panel.ID.Equals(CableBy.PanelID))
                    {
                        SelectedTreeNode = Panel;
                        break;
                    }
                }
                foreach (var Child in Panel.ChildNodes)
                {
                    if (!string.IsNullOrEmpty(Child.ID))
                    {
                        if (Child.ID.Equals(CableBy.PanelID))
                        {
                            SelectedTreeNode = Child;
                            break;
                        }
                    }
                }
            }


        }
        public override async void ExecuteOKCommandAsync(object para)
        {
            //创建SaveCable接口实例
            ec_Cable newCable = new ec_Cable();
            if (SelectedOption1.Equals("是"))
            {
                newCable.CableClass = "homerun";
                newCable.PreAssignIOType = CommunicationFormat;
            }
            else
            {
                newCable.CableClass = "conventional";
                newCable.PreAssignIOType = SelectedOption2;
            }
                
            newCable.CableID = CableBy.CableID;
            newCable.EngineerDataID = CableBy.EngineerDataID;
            if (SelectedTreeNode != null)
            {
                newCable.PanelID = SelectedTreeNode.ID;
            }
            else
            {
                MessageBox.Show("请选择系统柜！", "KunHengCAD", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
            
            newCable.UpdateUserID = GlobalObject.userInfo.userId;
            newCable.Sets = new List<ec_CableSet>();
            foreach (var CableBySet in CableBy.Sets)
            {
                ec_CableSet newCableSet = new ec_CableSet();
                newCableSet.CableSetID = CableBySet.CableSetID;
                newCableSet.CableSetName = CableBySet.CableSetName;
                newCableSet.CableSetSeq = CableBySet.CableSetSeq;
                newCableSet.IsConned = CableBySet.IsConned;
                newCableSet.PreAssignGroup_Desc = SignalPredistributionInfos.FirstOrDefault(s => s.CablePair.Equals(CableBySet.CableSetName)).ChineseDescription;
                newCableSet.PreAssignGroup_Desc_EN = SignalPredistributionInfos.FirstOrDefault(s => s.CablePair.Equals(CableBySet.CableSetName)).EnglishDescription;
                newCableSet.PreAssignIOTypeDetail = SignalPredistributionInfos.FirstOrDefault(s => s.CablePair.Equals(CableBySet.CableSetName)).SignalType;
                newCableSet.PreAssignInOrOut = SignalPredistributionInfos.FirstOrDefault(s => s.CablePair.Equals(CableBySet.CableSetName)).InorOut;
                newCableSet.PreAssignSensorCode = SignalPredistributionInfos.FirstOrDefault(s => s.CablePair.Equals(CableBySet.CableSetName)).SensorCode;
                newCableSet.Wires = new List<ec_CableSetWire>();
                foreach (var wire in CableBySet.Wires)
                {
                    ec_CableSetWire newWire = new ec_CableSetWire();
                    newWire.Polarity = wire.Polarity;
                    newWire.SetLevel = 0;
                    newWire.WireID = wire.WireID;
                    newWire.Wire_Tag = wire.Wire_Tag;
                    newWire.Wire_Color_ID = wire.Wire_Color_ID;
                    newWire.PreAssignChannelTermNo = SignalPredistributionInfos.FirstOrDefault(s => s.CablePair.Equals(CableBySet.CableSetName)).CableWires.FirstOrDefault(c => c.Wire_Tag.Equals(wire.Wire_Tag)).PreAssignChannelTermNo;

                    newCableSet.Wires.Add(newWire);
                }
                newCable.Sets.Add(newCableSet);
            }

            var httpres = await _iOModuleService.SaveCable(newCable);

            IDialogParameters res = new Prism.Services.Dialogs.DialogParameters();
            //res.Add(GlobalObject.dialogPar.info.ToString(), TagNumber);
            RequestClose.Invoke(new DialogResult(ButtonResult.Yes, res));
        }
        public override void ExecuteCloseCommand(object parameter)
        {
            if (parameter as string == "ClickNo")
            {
                DialogResult res = new DialogResult(ButtonResult.No);
                RequestClose.Invoke(res);
            }
            else
            {
                RequestClose.Invoke(new DialogResult(ButtonResult.Cancel));
            }
            this.Dispose();
        }
        #region 方法
        public ICommand ButtonCmd => new DelegateCommand(Button_Click);
        /// <summary>
        /// 页面左侧按钮
        /// </summary>
        /// <param name="parameter"></param>
        public virtual async void Button_Click(object parameter)
        {
            #region 清除配置
            if (parameter.ToString().Equals("清除配置"))
            {

                MessageBoxResult result = MessageBox.Show($"确定删除“{ CableBy.TagNumber}”电缆配置？", "KunHengCAD", MessageBoxButton.OKCancel, MessageBoxImage.Question);
                if (result == MessageBoxResult.OK)
                {
                    var httpres = await _iOModuleService.DeleteCableProfile(CableBy.CableID);
                    if (httpres == null)
                    {
                        RequestClose.Invoke(new DialogResult(ButtonResult.Cancel));
                        this.Dispose();
                    }
                }
                return;
            }
            #endregion

            #region 指定中英文
            if (parameter.ToString().Equals("指定中英文"))
            {
                //SelectedTreeNode = PanelTreels[2].ChildNodes.LastOrDefault();
                return;
            }
            #endregion
        }

        #region 修改输出和输入的可选项
        public void UpdateInorOuts(SignalPredistributionInfo sender)
        {
            if (SignalColumnName.Equals("Digital"))
            {
                string tempIntorOut = SignalPredistributionInfos.Where(s => !string.IsNullOrEmpty(s.InorOut)).Select(s => s.InorOut).FirstOrDefault();
                if (string.IsNullOrEmpty(tempIntorOut))
                {
                    InorOuts = new List<string>() { sender.InorOut };
                    if (sender.SignalType.Contains("带公共端"))
                    {
                        InorOuts = new List<string>() { "输入" };
                    }
                }
                else
                {
                    if (tempIntorOut.Equals("输出"))
                    {
                        if (sender.SignalType.Contains("带公共端"))
                        {
                            MessageBox.Show("带公共端只能跟输入信号搭配", "KunHengCAD", MessageBoxButton.OK, MessageBoxImage.Warning);
                            //需要还原信号类型的选项
                            var Set = CableBy.Sets.FirstOrDefault(s => s.CableSetName.Equals(sender.CablePair));
                            sender.SignalType = SignalTypeColumn.FirstOrDefault();
                            
                        }
                        
                    }
                }
                
            }
        }
        #endregion

        #region 查找节点路径
        public List<string> FindNodePath(ObservableCollection<TreeModel> nodes, TreeModel targetNode)
        {
            List<string> path = new List<string>();
            FindNodePathRecursive(nodes, targetNode, path);
            return path;
        }

        private bool FindNodePathRecursive(IEnumerable<TreeModel> nodes, TreeModel targetNode, List<string> currentPath)
        {
            foreach (var node in nodes)
            {
                currentPath.Add(node.Text);
                if (node == targetNode) return true; // 找到目标节点，返回True并结束搜索
                if (node.ChildNodes.Count > 0 && FindNodePathRecursive(node.ChildNodes, targetNode, currentPath))
                    return true; // 在子节点中继续搜索并找到目标节点，返回True并结束搜索
                currentPath.RemoveAt(currentPath.Count - 1); // 回溯，尝试下一个兄弟节点或父节点的其他兄弟节点
            }
            return false; // 没有找到目标节点，返回False
        }
        #endregion



        #endregion

    }

    public class SignalPredistributionInfo : DialogBase
    {
        public event EventHandler UpdateInorOutsChanged;

        #region 字段
        private ObservableCollection<string> _Index = new ObservableCollection<string>();
        /// <summary>
        /// 序号集合
        /// </summary>
        public ObservableCollection<string> Index
        {
            get { return _Index; }
            set { _Index = value; }
        }

        private string _CablePair;
        /// <summary>
        /// 电缆对
        /// </summary>
        public string CablePair
        {
            get { return _CablePair; }
            set { _CablePair = value; }
        }

        private ObservableCollection<ec_CableSetWire> _CableWires = new ObservableCollection<ec_CableSetWire>();
        /// <summary>
        /// 电缆线号
        /// </summary>
        public ObservableCollection<ec_CableSetWire> CableWires
        {
            get { return _CableWires; }
            set { _CableWires = value; }
        }

        private ObservableCollection<ec_CableSetWire> _Polaritys = new ObservableCollection<ec_CableSetWire>();
        /// <summary>
        /// 极性
        /// </summary>
        public ObservableCollection<ec_CableSetWire> Polaritys
        {
            get { return _Polaritys; }
            set
            {
                _Polaritys = value;
                RaisePropertyChanged(nameof(Polaritys));
            }
        }

        private string _SignalType;
        /// <summary>
        /// 信号类型
        /// </summary>
        public string SignalType
        {
            get { return _SignalType; }
            set
            {
                _SignalType = value;
                RaisePropertyChanged(nameof(SignalType));
                UpdateInorOutsChanged?.Invoke(this, EventArgs.Empty);

            }
        }


        private string _ChineseDescription;
        /// <summary>
        /// 中文描述
        /// </summary>
        public string ChineseDescription
        {
            get { return _ChineseDescription; }
            set
            {
                _ChineseDescription = value;
                RaisePropertyChanged(nameof(ChineseDescription));
            }
        }

        private string _EnglishDescription;
        /// <summary>
        /// 英文描述
        /// </summary>
        public string EnglishDescription
        {
            get { return _EnglishDescription; }
            set
            {
                _EnglishDescription = value;
                RaisePropertyChanged(nameof(EnglishDescription));
            }
        }

        private string _InorOut;
        /// <summary>
        /// 输入/输出
        /// </summary>
        public string InorOut
        {
            get { return _InorOut; }
            set
            {
                _InorOut = value;
                RaisePropertyChanged(nameof(InorOut));
                UpdateInorOutsChanged?.Invoke(this, EventArgs.Empty);

            }
        }

        private string _SensorCode;
        /// <summary>
        /// 传感器编号
        /// </summary>
        public string SensorCode
        {
            get { return _SensorCode; }
            set
            {
                _SensorCode = value;
                RaisePropertyChanged(nameof(SensorCode));
            }
        }


        private ObservableCollection<ec_PanelStripTerm> _Terms = new ObservableCollection<ec_PanelStripTerm>();
        /// <summary>
        /// 端子号集合
        /// </summary>
        public ObservableCollection<ec_PanelStripTerm> Terms
        {
            get { return _Terms; }
            set { _Terms = value; }
        }
        #endregion
    }

}