using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Représente une liste immuable d'objets. Toutes les méthodes qui modifient la liste
    /// renvoient une copie modifiée.
    /// </summary>
    /// <typeparam name="T">Type des éléments de la liste</typeparam>
    public class ImmutableList<T> : IList<T>, IEquatable<ImmutableList<T>>
    {
        #region Private data

        private readonly IList<T> _items;
        private readonly int _hashCode;

        #endregion

        #region Constructor

        /// <summary>
        /// Initialise une nouvelle instance de <see cref="ImmutableList{T}"/>
        /// </summary>
        /// <param name="items">Les éléments de la liste</param>
        public ImmutableList(IEnumerable<T> items)
        {
            _items = items.ToArray();
            _hashCode = ComputeHash();
        }

        #endregion

        #region Public members

        /// <summary>
        /// Renvoie une copie de la liste en y ajoutant l'élément spécifié
        /// </summary>
        /// <param name="item">Elément à ajouter</param>
        /// <returns>La nouvelle liste</returns>
        public ImmutableList<T> Add(T item)
        {
            return this
                    .Append(item)
                    .AsImmutable();
        }

        /// <summary>
        /// Renvoie une copie de la liste en en retirant l'élément spécifié
        /// </summary>
        /// <param name="item">Elément à retirer</param>
        /// <returns>La nouvelle liste</returns>
        public ImmutableList<T> Remove(T item)
        {
            return this
                    .SkipFirst(it => it.SafeEquals(item))
                    .AsImmutable();
        }

        /// <summary>
        /// Renvoie une copie de la liste en y insérant l'élément spécifié à la position spécifiée
        /// </summary>
        /// <param name="index">Position à laquelle insérer l'élément</param>
        /// <param name="item">Elément à insérer</param>
        /// <returns>La nouvelle liste</returns>
        public ImmutableList<T> Insert(int index, T item)
        {
            return this
                    .InsertAt(index, item)
                    .AsImmutable();
        }

        /// <summary>
        /// Renvoie une copie de la liste en en retirant l'élément à la position spécifiée
        /// </summary>
        /// <param name="index">Position de l'élément à retirer</param>
        /// <returns>La nouvelle liste</returns>
        public ImmutableList<T> RemoveAt(int index)
        {
            return this
                    .SkipAt(index)
                    .AsImmutable();
        }

        /// <summary>
        /// Renvoie une copie de la liste en remplaçant l'élément à la position spécifiée
        /// </summary>
        /// <param name="index">Position à laquelle remplacer un élément</param>
        /// <param name="item">Elément qui remplace l'élément existant</param>
        /// <returns>La nouvelle liste</returns>
        public ImmutableList<T> Replace(int index, T item)
        {
            return this
                    .ReplaceAt(index, item)
                    .AsImmutable();
        }

        #endregion

        #region Interface implementations

        /// <summary>
        /// Renvoie la position de la première occurence de l'élément spécifié
        /// </summary>
        /// <param name="item">Elément recherché</param>
        /// <returns>La position de l'élément s'il est présent dans la liste, sinon -1</returns>
        public int IndexOf(T item)
        {
            if (_items == null)
                return -1;

            return _items.IndexOf(item);
        }

        /// <summary>
        /// Indique si la liste contient l'élément spécifié
        /// </summary>
        /// <param name="item">Elément recherché</param>
        /// <returns>true si l'élément est présent dans la liste, sinon false</returns>
        public bool Contains(T item)
        {
            if (_items == null)
                return false;

            return _items.Contains(item);
        }

        /// <summary>
        /// Copie les éléments de la liste vers le tableau spécifié
        /// </summary>
        /// <param name="array">Tableau vers lequel les éléments sont copiés</param>
        /// <param name="arrayIndex">Position dans le tableau à laquelle la copie commence</param>
        public void CopyTo(T[] array, int arrayIndex)
        {
            if (_items == null)
                return;

            _items.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Renvoie le nombre d'éléments de la liste
        /// </summary>
        public int Count
        {
            get
            {
                if (_items == null)
                    return 0;

                return _items.Count;
            }
        }

        /// <summary>
        /// Renvoie un énumérateur pour parcourir les éléments de la liste
        /// </summary>
        /// <returns>Un énumérateur pour parcourir les éléments de la liste</returns>
        public IEnumerator<T> GetEnumerator()
        {
            if (_items == null)
                return Enumerable.Empty<T>().GetEnumerator();

            return _items.GetEnumerator();
        }

        /// <summary>
        /// Détermine si cette liste est égale à la liste spécifiée. Deux listes immuables sont
        /// considérées égales si et seulement si elles comportent les mêmes éléments dans le
        /// même ordre.
        /// </summary>
        /// <param name="other">La liste avec laquelle on compare la liste courante</param>
        /// <returns>true si les deux listes sont égales, false sinon</returns>
        public bool Equals(ImmutableList<T> other)
        {
            if (other == null || this._hashCode != other._hashCode)
                return false;
            return this.SequenceEqual(other);
        }

        #endregion

        #region Explicit interface implementations

        /// <summary>
        /// Opération non valide.
        /// </summary>
        /// <param name="index">Position à laquelle insérer un élément</param>
        /// <param name="item">Elément à insérer</param>
        void IList<T>.Insert(int index, T item)
        {
            throw new InvalidOperationException();
        }

        /// <summary>
        /// Opération non valide.
        /// </summary>
        /// <param name="index">Position à laquelle supprimer un élément</param>
        void IList<T>.RemoveAt(int index)
        {
            throw new InvalidOperationException();
        }

        /// <summary>
        /// Renvoie l'élément à la position spécifiée. L'accesseur set est une opération non valide.
        /// </summary>
        /// <param name="index">Position de l'élément à accéder</param>
        /// <returns>La valeur de l'élément à l'index spécifié</returns>
        T IList<T>.this[int index]
        {
            get
            {
                if (_items == null)
                    throw new IndexOutOfRangeException();

                return _items[index];
            }
            set
            {
                throw new InvalidOperationException();
            }
        }

        /// <summary>
        /// Opération non valide.
        /// </summary>
        /// <param name="item">Elément à ajouter</param>
        void ICollection<T>.Add(T item)
        {
            throw new InvalidOperationException();
        }

        /// <summary>
        /// Opération non valide.
        /// </summary>
        void ICollection<T>.Clear()
        {
            throw new InvalidOperationException();
        }

        /// <summary>
        /// Indique si la collection est en lecture seule. Renvoie toujours true.
        /// </summary>
        bool ICollection<T>.IsReadOnly
        {
            get { return true; }
        }

        /// <summary>
        /// Opération non valide.
        /// </summary>
        /// <param name="item">Elément à retirer</param>
        /// <returns>true si l'élément a été retiré, sinon false.</returns>
        bool ICollection<T>.Remove(T item)
        {
            throw new InvalidOperationException();
        }

        /// <summary>
        /// Renvoie un énumérateur pour parcourir les éléments de la liste
        /// </summary>
        /// <returns>Un énumérateur pour parcourir les éléments de la liste</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

        #region Overrides

        /// <summary>
        /// Détermine si cette instance est égale à l'objet spécifié. Deux listes immuables sont
        /// considérées égales si et seulement si elles comportent les mêmes éléments, dans le
        /// même ordre.
        /// </summary>
        /// <param name="obj">L'objet avec lequel on compare cette instance</param>
        /// <returns>true si <c>obj</c> est égal à cette instance, sinon false</returns>
        public override bool Equals(object obj)
        {
            if (obj is ImmutableList<T>)
            {
                var other = (ImmutableList<T>)obj;
                return this.Equals(other);
            }
            return false;
        }

        /// <summary>
        /// Renvoie le code de hachage de cette liste.
        /// </summary>
        /// <returns>Le code de hachage de cette liste</returns>
        public override int GetHashCode()
        {
            return _hashCode;
        }

        #endregion

        #region Private methods

        private int ComputeHash()
        {
            return this.MakeHashCode(_items);
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes statiques pour créer des listes immuables
    /// </summary>
    public static class ImmutableList
    {
        /// <summary>
        /// Crée une liste immuable à partir de la séquence spécifiée
        /// </summary>
        /// <typeparam name="T">Type des éléments</typeparam>
        /// <param name="source">Séquence à partir de laquelle la liste immuable est crée</param>
        /// <returns>Une liste immuable contenant les éléments spécifiés</returns>
        public static ImmutableList<T> CreateFrom<T>(IEnumerable<T> source)
        {
            return new ImmutableList<T>(source);
        }

        /// <summary>
        /// Crée une liste immuable à partir des éléments spécifiés
        /// </summary>
        /// <typeparam name="T">Type des éléments</typeparam>
        /// <param name="items">Eléments à partir desquels la liste immuable est crée</param>
        /// <returns>Une liste immuable contenant les éléments spécifiés</returns>
        public static ImmutableList<T> Create<T>(params T[] items)
        {
            return new ImmutableList<T>(items);
        }

        /// <summary>
        /// Renvoie une liste immuable contenant les éléments d'une séquence
        /// </summary>
        /// <typeparam name="T">Type des éléments</typeparam>
        /// <param name="source">Séquence à partir de laquelle la liste immuable est crée</param>
        /// <returns>Une liste immuable contenant les éléments de la séquence</returns>
        public static ImmutableList<T> AsImmutable<T>(this IEnumerable<T> source)
        {
            return new ImmutableList<T>(source);
        }
    }
}