using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Mono.Cecil;
using Mono.Collections.Generic;

namespace Mono.Documentation.Updater.Frameworks
{
    /// <summary>resolver to handle assembly lookups</summary>
    /// <remarks><para>This resolver handles two scenarios. First is UWP
    /// references to 'mscorlib' (which simply picks up the 4.5 version, 
    /// or whatever you have installed). And second, it tries its 
    /// best to match on version. If it can't find the exact version, it 
    /// will try to find the next highest version, and if that fails, 
    /// a lower version if available.</para>
    /// <para>Please note that you will need to provide a reference
    /// to the UWP framework directory, if you are trying to document
    /// a UWP library. </para></remarks>
    public class MDocResolver : MDocBaseResolver
    {
        public bool MatchHighestVersionOnZeroVersion { get; private set; }

        public class TypeForwardEventArgs : EventArgs
        {
            public AssemblyNameReference From { get; private set; }
            public AssemblyNameReference To { get; private set; }
            /// <summary>The Type's FullName</summary>
            public string ForType { get; set; }

            public TypeForwardEventArgs(AssemblyNameReference from, AssemblyNameReference to, string forType)
            {
                From = from;
                To = to;
                ForType = forType;
            }

            public override string ToString()
            {
                return $"forward {ForType} from {From} to {To}";
            }
        }

        public MDocResolver() : base()
        {
            try
            {
                this.RemoveSearchDirectory(".");
                this.RemoveSearchDirectory("bin");
            }
            catch { }
        }

        public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
        {
            return Resolve(name, parameters, null, null);
        }

        public event EventHandler<TypeForwardEventArgs> TypeExported;

        internal AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters r, TypeReference forType, List<string> exportedFiles)
        {
            if (exportedFiles == null)
                exportedFiles = new List<string>();

            var a = this.ResolveCore(name, r, exportedFiles);

            if (forType != null && a.MainModule.HasExportedTypes)
            {
                var etype = a.MainModule.ExportedTypes.SingleOrDefault(t => t.FullName == forType.FullName) as ExportedType;
                if (etype != null)
                {
                    string file = a.MainModule.FileName;
                    AssemblyNameReference exportedTo = (AssemblyNameReference)etype.Scope;
                    Console.WriteLine($"resolving {forType.FullName} in {name.FullName}. Found {file}, but it's exported to {exportedTo.FullName}");
                    if (forType != null)
                        TypeExported?.Invoke(this, new TypeForwardEventArgs(name, exportedTo, forType?.FullName));

                    exportedFiles.Add(file);
                    return Resolve(exportedTo, r, forType, exportedFiles);
                }
            }

            return a;
        }

        AssemblyDefinition ResolveCore(AssemblyNameReference name, ReaderParameters parameters, IEnumerable<string> assembliesToIgnore)
        {
            var ver = name.Version;
            if (ver.Major == 255 && ver.Minor == 255 && ver.Revision == 255 && name.Name == "mscorlib")
            {
                var v = new Version(4, 5, 0);
                var anr = new AssemblyNameReference(name.Name, v);
                return base.Resolve(anr, parameters, assembliesToIgnore);
            }
            else
                return base.Resolve(name, parameters, assembliesToIgnore);
        }

        IEnumerable<AssemblyDefinition> GetInstalledAssemblies(AssemblyNameReference name, ReaderParameters parameters, IEnumerable<string> filesToIgnore)
        {
            AssemblyDefinition assembly;
            if (name.IsRetargetable)
            {
                // if the reference is retargetable, zero it
                name = new AssemblyNameReference(name.Name, MDocResolverMixin.ZeroVersion)
                {
                    PublicKeyToken = Empty<byte>.Array,
                };
            }

            string[] framework_dirs = GetFrameworkPaths();

            if (IsZero(name.Version))
            {
                assembly = base.SearchDirectory(name, framework_dirs, parameters, filesToIgnore);
                if (assembly != null)
                    yield return assembly;
            }

            if (name.Name == "mscorlib")
            {
                assembly = base.GetCorlib(name, parameters);
                if (assembly != null)
                    yield return assembly;
            }

            assembly = base.GetAssemblyInGac(name, parameters);
            if (assembly != null)
                yield return assembly;

            assembly = base.SearchDirectory(name, framework_dirs, parameters, filesToIgnore);
            if (assembly != null)
                yield return assembly;
        }

