using System;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Reflection;
using System.Text;
using System.Xml.XPath;
using GThinking.N_MISPROAS.Web.AjaxServices;
using GThinking.N_MISPRO.Data;

namespace GThinking.S_XLXSBJ
{
    /// <summary>
    /// 服务方法管理相关服务。
    /// </summary>
    public class ServiceMethod
    {
        /// <summary>
        /// 根据传入的 DLL 文件地址，反射获取其中标记了 AjaxMethod 的服务方法信息，
        /// 并写入数据库表：SRCMD、SRCMETHOD、SRCMETHODPARAMS、SRCTYPE、SRCPROP。
        /// </summary>
        /// <param name="filePath">DLL 文件地址。</param>
        /// <returns>操作结果。</returns>
        [AjaxMethod(AuthRequried = false)]
        public static Dictionary<string, object> SaveServiceMethodInfo(string filePath)
        {
            Dictionary<string, object> result = new Dictionary<string, object>();
            TDatabase dberp = null;

            if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
            {
                result["success"] = false;
                result["msg"] = "文件地址不能为空或文件不存在";
                return result;
            }

            try
            {
                dberp = TContextDatabases.GetDatabase("DBERP");
                dberp.BeginTrans();

                Assembly assembly = Assembly.LoadFrom(filePath);
                string macId = Truncate(assembly.GetName().Name, 20);

                // 先删除该部件旧数据
                DeleteOldModuleData(dberp, macId);

                XmlDocHelper xmlDoc = new XmlDocHelper(filePath);
                int mdIndex = 0;
                Dictionary<string, string> visitedTypes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

                Type[] types = null;
                try
                {
                    types = assembly.GetTypes();
                }
                catch (ReflectionTypeLoadException ex)
                {
                    types = ex.Types;
                }

                if (types == null)
                {
                    dberp.CommitTrans();
                    result["success"] = true;
                    result["msg"] = "未找到可扫描的类型";
                    result["macId"] = macId;
                    return result;
                }

                foreach (Type type in types)
                {
                    if (type == null)
                        continue;
                    if (!type.IsClass)
                        continue;

                    Dictionary<string, ServiceMethodInfo> methods = GetServiceMethods(type);
                    if (methods == null || methods.Count == 0)
                        continue;

                    mdIndex++;
                    double mdId = (double)mdIndex;

                    InsertSRCMD(dberp, macId, mdId, Truncate(type.FullName, 40));

                    foreach (ServiceMethodInfo smi in methods.Values)
                    {
                        string methodDesc = xmlDoc.GetMethodSummary(smi.MethodInfo);
                        string retDesc = xmlDoc.GetMethodReturns(smi.MethodInfo);

                        InsertSRCMETHOD(
                            dberp,
                            macId,
                            mdId,
                            Truncate(smi.MethodName, 32),
                            Truncate(GetMethodModifiers(smi.MethodInfo), 80),
                            smi.AuthRequried ? "Y" : "N",
                            smi.UseHttpGet ? "Y" : "N",
                            Truncate(methodDesc, 4000),
                            Truncate(GetTypeDisplayName(smi.ReturnType), 80),
                            Truncate(retDesc, 1000));

                        if (smi.ParameterList != null)
                        {
                            int paramXh = 0;
                            foreach (ServiceParameterInfo spi in smi.ParameterList)
                            {
                                string paramDesc = xmlDoc.GetParameterSummary(smi.MethodInfo, spi.Name);

                                InsertSRCMETHODPARAMS(
                                    dberp,
                                    macId,
                                    mdId,
                                    Truncate(smi.MethodName, 32),
                                    (double)paramXh,
                                    Truncate(spi.Name, 32),
                                    Truncate(GetTypeDisplayName(spi.ParameterType), 80),
                                    Truncate(paramDesc, 1000));

                                ReflectType(spi.ParameterType, dberp, visitedTypes, xmlDoc);
                                paramXh++;
                            }
                        }

                        ReflectType(smi.ReturnType, dberp, visitedTypes, xmlDoc);
                    }
                }

                dberp.CommitTrans();
                result["success"] = true;
                result["msg"] = "扫描完成";
                result["macId"] = macId;
            }
            catch (Exception ex)
            {
                if (dberp != null && dberp.InTransaction)
                    dberp.RollbackTrans();

                result["success"] = false;
                result["msg"] = ex.Message;
            }

            return result;
        }

