using System;
using System.Collections.Generic;
using System.Collections.Immutable;

namespace Vellum.Generator
{
    /// <summary>
    /// Holds an array that an incremental generator step can hand on, because it compares by its items.
    /// </summary>
    public readonly struct EquatableArray<ItemType> : IEquatable<EquatableArray<ItemType>>
    {
        private readonly ImmutableArray<ItemType> items;

        public EquatableArray(ImmutableArray<ItemType> items)
        {
            this.items = items;
        }

        /// <summary>
        /// Gets the items, which are empty for a default array.
        /// </summary>
        public ImmutableArray<ItemType> Items
        {
            get
            {
                if (items.IsDefault)
                {
                    return ImmutableArray<ItemType>.Empty;
                }

                return items;
            }
        }

        public bool Equals(EquatableArray<ItemType> other)
        {
            ImmutableArray<ItemType> mine = Items;
            ImmutableArray<ItemType> theirs = other.Items;
            if (mine.Length != theirs.Length)
            {
                return false;
            }

            for (int i = 0; i < mine.Length; ++i)
            {
                if (!EqualityComparer<ItemType>.Default.Equals(mine[i], theirs[i]))
                {
                    return false;
                }
            }

            return true;
        }

        public override bool Equals(object obj)
        {
            return obj is EquatableArray<ItemType> other && Equals(other);
        }

        public override int GetHashCode()
        {
            int returnMe = 17;
            foreach (ItemType item in Items)
            {
                returnMe = returnMe * 31 + EqualityComparer<ItemType>.Default.GetHashCode(item);
            }

            return returnMe;
        }
    }
}