Sai.Toolkit.Revit/Helpers/SharedParamsAssist.cs

using System.IO;
using System.Reflection;

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

namespace Sai.Toolkit.Revit.Helpers;

public class SharedParamsAssist
{
	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 "风道末端";
		}
	}

	/// <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 parameter 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 parameter 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;
	}

	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;
	}

	/// <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 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="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);
	}

	/// <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;
	}

	public 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);

				// If the parameter group's name contains type key, it's means type binding.
				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);
					}
				}
			}
		}
	}

	public bool IsExistSharedParam(
		Document doc,
		string paramName,
		out Definition definition,
		out ElementBinding binding
	)
	{
		DefinitionBindingMap map = doc.ParameterBindings;
		var dep = map.ForwardIterator();
		var isExist = false;
		binding = null;
		definition = null;
		while (dep.MoveNext())
		{
			definition = dep.Key;
			var definitionName = definition.Name;
			binding = dep.Current as ElementBinding;
			//ParameterType parameterType = definition.ParameterType;
			//InstanceBinding instanceBinding = dep.Current as InstanceBinding;
			//if (instanceBinding != null)
			//{
			//    CategorySet categorySet = instanceBinding.Categories;
			//}
			if (definitionName == paramName)
			{
				isExist = true;
				break;
			}
		}

		return isExist;
	}

	/// <summary>
	///     判断共享参数和项目参数
	/// </summary>
	/// <param name="parameter">The parameter<see cref="Parameter" /></param>
	/// <returns></returns>
	public bool IsSharedPara(Parameter parameter)
	{
		var definition = parameter.Definition as InternalDefinition;

		var isSharedParameter = parameter.IsShared; //共享参数

		var isProjectParameter = definition.BuiltInParameter == BuiltInParameter.INVALID && !parameter.IsShared; //项目参数
		return isSharedParameter;
	}

	/// <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 && !parameter.IsReadOnly)
		{
			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("赋值失败");
			}
		}
		else
		{
			throw new Exception("参数是只读的");
		}
	}

	public static DefinitionFile OpenSharedParametersFile(Application application)
	{
		var sharedParametersFile = application.OpenSharedParameterFile();
		return sharedParametersFile;
	}

	/// <summary>
	///     移除当前文档中所有族的某些参数
	/// </summary>
	/// <param name="doc"></param>
	/// <param name="paramnames"></param>
	public static void RemoveParams(Document doc, params string[] paramnames)
	{
		var instances = new FilteredElementCollector(doc).OfClass(typeof(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);
		}
	}

	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;
			}
		}
	}

	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;
	}
}