using System.Collections.ObjectModel;
using System.Data.SQLite;
using System.Linq;
using System.Windows;
using System.Windows.Controls.Primitives;

using Autodesk.Revit.DB;

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

using Dapper;
using Dapper.Contrib.Extensions;

using Nice3point.Revit.Toolkit.External.Handlers;

using Szmedi.RvKits.InfoManager.Delivery;

namespace Szmedi.RvKits.InfoManager.AFCA
{
    public partial class ApprovalViewModel : ObservableObject
    {
        private readonly ActionEventHandler handler;
        private readonly SQLiteConnection cnn;

        [ObservableProperty]
        private ObservableCollection<PropertyBase> properties;
        //[ObservableProperty]
        //private MetroPropTable baseTable;
        private const string id = "深圳构件标识";
        private const string code = "AM-100-EAM分类编码";
        //[ObservableProperty]
        //private List<MetroPropTable> metroPropTables;

        [ObservableProperty] private List<ClassificationModel> classHierarchicalData;

        [ObservableProperty] private Dictionary<string, List<Element>> keyValues;

        private readonly List<ClassificationModel> allClassifications;

        private readonly IEnumerable<MetroBaseProperty> baseProps;

        public ApprovalViewModel(SQLiteConnection cnn)
        {
            this.cnn = cnn;

            handler = new ActionEventHandler();
            //获取基本属性。
            ClassHierarchicalData = InitData(cnn, out var classes);
            baseProps = cnn.GetAll<MetroBaseProperty>();

            allClassifications = classes;
        }
        [RelayCommand]
        private void LocationElement(object obj)
        {
            if (obj is Element elem)
            {
                handler.Raise(
                    uiapp =>
                    {
                        var uidoc = uiapp.ActiveUIDocument;
                        uidoc.ShowElements([elem.Id]);
                        uidoc.Selection.SetElementIds([elem.Id]);
                    });
            }
        }

