using System.Diagnostics;
using System.IO;
using System.Reflection;

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

using Sai.Toolkit.Revit.Assist;

namespace Sai.Toolkit.Revit.Helpers;

public class ParameterAssist
{

    private static ExternalDefinition GetSharedParameter(DefinitionFile file, string groupname, string paramname)
    {
        var myGroups = file.Groups;
        var myGroup = myGroups.get_Item(groupname);

        ExternalDefinition extDef = null;

        if (myGroup != null)
        {
            extDef = myGroup.Definitions.get_Item(paramname) as ExternalDefinition;
        }

        return extDef;
    }

    /// <summary>
    ///     关联族参数
    /// </summary>
    /// <param name="familyMgr"></param>
    /// <param name="lengthElementPara"></param>
    /// <param name="lengthFamilyPara"></param>
    public static void AssociateParametersInFamilyDocument(
        FamilyManager familyMgr,
        Parameter lengthElementPara, // 长度类型的图元参数
        FamilyParameter lengthFamilyPara
    ) // 长度类型的族参数
    {
#if REVIT2018 || REVIT2020
        var lengthElementParaType = lengthElementPara.Definition.ParameterType;
        var lengthFamilyParaType = lengthFamilyPara.Definition.ParameterType;
#elif REVIT2025
		var lengthElementParaType = lengthElementPara.Definition.GetDataType();
		var lengthFamilyParaType = lengthFamilyPara.Definition.GetDataType();
#endif
        // 能关联起来的图元参数和族参数的类型要相同
        if (lengthElementParaType != lengthFamilyParaType)
        {
            // 注意：有些类型不同的图元参数和族参数也是可以关联的。
            // 比如PipeSize和Length类型的参数可以关联，因为他们代表了相同的物理量：长度
            return;
        }

        // 判断该长度单位是否能够和族参数关联
        if (!familyMgr.CanElementParameterBeAssociated(lengthElementPara))
        {
            return;
        }

        // 进行关联操作
        familyMgr.AssociateElementParameterToFamilyParameter(lengthElementPara, lengthFamilyPara);
    }

    /// <summary>
    ///     绑定新建参数参数
    /// </summary>
    /// <param name="doc"></param>
    /// <param name="e"></param>
    /// <param name="definition"></param>
    /// <param name="isInstance"></param>
    public static void BindingElementCategory(Document doc, Element e, Definition definition, bool isInstance)
    {
        var app = doc.Application;
        var bindmap = doc.ParameterBindings;
        Binding binding = null;
        var dep = bindmap.ForwardIterator();
        while (dep.MoveNext())
        {
            var depKey = dep.Key;
            var definitionName = depKey.Name;
            if (definitionName == definition.Name)
            {
#if REVIT2018 || REVIT2020

                _ = depKey.ParameterType;
#elif REVIT2025
				_ = depKey.GetDataType();
#endif

                binding = bindmap.get_Item(depKey);
                break;
            }
        }

        if (binding == null)
        {
            var categorySet = app.Create.NewCategorySet();
            categorySet.Insert(e.Category);
            binding = isInstance ? app.Create.NewInstanceBinding(categorySet) : app.Create.NewTypeBinding(categorySet);

            bindmap.Remove(definition);

#if REVIT2018 || REVIT2020
            bindmap.ReInsert(definition, binding, BuiltInParameterGroup.PG_ADSK_MODEL_PROPERTIES);
#elif REVIT2025
			bindmap.ReInsert(definition, binding, GroupTypeId.AdskModelProperties);
#endif
        }
        else
        {
            CategorySet categorySet;
            if (binding is InstanceBinding instanceBinding)
            {
                categorySet = instanceBinding.Categories;
            }
            else
            {
                var typeBinding = binding as TypeBinding;
                categorySet = typeBinding!.Categories;
            }

            categorySet.Insert(e.Category);
        }
    }

    public static FamilyParameter CreateFamilyPara(
        Document famdoc,
        string paraName,
#if REVIT2018 || REVIT2020
        BuiltInParameterGroup paraGroup,
        ParameterType paramType,
#elif REVIT2025
		ForgeTypeId paraGroup,
		ForgeTypeId paramType,
#endif
        bool isInstance
    )
    {
        // 得到FamilyManager
        if (!famdoc.IsFamilyDocument)
        {
            throw new Exception("不是族文档");
        }

        var familyMgr = famdoc.FamilyManager;
        return familyMgr.AddParameter(paraName, paraGroup, paramType, isInstance);
    }

