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

namespace Vellum.Generator
{
    /// <summary>
    /// Describes everything the writer needs to generate a [Saveable] type's half, as plain data. A symbol can't be
    /// compared between runs of an incremental generator, since each edit makes new ones.
    /// </summary>
    public sealed class SaveableShape : IEquatable<SaveableShape>
    {
        public const string FileSuffix = ".Saveable.g.cs";

        /// <summary>
        /// Holds the name of the generated file.
        /// </summary>
        public readonly string FileName;

        /// <summary>
        /// Holds the namespace the type is in, or an empty string for the global namespace.
        /// </summary>
        public readonly string NamespaceName;

        /// <summary>
        /// Holds how each type around the type is redeclared, outermost first and the type itself last.
        /// </summary>
        public readonly EquatableArray<string> Declarations;

        public readonly string Name;

        /// <summary>
        /// Holds the type, spelled so generated code names it from anywhere.
        /// </summary>
        public readonly string TypeName;

        public readonly string ConverterFullName;
        public readonly EquatableArray<MemberShape> Members;
        public readonly bool WritesOwnLoader;
        public readonly bool ChainsToParameterless;
        public readonly bool KeepsImplicitConstructor;

        /// <summary>
        /// Holds whether the type is a class others can derive from, so its loaders must be protected.
        /// </summary>
        public readonly bool IsDerivable;

        /// <summary>
        /// Holds whether the type derives from another [Saveable] class.
        /// </summary>
        public readonly bool HasSaveableBase;

        /// <summary>
        /// Holds whether the type is abstract, so it gets no converter.
        /// </summary>
        public readonly bool IsAbstract;

        /// <summary>
        /// Holds whether a [Saveable] class above this one gets a converter, which this type's converter then hides.
        /// </summary>
        public readonly bool HidesBaseConverter;

        /// <summary>
        /// Holds whether the type is a class, which can be handed out part-built to a value that refers back to it.
        /// </summary>
        public readonly bool IsClass;

        /// <summary>
        /// Holds the base class, spelled so generated code names it from anywhere, or an empty string when the type
        /// has no [Saveable] base.
        /// </summary>
        public readonly string BaseTypeName;

        /// <summary>
        /// Holds the members that aren't of a built-in type, which are the ones loading has to descend into.
        /// </summary>
        public readonly EquatableArray<MemberShape> ChildMembers;

        public SaveableShape(string fileName, string namespaceName, EquatableArray<string> declarations, string name,
            string typeName, string converterFullName, EquatableArray<MemberShape> members, bool writesOwnLoader,
            bool chainsToParameterless, bool keepsImplicitConstructor, bool isDerivable, bool hasSaveableBase,
            bool isAbstract, bool hidesBaseConverter, bool isClass, string baseTypeName,
            EquatableArray<MemberShape> childMembers)
        {
            FileName = fileName;
            NamespaceName = namespaceName;
            Declarations = declarations;
            Name = name;
            TypeName = typeName;
            ConverterFullName = converterFullName;
            Members = members;
            WritesOwnLoader = writesOwnLoader;
            ChainsToParameterless = chainsToParameterless;
            KeepsImplicitConstructor = keepsImplicitConstructor;
            IsDerivable = isDerivable;
            HasSaveableBase = hasSaveableBase;
            IsAbstract = isAbstract;
            HidesBaseConverter = hidesBaseConverter;
            IsClass = isClass;
            BaseTypeName = baseTypeName;
            ChildMembers = childMembers;
        }

        private static string FullName(ITypeSymbol type)
        {
            return type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
        }

        // A saved member is a field or an auto-property.  Either can be written by code in the type, unless it's
        // readonly or its property has no setter beyond an init one, which only a constructor may call.
        private static bool AssignsDirectly(ISymbol declared)
        {
            var field = declared as IFieldSymbol;
            if (field != null)
            {
                return !field.IsReadOnly;
            }

            var property = declared as IPropertySymbol;
            return property != null && property.SetMethod != null && !property.SetMethod.IsInitOnly;
        }

        // Repeats the type's own static and readonly, so the redeclaration matches it.
        private static string Declaration(INamedTypeSymbol type)
        {
            string returnMe = "partial class ";
            if (type.TypeKind == TypeKind.Struct)
            {
                returnMe = "partial struct ";
            }

            if (type.IsReadOnly)
            {
                returnMe = "readonly " + returnMe;
            }

            if (type.IsStatic)
            {
                returnMe = "static " + returnMe;
            }

            // Constraints are left out, since a partial type's other part declares them.
            returnMe += type.Name;
            if (type.Arity > 0)
            {
                returnMe += "<" + string.Join(", ", type.TypeParameters.Select(parameter => parameter.Name)) + ">";
            }

            return returnMe;
        }

