using System;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Input;

using Autodesk.Revit.DB;
using Autodesk.Revit.DB.Architecture;
using Autodesk.Revit.UI;

using Nice3point.Revit.Toolkit.External.Handlers;

using Szmedi.RvKits.InfoManager.Delivery;
using Szmedi.RvKits.Models;


namespace Szmedi.RvKits.InfoManager
{
    public partial class ParamEditViewModel : ObservableObject
    {
        [ObservableProperty]
        private bool isFamilyParam;

        [ObservableProperty]
        private bool isSharedFamilyParam;

        [ObservableProperty]
        private bool isSharedProjectParam = true;

        [ObservableProperty]
        private List<Element> elementsSelected;

        [ObservableProperty]
        private List<Parameter> paramNamesSelected;

        [ObservableProperty]
        private Parameter paramNameSelected;
        private readonly UIApplication uiapp;
        private readonly ActionEventHandler editHandler;
        [RelayCommand]
        private void PreviewTextInput(TextCompositionEventArgs args)
        {
            if (args != null && args.Source is System.Windows.Controls.ComboBox cb)
            {
                if (cb.Text == cb.SelectedItem?.ToString())
                {
                    args.Handled = true;
                }
            }
        }
        /// <summary>
        /// 修改标识
        /// </summary>
        //[RelayCommand]
        //[Obsolete]
        //private void ApplyIdentification()
        //{
        //    editHandler.Raise(uiapp =>
        //    {
        //        var doc = uiapp.ActiveUIDocument.Document;
        //        var view = doc.ActiveView;
        //        if (view.ViewType == ViewType.ThreeD)
        //        {
        //            FilteredElementCollector collector = new(doc, view.Id);
        //            foreach (var elem in collector)
        //            {
        //                switch (elem)
        //                {
        //                    case Wall wall:
        //                        break;
        //                    case Floor floor:
        //                        break;
        //                }
        //            }
        //        }
        //    });
        //}

        //[RelayCommand]
        //private void ApplyBelongFloor()
        //{
        //    editHandler.Raise(uiapp =>
        //    {
        //        doc doc = uiapp.ActiveUIDocument.doc;
        //    });
        //}

        public List<TreeModel> Models { get; } = new();


        public ParamEditViewModel(UIApplication uiapp, ActionEventHandler editHandler)
        {
            this.uiapp = uiapp;
            this.editHandler = editHandler;
        }

        //[Obsolete]
        //private void GenerateArchiTree(IList<ParamData> paramsData)
        //{
        //    var majors = paramsData.GroupBy(param => param.Major);