    public static void CreateSharedFamilyParam(Application app, Document famdoc)
    {
        var familyMgr = famdoc.FamilyManager;

        // 共享参数的基本信息, 包括定义文件路径，参数分组名称，参数名称和参数类型。
        var sharedParameterFilePath = @"C:\SharedParameter.txt";
        var sharedParameterGroupName = "Shared_Group";
        var sharedParameter = "Shared_Parameter";
#if REVIT2018 || REVIT2020
        var sharedParameterType = ParameterType.Length;
#elif REVIT2025
        var sharedParameterType = SpecTypeId.Length;
#endif
        ExternalDefinitionCreationOptions externalDefinitionCreationOptions = new(sharedParameter, sharedParameterType);
        // 打开或创建共享参数定义文件。
        app.SharedParametersFilename = sharedParameterFilePath;
        var sharedDefinitonFile = app.OpenSharedParameterFile();
        if (sharedDefinitonFile == null)
        {
            return;
        }

        // 查找共享参数的分组名称，如果没找到，就创建一个。
        DefinitionGroup sharedGroup;
        sharedGroup = sharedDefinitonFile.Groups.get_Item(sharedParameterGroupName);
        if (null == sharedGroup)
        {
            sharedGroup = sharedDefinitonFile.Groups.Create(sharedParameterGroupName);
        }

        // 查找共享参数的定义，如果没有找到，就用名字和类型创建一个。
        if (sharedGroup.Definitions.get_Item(sharedParameter) is not ExternalDefinition parameterDef)
        {
            parameterDef = sharedGroup.Definitions.Create(externalDefinitionCreationOptions) as ExternalDefinition;
        }

        // 创建共享族参数
#if REVIT2018 || REVIT2020
        _ = familyMgr.AddParameter(parameterDef, BuiltInParameterGroup.PG_CONSTRAINTS, true);
#elif REVIT2025
		_ = familyMgr.AddParameter(parameterDef, GroupTypeId.Constraints, true);
#endif
    }

    public void CreateSharedParam(
        Application app,
        Document doc,
        bool instanceParameter,
        string sharedParametersFilePath,
        string groupName,
        string definitionName
    )
    {
#if REVIT2018 || REVIT2020
        var parameterType = ParameterType.Text;
        var parameterGroup = BuiltInParameterGroup.PG_DATA;
#elif REVIT2025
		var parameterType = SpecTypeId.String.Text;
		var parameterGroup = GroupTypeId.Data;
#endif
        CategorySet categorySet = new();
        var wallCategory = doc.Settings.Categories.get_Item(BuiltInCategory.OST_Walls);
        categorySet.Insert(wallCategory);

        if (!File.Exists(sharedParametersFilePath))
        {
            try
            {
                var sw = File.CreateText(sharedParametersFilePath);
                sw.Close();
            }
            catch (Exception)
            {
                throw new Exception("无法创建共享参数文件: " + sharedParametersFilePath);
            }
        }

        // 设置共享参数文件
        app.SharedParametersFilename = sharedParametersFilePath;

        // 打开共享参数文件
        var definitionFile = app.OpenSharedParameterFile();
        if (definitionFile == null)
        {
            throw new Exception("无法打开共享参数文件");
        }

        // 获取参数组的集合
        var groups = definitionFile.Groups;

        // 获取参数组
        var group = groups.get_Item(groupName);
        if (null == group)
        {
            // 如果参数组不存在，则创建一个
            group = groups.Create(groupName);
        }

        if (null == group)
        {
            throw new Exception("获取参数组失败: " + groupName);
        }

        // 获取参数定义
        var definition = group.Definitions.get_Item(definitionName);
        // 如果参数定义不存在，则创建一个
        definition ??= group.Definitions.Create(new ExternalDefinitionCreationOptions(definitionName, parameterType));

        // 调用不同的函数创建类型参数或者实例参数
        ElementBinding binding = instanceParameter
            ? app.Create.NewInstanceBinding(categorySet)
            : app.Create.NewTypeBinding(categorySet);

        // 把参数定义和类别绑定起来，元素的新的参数就创建成功了。
        var insertSuccess = doc.ParameterBindings.Insert(definition, binding, parameterGroup);

        if (!insertSuccess)
        {
            throw new Exception("绑定类别失败");
        }
    }

