using System;

namespace Vellum.Generator
{
    /// <summary>
    /// Describes one type inside a saved type, as plain data an incremental generator step can compare between runs.
    /// </summary>
    public sealed class TypePart : IEquatable<TypePart>
    {
        /// <summary>
        /// Holds how C# spells the type, without a Nullable around it.
        /// </summary>
        public readonly string Name;

        /// <summary>
        /// Holds how C# spells the generic type this one is built from, or null if it isn't generic.
        /// </summary>
        public readonly string OpenName;

        public readonly PartKind Kind;

        /// <summary>
        /// Holds where this part's own parts start in the shape, which keeps them next to each other.
        /// </summary>
        public readonly int FirstChild;

        public readonly int ChildCount;

        /// <summary>
        /// Holds the name of the type and of each class it derives from, which a family converter of any of them
        /// saves. It's empty for a part that isn't a class.
        /// </summary>
        public readonly EquatableArray<string> FamilyNames;

        /// <summary>
        /// Holds where the type arguments of the type and of each generic class it derives from are in the shape,
        /// which a family converter that marks one of its type parameters [Saveable] needs to check.
        /// </summary>
        public readonly EquatableArray<BaseArguments> BaseArguments;

        public TypePart(string name, string openName, PartKind kind, int firstChild, int childCount,
            EquatableArray<string> familyNames = default, EquatableArray<BaseArguments> baseArguments = default)
        {
            FamilyNames = familyNames;
            BaseArguments = baseArguments;
            Name = name;
            OpenName = openName;
            Kind = kind;
            FirstChild = firstChild;
            ChildCount = childCount;
        }

        public bool Equals(TypePart other)
        {
            return other != null
                && Name == other.Name
                && OpenName == other.OpenName
                && Kind == other.Kind
                && FirstChild == other.FirstChild
                && ChildCount == other.ChildCount
                && FamilyNames.Equals(other.FamilyNames)
                && BaseArguments.Equals(other.BaseArguments);
        }

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

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