        /// <summary>
        /// 根据 MACID 查询已扫描的服务方法数据。
        /// </summary>
        /// <param name="macId">服务部件ID（程序集名称）。</param>
        /// <returns>包含各表数据的结果。</returns>
        [AjaxMethod(AuthRequried = false)]
        public static Dictionary<string, object> GetServiceMethodData(string macId)
        {
            Dictionary<string, object> result = new Dictionary<string, object>();
            TDatabase dberp = null;

            try
            {
                dberp = TContextDatabases.GetDatabase("DBERP");

                result["SRCMD"] = QueryTableByMacId(dberp, "SRCMD", macId);
                result["SRCMETHOD"] = QueryTableByMacId(dberp, "SRCMETHOD", macId);
                result["SRCMETHODPARAMS"] = QueryTableByMacId(dberp, "SRCMETHODPARAMS", macId);
                result["SRCTYPE"] = QueryAll(dberp, "SRCTYPE");
                result["SRCPROP"] = QueryAll(dberp, "SRCPROP");
                result["success"] = true;
                result["msg"] = "";
            }
            catch (Exception ex)
            {
                result["success"] = false;
                result["msg"] = ex.Message;
            }

            return result;
        }

        #region 数据库操作

        private static void DeleteOldModuleData(TDatabase dberp, string macId)
        {
            string[] tables = new string[] { "SRCMETHODPARAMS", "SRCMETHOD", "SRCMD" };
            TSQL sql = new TSQL(dberp);
            foreach (string table in tables)
            {
                sql.Clear();
                sql.Add("delete from " + table + " where MACID=:pMACID");
                sql.ParamByName("pMACID").Value = macId;
                dberp.ExecSQL(sql);
            }
        }

        private static void DeleteTypeData(TDatabase dberp, string typeFullName)
        {
            TSQL sql = new TSQL(dberp);
            sql.Clear();
            sql.Add("delete from SRCPROP where TYPEFULLNAME=:pTYPEFULLNAME");
            sql.ParamByName("pTYPEFULLNAME").Value = typeFullName;
            dberp.ExecSQL(sql);

            sql.Clear();
            sql.Add("delete from SRCTYPE where TYPEFULLNAME=:pTYPEFULLNAME");
            sql.ParamByName("pTYPEFULLNAME").Value = typeFullName;
            dberp.ExecSQL(sql);
        }

        private static List<Dictionary<string, object>> QueryTableByMacId(TDatabase dberp, string tableName, string macId)
        {
            TSQL sql = new TSQL(dberp);
            sql.Add("select " + GetTableColumns(tableName) + " from " + tableName + " where MACID=:pMACID");
            sql.ParamByName("pMACID").Value = macId;
            DataSet ds = dberp.OpenDataSet(sql);
            return DataTableToList(ds.Tables[0]);
        }

        private static List<Dictionary<string, object>> QueryAll(TDatabase dberp, string tableName)
        {
            TSQL sql = new TSQL(dberp);
            sql.Add("select " + GetTableColumns(tableName) + " from " + tableName);
            DataSet ds = dberp.OpenDataSet(sql);
            return DataTableToList(ds.Tables[0]);
        }

        private static string GetTableColumns(string tableName)
        {
            switch (tableName)
            {
                case "SRCMD":
                    return "MACID, MDID, MDNAME";
                case "SRCMETHOD":
                    return "MACID, MDID, METHODNAME, MODIFIERS, AUTHREQUIRED, USEHTTPGET, METHODDESC, RETTYPE, RETDESC";
                case "SRCMETHODPARAMS":
                    return "MACID, MDID, METHODNAME, PARAMXH, PARAMNAME, PARAMTYPE, PARAMDESC";
                case "SRCTYPE":
                    return "TYPEFULLNAME, NAMESPACE, TYPENAME, TYPEDESC";
                case "SRCPROP":
                    return "TYPEFULLNAME, PROPNAME, PROPTYPEFULLNAME, NAMESPACE, PROPTYPE, PROPDESC";
                default:
                    return "*";
            }
        }

        private static List<Dictionary<string, object>> DataTableToList(DataTable dt)
        {
            List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
            foreach (DataRow row in dt.Rows)
            {
                Dictionary<string, object> item = new Dictionary<string, object>();
                foreach (DataColumn col in dt.Columns)
                {
                    object val = row[col];
                    item[col.ColumnName] = val == DBNull.Value ? null : val;
                }
                list.Add(item);
            }
            return list;
        }