    public DefinitionFile CreateTempSharedParameterFile(Application revitApp, string fileName)
    {
        var shapeFile = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + $"\\{fileName}.txt";
        System.Text.StringBuilder contents = new();
        contents.AppendLine("# This is a Revit shared parameterElement file.");
        contents.AppendLine("# Do not edit manually.");
        contents.AppendLine("*META	VERSION	MINVERSION");
        contents.AppendLine("META	2	1");
        contents.AppendLine("*GROUP	ID	NAME");
        contents.AppendLine("*PARAM	GUID	NAME	DATATYPE	DATACATEGORY	GROUP	VISIBLE");
        File.WriteAllText(shapeFile, contents.ToString());
        revitApp.SharedParametersFilename = shapeFile;
        return revitApp.OpenSharedParameterFile();
    }

    /// <summary>
    ///     生成共享文件
    /// </summary>
    /// <param name="groups">参数组</param>
    /// <param name="definitions">参数外部定义</param>
    /// <returns></returns>
    public static string GenerateSharedParameterFile(List<DefinitionGroup> groups, List<ExternalDefinition> definitions)
    {
        var name = Assembly.GetCallingAssembly().GetName();
        var date = string.Format(
            "{0:s}",
            File.GetLastWriteTime(Assembly.GetExecutingAssembly().Location).ToUniversalTime()
        );
        var result =
            "# This is a Revit shared parameterElement file, generated "
            + DateTime.Now.ToShortDateString()
            + " using "
            + name.Name
            + " v"
            + name.Version
            + " built "
            + date
            + "\r\n";
        result += "# Do not edit manually.\r\n";
        result += "*META\tVERSION\tMINVERSION\r\n";
        result += "META\t2\t1\r\n";
        result += "*GROUP\tID\tNAME\r\n";
        for (var i = 0; i < groups.Count; i++)
        {
            var group = groups[i];
            result += "GROUP\t" + $"{i + 1}" + "\t" + group.Name + "\r\n";
        }

        result += "*PARAM\tGUID\tNAME\tDATATYPE\tDATACATEGORY\tGROUP\tVISIBLE\tDESCRIPTION\tUSERMODIFIABLE\r\n";
        foreach (var definition in definitions)
        {
            var id = groups.FindIndex(g => g.Name == definition.OwnerGroup.Name) + 1;
            if (id > 0)
            {
                result +=
                    "PARAM\t"
                    + definition.GUID
                    + "\t"
                    + definition.Name
                    + "\t"
#if REVIT2018 || REVIT2020
                    + definition.ParameterType.ToString().ToUpper()
#elif REVIT2025
                    + definition.GetDataType().ToString().ToUpper()
#endif
                    + "\t\t"
                    + id
                    + (definition.Visible ? "\t1\t" : "\t0\t")
                    + System.Text.RegularExpressions.Regex.Replace(definition.Description, @"\t|\n|\r", string.Empty)
                    + "\t"
                    + (definition.UserModifiable ? "1" : string.Empty)
                    + "\r\n";
            }
        }

        return result;
    }

    /// <summary>
    ///     获取或创建共享参数文件的参数组中的参数
    /// </summary>
    /// <param name="group"></param>
    /// <param name="paramName"></param>
    /// <param name="canEdit"></param>
    /// <returns></returns>
    public static Definition GetDefinition(DefinitionGroup group, string paramName, bool canEdit = false)
    {
        if (group is null)
        {
            throw new ArgumentNullException(nameof(group));
        }

        if (paramName is null)
        {
            throw new ArgumentNullException(nameof(paramName));
        }

        var definition = group.Definitions.get_Item(paramName);

        if (definition != null)
        {
            return definition;
        }
#if REVIT2018 || REVIT2020
        var opt = new ExternalDefinitionCreationOptions(paramName, ParameterType.Text) { UserModifiable = canEdit };

#elif REVIT2025
		var opt = new ExternalDefinitionCreationOptions(paramName, SpecTypeId.String.Text) { UserModifiable = canEdit };
#endif

        return group.Definitions.Create(opt);
    }