        protected override AssemblyDefinition SearchDirectory(AssemblyNameReference name, IEnumerable<string> directories, ReaderParameters parameters, IEnumerable<string> filesToIgnore)
        {
            // look in all sub directies for assemblies
            var namedPaths = GetAssemblyPaths(name, directories, filesToIgnore, true).ToArray();

            if (!namedPaths.Any()) return null;

            Func<Version, int> aggregateVersion = version => version.Major * 100000 +
                        version.Minor * 10000 +
                        version.Build * 10 +
                        version.Revision;

            Func<string, AssemblyDefinition> getAssemblies = (path) => {
                return GetAssembly(path, parameters);
            };

            var applicableVersions = namedPaths
                .Select(getAssemblies)
                .Concat(GetInstalledAssemblies(name, parameters, filesToIgnore))
                .Select(a => new
                {
                    Assembly = a,
                    SuppliedDependency = namedPaths.Any(np => np == a.MainModule.FileName),
                    VersionSort = aggregateVersion(a.Name.Version),
                    VersionDiff = aggregateVersion(a.Name.Version) - aggregateVersion(name.Version),
                    MajorMatches = a.Name.Version.Major == name.Version.Major
                });

            AssemblyDefinition assemblyToUse = null;

            // If the assembly has all zeroes, just grab the latest assembly
            if (IsZero(name.Version))
            {
                if (!this.MatchHighestVersionOnZeroVersion)
                    return applicableVersions.First().Assembly;
                else
                {
                    var possibleSet = applicableVersions;
                    if (applicableVersions.Any(s => s.SuppliedDependency))
                        possibleSet = applicableVersions.Where(av => av.SuppliedDependency).ToArray();

                    var sorted = possibleSet.OrderByDescending(v => v.VersionSort).ToArray();

                    var highestMatch = sorted.FirstOrDefault();
                    if (highestMatch != null)
                    {
                        assemblyToUse = highestMatch.Assembly;
                        goto TheReturn;
                    }
                }
            }

            applicableVersions = applicableVersions.ToArray();

            // Perfect Match
            var exactMatch = applicableVersions.FirstOrDefault(v => v.VersionDiff == 0);
            if (exactMatch != null)
            {
                assemblyToUse = exactMatch.Assembly;
                goto TheReturn;
            }

            // closest high version
            var newerVersions = applicableVersions
                .Where(v => v.VersionDiff > 0)
                .OrderBy(a => a.VersionSort)
                .Select(v => v.Assembly)
                .ToArray();
            if (newerVersions.Any())
            {
                assemblyToUse = newerVersions.First();
                goto TheReturn;
            }

            // Are there any lower versions as a last resort?
            var olderVersions = applicableVersions
                .Where(v => v.VersionDiff < 0)
                .OrderByDescending(v => v.VersionSort)
                .Select(v => v.Assembly)
                .ToArray();
            if (olderVersions.Any())
            {
                assemblyToUse = olderVersions.First();
                goto TheReturn;
            }

            // return null if you don't find anything
            TheReturn:
            foreach (var assemblyToDisposeOf in applicableVersions.Where(a => a.Assembly != assemblyToUse))
            {
                assemblyToDisposeOf.Assembly.Dispose();
            }
            return assemblyToUse;

        }

        // some helper classes
        static class Empty<T>
        {
            public static readonly T[] Array = new T[0];
        }

