using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace Tango.Scripting.Editors.Intellisense
{
    public static class Utils
    {
        private static String dotNetXmlFolder = @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.X";
        private static Dictionary<Assembly, XmlDocument> _assemblies_docs_cache;

        static Utils()
        {
            _assemblies_docs_cache = new Dictionary<Assembly, XmlDocument>();
        }

        public static void LoadKnownTypeDocs(KnownType knownType)
        {
            XmlDocument xmlDoc = null;

            if (_assemblies_docs_cache.ContainsKey(knownType.Type.Assembly))
            {
                xmlDoc = _assemblies_docs_cache[knownType.Type.Assembly];
            }

            if (xmlDoc == null)
            {
                String dllPath = knownType.Type.Assembly.Location;

                string docuPath = dllPath.Substring(0, dllPath.LastIndexOf(".")) + ".XML";

                if (File.Exists(docuPath))
                {
                    xmlDoc = new XmlDocument();
                    xmlDoc.Load(docuPath);
                }
                else if (File.Exists(System.IO.Path.Combine(dotNetXmlFolder, System.IO.Path.GetFileName(docuPath))))
                {
                    xmlDoc = new XmlDocument();
                    xmlDoc.Load(System.IO.Path.Combine(dotNetXmlFolder, System.IO.Path.GetFileName(docuPath)));
                }

                if (xmlDoc != null)
                {
                    _assemblies_docs_cache.Add(knownType.Type.Assembly, xmlDoc);
                }
            }

            if (xmlDoc == null)
            {
                xmlDoc = new XmlDocument();
            }

            //Load Type Summary
            {
                string path = "T:" + knownType.Type.FullName;
                XmlNode xmlDocuOfType = xmlDoc.SelectSingleNode("//member[starts-with(@name, '" + path + "')]");

                if (xmlDocuOfType != null)
                {
                    XmlNode summaryNode = xmlDocuOfType.SelectSingleNode("summary");
                    knownType.Summary = summaryNode.InnerText;
                }
            }

            //Load Constructors...
            {
                string path = "M:" + knownType.Type.FullName + ".#ctor";

                var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();

                for (int i = 0; i < knownType.Constructors.Count; i++)
                {
                    var constructor = knownType.Constructors[i];
                    XmlNode cDoc = null;

                    if (i < docNodes.Count)
                    {
                        cDoc = docNodes[i];
                    }

                    constructor.Summary = cDoc != null ? cDoc.SelectSingleNode("summary").InnerXml : $"Initializes a new instance of {knownType.FriendlyName}.";

                    var parameters = constructor.Parameters.ToList();
                    var parametersNodes = cDoc != null ? cDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();

                    for (int j = 0; j < parameters.Count; j++)
                    {
                        var parameter = parameters[j];
                        XmlNode pNode = null;

                        if (j < parametersNodes.Count)
                        {
                            pNode = parametersNodes[j];
                        }

                        parameter.Description = pNode != null ? pNode.InnerText : null;
                    }
                }
            }

            //Load Methods...
            {
                string path = "M:" + knownType.Type.FullName;

                var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();

                for (int i = 0; i < knownType.Methods.Count; i++)
                {
                    var method = knownType.Methods[i];
                    XmlNode mDoc = null;

                    mDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(knownType.Type.Name + "." + method.Name));
                    method.Summary = mDoc != null ? mDoc.SelectSingleNode("summary").InnerXml.Remove("(<see cref=\".:)|(\" \\/>)") : "No documentation";

                    var parameters = method.Parameters.ToList();
                    var parametersNodes = mDoc != null ? mDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();

                    bool isLinq = knownType.Type == typeof(Enumerable);

                    for (int j = 0; j < parameters.Count; j++)
                    {
                        var parameter = parameters[j];

                        XmlNode pNode = null;

                        if (j < parametersNodes.Count)
                        {
                            pNode = parametersNodes[j];
                        }

                        parameter.Description = pNode != null ? pNode.InnerText.Remove("(<see cref=\".:)|(\" \\/>)") : null;
                    }
                }
            }

            //Load Properties
            {
                string path = "P:" + knownType.Type.FullName;

                var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();

                for (int i = 0; i < knownType.Properties.Count; i++)
                {
                    var property = knownType.Properties[i];
                    var pDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(knownType.Type.Name + "." + property.Name));

                    property.Summary = pDoc != null ? pDoc.SelectSingleNode("summary").InnerXml : "No documentation";
                }
            }

            //Load Enum Values
            {
                if (knownType.Type.IsEnum)
                {
                    for (int i = 0; i < knownType.Fields.Count; i++)
                    {
                        var field = knownType.Fields[i];
                        var pDoc = xmlDoc.SelectSingleNode("//member[starts-with(@name, '" + $"F:{knownType.Type.FullName}.{field.Name}" + "')]");
                        field.Summary = pDoc != null ? pDoc.SelectSingleNode("summary").InnerXml : "No documentation";
                    }
                }
            }
        }
    }
}