    public static ExternalDefinition GetDefinition(
        DefinitionFile sharedParamFile,
        string definitionName,
#if REVIT2018 || REVIT2020
        ParameterType paramType,
#elif REVIT2025
        ForgeTypeId paramType,
#endif
        ref Guid guid,
        DefinitionGroup group
    )
    {
        new List<ExternalDefinition>();
        foreach (var definitionGroup in sharedParamFile.Groups)
        {
            foreach (var definition in definitionGroup.Definitions)
            {
                var externalDefinition = (ExternalDefinition)definition;
                if (externalDefinition.Name == definitionName)
                {
                    return externalDefinition;
                }
            }
        }

        ExternalDefinitionCreationOptions externalDefinitionCreationOptions = new(definitionName, paramType);
        return group.Definitions.Create(externalDefinitionCreationOptions) as ExternalDefinition;
    }
    public static Dictionary<Definition, ElementBinding> GetDefinitionBindings(Document doc)
    {
        Dictionary<Definition, ElementBinding> dict = [];
        var dep = doc.ParameterBindings.ForwardIterator();
        while (dep.MoveNext())
        {
            var definition = dep.Key;
            var binding = dep.Current as ElementBinding;
            dict.Add(definition, binding);
        }
        return dict;
    }

    /// <summary>
    ///     获取共享参数文件中的参数组
    /// </summary>
    /// <param name="groups"></param>
    /// <param name="groupName">分组</param>
    /// <returns></returns>
    public static DefinitionGroup GetGroup(DefinitionGroups groups, string groupName)
    {
        return groups is null
            ? throw new ArgumentNullException(nameof(groups))
            : groupName is null
                ? throw new ArgumentNullException(nameof(groupName))
                : groups.get_Item(groupName) ?? groups.Create(groupName);
    }

    public static DefinitionGroup GetGroup(DefinitionFile myDefinitionFile, string groupName, string log)
    {
        DefinitionGroup definitionGroup = null;
        var groups = myDefinitionFile.Groups;
        foreach (var definitionGroup2 in groups)
        {
            if (definitionGroup2.Name == groupName)
            {
                using (StreamWriter streamWriter = new(log, true))
                {
                    streamWriter.WriteLine("Group {0} already exists", groupName);
                }

                definitionGroup = definitionGroup2;
                return definitionGroup;
            }
        }

        using (StreamWriter streamWriter2 = new(log, true))
        {
            streamWriter2.WriteLine("Group {0} not found", groupName);
        }

        definitionGroup = groups.Create(groupName);
        using (StreamWriter streamWriter3 = new(log, true))
        {
            streamWriter3.WriteLine("Group {0} created", definitionGroup.Name);
        }

        return definitionGroup;
    }

    /// <summary>
    ///     获取共享参数文件中的参数组
    /// </summary>
    /// <param name="uiapp"></param>
    /// <param name="parmPath">共享文件路径</param>
    /// <returns></returns>
    public static DefinitionGroups GetGroupList(UIApplication uiapp, string parmPath)
    {
        if (uiapp is null)
        {
            throw new ArgumentNullException(nameof(uiapp));
        }

        if (parmPath is null)
        {
            throw new ArgumentNullException(nameof(parmPath));
        }

        if (!File.Exists(parmPath))
        {
            File.CreateText(parmPath);
        }

        uiapp.Application.SharedParametersFilename = parmPath;

        return uiapp.Application.OpenSharedParameterFile()?.Groups;
    }
    /// <summary>
    /// 获取所有项目参数和定义元素绑定
    /// </summary>
    /// <param name="doc"></param>
    /// <returns></returns>
    public static Dictionary<ParameterElement, ElementBinding> GetParameterElementBindings(Document doc)
    {
        //项目中所有的参数元素，包含共享参数元素
        var parameterElements = doc.OfClass<ParameterElement>().Cast<ParameterElement>();

        Dictionary<ParameterElement, ElementBinding> dict = [];
        //绑定
        var dep = doc.ParameterBindings.ForwardIterator();
        while (dep.MoveNext())
        {
            if (dep.Key is InternalDefinition definition)
            {
                var binding = dep.Current as ElementBinding;
                foreach (var param in parameterElements)
                {
                    var def = param.GetDefinition();

                    if (def.Id == definition.Id)
                    {
                        dict.Add(param, binding);
                    }
                }
            }

        }
        return dict;
    }