        //    //专业
        //    foreach (var major in majors)
        //    {
        //        List<TreeModel> majorChildren = new();
        //        TreeModel majorTreeModel =
        //            new()
        //            {
        //                Name = major.Key,
        //                Icon = null,
        //                IsChecked = false,
        //                IsExpanded = false,
        //                Children = majorChildren,
        //                Tag = null
        //            };
        //        Models.Add(majorTreeModel);
        //        //构件
        //        var components = major.GroupBy(p => p.Component);
        //        foreach (var component in components)
        //        {
        //            TreeModel componentTreeModel =
        //                new()
        //                {
        //                    Id = null,
        //                    Name = component.Key,
        //                    Icon = null,
        //                    IsExpanded = false,
        //                    Parent = null,
        //                    Children = null,
        //                    Tag = component.ToList()
        //                };
        //            majorChildren.Add(componentTreeModel);
        //        }
        //    }
        //}

        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AddParameterCommand))]
        private string paramName;

        private bool CanAddParams()
        {
            return !string.IsNullOrEmpty(ParamName) && !string.IsNullOrWhiteSpace(ParamName);
        }

        [RelayCommand(CanExecute = nameof(CanAddParams))]
        private void AddParameter()
        {
            //KeyPressAssists.SetFocusRVT();
            //KeyPressAssists.keybd_event(0x1B, 0, 0, 0);
            //KeyPressAssists.keybd_event(0x1B, 0, 2, 0);
            if (!string.IsNullOrEmpty(ParamName))
            {
                CustomParamData pd =
                    new()
                    {
                        Guid = Guid.NewGuid().ToString(),
                        Property = ParamName,
                        Unit = "/"
                    };
                editHandler.Raise(
                    uiapp =>
                    {
                        var uidoc = uiapp.ActiveUIDocument;
                        var filePath = Path.Combine(GlobalVariables.DirAssembly, $"TempSharedParameters.txt");
                        if (IsSharedProjectParam)
                        {
                            ParameterHelpers.AddParamBinding(uidoc, pd, filePath);
                        }
                        else
                        {
                            ParameterHelpers.AddFamilyParam(uidoc, pd, IsFamilyParam, filePath);
                        }
                    });
            }
        }

        [RelayCommand]
        private void ModifyParameter(object obj)
        {
            editHandler.Raise(
                uiapp =>
                {
                    var value = obj.ToString();
                    var uidoc = uiapp.ActiveUIDocument;
                    var doc = uidoc.Document;
                    using Transaction trans = new(doc, "修改参数值");
                    StringBuilder sb = new();
                    trans.Start();
                    foreach (var elem in ElementsSelected)
                    {
                        //先获取实例参数
                        var param = elem.GetParameters(ParamNameSelected.Definition.Name).FirstOrDefault();
                        //在获取类型参数
                        if (param == null)
                        {
                            var symbolOrType = doc.GetElement(elem.GetTypeId());
                            param = symbolOrType.GetParameters(ParamNameSelected.Definition.Name).FirstOrDefault();
                        }

                        try
                        {
                            if (param != null)
                            {
                                switch (param.StorageType)
                                {
                                    case StorageType.None:
                                        break;
                                    case StorageType.Integer:
                                        param.Set(Convert.ToInt16(value));
                                        break;
                                    case StorageType.Double:
                                        param.Set(Convert.ToDouble(value));
                                        break;
                                    case StorageType.String:
                                        param.Set(value);
                                        break;
                                    case StorageType.ElementId:
                                        param.Set(new ElementId(Convert.ToInt16(value)));
                                        break;
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            if (!sb.ToString().Contains(e.Message))
                            {
                                sb.AppendLine(e.Message);
                            }
                        }
                    }

                    trans.Commit();
                    if (!string.IsNullOrEmpty(sb.ToString()))
                    {
                        MessageBox.Show(sb.ToString(), "错误");
                    }
                    else
                    {
                        MessageBox.Show("修改完成！", "提示");
                    }
                });
            //ParentWindow.ModifyElementsParamEventHandler.value = obj.ToString();
            //ParentWindow.ModifyElementsParamEventHandler.ParameterSelected = ParamNameSelected;
            //ParentWindow.ModifyElementsParamEventHandler.ElementsSelected = ElementsSelected;
            //ParentWindow.ModifyElementsParamEvent.Raise();
        }

        [RelayCommand]
        private void SelectElements()
        {
            //KeyPressAssists.SetFocusRVT();
            //KeyPressAssists.keybd_event(0x1B, 0, 0, 0);
            //KeyPressAssists.keybd_event(0x1B, 0, 2, 0);
            var uidoc = uiapp.ActiveUIDocument;
            var doc = uidoc.Document;
            if (uidoc.Selection.GetElementIds().Count == 0)
            {
                var instancesSelected = uidoc.Selection.PickElementsByRectangle(
                    new TypesSelectionFilter(typeof(FamilyInstance), typeof(HostObject), typeof(Railing)),
                    "请框选元素"
                );

                ElementsSelected = instancesSelected.ToList();
            }
            else
            {
                var instancesSelected = from id in uidoc.Selection.GetElementIds() select doc.GetElement(id);
                ElementsSelected = instancesSelected.ToList();
            }

            List<Parameter> parameters = new();
            var element = ElementsSelected.FirstOrDefault(element => element.GetTypeId() != ElementId.InvalidElementId);
            var firstParameterSet = element.ParametersMap;
            var firstTypeOrSymbol = doc.GetElement(element.GetTypeId());
            var firstTypeParameterSet = firstTypeOrSymbol.ParametersMap;
            foreach (Parameter param in firstParameterSet)
            {
                if (param.IsReadOnly)
                {
                    continue;
                }

                parameters.Add(param);
            }

            foreach (Parameter param in firstTypeParameterSet)
            {
                if (param.IsReadOnly)
                {
                    continue;
                }

                parameters.Add(param);
            }

            foreach (var elem in ElementsSelected)
            {
                var instanceParameterSet = elem.ParametersMap;
                if (elem.GetTypeId() == ElementId.InvalidElementId)
                {
                    continue;
                }
                var typeOrSymbol = doc.GetElement(elem.GetTypeId());

                var typeParameterSet = typeOrSymbol.ParametersMap;
                for (var i = parameters.Count - 1; i >= 0; i--)
                {
                    var parameter = parameters[i];
                    var isExist = false;
                    foreach (Parameter param in instanceParameterSet)
                    {
                        if (param.IsReadOnly)
                        {
                            continue;
                        }

                        if (
                            parameter.Definition.Name == param.Definition.Name
                            && (
                                param.StorageType == StorageType.String
                                || param.StorageType == StorageType.Integer
                                || param.StorageType == StorageType.Double
                            )
                        )
                        {
                            isExist = true;
                            break;
                        }
                    }

                    foreach (Parameter param in typeParameterSet)
                    {
                        if (param.IsReadOnly)
                        {
                            continue;
                        }

                        if (
                            parameter.Definition.Name == param.Definition.Name
                            && (
                                param.StorageType == StorageType.String
                                || param.StorageType == StorageType.Integer
                                || param.StorageType == StorageType.Double
                            )
                        )
                        {
                            isExist = true;
                            break;
                        }
                    }

                    if (isExist == false)
                    {
                        parameters.Remove(parameter);
                    }
                }
            }

            ParamNamesSelected = parameters.OrderBy(p => p.Definition.Name).ToList();
        }
    }
}