        [RelayCommand]
        private void CheckId(object obj)
        {
            handler.Raise(
             uiapp =>
             {
                 var uidoc = uiapp.ActiveUIDocument;
                 var doc = uidoc.Document;
                 var allElements = doc.OfAllModelCollector()?.ToList();
                 if (allElements == null)
                 {
                     MessageBox.Show("没有找到模型元素", "错误");
                     return;
                 }
                 KeyValues = allElements.GroupBy(e => GetIDProperty(e)).ToDictionary(g => g.Key ?? "空", g => g.ToList());
                 if (obj is ToggleButton toggle && toggle.IsChecked == false)
                 {
                     toggle.IsChecked = true;
                 }
             });

        }
        [RelayCommand]
        private void ModifyCode()
        {
            handler.Raise(
                uiapp =>
                {
                    var uidoc = uiapp.ActiveUIDocument;
                    uidoc.Document
                        .Invoke(
                            ts =>
                            {
                                var elems = uidoc.Document.OfAllModelCollector()?.ToList();
                                if (elems == null)
                                {
                                    MessageBox.Show("没有找到模型元素", "错误");
                                    return;
                                }
                                foreach (var item in elems)
                                {
                                    var paras = item.GetParameters(id);
                                    var categoryName = string.Empty;

                                    if (paras.Count > 0)
                                    {
                                        foreach (var param in paras)
                                        {
                                            categoryName = param.AsString();
                                            break;
                                        }
                                    }
                                    var codesParams = item.GetParameters(code);
                                    var classification =
                                    allClassifications.FirstOrDefault(d => d.CategoryName == categoryName);
                                    if (codesParams.Count > 0)
                                    {
                                        foreach (var param in codesParams.Where(p => !p.IsReadOnly))
                                        {
                                            param.SetValue(classification?.Code);
                                        }
                                    }
                                }
                            }, "批处理编码");
                });
        }
        /// <summary>
        /// 添加属性
        /// </summary>
        [RelayCommand]
        private void BatchAddProperty()
        {
            handler.Raise(
                uiapp =>
                {
                    var uidoc = uiapp.ActiveUIDocument;
                    var doc = uidoc.Document;
                    var allElements = doc.OfAllModelCollector().ToList();
                    var group = allElements.GroupBy(
                                        e => GetIDProperty(e));
                    foreach (var item in group)
                    {
                        var classification = allClassifications.SingleOrDefault(c => c.CategoryName == item.Key);
                        if (classification != null)
                        {
                            if (item is FamilyInstance instance && !instance.Symbol.Family.IsInPlace)
                            {
                                //ParameterHelpers.AddFamilyParameters(uidoc,,true,)
                            }
                            else//使用共享参数
                            {

                            }
                        }

                    }
                });
        }
        private string GetIDProperty(Element e)
        {
            var list = e.GetParameters(id);
            if (list.Any())
            {
                var str = list.FirstOrDefault().AsString();
                if (str == string.Empty)
                {
                    return "未填写标识";
                }
                return str;
            }
            else
            {
                return "未定义标识";
            }
        }
        /// <summary>
        /// 批量修改节点
        /// </summary>
        /// <param name="model"></param>
        [RelayCommand]
        private void ModifyIdAndCode(ClassificationModel model)
        {
            if (model == null)
            {
                MessageBox.Show("请选择分类节点");
                return;
            }
            if (model.Children.Count > 0)
            {
                MessageBox.Show("请选择子节点");
                return;
            }
            handler.Raise(
                uiapp =>
                {
                    var uidoc = uiapp.ActiveUIDocument;
                    var elems = uidoc.Selection.PickElementsByRectangle("请框选元素!");
                    uidoc.Document
                        .Invoke(
                            ts =>
                            {
                                foreach (var item in elems)
                                {
                                    var paras = item.GetParameters(id);
                                    if (paras.Count > 0)
                                    {
                                        foreach (var param in paras.Where(p => !p.IsReadOnly))
                                        {
                                            param.Set(model.CategoryName);
                                        }
                                    }
                                    var codesParams = item.GetParameters(code);
                                    var classification =
                                    allClassifications.FirstOrDefault(d => d.CategoryName == model.CategoryName);
                                    if (codesParams.Count > 0)
                                    {
                                        foreach (var param in codesParams.Where(p => !p.IsReadOnly))
                                        {
                                            param.SetValue(classification?.Code);
                                        }
                                    }
                                }
                            }, "批处理标识&编码");
                });
        }
        /// <summary>
        /// 预处理，根据类别，自动赋予构件分类
        /// </summary>
        [RelayCommand]
        private void BatchProcess()
        {
            handler.Raise(
                uiapp =>
                {
                    var uidoc = uiapp.ActiveUIDocument;
                    var doc = uidoc.Document;
                    doc.InvokeGroup(
                        tg =>
                        {
                            var b1 = SharedParameterAssists.IsExistProjectParam(
                                doc,
                                id,
                                out var def1,
                                out var bindng1);
                            var b2 = SharedParameterAssists.IsExistProjectParam(
                               doc,
                               code,
                               out var def2,
                               out var bindng2);
                            CategorySet set = uiapp.Application.Create.NewCategorySet();

                            var builtInCategories = Enum.GetValues(typeof(BuiltInCategory));
                            foreach (BuiltInCategory cate in builtInCategories)
                            {
                                try
                                {
                                    if (cate == BuiltInCategory.OST_StairsStringerCarriage)
                                    {

                                    }
                                    //有的类别不支持这个方法获取
                                    var category = Category.GetCategory(doc, cate);
                                    if (category != null &&
                                        category.CategoryType == CategoryType.Model &&
                                        category.AllowsBoundParameters)
                                    {

                                        set.Insert(category);
                                    }
                                }
                                catch (Exception)
                                {
                                }
                            }

                            if (b1)
                            {
                                doc.Invoke(
                                   ts =>
                                   {
                                       bindng1.Categories = set;
                                       doc.ParameterBindings.ReInsert(def1, bindng1);
                                   }, "重新绑定ID参数类别");
                            }
                            else
                            {
                                ParameterHelpers.AddSharedParam(doc, id, set, BuiltInParameterGroup.PG_IFC);
                            }
                            if (b2)
                            {
                                doc.Invoke(
                                   ts =>
                                   {
                                       bindng2.Categories = set;
                                       doc.ParameterBindings.ReInsert(def2, bindng2);
                                   }, "重新绑定Code参数类别");
                            }
                            else
                            {
                                ParameterHelpers.AddSharedParam(doc, code, set, BuiltInParameterGroup.PG_ADSK_MODEL_PROPERTIES);
                            }
                            var allElements = doc.OfAllModelCollector();
                            if (allElements == null)
                            {
                                MessageBox.Show("没有找到模型元素", "错误");
                                return;
                            }
                            try
                            {
                                foreach (var elem in allElements)
                                {
                                    var idParams = elem.GetParameters(id).Where(p => !p.IsReadOnly);
                                    var codesParams = elem.GetParameters(code).Where(p => !p.IsReadOnly);
                                    var ids = idParams.ToList();
                                    var codes = codesParams.ToList();
                                    if (!ids.Any() || !codes.Any())
                                    {
                                        continue;
                                    }
                                    //获取元素类别名称
                                    string categroyName = GetCategory(doc, elem);
                                    doc.Invoke(
                                        ts =>
                                        {
                                            foreach (var param in ids)
                                            {
                                                param.SetValue(categroyName);
                                            }

                                            var classification =
                                        allClassifications.FirstOrDefault(d => d.CategoryName == categroyName);
                                            foreach (var param in codes)
                                            {
                                                param.SetValue(classification?.Code);
                                            }
                                        },
                                        "标识填写和编码");

                                }
                            }
                            catch (Exception)
                            {

                                throw;
                            }

                        }, "预处理标识&编码");

                });
        }