        // A hint name can't hold the angle brackets of a generic type, so each generic type gets its arity instead.
        private static string FileNameOf(INamedTypeSymbol type)
        {
            var names = new List<string>();
            for (INamedTypeSymbol current = type; current != null; current = current.ContainingType)
            {
                string name = current.Name;
                if (current.Arity > 0)
                {
                    name += "`" + current.Arity;
                }

                names.Insert(0, name);
            }

            string returnMe = string.Join(".", names);
            if (!type.ContainingNamespace.IsGlobalNamespace)
            {
                returnMe = type.ContainingNamespace.ToDisplayString() + "." + returnMe;
            }

            return returnMe + FileSuffix;
        }

        // A converter nested in a generic type is generic too, so it's registered open.
        private static string ConverterNameOf(INamedTypeSymbol type)
        {
            INamedTypeSymbol open = type;
            if (type.IsGenericType)
            {
                open = type.ConstructUnboundGenericType();
            }

            return FullName(open) + "." + SaveableClass.ConverterName;
        }

        /// <summary>
        /// Returns the shape of <paramref name="type"/>, which saves <paramref name="saved"/>.
        /// </summary>
        /// <param name="writesOwnLoader">Whether the type writes its own SaveReader constructor.</param>
        /// <param name="chainsToParameterless">Whether loading starts from the parameterless constructor.</param>
        /// <param name="keepsImplicitConstructor">
        /// Whether the type is a class whose only constructor is the one C# writes for it.
        /// </param>
        public static SaveableShape Of(INamedTypeSymbol type, List<SaveableMember> saved, bool writesOwnLoader,
            bool chainsToParameterless, bool keepsImplicitConstructor)
        {
            var declarations = new List<string>();
            for (INamedTypeSymbol current = type; current != null; current = current.ContainingType)
            {
                declarations.Insert(0, Declaration(current));
            }

            var members = new List<MemberShape>();
            var childMembers = new List<MemberShape>();
            foreach (SaveableMember member in saved)
            {
                var shape = new MemberShape(member.Key, FullName(member.Type), AssignsDirectly(member.Declared));
                members.Add(shape);
                if (!SaveableTypes.IsBuiltIn(member.Type))
                {
                    childMembers.Add(shape);
                }
            }

            string namespaceName = "";
            if (!type.ContainingNamespace.IsGlobalNamespace)
            {
                namespaceName = type.ContainingNamespace.ToDisplayString();
            }

            bool isClass = type.TypeKind == TypeKind.Class;
            bool hasSaveableBase = isClass && type.BaseType.SpecialType != SpecialType.System_Object;
            bool hidesBaseConverter = false;
            string baseTypeName = "";
            if (hasSaveableBase)
            {
                baseTypeName = FullName(type.BaseType);
                for (INamedTypeSymbol current = type.BaseType; current != null && SaveableClass.IsMarked(current);
                    current = current.BaseType)
                {
                    hidesBaseConverter |= !current.IsAbstract;
                }
            }

            return new SaveableShape(FileNameOf(type),
                namespaceName,
                new EquatableArray<string>(declarations.ToImmutableArray()),
                type.Name,
                FullName(type),
                ConverterNameOf(type),
                new EquatableArray<MemberShape>(members.ToImmutableArray()),
                writesOwnLoader,
                chainsToParameterless,
                keepsImplicitConstructor,
                isDerivable: isClass && !type.IsSealed,
                hasSaveableBase: hasSaveableBase,
                isAbstract: type.IsAbstract,
                hidesBaseConverter: hidesBaseConverter,
                isClass: isClass,
                baseTypeName: baseTypeName,
                childMembers: new EquatableArray<MemberShape>(childMembers.ToImmutableArray())
            );
        }

        public bool Equals(SaveableShape other)
        {
            return other != null
                && FileName == other.FileName
                && NamespaceName == other.NamespaceName
                && Declarations.Equals(other.Declarations)
                && Name == other.Name
                && TypeName == other.TypeName
                && ConverterFullName == other.ConverterFullName
                && Members.Equals(other.Members)
                && WritesOwnLoader == other.WritesOwnLoader
                && ChainsToParameterless == other.ChainsToParameterless
                && KeepsImplicitConstructor == other.KeepsImplicitConstructor
                && IsDerivable == other.IsDerivable
                && HasSaveableBase == other.HasSaveableBase
                && IsAbstract == other.IsAbstract
                && HidesBaseConverter == other.HidesBaseConverter
                && IsClass == other.IsClass
                && BaseTypeName == other.BaseTypeName
                && ChildMembers.Equals(other.ChildMembers);
        }

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

        public override int GetHashCode()
        {
            return (FileName.GetHashCode() * 31 + Declarations.GetHashCode()) * 31 + Members.GetHashCode();
        }
    }
}