        private static void InsertSRCMD(TDatabase dberp, string macId, double mdId, string mdName)
        {
            TSQL sql = new TSQL(dberp);
            sql.Clear();
            sql.Add("insert into SRCMD(MACID, MDID, MDNAME) values(:pMACID, :pMDID, :pMDNAME)");
            sql.ParamByName("pMACID").Value = macId;
            sql.ParamByName("pMDID").Value = mdId;
            sql.ParamByName("pMDNAME").Value = mdName;
            dberp.ExecSQL(sql);
        }

        private static void InsertSRCMETHOD(TDatabase dberp, string macId, double mdId, string methodName,
            string modifiers, string authRequired, string useHttpGet, string methodDesc,
            string retType, string retDesc)
        {
            TSQL sql = new TSQL(dberp);
            sql.Clear();
            sql.Add("insert into SRCMETHOD(MACID, MDID, METHODNAME, MODIFIERS, AUTHREQUIRED, USEHTTPGET, METHODDESC, RETTYPE, RETDESC) ");
            sql.Add("values(:pMACID, :pMDID, :pMETHODNAME, :pMODIFIERS, :pAUTHREQUIRED, :pUSEHTTPGET, :pMETHODDESC, :pRETTYPE, :pRETDESC)");
            sql.ParamByName("pMACID").Value = macId;
            sql.ParamByName("pMDID").Value = mdId;
            sql.ParamByName("pMETHODNAME").Value = methodName;
            sql.ParamByName("pMODIFIERS").Value = modifiers;
            sql.ParamByName("pAUTHREQUIRED").Value = authRequired;
            sql.ParamByName("pUSEHTTPGET").Value = useHttpGet;
            sql.ParamByName("pMETHODDESC").Value = methodDesc;
            sql.ParamByName("pRETTYPE").Value = retType;
            sql.ParamByName("pRETDESC").Value = retDesc;
            dberp.ExecSQL(sql);
        }

        private static void InsertSRCMETHODPARAMS(TDatabase dberp, string macId, double mdId, string methodName,
            double paramXh, string paramName, string paramType, string paramDesc)
        {
            TSQL sql = new TSQL(dberp);
            sql.Clear();
            sql.Add("insert into SRCMETHODPARAMS(MACID, MDID, METHODNAME, PARAMXH, PARAMNAME, PARAMTYPE, PARAMDESC) ");
            sql.Add("values(:pMACID, :pMDID, :pMETHODNAME, :pPARAMXH, :pPARAMNAME, :pPARAMTYPE, :pPARAMDESC)");
            sql.ParamByName("pMACID").Value = macId;
            sql.ParamByName("pMDID").Value = mdId;
            sql.ParamByName("pMETHODNAME").Value = methodName;
            sql.ParamByName("pPARAMXH").Value = paramXh;
            sql.ParamByName("pPARAMNAME").Value = paramName;
            sql.ParamByName("pPARAMTYPE").Value = paramType;
            sql.ParamByName("pPARAMDESC").Value = paramDesc;
            dberp.ExecSQL(sql);
        }

        private static void InsertSRCTYPE(TDatabase dberp, string typeFullName, string nameSpace,
            string typeName, string typeDesc)
        {
            TSQL sql = new TSQL(dberp);
            sql.Clear();
            sql.Add("insert into SRCTYPE(TYPEFULLNAME, NAMESPACE, TYPENAME, TYPEDESC) ");
            sql.Add("values(:pTYPEFULLNAME, :pNAMESPACE, :pTYPENAME, :pTYPEDESC)");
            sql.ParamByName("pTYPEFULLNAME").Value = typeFullName;
            sql.ParamByName("pNAMESPACE").Value = nameSpace;
            sql.ParamByName("pTYPENAME").Value = typeName;
            sql.ParamByName("pTYPEDESC").Value = typeDesc;
            dberp.ExecSQL(sql);
        }

