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

namespace Vellum.Generator
{
    /// <summary>
    /// Names the types a compilation can save, and works out what kind of type each is: one Vellum's runtime saves
    /// itself, or one with a converter or [Saveable] mark of its own.
    /// </summary>
    public static class SaveableTypes
    {
        /// <summary>
        /// Holds the types the runtime saves without a converter, other than enums, by the full metadata name its own
        /// types have.
        /// </summary>
        public static readonly HashSet<string> BuiltInNames = new HashSet<string>(
            SavedValue.BuiltInTypes.Select(type => type.FullName));

        /// <summary>
        /// Holds the generic collections the runtime saves itself, by the full metadata name its own types have.
        /// </summary>
        public static readonly HashSet<string> BuiltInCollectionNames = new HashSet<string>(
            SaveConverters.BuiltInCollections.Select(definition => definition.FullName));

        public const string SavedWithAttributeName = "Vellum.SavedWithAttribute";

        /// <summary>
        /// Returns the name of <paramref name="type"/> and of each class it derives from, nearest first and leaving
        /// out object, as matched against the base classes of the family converters.  A generic class is named by its
        /// generic type, since a family saves every type made from it.
        /// </summary>
        public static EquatableArray<string> ClassNamesOf(ITypeSymbol type)
        {
            ImmutableArray<string>.Builder returnMe = ImmutableArray.CreateBuilder<string>();
            if (type.TypeKind == TypeKind.Class)
            {
                for (ITypeSymbol current = type; current != null && current.SpecialType != SpecialType.System_Object;
                    current = current.BaseType)
                {
                    returnMe.Add(NameOf(current.OriginalDefinition));
                }
            }

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

        /// <summary>
        /// Returns the name of each interface <paramref name="type"/> implements, the ones that extend others first,
        /// as matched against the interfaces of the family converters.  A generic interface is named by its generic
        /// type, once however many ways the type implements it.  An interface is named too, since a field declared as
        /// it holds any type a family of it or of an interface it extends saves.
        /// </summary>
        public static EquatableArray<string> InterfaceNamesOf(ITypeSymbol type)
        {
            if (type.TypeKind != TypeKind.Class && type.TypeKind != TypeKind.Struct
                && type.TypeKind != TypeKind.Interface)
            {
                return default;
            }

            IEnumerable<INamedTypeSymbol> implemented = type.AllInterfaces;
            if (type.TypeKind == TypeKind.Interface)
            {
                implemented = implemented.Prepend((INamedTypeSymbol)type);
            }

            return new EquatableArray<string>(implemented
                .OrderByDescending(candidate => candidate.AllInterfaces.Length)
                .Select(candidate => NameOf(candidate.OriginalDefinition))
                .Distinct()
                .ToImmutableArray());
        }

        /// <summary>
        /// Returns the name of each generic interface <paramref name="type"/> implements with more than one set of
        /// type arguments.
        /// </summary>
        public static EquatableArray<string> RepeatedInterfacesOf(ITypeSymbol type)
        {
            if (type.TypeKind != TypeKind.Class && type.TypeKind != TypeKind.Struct)
            {
                return default;
            }

            return new EquatableArray<string>(type.AllInterfaces
                .GroupBy(implemented => NameOf(implemented.OriginalDefinition))
                .Where(group => group.Count() > 1)
                .Select(group => group.Key)
                .ToImmutableArray());
        }

        /// <summary>
        /// Returns the names of <paramref name="type"/>'s classes, then its interfaces, as matched against the family
        /// converters.  A class family beats an interface family, so the first name a family has is the one that
        /// saves the type.
        /// </summary>
        public static EquatableArray<string> FamilyNamesOf(ITypeSymbol type)
        {
            return new EquatableArray<string>(ClassNamesOf(type).Items.AddRange(InterfaceNamesOf(type).Items));
        }

        /// <summary>
        /// Holds how a type is spelled when matching it to its converter, which leaves out the question mark of a
        /// nullable reference type so a Foo? and a Foo are the same type.
        /// </summary>
        public static readonly SymbolDisplayFormat NameFormat = SymbolDisplayFormat.CSharpErrorMessageFormat
            .RemoveMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);

        /// <summary>
        /// Returns <paramref name="type"/>'s name as matched against the types something has a converter for.
        /// </summary>
        public static string NameOf(ITypeSymbol type)
        {
            return type.ToDisplayString(NameFormat);
        }

        public static ITypeSymbol WithoutNullable(ITypeSymbol type)
        {
            var named = type as INamedTypeSymbol;
            if (named != null && named.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
            {
                return named.TypeArguments[0];
            }

            return type;
        }

        /// <summary>
        /// Returns the name <paramref name="type"/>'s definition has as a runtime Type's FullName, or null for a type
        /// that name can't match, such as one nested in another.
        /// </summary>
        public static string FullMetadataNameOf(ITypeSymbol type)
        {
            var definition = type.OriginalDefinition as INamedTypeSymbol;
            if (definition == null || definition.ContainingType != null || definition.ContainingNamespace == null)
            {
                return null;
            }

            if (definition.ContainingNamespace.IsGlobalNamespace)
            {
                return definition.MetadataName;
            }

            return definition.ContainingNamespace.ToDisplayString() + "." + definition.MetadataName;
        }

        /// <summary>
        /// Returns true if Vellum's SavedValue saves <paramref name="type"/> itself, or a Nullable of one.
        /// </summary>
        public static bool IsBuiltIn(ITypeSymbol type)
        {
            type = WithoutNullable(type);
            string name = FullMetadataNameOf(type);

            return type.TypeKind == TypeKind.Enum || (name != null && BuiltInNames.Contains(name));
        }

        /// <summary>
        /// Returns true for an array, and for the generic collections SaveConverters saves itself whatever they
        /// hold.
        /// </summary>
        public static bool IsBuiltInCollection(ITypeSymbol type)
        {
            if (type is IArrayTypeSymbol)
            {
                return true;
            }

            string name = FullMetadataNameOf(type);

            return name != null && BuiltInCollectionNames.Contains(name);
        }

        /// <summary>
        /// Returns true if <paramref name="converted"/>, what a generic converter converts, is a generic type Vellum
        /// already saves itself.
        /// </summary>
        public static bool IsBuiltInGeneric(ITypeSymbol converted)
        {
            return converted.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T
                || IsBuiltInCollection(converted);
        }

        /// <summary>
        /// Returns the type arguments of <paramref name="type"/>, those of the types it's nested in first.
        /// </summary>
        public static List<ITypeSymbol> ArgumentsOf(INamedTypeSymbol type)
        {
            var returnMe = new List<ITypeSymbol>();
            for (INamedTypeSymbol current = type; current != null; current = current.ContainingType)
            {
                returnMe.InsertRange(0, current.TypeArguments);
            }

            return returnMe;
        }

    }
}