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

namespace Vellum.Generator
{
    /// <summary>
    /// Describes a class that derives from others, as plain data, so it can be checked for a converter of its own.
    /// </summary>
    public sealed class UnsavedSubtype : IEquatable<UnsavedSubtype>
    {
        public readonly string Name;

        /// <summary>
        /// Holds the class's name as matched against the types something has a converter for.
        /// </summary>
        public readonly string ConvertedName;

        /// <summary>
        /// Holds the name of each class it derives from, nearest first, as matched against the same.
        /// </summary>
        public readonly EquatableArray<string> BaseNames;

        public readonly SourcePlace Place;

        /// <summary>
        /// Holds the name of the class and of each class it derives from, as matched against the base classes of
        /// the family converters.
        /// </summary>
        public readonly EquatableArray<string> FamilyNames;

        public UnsavedSubtype(string name, string convertedName, EquatableArray<string> baseNames, SourcePlace place,
            EquatableArray<string> familyNames = default)
        {
            FamilyNames = familyNames;
            Name = name;
            ConvertedName = convertedName;
            BaseNames = baseNames;
            Place = place;
        }

        /// <summary>
        /// Returns <paramref name="type"/> as plain data, or null if it can never be a value that's saved: it is
        /// abstract or static, or derives from nothing but object.
        /// </summary>
        public static UnsavedSubtype Of(INamedTypeSymbol type)
        {
            if (type.IsAbstract || type.IsStatic || type.TypeKind != TypeKind.Class)
            {
                return null;
            }

            ImmutableArray<string>.Builder baseNames = ImmutableArray.CreateBuilder<string>();
            for (INamedTypeSymbol current = type.BaseType; current != null
                && current.SpecialType != SpecialType.System_Object; current = current.BaseType)
            {
                baseNames.Add(SaveableTypes.NameOf(current));

                // A generic converter is matched by the generic type it converts, not by each type made from it.
                if (current.IsGenericType)
                {
                    baseNames.Add(SaveableTypes.NameOf(current.OriginalDefinition));
                }
            }

            if (baseNames.Count == 0)
            {
                return null;
            }

            return new UnsavedSubtype(type.Name, SaveableTypes.NameOf(type),
                new EquatableArray<string>(baseNames.ToImmutable()), SourcePlace.Of(type.Locations.FirstOrDefault()),
                SaveableTypes.FamilyNamesOf(type));
        }

        /// <summary>
        /// Returns what is wrong with the class in <paramref name="compilation"/>, given the names
        /// <paramref name="converted"/> of what converters convert and the base classes <paramref name="families"/>
        /// of the family converters, which save every class derived from them.
        /// </summary>
        public List<Diagnostic> Check(Compilation compilation, HashSet<string> converted,
            Dictionary<string, EquatableArray<int>> families)
        {
            var returnMe = new List<Diagnostic>();
            if (converted.Contains(ConvertedName) || FamilyNames.Items.Any(families.ContainsKey))
            {
                return returnMe;
            }

            string saved = BaseNames.Items.FirstOrDefault(converted.Contains);
            if (saved != null)
            {
                returnMe.Add(Diagnostic.Create(VellumDiagnostics.UnsavedSubtype, Place.LocationIn(compilation), Name,
                    saved));
            }

            return returnMe;
        }

        public bool Equals(UnsavedSubtype other)
        {
            return other != null
                && Name == other.Name
                && ConvertedName == other.ConvertedName
                && BaseNames.Equals(other.BaseNames)
                && FamilyNames.Equals(other.FamilyNames)
                && Place.Equals(other.Place);
        }

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

        public override int GetHashCode()
        {
            return ConvertedName.GetHashCode() * 31 + BaseNames.GetHashCode();
        }
    }
}