        private static string GetCategory(Document doc, Element item)
        {
            string categroyName = string.Empty;
            switch (item.Category.ToBuiltInCategory())
            {
                //结构连接
                case BuiltInCategory.OST_StructConnections:
                    {
                        if (item.Name.Contains("钢") && item.Name.Contains("节点"))
                        {
                            categroyName = "钢结构连接节点";
                        }

                        if (item.Name.Contains("钢") && item.Name.Contains("附件"))
                        {
                            categroyName = "钢结构连接附件";
                        }
                    }
                    break;
                //钢筋形状
                case BuiltInCategory.OST_RebarShape:
                    break;
                //结构路径钢筋
                case BuiltInCategory.OST_PathRein:
                    break;
                //结构区域钢筋
                case BuiltInCategory.OST_AreaRein:
                    break;
                //结构钢筋
                case BuiltInCategory.OST_Rebar:
                    break;
                //隔热层
                case BuiltInCategory.OST_FabricationPipeworkInsulation:
                    break;
                //内衬
                case BuiltInCategory.OST_FabricationDuctworkLining:
                    break;
                //MEP 预制保护层
                case BuiltInCategory.OST_FabricationContainment:
                    break;
                // MEP 预制管道
                case BuiltInCategory.OST_FabricationPipework:
                    break;
                //MEP 预制支架
                case BuiltInCategory.OST_FabricationHangers:
                    break;
                //隔热层
                case BuiltInCategory.OST_FabricationDuctworkInsulation:
                    break;
                //线管
                case BuiltInCategory.OST_Conduit:
                    break;
                //电缆桥架
                case BuiltInCategory.OST_CableTray:
                    break;
                //线管配件
                case BuiltInCategory.OST_ConduitFitting:
                    break;
                //电缆桥架配件
                case BuiltInCategory.OST_CableTrayFitting:
                    break;
                //风管内衬
                case BuiltInCategory.OST_DuctLinings:
                    break;
                //风管隔热层
                case BuiltInCategory.OST_DuctInsulations:
                    break;
                //管道隔热层
                case BuiltInCategory.OST_PipeInsulations:
                    break;
                //HVAC 区
                case BuiltInCategory.OST_HVAC_Zones:
                    break;
                //喷头
                case BuiltInCategory.OST_Sprinklers:
                    break;
                //灯具
                case BuiltInCategory.OST_LightingDevices:
                    break;
                //火警设备
                case BuiltInCategory.OST_FireAlarmDevices:
                    break;
                //数据设备
                case BuiltInCategory.OST_DataDevices:
                    break;
                //通讯设备
                case BuiltInCategory.OST_CommunicationDevices:
                    break;
                //安全设备
                case BuiltInCategory.OST_SecurityDevices:
                    break;
                //护理呼叫设备
                case BuiltInCategory.OST_NurseCallDevices:
                    break;
                //电话设备
                case BuiltInCategory.OST_TelephoneDevices:
                    break;
                //管道附件
                case BuiltInCategory.OST_PipeAccessory:
                    break;
                //软管
                case BuiltInCategory.OST_FlexPipeCurves:
                    break;
                //管件
                case BuiltInCategory.OST_PipeFitting:
                    break;
                //管道
                case BuiltInCategory.OST_PipeCurves:
                    break;
                //管道系统
                case BuiltInCategory.OST_PipingSystem:
                    break;
                //导线
                case BuiltInCategory.OST_Wire:
                    break;
                //软风管
                case BuiltInCategory.OST_FlexDuctCurves:
                    break;
                //风管附件
                case BuiltInCategory.OST_DuctAccessory:
                    break;
                //风管系统
                case BuiltInCategory.OST_DuctSystem:
                    break;
                //风道末端
                case BuiltInCategory.OST_DuctTerminal:
                    break;
                //风管管件
                case BuiltInCategory.OST_DuctFitting:
                    break;
                //风管
                case BuiltInCategory.OST_DuctCurves:
                    break;
                //桥梁支座
                case BuiltInCategory.OST_BridgeBearings:
                    break;
                //桥梁大梁
                case BuiltInCategory.OST_BridgeGirders:
                    break;
                //桥梁基础
                case BuiltInCategory.OST_BridgeFoundations:
                    {
                        categroyName = "混凝土桥台";
                    }
                    break;
                //桥面
                case BuiltInCategory.OST_BridgeDecks:
                    break;
                //桥拱
                case BuiltInCategory.OST_BridgeArches:
                    break;
                //桥梁缆索
                case BuiltInCategory.OST_BridgeCables:
                    break;
                //桥塔
                case BuiltInCategory.OST_BridgeTowers:
                    break;
                //桥墩
                case BuiltInCategory.OST_BridgePiers:
                    {
                        categroyName = "混凝土桥墩";
                    }
                    break;
                //桥台
                case BuiltInCategory.OST_BridgeAbutments:
                    break;
                //空间
                case BuiltInCategory.OST_MEPSpaces:
                    break;
                //体量洞口
                case BuiltInCategory.OST_MassOpening:
                    break;
                //体量天窗
                case BuiltInCategory.OST_MassSkylights:
                    break;
                //体量玻璃
                case BuiltInCategory.OST_MassGlazing:
                    break;
                //体量屋顶
                case BuiltInCategory.OST_MassRoof:
                    break;
                //体量外墙
                case BuiltInCategory.OST_MassExteriorWall:
                    break;
                //体量内墙
                case BuiltInCategory.OST_MassInteriorWall:
                    break;
                //体量分区
                case BuiltInCategory.OST_MassZone:
                    break;
                //体量楼层
                case BuiltInCategory.OST_MassFloor:
                    break;
                //体量
                case BuiltInCategory.OST_Mass:
                    break;
                //项目信息
                case BuiltInCategory.OST_ProjectInformation:
                    break;
                //环境
                case BuiltInCategory.OST_Entourage:
                    break;
                //植物
                case BuiltInCategory.OST_Planting:
                    break;
                //专用设备
                case BuiltInCategory.OST_SpecialityEquipment:
                    break;
                //建筑地坪
                case BuiltInCategory.OST_BuildingPad:
                    break;
                //场地
                case BuiltInCategory.OST_Site:
                    break;
                //道路
                case BuiltInCategory.OST_Roads:
                    break;
                //停车场
                case BuiltInCategory.OST_Parking:
                    break;
                //卫浴装置
                case BuiltInCategory.OST_PlumbingFixtures:
                    break;
                //机械设备
                case BuiltInCategory.OST_MechanicalEquipment:
                    break;
                //照明设备
                case BuiltInCategory.OST_LightingFixtures:
                    break;
                //电气装置
                case BuiltInCategory.OST_ElectricalFixtures:
                    break;
                //电气设备
                case BuiltInCategory.OST_ElectricalEquipment:
                    break;
                //橱柜
                case BuiltInCategory.OST_Casework:
                    break;
                //竖井洞口
                case BuiltInCategory.OST_ShaftOpening:
                    break;
                //房间
                case BuiltInCategory.OST_Rooms:
                    break;
                //结构桁架
                case BuiltInCategory.OST_StructuralTruss:
                    {
                        categroyName = "钢桁架";
                        if (item.Name.Contains("网"))
                        {
                            categroyName = "钢网架";
                        }
                    }
                    break;
                //结构柱
                case BuiltInCategory.OST_StructuralColumns:
                    {
                        categroyName = "混凝土柱";
                        if (item.Name.Contains("钢"))
                        {
                            categroyName = "钢柱";
                        }

                        if (doc.Title.Contains("围护"))
                        {
                            categroyName = "围护柱";
                            if (item.Name.Contains("桩"))
                            {
                                categroyName = "围护桩";
                            }
                        }
                    }
                    break;
                //结构框架
                case BuiltInCategory.OST_StructuralFraming:
                    {
                        categroyName = "混凝土梁";
                        if (item.Name.Contains("钢") && item.Name.Contains("梁"))
                        {
                            categroyName = "钢梁";
                        }

                        if (item.Name.Contains("钢") && item.Name.Contains("支撑"))
                        {
                            categroyName = "钢支撑";
                        }

                        if (doc.Title.Contains("围护"))
                        {
                            categroyName = "围护梁";
                        }
                    }
                    break;
                //结构基础
                case BuiltInCategory.OST_StructuralFoundation:
                    {
                        if (doc.Title.Contains("围护"))
                        {
                            categroyName = "围护柱";
                            if (item.Name.Contains("桩"))
                            {
                                categroyName = "围护桩";
                            }
                        }
                        if (item is Floor floor)
                        {
                            categroyName = "混凝土板";
                        }
                        if (item is WallFoundation)
                        {
                            categroyName = "混凝土墙";
                        }
                    }
                    break;

                //常规模型
                case BuiltInCategory.OST_GenericModel:
                    {
                        if (item.Name.Contains("雨棚"))
                        {
                            categroyName = "雨棚";
                        }

                        if (item.Name.Contains("台阶"))
                        {
                            categroyName = "台阶";
                        }

                        if (item.Name.Contains("预埋件"))
                        {
                            categroyName = "预埋件";
                        }
                    }
                    break;
                //终端
                case BuiltInCategory.OST_RailingTermination:
                //支座
                case BuiltInCategory.OST_RailingSupport:
                //扶手
                case BuiltInCategory.OST_RailingHandRail:
                //顶部扶栏
                case BuiltInCategory.OST_RailingTopRail:
                //栏杆扶手
                case BuiltInCategory.OST_StairsRailing:
                    {
                        categroyName = "栏杆";
                    }
                    break;
                //柱
                case BuiltInCategory.OST_Columns:
                    {
                        categroyName = "建筑柱";
                    }
                    break;
                //家具
                case BuiltInCategory.OST_Furniture:
                    break;
                //结构加强板
                case BuiltInCategory.OST_StructuralStiffener:
                //楼板边缘
                case BuiltInCategory.OST_EdgeSlab:
                //楼板
                case BuiltInCategory.OST_Floors:
                    {
                        categroyName = "楼地板";
                        if (item is Floor floor)
                        {
                            var structural = floor
                                .get_Parameter(BuiltInParameter.FLOOR_PARAM_IS_STRUCTURAL)
                                .AsInteger();
                            if (structural == 1)
                            {
                                categroyName = "混凝土板";
                            }

                            var levelMax = doc.OfClass<Level>()
                                .Cast<Level>()
                                .OrderBy(l => l.Elevation)
                                .LastOrDefault();
                            if (levelMax!.Id == floor.LevelId)
                            {
                                categroyName = "混凝土屋面";
                            }
                        }
                    }
                    break;
                //平台
                case BuiltInCategory.OST_StairsLandings:
                //梯段
                case BuiltInCategory.OST_StairsRuns:
                //楼梯
                case BuiltInCategory.OST_Stairs:
                //支撑
                case BuiltInCategory.OST_StairsStringerCarriage:
                    {
                        categroyName = "楼梯";
                    }
                    break;
                //屋顶
                case BuiltInCategory.OST_Roofs:
                //檐沟
                case BuiltInCategory.OST_Gutter:
                //封檐板
                case BuiltInCategory.OST_Fascia:
                //屋檐底板
                case BuiltInCategory.OST_RoofSoffit:
                    {
                        categroyName = "屋顶";
                    }
                    break;
                //坡道
                case BuiltInCategory.OST_Ramps:
                //门
                case BuiltInCategory.OST_Doors:
                //窗
                case BuiltInCategory.OST_Windows:
                //天花板
                case BuiltInCategory.OST_Ceilings:
                    {
                        categroyName = item.Category.Name;
                    }
                    break;
                //幕墙系统
                case BuiltInCategory.OST_CurtaSystem:
                //幕墙竖梃
                case BuiltInCategory.OST_CurtainWallMullions:
                //幕墙嵌板
                case BuiltInCategory.OST_CurtainWallPanels:
                    {
                        categroyName = "幕墙";
                    }
                    break;
                //墙饰条
                case BuiltInCategory.OST_Cornices:
                //墙
                case BuiltInCategory.OST_Walls:
                    {
                        categroyName = "建筑墙";
                        if (item is Wall wall)
                        {
                            var structural = wall
                                .get_Parameter(BuiltInParameter.WALL_STRUCTURAL_SIGNIFICANT)
                                .AsInteger();
                            if (structural == 1)
                            {
                                categroyName = "混凝土墙";
                            }

                            if (wall.StructuralUsage ==
                                Autodesk.Revit.DB.Structure.StructuralWallUsage.NonBearing)
                            {
                                categroyName = "建筑墙";
                            }

                            if (wall.WallType.Kind == WallKind.Curtain)
                            {
                                categroyName = "幕墙";
                            }

                            if (doc.Title.Contains("围护"))
                            {
                                categroyName = "围护墙";
                            }
                        }
                    }
                    break;
                default:
                    break;
            }

            return categroyName;
        }

