using Autodesk.Revit.Attributes;

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

using Nice3point.Revit.Toolkit.External;

using ShrlAlgo.Toolkit.Core.Assist;

using System.Windows;
using ShrlAlgoToolkit.Core.Assist;


namespace ShrlAlgo.RvKits.RvView;

[Transaction(TransactionMode.Manual)]
[Regeneration(RegenerationOption.Manual)]
public class CivilViewFilterCmd : ExternalCommand
{
    public override void Execute()
    {
        using TransactionGroup tg = new(Document, "区分土建构件");
        tg.Start();
        //建筑模型与结构模型相关构件颜色区分。例如剪力墙和内隔墙颜色区分
        using (Transaction trans = new(Document, "建筑结构构件颜色区分"))
        {
            trans.Start();
            //类别
            ISet<ElementId> categoryIds = new HashSet<ElementId>
                {
                    new(BuiltInCategory.OST_Walls),
                    new(BuiltInCategory.OST_Floors),
                    new(BuiltInCategory.OST_StructuralFraming),
                    new(BuiltInCategory.OST_StructuralColumns),
                    new(BuiltInCategory.OST_StructuralFoundation)
                };
            //结构墙过滤器
            var wallParamId = new ElementId(BuiltInParameter.WALL_STRUCTURAL_USAGE_PARAM);
            var wallFilterRule = ParameterFilterRuleFactory.CreateEqualsRule(wallParamId, 1);
            //结构楼板过滤器
            var floorParamId = new ElementId(BuiltInParameter.FLOOR_PARAM_IS_STRUCTURAL);
            var floorFilterRule = ParameterFilterRuleFactory.CreateEqualsRule(floorParamId, 1);
#if REVIT2018
            try
            {
                var wallFilter = CreateViewFilter(Document, "结构墙", BuiltInCategory.OST_Walls, wallFilterRule);
                var floorFilter = CreateViewFilter(Document, "结构板", BuiltInCategory.OST_Floors, floorFilterRule);

                ActiveView.AddFilter(wallFilter.Id);
                ActiveView.AddFilter(floorFilter.Id);

                List<ElementId> ids = [new ElementId(BuiltInCategory.OST_StructuralFraming)];
                if (FilterCategoryRule.AllCategoriesFilterable(ids))
                {
                    FilterCategoryRule framingCategoryRule = new(ids);
                    var filter = CreateViewFilter(Document, "结构梁", BuiltInCategory.OST_StructuralFraming);
                    ActiveView.AddFilter(filter.Id);
                }

                ids = [new(BuiltInCategory.OST_StructuralColumns)];
                if (FilterCategoryRule.AllCategoriesFilterable(ids))
                {
                    FilterCategoryRule columnCategoryRule = new(ids);
                    var filter = CreateViewFilter(Document, "结构柱", BuiltInCategory.OST_StructuralColumns);
                    ActiveView.AddFilter(filter.Id);
                }

                ids = [new(BuiltInCategory.OST_StructuralFoundation)];
                if (FilterCategoryRule.AllCategoriesFilterable(ids))
                {
                    FilterCategoryRule foundationCategoryRule = new(ids);
                    var filter = CreateViewFilter(Document, "结构基础", BuiltInCategory.OST_StructuralFoundation);
                    ActiveView.AddFilter(filter.Id);
                }
            }
            catch (Exception e)
            {
                ErrorMessage = e.Message;
                LogHelper.ToLog(e.StackTrace);
                Result = Result.Failed;
                return;
            }

#elif REVIT2019 || REVIT2020
            try
            {
                //墙
                var structuralWallFilter = ViewFilterAssist.CreateParameterFilter(BuiltInCategory.OST_Walls, wallFilterRule);
                //板
                var structuralFloorFilter = ViewFilterAssist.CreateParameterFilter(BuiltInCategory.OST_Floors, floorFilterRule);
                //梁
                var framingFilter = ViewFilterAssist.CreateCategoryFilter(BuiltInCategory.OST_StructuralFraming);
                //结构柱
                var columnFilter = ViewFilterAssist.CreateCategoryFilter(BuiltInCategory.OST_StructuralColumns);
                //结构基础
                var foundationFilter = ViewFilterAssist.CreateCategoryFilter(BuiltInCategory.OST_StructuralFoundation);

                List<ElementFilter> filters =
                    [framingFilter, columnFilter, structuralWallFilter, structuralFloorFilter, foundationFilter];

                LogicalOrFilter orFilter = new(filters);
                if (!ParameterFilterElement.ElementFilterIsAcceptableForParameterFilterElement(Document, categoryIds, orFilter))
                {
                    MessageBox.Show("结构元素过滤器不能用于视图过滤器", "错误");
                }
                else
                {
                    var structuralFilter = ParameterFilterElement.Create(Document, "结构构件", categoryIds);
                    if (structuralFilter.AllRuleParametersApplicable(orFilter))
                    {
                        structuralFilter.SetElementFilter(orFilter);
                        ActiveView.AddFilter(structuralFilter.Id);
                    }
                    else
                    {
                        MessageBox.Show("结构过滤器错误", "错误");
                    }
                }
            }
            catch (Exception e)
            {
                ErrorMessage = e.Message;
                LogHelper.ToLog(e.StackTrace);
                Result = Result.Failed;
                return;
            }
#endif

            trans.Commit();
        }

        //不同功能区域例如人防板与非人防区域板用颜色加以区分。
        using (Transaction trans = new(Document, "是否人防板模型区分"))
        {
            trans.Start();
            ISet<ElementId> categoryIds = new HashSet<ElementId> { new(BuiltInCategory.OST_Floors) };
#if REVIT2018 || REVIT2020
            //注释
            var floorParamId = new ElementId(BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS);
            var floorFilterRule = ParameterFilterRuleFactory.CreateContainsRule(floorParamId, "人防", true);

            //类型名称
            var floorTypeParamId = new ElementId(BuiltInParameter.SYMBOL_NAME_PARAM);
            var floorTypeFilterRule = ParameterFilterRuleFactory.CreateContainsRule(floorTypeParamId, "人防", true);

#elif REVIT2025
                //注释
                var floorParamId = new ElementId(BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS);
                var floorFilterRule = ParameterFilterRuleFactory.CreateContainsRule(floorParamId, "人防");

                //类型名称
                var floorTypeParamId = new ElementId(BuiltInParameter.SYMBOL_NAME_PARAM);
                var floorTypeFilterRule = ParameterFilterRuleFactory.CreateContainsRule(floorTypeParamId, "人防");
#endif

#if REVIT2018
            try
            {
                var floorCommentFilter = CreateViewFilter(Document, "人防楼板-注释", BuiltInCategory.OST_Floors, floorFilterRule);
                ActiveView.AddFilter(floorCommentFilter.Id);
                var settings = ActiveView.GetFilterOverrides(floorCommentFilter.Id);
                //view.SetCutLineColor(new SelectedColor(255, 0, 0));
                settings.SetProjectionLineColor(new Color(255, 0, 0));
                ActiveView.SetFilterOverrides(floorCommentFilter.Id, settings);

                var floorTypeFilter = CreateViewFilter(Document, "人防楼板-类型名称", BuiltInCategory.OST_Floors, floorTypeFilterRule);
                ActiveView.AddFilter(floorTypeFilter.Id);
                settings = ActiveView.GetFilterOverrides(floorTypeFilter.Id);
                //view.SetCutLineColor(new SelectedColor(255, 0, 0));
                settings.SetProjectionLineColor(new Color(255, 0, 0));
                ActiveView.SetFilterOverrides(floorTypeFilter.Id, settings);
            }
            catch (Exception e)
            {
                ErrorMessage = e.Message;
                LogHelper.ToLog(e.StackTrace);
                Result = Result.Failed;
                return;
            }
#elif REVIT2020 || REVIT2019
            var floorFilter = ViewFilterAssist.CreateParameterFilter(BuiltInCategory.OST_Floors, floorFilterRule);
            var floorTypeFilter = ViewFilterAssist.CreateParameterFilter(BuiltInCategory.OST_Floors, floorTypeFilterRule);
            List<ElementFilter> filters = [floorFilter, floorTypeFilter];
            LogicalOrFilter orFilter = new(filters);
            try
            {
                if (ParameterFilterElement.ElementFilterIsAcceptableForParameterFilterElement(Document, categoryIds, orFilter))
                {
                    var filter = ParameterFilterElement.Create(Document, "人防板", categoryIds);
                    if (filter.AllRuleParametersApplicable(orFilter))
                    {
                        filter.SetElementFilter(orFilter);
                    }

                    ActiveView.AddFilter(filter.Id);
                    var view = ActiveView.GetFilterOverrides(filter.Id);
                    //view.SetCutLineColor(new SelectedColor(255, 0, 0));
                    view.SetProjectionLineColor(new Color(255, 0, 0));

                    ActiveView.SetFilterOverrides(filter.Id, view);
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
                LogHelper.ToLog(e.StackTrace);
            }

#endif
            trans.Commit();
        }

        //为了后期分析管线等便捷直观，结构建模时，梁要根据高度进行颜色标注区分。不仅要标注梁构件外观颜色，内部材质颜色也最好同时标注，以利于切面观察颜色。
        using (Transaction trans = new(Document, "梁高度颜色区分"))
        {
            trans.Start();

            ISet<ElementId> categoryIds = new HashSet<ElementId> { new(BuiltInCategory.OST_StructuralFraming) };
            //得到所有梁底标高
            var framings = Document.OfCollector()
                .OfCategory(BuiltInCategory.OST_StructuralFraming)
                .OfClass(typeof(FamilyInstance))
                .ToElements();
            var heightSet = new HashSet<double>();
            foreach (var framing in framings)
            {
                var bottomElev = framing.get_Parameter(BuiltInParameter.STRUCTURAL_ELEVATION_AT_BOTTOM).AsDouble();
                heightSet.Add(bottomElev);
            }

            var heightsOrdered = heightSet.OrderBy(d => d).ToList();
            var count = heightsOrdered.Count;
            if (count > 0)
            {
                var step = 255 / count;

                //创建梁过滤器
                for (var i = 0; i < count; i++)
                {
                    var height = heightsOrdered[i];
                    var framingBottomParamId = new ElementId(BuiltInParameter.STRUCTURAL_ELEVATION_AT_BOTTOM);
                    var framingFilterRule = ParameterFilterRuleFactory.CreateEqualsRule(framingBottomParamId, height, 0.001);
#if REVIT2018
                    try
                    {
                        var filter = CreateViewFilter(
                            Document,
                            $"梁底高度-({Convert.ToInt16(height * 304.8)})",
                            BuiltInCategory.OST_StructuralFraming,
                            framingFilterRule
                        );
                        ActiveView.AddFilter(filter.Id);
                        var settings = ActiveView.GetFilterOverrides(filter.Id);
                        //view.SetCutLineColor(new SelectedColor(255, 0, 0));
                        settings.SetProjectionLineColor(new Color((byte)(step * (count - i)), (byte)(step * i), (byte)(step * i)));

                        ActiveView.SetFilterOverrides(filter.Id, settings);
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message);
                        LogHelper.ToLog(e.StackTrace);
                    }

#elif REVIT2020 || REVIT2019
                    var framingFilter = ViewFilterAssist.CreateParameterFilter(BuiltInCategory.OST_StructuralFraming, framingFilterRule);
                    List<ElementFilter> filters = [framingFilter];
                    LogicalOrFilter orFilter = new(filters);
                    try
                    {
                        if (ParameterFilterElement.ElementFilterIsAcceptableForParameterFilterElement(Document, categoryIds, orFilter))
                        {
                            var filter = ParameterFilterElement.Create(Document, $"梁底高度-({Convert.ToInt16(height * 304.8)})", categoryIds);
                            if (filter.AllRuleParametersApplicable(orFilter))
                            {
                                filter.SetElementFilter(orFilter);
                            }
                            else
                            {
                                MessageBox.Show("梁底高过滤器错误", "错误");
                            }

                            ActiveView.AddFilter(filter.Id);
                            var view = ActiveView.GetFilterOverrides(filter.Id);
                            //view.SetCutLineColor(new SelectedColor(255, 0, 0));
                            view.SetProjectionLineColor(new Color((byte)(step * (count - i)), (byte)(step * i), (byte)(step * i)));

                            ActiveView.SetFilterOverrides(filter.Id, view);
                        }
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message);
                        e.StackTrace.ToLog();
                    }
#endif
                }
            }

            trans.Commit();
        }

        tg.Commit();
        //说明文档已经被修改但还未保存
        if (Document.IsModified)
        {
            MessageBox.Show("添加土建过滤器处理完成", "处理结果");
        }
    }

#if REVIT2018
    /// <summary>
    ///     创建视图过滤器
    /// </summary>
    /// <param name="doc"></param>
    /// <param name="filterName"></param>
    /// <param name="category"></param>
    /// <param name="filterRules"></param>
    /// <returns></returns>
    private static ParameterFilterElement CreateViewFilter(Document doc, string filterName, BuiltInCategory category, params FilterRule[] filterRules)
    {
        ParameterFilterElement viewFilter = null;
        ISet<ElementId> categoryIds = new HashSet<ElementId> { new(category) };
        List<FilterRule> rules = [.. filterRules];

        if (ParameterFilterElement.AllRuleParametersApplicable(doc, categoryIds, rules))
        {
            viewFilter = ParameterFilterElement.Create(doc, filterName, categoryIds, rules);
        }

        return viewFilter;
    }
#endif
}