using Autodesk.Revit.Creation;
using Autodesk.Revit.DB;
using Autodesk.Revit.DB.Architecture;
using Autodesk.Revit.DB.Mechanical;
using Autodesk.Revit.DB.Plumbing;
using HStation.RevitDev.RevitDataExport;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using Document = Autodesk.Revit.DB.Document;

namespace Glodon.Revit.Utility
{
    public class ParameterOperator
    {
        /// <summary>
        /// 构件属性
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="inputElement"></param>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        public static Parameter GetParameterByEnum(Document doc, Element inputElement, string attributeName)
        {
            Parameter useParameter = null;
            try
            {
                var fi = inputElement as FamilyInstance;
                if (null != fi)
                {
                    useParameter = fi.LookupParameter(attributeName);
                    if (useParameter != null)
                    {
                        return useParameter;
                    }
                    useParameter = fi.Symbol.LookupParameter(attributeName);
                    if (null != useParameter) { return useParameter; }
                }

                useParameter = inputElement.LookupParameter(attributeName);
                if (null != useParameter) { return useParameter; }

                Element element = doc.GetElement(inputElement.GetTypeId());
                if (null != element)
                {
                    useParameter = element.LookupParameter(attributeName);
                    if (null != useParameter) { return useParameter; }
                }
            }
            catch (Exception)
            {
            }

            return null;
        }

        public static PipingSystemType GetElementPipingSystemType(Element elem)
        {
            if (elem is Pipe pipe)
            {
                var mepSystem = pipe.MEPSystem;
                if (mepSystem == null) { return null; }
                var typeId = mepSystem.GetTypeId();
                return elem.Document.GetElement(typeId) as PipingSystemType;
            }
            else if(elem is FamilyInstance fi)
            {
                var parameter = fi.LookupParameter("系统类型");
                if (parameter == null) { return null; }
                if (parameter.StorageType == StorageType.String)
                {
                    var name = parameter.AsString();
                    var pst = new FilteredElementCollector(elem.Document).OfClass(typeof(PipingSystemType)).ToElements()?.Cast<PipingSystemType>().ToList()?.Find(x=>x.Name == name);
                    return pst;
                }
                else if (parameter.StorageType == StorageType.ElementId)
                {
                    var elemId = parameter.AsElementId();
                    return elem.Document.GetElement(elemId) as PipingSystemType;
                }
               
            }
            return null;
        }

        /// <summary>
        /// 获取属性
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="inputElement"></param>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        public static Parameter GetParameter(Document doc, Element inputElement, string attributeName)
        {
            return GetParameterByEnum(doc, inputElement, attributeName);
        }

        /// <summary>
        /// 获取属性值
        /// </summary>
        /// <param name="inputParameter"></param>
        /// <returns></returns>
        public static string GetParemeterValue(Parameter parameter)
        {
            if (parameter == null)
            {
                return string.Empty;
            }

            var result = string.Empty;
            if (parameter.StorageType == StorageType.Integer)
            {
                result = parameter.AsInteger().ToString();
            }
            else if (parameter.StorageType == StorageType.Double)
            {
                result = parameter.AsDouble().ToString();
            }
            else if (parameter.StorageType == StorageType.ElementId)
            {
                result = parameter.AsValueString();
            }
            else
            {
                result = string.IsNullOrWhiteSpace(parameter.AsString()) ? parameter.AsValueString() : parameter.AsString();
            }
            if (result == null)
            {
                return string.Empty;
            }
            return result;
        }

        /// <summary>
        /// 获取名称属性值
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="inputElement"></param>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        public static string GetElementName(Element eachElement)
        {
            try
            {
                //获取实例 族与类型 参数值
                Parameter param = eachElement.get_Parameter(BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM);
                string value = GetParemeterValue(param);
                if (!String.IsNullOrEmpty(value))
                {
                    return value;
                }

                return eachElement.Name;
            }
            catch (Exception)
            {
                return String.Empty;
            }
        }

