using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;

namespace Vellum.Generator
{
    /// <summary>
    /// Describes a class or struct that implements interfaces, as plain data, so it can be checked for an interface
    /// family that saves it without ambiguity.
    /// </summary>
    public sealed class FamilyMember : IEquatable<FamilyMember>
    {
        public readonly string Name;

        /// <summary>
        /// Holds the name of the type and of each class it derives from, which a class family would save it by.
        /// </summary>
        public readonly EquatableArray<string> ClassNames;

        /// <summary>
        /// Holds the name of each interface it implements, the ones that extend others first.
        /// </summary>
        public readonly EquatableArray<string> InterfaceNames;

        /// <summary>
        /// Holds the name of each generic interface it implements with more than one set of type arguments.
        /// </summary>
        public readonly EquatableArray<string> RepeatedInterfaces;

        public readonly SourcePlace Place;

        public FamilyMember(string name, EquatableArray<string> classNames, EquatableArray<string> interfaceNames,
            EquatableArray<string> repeatedInterfaces, SourcePlace place)
        {
            Name = name;
            ClassNames = classNames;
            InterfaceNames = interfaceNames;
            RepeatedInterfaces = repeatedInterfaces;
            Place = place;
        }

        /// <summary>
        /// Returns <paramref name="type"/> as plain data, or null if it can never be a value that's saved or
        /// implements no interface.
        /// </summary>
        public static FamilyMember Of(INamedTypeSymbol type)
        {
            bool isClassOrStruct = type.TypeKind == TypeKind.Class || type.TypeKind == TypeKind.Struct;
            if (type.IsAbstract || type.IsStatic || !isClassOrStruct)
            {
                return null;
            }

            EquatableArray<string> interfaces = SaveableTypes.InterfaceNamesOf(type);
            if (interfaces.Items.Length == 0)
            {
                return null;
            }

            return new FamilyMember(type.Name, SaveableTypes.ClassNamesOf(type), interfaces,
                SaveableTypes.RepeatedInterfacesOf(type), SourcePlace.Of(type.Locations.FirstOrDefault()));
        }

        // A type can only implement an interface if its assembly defines it or references the one that does.  That
        // keeps the scan off the BCL and off every other assembly with no part in a family.
        private static bool CouldImplement(IAssemblySymbol assembly, HashSet<string> interfaceAssemblies)
        {
            if (interfaceAssemblies.Contains(assembly.Name))
            {
                return true;
            }

            foreach (IModuleSymbol module in assembly.Modules)
            {
                foreach (IAssemblySymbol referenced in module.ReferencedAssemblySymbols)
                {
                    if (interfaceAssemblies.Contains(referenced.Name))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// Returns each type in the referenced assemblies that implements the interface of an interface family in
        /// <paramref name="converters"/>, which is all that <see cref="Check"/> can find fault with.
        /// </summary>
        public static EquatableArray<FamilyMember> Referenced(Compilation compilation, ConverterList converters)
        {
            ImmutableArray<FamilyMember>.Builder returnMe = ImmutableArray.CreateBuilder<FamilyMember>();
            Dictionary<string, EquatableArray<string>> interfaceFamilies = converters.InterfaceFamilies();
            if (interfaceFamilies.Count > 0)
            {
                HashSet<string> interfaceAssemblies = converters.InterfaceFamilyAssemblies();
                foreach (IAssemblySymbol assembly in compilation.SourceModule.ReferencedAssemblySymbols)
                {
                    if (!CouldImplement(assembly, interfaceAssemblies))
                    {
                        continue;
                    }

                    var pending = new Stack<INamespaceSymbol>();
                    var types = new Stack<INamedTypeSymbol>();
                    pending.Push(assembly.GlobalNamespace);
                    while (pending.Count > 0)
                    {
                        INamespaceSymbol current = pending.Pop();
                        foreach (INamespaceSymbol child in current.GetNamespaceMembers())
                        {
                            pending.Push(child);
                        }

                        foreach (INamedTypeSymbol type in current.GetTypeMembers())
                        {
                            types.Push(type);
                        }
                    }

                    while (types.Count > 0)
                    {
                        INamedTypeSymbol type = types.Pop();
                        foreach (INamedTypeSymbol nested in type.GetTypeMembers())
                        {
                            types.Push(nested);
                        }

                        FamilyMember member = Of(type);
                        if (member != null && member.InterfaceNames.Items.Any(interfaceFamilies.ContainsKey))
                        {
                            returnMe.Add(member);
                        }
                    }
                }
            }

            return new EquatableArray<FamilyMember>(returnMe.ToImmutable());
        }

        /// <summary>
        /// Returns what is wrong with the type in <paramref name="compilation"/>, given the base class or interface
        /// of each family <paramref name="families"/> and, for the interface ones, the interfaces
        /// <paramref name="interfaceFamilies"/> each extends.
        /// </summary>
        public List<Diagnostic> Check(Compilation compilation, Dictionary<string, EquatableArray<int>> families,
            Dictionary<string, EquatableArray<string>> interfaceFamilies)
        {
            var returnMe = new List<Diagnostic>();

            // A class family saves the type before any interface family is asked.
            if (ClassNames.Items.Any(families.ContainsKey))
            {
                return returnMe;
            }

            List<string> matched = InterfaceNames.Items.Where(interfaceFamilies.ContainsKey).ToList();
            List<string> mostDerived = FamilyChoice.MostDerived(matched,
                (derived, baseName) => interfaceFamilies[derived].Items.Contains(baseName));
            if (mostDerived.Count > 1)
            {
                returnMe.Add(Diagnostic.Create(VellumDiagnostics.AmbiguousInterfaceFamilies,
                    Place.LocationIn(compilation), Name, string.Join(" and ", mostDerived)));
            }

            foreach (string name in mostDerived.Where(derived => RepeatedInterfaces.Items.Contains(derived)))
            {
                returnMe.Add(Diagnostic.Create(VellumDiagnostics.RepeatedFamilyInterface,
                    Place.LocationIn(compilation), Name, name));
            }

            return returnMe;
        }

        public bool Equals(FamilyMember other)
        {
            return other != null
                && Name == other.Name
                && ClassNames.Equals(other.ClassNames)
                && InterfaceNames.Equals(other.InterfaceNames)
                && RepeatedInterfaces.Equals(other.RepeatedInterfaces)
                && Place.Equals(other.Place);
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as FamilyMember);
        }

        public override int GetHashCode()
        {
            return Name.GetHashCode() * 31 + InterfaceNames.GetHashCode();
        }
    }
}