        private static void InsertSRCPROP(TDatabase dberp, string typeFullName, string propName,
            string propTypeFullName, string nameSpace, string propType, string propDesc)
        {
            TSQL sql = new TSQL(dberp);
            sql.Clear();
            sql.Add("insert into SRCPROP(TYPEFULLNAME, PROPNAME, PROPTYPEFULLNAME, NAMESPACE, PROPTYPE, PROPDESC) ");
            sql.Add("values(:pTYPEFULLNAME, :pPROPNAME, :pPROPTYPEFULLNAME, :pNAMESPACE, :pPROPTYPE, :pPROPDESC)");
            sql.ParamByName("pTYPEFULLNAME").Value = typeFullName;
            sql.ParamByName("pPROPNAME").Value = propName;
            sql.ParamByName("pPROPTYPEFULLNAME").Value = propTypeFullName;
            sql.ParamByName("pNAMESPACE").Value = nameSpace;
            sql.ParamByName("pPROPTYPE").Value = propType;
            sql.ParamByName("pPROPDESC").Value = propDesc;
            dberp.ExecSQL(sql);
        }

        #endregion

        #region 反射与类型辅助

        private static Dictionary<string, ServiceMethodInfo> GetServiceMethods(Type classType)
        {
            if (classType == null)
                return null;

            List<Type> typeList = new List<Type>();
            Type current = classType;
            typeList.Add(current);
            while (current.BaseType != null)
            {
                current = current.BaseType;
                if (current != typeof(object))
                    typeList.Add(current);
            }

            Dictionary<string, ServiceMethodInfo> methods = new Dictionary<string, ServiceMethodInfo>(StringComparer.OrdinalIgnoreCase);
            BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
                                 BindingFlags.Static | BindingFlags.Instance;

            for (int i = typeList.Count - 1; i >= 0; --i)
            {
                MethodInfo[] methodInfos = typeList[i].GetMethods(flags);
                foreach (MethodInfo method in methodInfos)
                {
                    object[] attribs = method.GetCustomAttributes(typeof(AjaxMethodAttribute), true);
                    if (attribs.Length > 0)
                    {
                        AjaxMethodAttribute ajaxAttr = (AjaxMethodAttribute)attribs[0];
                        ServiceMethodInfo smi = new ServiceMethodInfo(method, ajaxAttr);
                        smi.LoadMethodParameters();
                        methods[smi.MethodName] = smi;
                    }
                }
            }
            return methods;
        }

        private static string GetMethodModifiers(MethodInfo method)
        {
            StringBuilder sb = new StringBuilder();
            if (method.IsPublic)
                sb.Append("public ");
            else if (method.IsPrivate)
                sb.Append("private ");
            else if (method.IsFamily)
                sb.Append("protected ");
            else if (method.IsAssembly)
                sb.Append("internal ");

            if (method.IsStatic)
                sb.Append("static ");

            return sb.ToString().Trim();
        }

        private static void ReflectType(Type type, TDatabase dberp,
            Dictionary<string, string> visitedTypes, XmlDocHelper xmlDoc)
        {
            if (type == null)
                return;

            if (type.IsByRef || type.IsPointer)
            {
                ReflectType(type.GetElementType(), dberp, visitedTypes, xmlDoc);
                return;
            }

            if (type.IsArray)
            {
                ReflectType(type.GetElementType(), dberp, visitedTypes, xmlDoc);
                return;
            }

            Type underlying = Nullable.GetUnderlyingType(type);
            if (underlying != null)
            {
                ReflectType(underlying, dberp, visitedTypes, xmlDoc);
                return;
            }

            if (type.IsGenericType)
            {
                Type[] args = type.GetGenericArguments();
                foreach (Type arg in args)
                    ReflectType(arg, dberp, visitedTypes, xmlDoc);

                Type def = type.GetGenericTypeDefinition();
                if (!IsCustomType(def))
                    return;

                type = def;
            }

            if (!IsCustomType(type))
                return;

            string key = type.FullName;
            if (string.IsNullOrEmpty(key))
                return;
            if (visitedTypes.ContainsKey(key))
                return;
            visitedTypes[key] = key;

            string typeFullName = type.FullName.Replace('+', '.');

            // 先清理该类型旧数据，再重新写入
            DeleteTypeData(dberp, typeFullName);

            InsertSRCTYPE(
                dberp,
                Truncate(typeFullName, 80),
                Truncate(type.Namespace, 80),
                Truncate(GetTypeShortName(type), 80),
                Truncate(xmlDoc.GetSummary(type), 1000));

            List<MemberInfo> members = new List<MemberInfo>();
            members.AddRange(type.GetProperties(BindingFlags.Public | BindingFlags.Instance));
            members.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.Instance));
            members.Sort(new MemberNameComparer());