        /// <summary>
        /// 获取族与类型参数
        /// </summary>
        /// <returns></returns>
        public static string GetElementFamilyAndTypeValue(Element eachElement)
        {
            try
            {
                //获取实例 族与类型 参数值
                Parameter param = eachElement.get_Parameter(BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM);
                string value = GetParemeterValue(param);
                if (!string.IsNullOrEmpty(value))
                {
                    return value;
                }

                //如 族与类型 获取失败，只提取类型名称
                var type = eachElement.Document.GetElement(eachElement.GetTypeId());
                return type == null ? string.Empty : type.Name;
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 属性值是否可用
        /// </summary>
        /// <param name="lstParametet"></param>
        /// <param name="paraValue"></param>
        /// <returns></returns>
        private static bool ExtractParameter(IList<Parameter> lstParametet, out string paraValue)
        {
            paraValue = string.Empty;

            foreach (var item in lstParametet)
            {
                var value = GetParemeterValue(item);

                var succeed = value != null
                    && !string.IsNullOrWhiteSpace(value)
                    && value != "0";

                if (succeed)
                {
                    paraValue = value;
                    return succeed;
                }
            }

            return false;
        }

        /// <summary>
        /// 是否为mep构件
        /// </summary>
        /// <returns></returns>
        private static bool IsMEPInstace(BuiltInCategory instanceCategory)
        {
            switch (instanceCategory)
            {
                case BuiltInCategory.OST_DuctSystem:
                case BuiltInCategory.OST_PipingSystem:
                    return true;
                default:
                    return false;
            }
        }

        public static string GetPipeSystemTypeName(Pipe pipe)
        {
            try
            {
                var parameter = pipe.get_Parameter(BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM);
                return parameter.AsValueString();
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        public static string GetDuctSystemTypeName(Duct duct)
        {
            try
            {
                var parameter = duct.get_Parameter(BuiltInParameter.RBS_DUCT_SYSTEM_TYPE_PARAM);
                if (parameter == null) { return null; }
                return parameter.AsValueString();
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 获取参数值 AsDouble
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static double? GetParameterValueAsDouble(Element elem, BuiltInParameter builtInParameter)
        {
            double? result = null;
            if (elem != null && elem.get_Parameter(builtInParameter) is Parameter para)
            {
                if (para == null || !para.HasValue) { return result; }
                result =para.AsDouble();
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsDouble
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="innerTo">单位转换方法</param>
        /// <returns></returns>
        public static double? GetParameterValueAsDouble(Element elem, string paramName, Func<object, double?> innerTo = null)
        {
            double? result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameterByProName(paramName);
                if (para == null || !para.HasValue) { return result; }
                switch (para.StorageType)
                {
                    case StorageType.None:
                        break;
                    case StorageType.Integer:
                        result = para.AsInteger();
                        break;
                    case StorageType.Double:
                        if (innerTo != null && para.GetUnitTypeId() != UnitTypeId.General)
                        {
                            result = innerTo(para.AsDouble());
                        }
                        else
                        {
                            result = para.AsDouble();
                        }
                        break;
                    case StorageType.String:
                        result = StringToDouble(para.AsString());
                        break;
                    case StorageType.ElementId:
                        //不处理
                        break;
                    default:
                        break;
                }
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsDouble
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramNames"></param>
        /// <param name="innerTo"></param>
        /// <returns></returns>
        public static double? GetParameterValueAsDouble(Element elem, string[] paramNames, Func<object, double?> innerTo = null)
        {
            double? result = null;
            foreach (var paramName in paramNames)
            {
                var res = GetParameterValueAsDouble(elem, paramName, innerTo);
                if (res != null)
                {
                    result = res;
                    break;
                }
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsString
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <returns></returns>
        public static string GetParameterValueAsString(Element elem, string paramName)
        {
            string result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameterByProName(paramName);
                if (para == null || !para.HasValue) { return result; }
                switch (para.StorageType)
                {
                    case StorageType.None:
                        result = para.AsString();
                        break;
                    case StorageType.Integer:
                        result = para.AsInteger().ToString();
                        break;
                    case StorageType.Double:
                        result = para.AsValueString();
                        break;
                    case StorageType.String:
                        result = para.AsString();
                        break;
                    case StorageType.ElementId:
                        result = para.AsElementId().IntegerValue.ToString();
                        break;
                    default:
                        break;
                }

            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsValueString
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <returns></returns>
        public static string GetParameterValueAsValueString(Element elem, string paramName)
        {
            string result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameterByProName(paramName);
                if (para == null || !para.HasValue) { return result; }
                switch (para.StorageType)
                {
                    case StorageType.None:
                        result = para.AsString();
                        break;
                    case StorageType.Integer:
                        result = para.AsInteger().ToString();
                        break;
                    case StorageType.Double:
                        result = para.AsValueString();
                        break;
                    case StorageType.String:
                        result = para.AsString();
                        break;
                    case StorageType.ElementId:
                        result = para.AsElementId().IntegerValue.ToString();
                        break;
                    default:
                        break;
                }
            }
            return result;
        }
       
        /// <summary>
        /// 获取参数值 AsDouble
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <param name="innerTo">单位转换方法</param>
        /// <returns></returns>
        public static double? GetParameterValueAsDouble(Element elem, string paramName, BuiltInParameter builtInParameter, Func<object, double?> innerTo = null)
        {
            double? result = null;
            try
            {
                if (elem != null)
                {
                    Parameter para = elem.GetParameter(paramName, builtInParameter);
                    if (para == null || !para.HasValue) { return result; }
                    switch (para.StorageType)
                    {
                        case StorageType.None:
                            break;
                        case StorageType.Integer:
                            result = para.AsInteger();
                            break;
                        case StorageType.Double:
                            if (innerTo != null && para.GetUnitTypeId() != UnitTypeId.General)//传入了单位转换方法 且参数设置了单位
                            {
                                result = innerTo(para.AsDouble());
                            }
                            else
                            {
                                result = para.AsDouble();
                            }
                            break;
                        case StorageType.String:
                            result = StringToDouble(para.AsString());
                            break;
                        case StorageType.ElementId:
                            //不处理
                            break;
                        default:
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                return null;
            }
            return result;
        }
       
        /// <summary>
        /// 值是字符串，可能是由是数字+单位组成，也可能没有单位
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static double? StringToDouble(string str)
        {
            double? value = null;
            if (string.IsNullOrWhiteSpace(str))
                return value;
            //Regex r = new Regex(@"([1-9]\d*\.?\d*)|(0\.\d*[1-9])");
            Regex r = new Regex(@"([+-]?(\d*\.\d+([eE]?[+-]?\d+)?|\d+[eE][+-]?\d+))|([+-]?\d*)|([1-9]\d*\.?\d*)|(0\.\d*[1-9])");
            //开始匹配
            Match m = r.Match(str);
            string newStr = "";
            while (m.Success)
            {
                //匹配成功
                newStr += m.Groups[0].Value;

                //从上一个匹配结束的位置开始下一个匹配
                m = m.NextMatch();
            }
            if (newStr == "")
            {
                return value;
            }
            value = Convert.ToDouble(newStr);
            return value;
        }
       
        /// <summary>
        /// 获取参数值 AsString
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static string GetParameterValueAsString(Element elem, string paramName, BuiltInParameter builtInParameter)
        {
            string result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameter(paramName, builtInParameter);
                if (para == null || !para.HasValue) { return result; }
                switch (para.StorageType)
                {
                    case StorageType.None:
                        result = para.AsString();
                        break;
                    case StorageType.Integer:
                        result = para.AsInteger().ToString();
                        break;
                    case StorageType.Double:
                        result = para.AsValueString();
                        break;
                    case StorageType.String:
                        result = para.AsString();
                        break;
                    case StorageType.ElementId:
                        result = para.AsElementId().IntegerValue.ToString();
                        break;
                    default:
                        break;
                }
            }
            return result;
        }
       
        /// <summary>
        /// 获取参数值 AsValueString
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static string GetParameterValueAsValueString(Element elem, string paramName, BuiltInParameter builtInParameter)
        {
            string result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameter(paramName, builtInParameter);
                if (para == null || !para.HasValue) { return result; }
                result = para.AsValueString();
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsInt
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static int? GetParameterValueAsInt(Element elem, string paramName, BuiltInParameter builtInParameter)
        {
            int? result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameter(paramName, builtInParameter);
                if (para == null || !para.HasValue) { return result; }
                switch (para.StorageType)
                {
                    case StorageType.None:
                        break;
                    case StorageType.Integer:
                        result = para.AsInteger();
                        break;
                    case StorageType.Double:
                        //不处理
                        break;
                    case StorageType.String:
                        result = StringToInt(para.AsString());
                        break;
                    case StorageType.ElementId:
                        result = para.AsElementId().IntegerValue;
                        break;
                    default:
                        break;
                }
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsInt
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static int? GetParameterValueAsInt(Element elem, string paramName)
        {
            int? result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameterByProName(paramName);
                if (para == null || !para.HasValue) { return result; }
                switch (para.StorageType)
                {
                    case StorageType.None:
                        break;
                    case StorageType.Integer:
                        result = para.AsInteger();
                        break;
                    case StorageType.Double:
                        //不处理
                        break;
                    case StorageType.String:
                        result = StringToInt(para.AsString());
                        break;
                    case StorageType.ElementId:
                        result = para.AsElementId().IntegerValue;
                        break;
                    default:
                        break;
                }
            }
            return result;
        }
       
        /// <summary>
        /// 将特殊的字符串转成int表示的bool
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static int? StringToInt(string str)
        {
            if (str == "是" || str == "正确" || str == "true" || str == "True" || str == "真" || str == "对" || str == "有")
            {
                return 1;
            }
            else if (str == "否" || str == "错误" || str == "不正确" || str == "false" || str == "False" || str == "假" || str == "不对" || str == "没有")
            {
                return 0;
            }
            else if(int.TryParse(str, out int result))
            {
                return result;
            }
            else 
            { 
                return null;
            }
        }
       
        /// <summary>
        /// 获取参数值 AsElementId
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static ElementId GetParameterValueAsElementId(Element elem, string paramName, BuiltInParameter builtInParameter)
        {
            ElementId result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameter(paramName, builtInParameter);
                if (para == null || !para.HasValue) { return result; }
                result = para.AsElementId();
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsElementId
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static ElementId GetParameterValueAsElementId(Element elem, BuiltInParameter builtInParameter)
        {
            ElementId result = null;
            if (elem != null)
            {
                Parameter para = elem.get_Parameter(builtInParameter);
                if (para == null || !para.HasValue) { return result; }
                result = para.AsElementId();
            }
            return result;
        }

        /// <summary>
        /// 获取参数值 AsElementId
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtInParameter"></param>
        /// <returns></returns>
        public static ElementId GetParameterValueAsElementId(Element elem, string paramName)
        {
            ElementId result = null;
            if (elem != null)
            {
                Parameter para = elem.GetParameterByProName(paramName);
                if (para == null || !para.HasValue) { return result; }
                result = para.AsElementId();
            }
            return result;
        }

        /// <summary>
        /// 获取系统类型名称字符串
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="paramName"></param>
        /// <param name="builtIn"></param>
        /// <returns></returns>
        public static string GetSystemTypeName(Element elem, string paramName, BuiltInParameter builtInParameter = BuiltInParameter.INVALID)
        {
            string res = null;
            try
            {
                if (builtInParameter != BuiltInParameter.INVALID)
                {
                    Parameter para = elem.GetParameter(paramName, builtInParameter);
                    if (para != null)
                    {
                        if (para.StorageType == StorageType.ElementId)
                        {
                            var elemId = para.AsElementId();
                            if (elemId != null && elemId != ElementId.InvalidElementId)
                            {
                                var tempElem = elem.Document.GetElement(elemId);
                                res = tempElem.Name;
                            }
                        }
                        else
                        {
                            res = para.AsValueString();
                        }
                    }
                }
                else
                {
                    Parameter para = elem.GetParameterByProName(paramName);
                    if (para != null)
                    {
                        if (para.StorageType == StorageType.ElementId)
                        {
                            var elemId = para.AsElementId();
                            if (elemId != null && elemId != ElementId.InvalidElementId)
                            {
                                var tempElem = elem.Document.GetElement(elemId);
                                res = tempElem.Name;
                            }
                        }
                        else
                        {
                            res = para.AsValueString();
                        }
                    }
                }
            }
            catch
            {

            }
            return res;
        }
    }

    public static class ParameterUtil
    {
        /// <summary>
        /// 有内置参数的，调用该函数
        /// </summary>
        /// <param name="element"></param>
        /// <param name="parameterName">参数名</param>
        /// <param name="builtInParameter">内置参数</param>
        /// <returns></returns>
        public static Parameter GetParameter(this Element element, string parameterName, BuiltInParameter builtInParameter)
        {
            Parameter para = null;
            try
            {
                if (element is ElementType)
                {
                    para = element.get_Parameter(builtInParameter);
                }
                else
                {
                    para = element.get_Parameter(builtInParameter);
                    if (para == null)
                    {
                        var typeId = element.GetTypeId();
                        if (typeId == null)
                        {
                            return null;
                        }
                        var type = element.Document.GetElement(typeId) as ElementType;
                        para = type.get_Parameter(builtInParameter);
                    }
                }
            }
            catch (Exception ex)
            {
                para = null;
            }
           
            return para == null ? GetParameterByProName(element, parameterName) : para;
        }
        /// <summary>
        /// 根据参数名获取参数，如果element是类型，获取的就是类型参数，
        /// 如果element是实例，先获取实例参数，如果获取不到，就获取类型参数，实例参数优先
        /// 如果参数有多个，取有参数值的那个，如果多个有参数值，就取第一个有参数值的
        /// </summary>
        /// <param name="element"></param>
        /// <param name="parameterName"></param>
        /// <returns></returns>
        public static Parameter GetParameterByProName(this Element element, string parameterName)
        {
            if (element is ElementType elementType)
            {
                return GetParameterByName(elementType, parameterName);
            }
            else
            {
                var result = GetParameterByName(element, parameterName);
                if (result != null)
                {
                    return result;
                }
                var typeId = element.GetTypeId();
                if (typeId == null || typeId == ElementId.InvalidElementId)
                {
                    return null;
                }
                var type = element.Document.GetElement(typeId) as ElementType;
                return GetParameterByName(type, parameterName);
            }
        }
        /// <summary>
        /// 根据参数名获取，如果参数有多个，取有参数值的那个，如果多个有参数值，就取第一个有参数值的
        /// </summary>
        /// <param name="element"></param>
        /// <param name="parameterName"></param>
        /// <returns></returns>
        private static Parameter GetParameterByName(this Element element, string parameterName)
        {
            if (string.IsNullOrEmpty(parameterName))
            {
                return null;
            }
            var parameters = element.GetParameters(parameterName);
            if (parameters.Count == 0)
            {
                return null;
            }
            if (parameters.Count == 1)
            {
                return parameters[0];
            }
            //如果参数有多个，获取有值的参数
            var tempParams = parameters.Where(x => !string.IsNullOrEmpty(ParameterOperator.GetParemeterValue(x))).ToList();
            //如果多个参数都没有值 则返回第一个
            if (tempParams.Count == 0)
            {
                return parameters.First();
            }
            //如果只有一个参数有值 则返回这个参数
            if (tempParams.Count == 1)
            {
                return tempParams.First();
            }

            return tempParams.First();
        }
    }
}