    public static void GetSharedPara(Application revitApp)
    {
        // 打开共享参数文件
        var definitionFile = revitApp.OpenSharedParameterFile();
        // 获取参数组的集合
        var groups = definitionFile.Groups;

        foreach (var group in groups)
        {
            // 获取参数组内的参数定义
            foreach (var definition in group.Definitions)
            {
                _ = definition.Name;
#if REVIT2018 || REVIT2020
                _ = definition.ParameterType;
#elif REVIT2025
                _ = definition.GetDataType();
#endif
                // 对参数定义的其他操作
            }
        }
    }

    /// <summary>
    ///     初始化元素绑定（或类型）
    /// </summary>
    /// <param name="uiapp"></param>
    /// <param name="elm">要绑定类别的元素</param>
    /// <param name="paramPath">共享文件路径</param>
    public static void InitParamList(UIApplication uiapp, Element elm, string paramPath)
    {
        if (uiapp is null)
        {
            throw new ArgumentNullException(nameof(uiapp));
        }

        if (elm is null)
        {
            throw new ArgumentNullException(nameof(elm));
        }

        if (paramPath is null)
        {
            throw new ArgumentNullException(nameof(paramPath));
        }

        var doc = uiapp.ActiveUIDocument.Document;

        var bindingMap = doc.ParameterBindings;

        var groups = GetGroupList(uiapp, paramPath);

        CategorySet elmCtgs = new();

        elmCtgs.Insert(elm.Category);

        foreach (var groupPram in groups)
        {
            var paramGroup = GetGroup(groups, groupPram.Name);

            foreach (var definition in groupPram.Definitions)
            {
                var binding = bindingMap.get_Item(definition);

                // 如果参数组的名称包含类型 key，则表示类型绑定。
                if (!paramGroup.Name.Contains("Group"))
                {
                    if (binding is InstanceBinding instanceBinding)
                    {
                        bindingMap.ReInsert(definition, instanceBinding);
                    }
                    else
                    {
                        instanceBinding = uiapp.Application.Create.NewInstanceBinding(elmCtgs);

                        bindingMap.Insert(definition, instanceBinding);
                    }
                }
                else
                {
                    if (binding is TypeBinding typeBinding)
                    {
                        bindingMap.ReInsert(definition, typeBinding);
                    }
                    else
                    {
                        typeBinding = uiapp.Application.Create.NewTypeBinding(elmCtgs);

                        bindingMap.Insert(definition, typeBinding);
                    }
                }
            }
        }
    }
    /// <summary>
    /// 是否存在该项目参数
    /// </summary>
    /// <param name="doc"></param>
    /// <param name="paramName">参数名称</param>
    /// <param name="definition">定义</param>
    /// <param name="binding">参数绑定</param>
    /// <returns></returns>
    public static bool IsExistProjectParam(
        Document doc,
        string paramName,
        out Definition definition,
        out ElementBinding binding
    )
    {
        var dep = doc.ParameterBindings.ForwardIterator();
        var isExist = false;
        binding = null;
        definition = null;
        while (dep.MoveNext())
        {
            definition = dep.Key;
            var definitionName = definition.Name;
            binding = dep.Current as ElementBinding;
            if (definitionName == paramName)
            {
                isExist = true;
                break;
            }
        }

        return isExist;
    }
    /// <summary>
    /// 判断参数是什么参数，true是项目参数的项目参数，false是共享参数的项目参数
    /// </summary>
    /// <param name="param"></param>
    /// <returns></returns>
    public static bool IsProject(Parameter param)
    {
        var doc = param.Element.Document;

        var dict = GetParameterElementBindings(doc);
        var ds = dict.Where(
    e => e.Key.GetDefinition().Id == (param.Definition as InternalDefinition)?.Id);
        if (ds.Any())//说明是项目参数
        {
            var d = ds.FirstOrDefault();
            var parameterElement = d.Key;
            var binding = d.Value;
            if (parameterElement is SharedParameterElement)//共享参数
            {
                return false;
            }
            else//项目参数
            {
                return true;
            }
        }
        return false;
    }
    /// <summary>
    /// 根据定义判断是什么参数
    /// </summary>
    /// <param name="doc"></param>
    /// <param name="paramName"></param>
    /// <returns></returns>
    public static bool IsShared(Document doc, Definition definition)
    {
        var sharedParamElems = doc.OfClass<SharedParameterElement>()
            .Cast<SharedParameterElement>();
        var internalDef = definition as InternalDefinition;

        foreach (var elem in sharedParamElems)
        {
            var def = elem.GetDefinition();
            if (internalDef.Id == def.Id)
            {
                return true;
            }
        }

        return false;
    }
    /// <summary>
    /// 根据参数名判断是否是共享参数
    /// </summary>
    /// <param name="doc"></param>
    /// <param name="paramName"></param>
    /// <returns></returns>
    public static bool IsShared(Document doc, string paramName)
    {
        var dict = GetParameterElementBindings(doc);
        foreach (var keyValue in dict)
        {
            var key = keyValue.Key;
            if (key is SharedParameterElement && key.Name == paramName)
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    ///     修改内建参数
    /// </summary>
    /// <param name="parameter"></param>
    /// <param name="value"></param>
    /// <exception cref="Exception"></exception>
    public static void ModifyBuiltInParameter(Parameter parameter, object value)
    {
        var success = false;
        if (parameter == null)
        {
            throw new Exception("参数为空");
        }
        if (parameter.IsReadOnly)
        {
            throw new Exception("参数是只读的");
        }
        switch (parameter.StorageType)
        {
            case StorageType.Double:
                success = parameter.Set((double)value);
                break;

            case StorageType.ElementId:
                success = parameter.Set((ElementId)value);
                break;

            case StorageType.String:
                success = parameter.Set((string)value);
                break;

            case StorageType.Integer:
                success = parameter.Set((int)value);
                break;
        }

        if (!success)
        {
            throw new Exception("赋值失败");
        }
    }

    public static DefinitionFile OpenSharedParametersFile(Application application)
    {
        var sharedParametersFile = application.OpenSharedParameterFile();
        return sharedParametersFile;
    }
    public static void RemoveFamilyParameter(FamilyInstance instance, string paramName)
    {
        Document famdoc = null;
        Document Document = instance.Document;
        try
        {
            Family family = instance.Symbol.Family;

            if (family.IsEditable)
            {
                famdoc = instance.Document.EditFamily(family);
            }
            else
            {
                Debug.WriteLine($"{family.Name} 不可编辑。");
            }

            if (famdoc != null)
            {
                using (Transaction ts = new(famdoc, "删除参数"))
                {
                    ts.Start();
                    var parametersToRemove = famdoc.FamilyManager
                        .GetParameters()
                        .Where(fp => paramName == fp.Definition.Name);
                    foreach (FamilyParameter fp in parametersToRemove)
                    {
                        famdoc.FamilyManager.RemoveParameter(fp);
                    }
                    ts.Commit();
                }

                famdoc.LoadFamily(Document);
                famdoc.Close(false);
            }
        }
        catch (Exception)
        {
            Debug.WriteLine($"{famdoc.Title} 发生错误！");
        }
    }

    /// <summary>
    ///     移除当前文档中所有可载入族的某些参数
    /// </summary>
    /// <param name="doc"></param>
    /// <param name="paramnames"></param>
    public static void RemoveFamilyParams(Document doc, params string[] paramnames)
    {
        var instances = doc.OfClass<FamilyInstance>().Cast<FamilyInstance>();
        foreach (var instance in instances)
        {
            var family = instance.Symbol.Family;
            var famdoc = doc.EditFamily(family);
            using (Transaction trans = new(famdoc, "删除参数"))
            {
                trans.Start();
                foreach (var paramname in paramnames)
                {
                    var param1 = instance.Symbol.GetParameters(paramname).FirstOrDefault();
                    if (param1 != null)
                    {
                        var fparam1 = famdoc.FamilyManager.get_Parameter(paramname);
                        if (fparam1 != null)
                        {
                            famdoc.FamilyManager.RemoveParameter(fparam1);
                        }
                    }

                    //MessageBox.ShowAhead(famdoc.Title);
                    //var fparams = famdoc.FamilyManager.GetAllTypeParameter();

                    //var para = from p in fparams
                    //           where p.Definition.Name == "Code"
                    //           select p;
                }

                famdoc.LoadFamily(doc, new LoadFamilyOptions());
                trans.Commit();
            }

            famdoc.Close(false);
        }
    }
    /// <summary>
    /// 移除元素上的项目参数
    /// </summary>
    /// <param name="param"></param>
    public static void RemoveProjectParameter(Parameter param)
    {
        Element element = param.Element;
        var doc = element.Document;

        var dict = GetParameterElementBindings(doc);
        var bindings = doc.ParameterBindings;

        var ds = dict.Where(
                e => e.Key.GetDefinition().Id == (param.Definition as InternalDefinition)?.Id);
        if (ds.Any())//说明是项目参数
        {
            var d = ds.FirstOrDefault();
            var parameter = d.Key;
            var binding = d.Value;
            if (binding.Categories.Size == 1)//如果只剩下一个类别，则直接移除
            {
                if (parameter is SharedParameterElement)//共享参数
                {
                    bindings.Remove(param.Definition);
                }
                else//项目参数
                {
                    doc.Delete(parameter.Id);
                }
            }
            else//否则只移除一个类别
            {
                binding.Categories.Erase(element.Category);
                doc.ParameterBindings.ReInsert(parameter.GetDefinition(), binding);
            }
        }
    }

    public static void SharedParamsBindingCategoryset(
        UIApplication uiapp,
        DefinitionFile sharedParametersFile,
        ExternalDefinition param,
        CategorySet categorySet,
        bool isInstance
    )
    {
#if REVIT2018 || REVIT2020
        var paramGroup = param.ParameterGroup;
#elif REVIT2025
        var paramGroup = param.GetGroupTypeId();
#endif

        var instanceBinding = uiapp.Application.Create.NewInstanceBinding(categorySet);
        var typeBinding = uiapp.Application.Create.NewTypeBinding(categorySet);
        var bindingMap = uiapp.ActiveUIDocument.Document.ParameterBindings;

        var extDef = GetSharedParameter(sharedParametersFile, param.OwnerGroup.Name, param.Name);

        if (isInstance)
        {
            bindingMap.Insert(extDef, instanceBinding, paramGroup);
        }
        else
        {
            bindingMap.Insert(extDef, typeBinding, paramGroup);
        }
    }

    /// <summary>
    ///     获取类别和参数的绑定
    /// </summary>
    /// <param name="doc">激活的文档</param>
    public void ShareParameterBinging(Document doc)
    {
        var map = doc.ParameterBindings;
        var dep = map.ForwardIterator();
        while (dep.MoveNext())
        {
            var definition = dep.Key;
            // 获取参数定义的基本信息
            var definitionName = definition.Name;
#if REVIT2018 || REVIT2020
            var parameterType = definition.ParameterType;
#elif REVIT2025
            var parameterType = definition.GetDataType();
#endif
            // 几乎都可以转型为InstanceBinding
            if (dep.Current is InstanceBinding instanceBinding)
            {
                // 获取绑定的类别列表
                var categorySet = instanceBinding.Categories;
            }
        }
    }

    public static IEnumerable<string> InstanceCategories
    {
        get
        {
            yield return "HVAC 区";
            yield return "专用设备";
            yield return "体量";
            yield return "停车场";
            yield return "卫浴装置";
            yield return "喷头";
            yield return "图纸";
            yield return "地形";
            yield return "场地";
            yield return "坡道";
            yield return "墙";
            yield return "天花板";
            yield return "安全设备";
            yield return "家具";
            yield return "家具系统";
            yield return "导线";
            yield return "屋顶";
            yield return "常规模型";
            yield return "幕墙嵌板";
            yield return "幕墙竖梃";
            yield return "幕墙系统";
            yield return "开关系统";
            yield return "房间";
            yield return "护理呼叫设备";
            yield return "数据设备";
            yield return "机械设备";
            yield return "材质";
            yield return "柱";
            yield return "标高";
            yield return "栏杆扶手";
            yield return "植物";
            yield return "楼板";
            yield return "楼梯";
            yield return "橱柜";
            yield return "火警设备";
            yield return "灯具";
            yield return "照明设备";
            yield return "环境";
            yield return "电气装置";
            yield return "电气设备";
            yield return "电缆桥架";
            yield return "电缆桥架管路";
            yield return "电缆桥架配件";
            yield return "电话设备";
            yield return "电路";
            yield return "空间";
            yield return "窗";
            yield return "竖井洞口";
            yield return "管件";
            yield return "管道";
            yield return "管道占位符";
            yield return "管道系统";
            yield return "管道附件";
            yield return "线管";
            yield return "线管管路";
            yield return "线管配件";
            yield return "组成部分";
            yield return "结构加强板";
            yield return "结构区域钢筋";
            yield return "结构基础";
            yield return "结构柱";
            yield return "结构桁架";
            yield return "结构框架";
            yield return "结构梁系统";
            yield return "结构路径钢筋";
            yield return "结构连接";
            yield return "结构钢筋";
            yield return "结构钢筋网";
            yield return "结构钢筋网区域";
            yield return "视图";
            yield return "详图项目";
            yield return "软管";
            yield return "软风管";
            yield return "轴网";
            yield return "通讯设备";
            yield return "道路";
            yield return "部件";
            yield return "钢筋形状";
            yield return "门";
            yield return "面积";
            yield return "项目信息";
            yield return "预制零件";
            yield return "风管";
            yield return "风管内衬";
            yield return "风管占位符";
            yield return "风管管件";
            yield return "风管系统";
            yield return "风管附件";
            yield return "风管隔热层";
            yield return "风道末端";
        }
    }

    public static IEnumerable<string> ProjectParamGroups
    {
        get
        {
            yield return "IFC参数";
            yield return "主端点";
            yield return "光域";
            yield return "其他";
            yield return "分区几何图形";
            yield return "分析平差";
            yield return "分析模型";
            yield return "分析结果";
            yield return "力";
            yield return "力矩";
            yield return "卫浴";
            yield return "可见性";
            yield return "图层";
            yield return "图形";
            yield return "尺寸标注";
            yield return "常规";
            yield return "数据";
            yield return "整个图例";
            yield return "文字";
            yield return "机械";
            yield return "机械 - 流量";
            yield return "机械 - 负荷";
            yield return "材质和装饰";
            yield return "构造";
            yield return "标识数据";
            yield return "标题文字";
            yield return "模型属性";
            yield return "次端点";
            yield return "消防系统";
            yield return "电气";
            yield return "电气 - 照明";
            yield return "电气 - 线路";
            yield return "电气 - 负荷";
            yield return "电气工程";
            yield return "管段和管件";
            yield return "结构";
            yield return "结构分析";
            yield return "绿色建筑属性";
            yield return "编辑板形状";
            yield return "能量分析";
            yield return "释放/杆件力";
            yield return "钢筋集";
            yield return "阶段化";
            yield return "限制条件";
        }
    }

    public static IEnumerable<string> TypeCategories
    {
        get
        {
            yield return "专用设备";
            yield return "体量";
            yield return "停车场";
            yield return "卫浴装置";
            yield return "喷头";
            yield return "地形";
            yield return "场地";
            yield return "坡道";
            yield return "墙";
            yield return "天花板";
            yield return "安全设备";
            yield return "家具";
            yield return "家具系统";
            yield return "导线";
            yield return "屋顶";
            yield return "常规模型";
            yield return "幕墙嵌板";
            yield return "幕墙竖梃";
            yield return "幕墙系统";
            yield return "开关系统";
            yield return "护理呼叫设备";
            yield return "数据设备";
            yield return "机械设备";
            yield return "柱";
            yield return "标高";
            yield return "栏杆扶手";
            yield return "植物";
            yield return "楼板";
            yield return "楼梯";
            yield return "橱柜";
            yield return "火警设备";
            yield return "灯具";
            yield return "照明设备";
            yield return "环境";
            yield return "电气装置";
            yield return "电气设备";
            yield return "电缆桥架";
            yield return "电缆桥架管路";
            yield return "电缆桥架配件";
            yield return "电话设备";
            yield return "窗";
            yield return "管件";
            yield return "管道";
            yield return "管道占位符";
            yield return "管道系统";
            yield return "管道附件";
            yield return "线管";
            yield return "线管管路";
            yield return "线管配件";
            yield return "组成部分";
            yield return "结构加强板";
            yield return "结构区域钢筋";
            yield return "结构基础";
            yield return "结构柱";
            yield return "结构桁架";
            yield return "结构框架";
            yield return "结构梁系统";
            yield return "结构路径钢筋";
            yield return "结构连接";
            yield return "结构钢筋";
            yield return "结构钢筋网";
            yield return "结构钢筋网区域";
            yield return "详图项目";
            yield return "软管";
            yield return "软风管";
            yield return "轴网";
            yield return "通讯设备";
            yield return "部件";
            yield return "钢筋形状";
            yield return "门";
            yield return "预制零件";
            yield return "风管";
            yield return "风管内衬";
            yield return "风管占位符";
            yield return "风管管件";
            yield return "风管系统";
            yield return "风管附件";
            yield return "风管隔热层";
            yield return "风道末端";
        }
    }
}