            foreach (MemberInfo mi in members)
            {
                Type memberType = null;
                if (mi is PropertyInfo)
                    memberType = ((PropertyInfo)mi).PropertyType;
                else if (mi is FieldInfo)
                    memberType = ((FieldInfo)mi).FieldType;
                else
                    continue;

                string propTypeFullName = memberType.FullName == null ? memberType.Name : memberType.FullName.Replace('+', '.');

                InsertSRCPROP(
                    dberp,
                    Truncate(typeFullName, 80),
                    Truncate(mi.Name, 32),
                    Truncate(propTypeFullName, 80),
                    Truncate(memberType.Namespace, 80),
                    Truncate(GetTypeDisplayName(memberType), 80),
                    Truncate(xmlDoc.GetSummary(mi), 250));

                ReflectType(memberType, dberp, visitedTypes, xmlDoc);
            }
        }

        private static bool IsCustomType(Type type)
        {
            if (type == null)
                return false;
            if (type.IsGenericParameter)
                return false;
            if (type.IsPrimitive)
                return false;
            if (type == typeof(string) || type == typeof(object) || type == typeof(decimal)
                || type == typeof(DateTime) || type == typeof(TimeSpan) || type == typeof(Guid))
                return false;
            if (type.Namespace != null &&
                (type.Namespace.StartsWith("System") || type.Namespace.StartsWith("Microsoft")))
                return false;
            return true;
        }

        private static string GetTypeDisplayName(Type type)
        {
            if (type == null)
                return "";

            if (type.IsByRef)
                return GetTypeDisplayName(type.GetElementType()) + "&";
            if (type.IsPointer)
                return GetTypeDisplayName(type.GetElementType()) + "*";
            if (type.IsArray)
                return GetTypeDisplayName(type.GetElementType()) + "[]";

            Type underlying = Nullable.GetUnderlyingType(type);
            if (underlying != null)
                return GetTypeDisplayName(underlying) + "?";

            if (type.IsGenericType)
            {
                Type def = type.GetGenericTypeDefinition();
                string baseName = def.FullName;
                if (string.IsNullOrEmpty(baseName))
                    baseName = type.Name;
                baseName = baseName.Replace('+', '.');
                int backtick = baseName.IndexOf('`');
                string cleanName = backtick > 0 ? baseName.Substring(0, backtick) : baseName;

                Type[] genericArgs = type.GetGenericArguments();
                StringBuilder sb = new StringBuilder();
                sb.Append(cleanName);
                sb.Append("<");
                for (int i = 0; i < genericArgs.Length; i++)
                {
                    sb.Append(GetTypeDisplayName(genericArgs[i]));
                    if (i < genericArgs.Length - 1)
                        sb.Append(", ");
                }
                sb.Append(">");
                return sb.ToString();
            }

            if (type.FullName == null)
                return type.Name;
            return type.FullName.Replace('+', '.');
        }

        private static string GetTypeShortName(Type type)
        {
            if (type == null)
                return "";
            string name = type.Name;
            int backtick = name.IndexOf('`');
            if (backtick > 0)
                name = name.Substring(0, backtick);
            return name;
        }

        private static string Truncate(string value, int maxLength)
        {
            if (string.IsNullOrEmpty(value))
                return string.Empty;
            if (value.Length > maxLength)
                return value.Substring(0, maxLength);
            return value;
        }

        #endregion

        #region 嵌套辅助类

        /// <summary>
        /// 服务方法信息。
        /// </summary>
        private class ServiceMethodInfo
        {
            internal ServiceMethodInfo(MethodInfo methodInfo, AjaxMethodAttribute methodAttribute)
            {
                _methodInfo = methodInfo;
                _methodName = methodInfo.Name;
                _isPublic = methodInfo.IsPublic;
                _isStatic = methodInfo.IsStatic;
                _returnType = methodInfo.ReturnType;
                _authRequried = methodAttribute.AuthRequried;
                _useHttpGet = methodAttribute.UseHttpGet;
            }

            private MethodInfo _methodInfo;
            internal MethodInfo MethodInfo
            {
                get { return _methodInfo; }
            }

            private string _methodName;
            public string MethodName
            {
                get { return _methodName == null ? string.Empty : _methodName; }
                set { _methodName = value; }
            }

            private bool _isPublic;
            public bool IsPublic
            {
                get { return _isPublic; }
                set { _isPublic = value; }
            }

            private bool _isStatic;
            public bool IsStatic
            {
                get { return _isStatic; }
                set { _isStatic = value; }
            }

            private Type _returnType;
            public Type ReturnType
            {
                get { return _returnType; }
                set { _returnType = value; }
            }

            private bool _authRequried;
            public bool AuthRequried
            {
                get { return _authRequried; }
                set { _authRequried = value; }
            }

            private bool _useHttpGet;
            public bool UseHttpGet
            {
                get { return _useHttpGet; }
                set { _useHttpGet = value; }
            }

            private List<ServiceParameterInfo> _parameterList;
            public List<ServiceParameterInfo> ParameterList
            {
                get { return _parameterList; }
                set { _parameterList = value; }
            }

            internal void LoadMethodParameters()
            {
                if (_methodInfo == null)
                    return;

                List<ServiceParameterInfo> list = new List<ServiceParameterInfo>();
                int index = 0;
                foreach (ParameterInfo param in _methodInfo.GetParameters())
                {
                    list.Add(new ServiceParameterInfo(param, index));
                    index++;
                }
                _parameterList = list;
            }
        }

        /// <summary>
        /// 服务方法参数信息。
        /// </summary>
        private class ServiceParameterInfo
        {
            private ParameterInfo _param;
            private int _index;

            internal ServiceParameterInfo(ParameterInfo param, int index)
            {
                _param = param;
                _index = index;
            }

            internal ParameterInfo ParameterInfo
            {
                get { return _param; }
            }

            internal int Index
            {
                get { return _index; }
            }

            public string Name
            {
                get { return _param.Name; }
            }

            public Type ParameterType
            {
                get { return _param.ParameterType; }
            }
        }

        /// <summary>
        /// XML 文档注释读取辅助类。
        /// </summary>
        private class XmlDocHelper
        {
            private XPathDocument _doc;
            private XPathNavigator _nav;

            public XmlDocHelper(string dllPath)
            {
                if (string.IsNullOrEmpty(dllPath))
                    return;

                string fullPath = Path.GetFullPath(dllPath);
                string dir = Path.GetDirectoryName(fullPath);
                string xmlPath = Path.Combine(dir, Path.GetFileNameWithoutExtension(fullPath) + ".xml");
                if (!File.Exists(xmlPath))
                    return;

                try
                {
                    _doc = new XPathDocument(xmlPath);
                    _nav = _doc.CreateNavigator();
                }
                catch
                {
                    _doc = null;
                    _nav = null;
                }
            }

            public string GetSummary(Type type)
            {
                if (_nav == null || type == null)
                    return "";
                string id = GetTypeDocId(type);
                return GetChildText("T", id, "summary");
            }

            public string GetSummary(MemberInfo member)
            {
                if (_nav == null || member == null)
                    return "";
                string prefix = "P";
                if (member is FieldInfo)
                    prefix = "F";
                else if (member is PropertyInfo)
                    prefix = "P";
                else if (member is MethodInfo)
                    prefix = "M";
                string id = GetMemberDocId(member);
                return GetChildText(prefix, id, "summary");
            }

            public string GetMethodSummary(MethodInfo method)
            {
                XPathNavigator node = FindMethodNode(method);
                if (node == null)
                    return "";
                XPathNavigator sum = node.SelectSingleNode("summary");
                return sum == null ? "" : sum.Value.Trim();
            }

            public string GetMethodReturns(MethodInfo method)
            {
                XPathNavigator node = FindMethodNode(method);
                if (node == null)
                    return "";
                XPathNavigator ret = node.SelectSingleNode("returns");
                return ret == null ? "" : ret.Value.Trim();
            }

            public string GetParameterSummary(MethodInfo method, string paramName)
            {
                XPathNavigator node = FindMethodNode(method);
                if (node == null || string.IsNullOrEmpty(paramName))
                    return "";
                string expr = "param[@name='" + Escape(paramName) + "']";
                XPathNavigator pn = node.SelectSingleNode(expr);
                return pn == null ? "" : pn.Value.Trim();
            }

            private string GetChildText(string prefix, string id, string childName)
            {
                if (_nav == null)
                    return "";
                string expr = "//member[@name='" + prefix + ":" + Escape(id) + "']";
                XPathNavigator node = _nav.SelectSingleNode(expr);
                if (node == null)
                    return "";
                XPathNavigator child = node.SelectSingleNode(childName);
                return child == null ? "" : child.Value.Trim();
            }

            private XPathNavigator FindMethodNode(MethodInfo method)
            {
                if (_nav == null || method == null)
                    return null;

                string exactId = GetMethodDocId(method);
                string expr = "//member[@name='M:" + Escape(exactId) + "']";
                XPathNavigator node = _nav.SelectSingleNode(expr);
                if (node != null)
                    return node;

                string typeId = GetTypeDocId(method.DeclaringType);
                string prefix = "M:" + Escape(typeId) + "." + method.Name;
                XPathNodeIterator iter = _nav.Select("//member[starts-with(@name,'" + prefix + "')]");
                int pCount = method.GetParameters().Length;

                while (iter.MoveNext())
                {
                    string name = iter.Current.GetAttribute("name", "");
                    int open = name.IndexOf('(');
                    int close = name.LastIndexOf(')');
                    if (open > 0 && close > open)
                    {
                        string sig = name.Substring(open + 1, close - open - 1);
                        int count = string.IsNullOrEmpty(sig) ? 0 : CountChar(sig, ',') + 1;
                        if (count == pCount)
                            return iter.Current.Clone();
                    }
                }
                return null;
            }

            private static string GetTypeDocId(Type type)
            {
                if (type == null)
                    return "";
                string fullName = type.FullName;
                if (string.IsNullOrEmpty(fullName))
                    return type.Name;
                return fullName.Replace('+', '.');
            }

            private static string GetMemberDocId(MemberInfo member)
            {
                Type type = member.DeclaringType;
                string typeId = GetTypeDocId(type);
                if (member is MethodInfo)
                    return GetMethodDocId((MethodInfo)member);
                return typeId + "." + member.Name;
            }

            private static string GetMethodDocId(MethodInfo method)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(GetTypeDocId(method.DeclaringType));
                sb.Append(".");
                sb.Append(method.Name);
                if (method.IsGenericMethod)
                    sb.Append("``").Append(method.GetGenericArguments().Length);
                sb.Append("(");
                ParameterInfo[] ps = method.GetParameters();
                for (int i = 0; i < ps.Length; i++)
                {
                    if (i > 0)
                        sb.Append(",");
                    sb.Append(GetParameterDocTypeName(ps[i].ParameterType));
                }
                sb.Append(")");
                return sb.ToString();
            }

            private static string GetParameterDocTypeName(Type type)
            {
                if (type == null)
                    return "";
                if (type.IsGenericParameter)
                    return type.Name;
                if (type.IsByRef)
                    return GetParameterDocTypeName(type.GetElementType()) + "@";
                if (type.IsPointer)
                    return GetParameterDocTypeName(type.GetElementType()) + "*";
                if (type.IsArray)
                    return GetParameterDocTypeName(type.GetElementType()) + "[]";

                Type underlying = Nullable.GetUnderlyingType(type);
                if (underlying != null)
                    return GetParameterDocTypeName(underlying) + "?";

                if (type.IsGenericType)
                {
                    Type def = type.GetGenericTypeDefinition();
                    string baseName = def.FullName;
                    if (string.IsNullOrEmpty(baseName))
                        baseName = type.Name;
                    baseName = baseName.Replace('+', '.');
                    Type[] args = type.GetGenericArguments();
                    StringBuilder sb = new StringBuilder();
                    sb.Append(baseName);
                    sb.Append("{");
                    for (int i = 0; i < args.Length; i++)
                    {
                        if (i > 0)
                            sb.Append(",");
                        sb.Append(GetParameterDocTypeName(args[i]));
                    }
                    sb.Append("}");
                    return sb.ToString();
                }

                string name = type.FullName;
                if (string.IsNullOrEmpty(name))
                    name = type.Name;
                return name.Replace('+', '.');
            }

            private static string Escape(string s)
            {
                if (s == null)
                    return "";
                return s.Replace("'", "''");
            }

            private static int CountChar(string s, char c)
            {
                int count = 0;
                for (int i = 0; i < s.Length; i++)
                {
                    if (s[i] == c)
                        count++;
                }
                return count;
            }
        }

        /// <summary>
        /// 按成员名称排序的比较器。
        /// </summary>
        private class MemberNameComparer : IComparer<MemberInfo>
        {
            public int Compare(MemberInfo x, MemberInfo y)
            {
                return string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
            }
        }

        #endregion
    }
}