        class MDocResolverMixin
        {
            public static Version ZeroVersion = new Version(0, 0, 0, 0);
        }
    }

    /// <summary>
    /// Wraps a resolver, and caches assemblies to avoid excessive calls to disk
    /// </summary>
    /// <remarks>
    /// Inspired by Mono.Cecil's DefaultAssemblyResolver (<see href="https://github.com/jbevain/cecil/blob/master/Mono.Cecil/DefaultAssemblyResolver.cs"/>).
    /// The big difference with this implementation, is one of using composition over inheritance.
    /// </remarks>
    public class CachedResolver : IAssemblyResolver
    {
        readonly IDictionary<string, AssemblyDefinition> cache;

        public IAssemblyResolver Resolver { get; private set; }

        public CachedResolver(IAssemblyResolver resolver)
        {
            Resolver = resolver;
            cache = new Dictionary<string, AssemblyDefinition>(StringComparer.Ordinal);
        }

        public AssemblyDefinition Resolve(AssemblyNameReference name)
        {
            return Resolve(name, new ReaderParameters() { AssemblyResolver = this });
        }

        float lastAverageStackLength = 0;
        int stackTraceIncrease = 0;
        Dictionary<string, int> dict = new Dictionary<string, int>();
        Queue<float> traces = new Queue<float>(10);

        public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
        {
            return ResolveCore(name, parameters, null);
        }

        internal AssemblyDefinition ResolveCore(AssemblyNameReference name, ReaderParameters parameters, TypeReference forType)
        {
            string cacheKey = name.FullName;
            AssemblyDefinition assembly;

            if (cache.TryGetValue(cacheKey, out assembly))
            {
                if (forType != null && assembly.MainModule.HasExportedTypes)
                {
                    // check to see if the type is in the exported assemblies
                    var etype = assembly.MainModule.ExportedTypes.SingleOrDefault(et => et.FullName == forType.FullName);
                    if (etype != null)
                    {
                        var escope = (AssemblyNameReference)etype.Scope;
                        if (cache.TryGetValue(escope.FullName, out assembly))
                        {
                            return assembly;
                        }
                        else
                        {
                            assembly = ((MDocResolver)this.Resolver).Resolve(escope, parameters, forType, null);
                            cache[escope.FullName] = assembly;
                        }
                    }
                }
                return assembly;
            }

            assembly = ((MDocResolver)this.Resolver).Resolve(name, parameters, forType, null);
            cache[cacheKey] = assembly;

            return assembly;
        }

        protected void RegisterAssembly(AssemblyDefinition assembly)
        {
            if (assembly == null)
                throw new ArgumentNullException(nameof(assembly));

            var name = assembly.Name.FullName;
            if (cache.ContainsKey(name))
                return;

            cache[name] = assembly;
        }

        bool disposed = false;
        public void Dispose()
        {
            if (disposed) return;

            foreach (var assembly in cache.Values)
                assembly.Dispose();

            cache.Clear();

            Resolver.Dispose();

            disposed = true;
        }

    }

    /// <summary>
    /// Sourced from Mono.Cecil's BaseAssemblyResolver: <see href="https://github.com/jbevain/cecil/blob/master/Mono.Cecil/BaseAssemblyResolver.cs" /> 
    /// </summary>
    /// <remarks>
    /// There are two changes made from the original source
    /// </remarks>
    public abstract class MDocBaseResolver : BaseAssemblyResolver
    {
        static readonly bool on_mono = Type.GetType("Mono.Runtime") != null;

        Collection<string> gac_paths;

        protected AssemblyDefinition GetAssembly(string file, ReaderParameters parameters)
        {
            if (parameters.AssemblyResolver == null)
                parameters.AssemblyResolver = this;

            return ModuleDefinition.ReadModule(file, parameters).Assembly;
        }

        public override AssemblyDefinition Resolve(AssemblyNameReference name)
        {
            return this.Resolve(name, new ReaderParameters());
        }

        string[] emptyStringArray = new string[0];

        public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
        {
            return Resolve(name, parameters, emptyStringArray);
        }
        
        internal AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters, IEnumerable<string> filesToIgnore)
        {
            var directories = this.GetSearchDirectories();
            
            var assembly = SearchDirectory(name, directories, parameters, filesToIgnore);
            if (assembly != null)
                return assembly;

            if (name.IsRetargetable)
            {
                // if the reference is retargetable, zero it
                name = new AssemblyNameReference(name.Name, MDocResolverMixin.ZeroVersion)
                {
                    PublicKeyToken = Empty<byte>.Array,
                };
            }

            string[] framework_dirs = GetFrameworkPaths();

            if (IsZero(name.Version))
            {
                assembly = SearchDirectory(name, framework_dirs, parameters, filesToIgnore);
                if (assembly != null)
                    return assembly;
            }

            if (name.Name == "mscorlib")
            {
                assembly = GetCorlib(name, parameters);
                if (assembly != null)
                    return assembly;
            }

            assembly = GetAssemblyInGac(name, parameters);
            if (assembly != null)
                return assembly;

            assembly = SearchDirectory(name, framework_dirs, parameters, filesToIgnore);
            if (assembly != null)
                return assembly;

            throw new AssemblyResolutionException(name);
        }

        protected virtual AssemblyDefinition SearchDirectory(AssemblyNameReference name, IEnumerable<string> directories, ReaderParameters parameters, IEnumerable<string> filesToIgnore)
        {
            // just look in the current directory for a matching assembly
            foreach (var file in GetAssemblyPaths(name, directories, filesToIgnore, false))
            {
                try
                {
                    return GetAssembly(file, parameters);
                }
                catch (BadImageFormatException)
                {
                    continue;
                }
            }

            return null;
        }

        internal static bool IsZero(Version version)
        {
            return version.Major == 0 && version.Minor == 0 && version.Build == 0 && version.Revision == 0;
        }

        internal AssemblyDefinition GetCorlib(AssemblyNameReference reference, ReaderParameters parameters)
        {
            var version = reference.Version;
            var corlib = typeof(object).Assembly.GetName();

            if (corlib.Version == version || IsZero(version))
                return GetAssembly(typeof(object).Module.FullyQualifiedName, parameters);

            var path = Directory.GetParent(
                Directory.GetParent(
                    typeof(object).Module.FullyQualifiedName).FullName
                ).FullName;

            if (on_mono)
            {
                if (version.Major == 1)
                    path = Path.Combine(path, "1.0");
                else if (version.Major == 2)
                {
                    if (version.MajorRevision == 5)
                        path = Path.Combine(path, "2.1");
                    else
                        path = Path.Combine(path, "2.0");
                }
                else if (version.Major == 4)
                    path = Path.Combine(path, "4.0");
                else
                    throw new NotSupportedException("Version not supported: " + version);
            }
            else
            {
                switch (version.Major)
                {
                    case 1:
                        if (version.MajorRevision == 3300)
                            path = Path.Combine(path, "v1.0.3705");
                        else
                            path = Path.Combine(path, "v1.0.5000.0");
                        break;
                    case 2:
                        path = Path.Combine(path, "v2.0.50727");
                        break;
                    case 4:
                        path = Path.Combine(path, "v4.0.30319");
                        break;
                    default:
                        throw new NotSupportedException("Version not supported: " + version);
                }
            }

            var file = Path.Combine(path, "mscorlib.dll");
            if (File.Exists(file))
                return GetAssembly(file, parameters);

            // if we haven't found mscorlib so far, let's just fall back on the currently executing version:
            return GetAssembly(typeof(object).Module.FullyQualifiedName, parameters);
        }

        protected static Collection<string> GetGacPaths()
        {
            if (on_mono)
                return GetDefaultMonoGacPaths();

            var paths = new Collection<string>(2);
            var windir = Environment.GetEnvironmentVariable("WINDIR");
            if (windir == null)
                return paths;

            paths.Add(Path.Combine(windir, "assembly"));
            paths.Add(Path.Combine(windir, Path.Combine("Microsoft.NET", "assembly")));
            return paths;
        }

        protected static string[] GetFrameworkPaths()
        {
            var framework_dir = Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName);
            var framework_dirs = on_mono
                ? new[] { framework_dir, Path.Combine(framework_dir, "Facades") }
                : new[] { framework_dir };

            if (!on_mono)
            {
                framework_dirs = framework_dirs
                    .Concat(new[]
                    {
                        @"C:\Program Files\dotnet\sdk",
                        @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework",
                        @"C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework"
                    })
                    .Where(Directory.Exists)
                    .ToArray();
            }
            return framework_dirs;
        }

        static Collection<string> GetDefaultMonoGacPaths()
        {
            var paths = new Collection<string>(1);
            var gac = GetCurrentMonoGac();
            if (gac != null)
                paths.Add(gac);

            var gac_paths_env = Environment.GetEnvironmentVariable("MONO_GAC_PREFIX");
            if (string.IsNullOrEmpty(gac_paths_env))
                return paths;

            var prefixes = gac_paths_env.Split(Path.PathSeparator);
            foreach (var prefix in prefixes)
            {
                if (string.IsNullOrEmpty(prefix))
                    continue;

                var gac_path = Path.Combine(Path.Combine(Path.Combine(prefix, "lib"), "mono"), "gac");
                if (Directory.Exists(gac_path) && !paths.Contains(gac))
                    paths.Add(gac_path);
            }

            return paths;
        }

        static string GetCurrentMonoGac()
        {
            return Path.Combine(
                Directory.GetParent(
                    Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)).FullName,
                "gac");
        }

        internal AssemblyDefinition GetAssemblyInGac(AssemblyNameReference reference, ReaderParameters parameters)
        {
            if (reference.PublicKeyToken == null || reference.PublicKeyToken.Length == 0)
                return null;

            if (gac_paths == null)
                gac_paths = GetGacPaths();

            if (on_mono)
                return GetAssemblyInMonoGac(reference, parameters);

            return GetAssemblyInNetGac(reference, parameters);
        }

        AssemblyDefinition GetAssemblyInMonoGac(AssemblyNameReference reference, ReaderParameters parameters)
        {
            for (int i = 0; i < gac_paths.Count; i++)
            {
                var gac_path = gac_paths[i];
                var file = GetAssemblyFile(reference, string.Empty, gac_path);
                if (File.Exists(file))
                    return GetAssembly(file, parameters);
            }

            return null;
        }

        AssemblyDefinition GetAssemblyInNetGac(AssemblyNameReference reference, ReaderParameters parameters)
        {
            var gacs = new[] { "GAC_MSIL", "GAC_32", "GAC_64", "GAC" };
            var prefixes = new[] { string.Empty, "v4.0_" };

            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < gacs.Length; j++)
                {
                    var gac = Path.Combine(gac_paths[i], gacs[j]);
                    var file = GetAssemblyFile(reference, prefixes[i], gac);
                    if (Directory.Exists(gac) && File.Exists(file))
                        return GetAssembly(file, parameters);
                }
            }

            return null;
        }

        static string GetAssemblyFile(AssemblyNameReference reference, string prefix, string gac)
        {
            var gac_folder = new StringBuilder()
                .Append(prefix)
                .Append(reference.Version)
                .Append("__");

            for (int i = 0; i < reference.PublicKeyToken.Length; i++)
                gac_folder.Append(reference.PublicKeyToken[i].ToString("x2"));

            return Path.Combine(
                Path.Combine(
                    Path.Combine(gac, reference.Name), gac_folder.ToString()),
                reference.Name + ".dll");
        }

        Dictionary<string, string[]> allDirectories = new Dictionary<string, string[]>();

        internal IEnumerable<string> GetAssemblyPaths(AssemblyNameReference name, IEnumerable<string> directories, IEnumerable<string> filesToIgnore, bool subdirectories)
        {
            var extensions = name.IsWindowsRuntime ? new[] { ".winmd", ".dll", ".exe" } : new[] { ".exe", ".dll", ".winmd" };

            string[] darray = directories.Distinct().ToArray();
            string dkey = string.Join("|", darray);

            if (!allDirectories.ContainsKey(dkey))
            {
                if (subdirectories)
                {
                    darray = GetAllDirectories(darray).Distinct().ToArray();
                }

                // filter out directories that don't have any assemblies
                darray = darray
                    .Where(d => Directory.Exists(d) && Directory.EnumerateFiles(d, "*.*").Any(f => extensions.Any(e => f.EndsWith(e, StringComparison.OrdinalIgnoreCase))))
                    .ToArray();

                allDirectories.Add(dkey, darray);
            }

            foreach (var dir in allDirectories[dkey])
            {
                foreach (var extension in extensions)
                {
                    var file = Path.Combine(dir, name.Name + extension);

                    if (!File.Exists(file) || filesToIgnore.Any(f => f == file))
                        continue;

                    yield return file;
                }
            }
        }

        internal IEnumerable<string> GetAllDirectories(IEnumerable<string> directories)
        {
            foreach (var dir in directories)
            {
                if (!Directory.Exists(dir))
                    continue;

                yield return dir;

                foreach (var sub in Directory.EnumerateDirectories(dir, "*", SearchOption.AllDirectories))
                {
                    yield return sub;
                }
            }
        }

        // some helper classes
        static class Empty<T>
        {
            public static readonly T[] Array = new T[0];
        }

        class MDocResolverMixin
        {
            public static Version ZeroVersion = new Version(0, 0, 0, 0);
        }
    }
}