        [RelayCommand]
        private void GetProperties(ClassificationModel model)
        {
            if (model != null)
            {
                Properties?.Clear();

                if (model.Parent == null)
                {
                    var list = new List<PropertyBase>();
                    //var baseProps = cnn.GetList<MetroBaseProperty>();
                    list.AddRange(baseProps);
                    Properties = [.. list];
                    return;
                }

                if (model.Children.Count == 0)
                {
                    var list = new List<PropertyBase>();
                    //var baseProps = cnn.GetList<MetroBaseProperty>();
                    list.AddRange(baseProps);

                    var dedicatedProps = model.Properties;
                    list.AddRange(dedicatedProps);
                    Properties = [.. list];
                }
            }
        }

        private static List<ClassificationModel> InitData(SQLiteConnection cnn,
            out List<ClassificationModel> treeModels)
        {
            //专项属性
            var metroProps = cnn.GetAll<MetroDedicatedProperty>();
            //获取分类节点
            treeModels = [.. cnn.GetAll<ClassificationModel>()];

            foreach (var model in treeModels)
            {
                //找到model的父节点
                model.Parent = treeModels.FirstOrDefault(t => t.CategoryName == model.ParentName);
                //model的属性集
                model.Properties = [.. metroProps.Where(p => p.ParamTableIndex == model.ParamTableIndex)];
                //找到model的子节点
                model.Children = [.. treeModels.Where(t => t.ParentName == model.CategoryName)];
            }

            var result = treeModels.Where(t => t.Parent == null && t.ParentName == null);
            return [.. result];
        }
    }
}