using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Classe de base pour des collections réalisant la virtualisation des données. L'implémentation de base est en lecture seule.
    /// </summary>
    /// <typeparam name="T">Type des éléments de la collection</typeparam>
    /// <remarks>Les données sont chargées page par page au fur et à mesure des besoins. Seules les pages adjacentes à la dernière page accédée sont conservées en mémoire.</remarks>
    public abstract class VirtualizingCollectionBase<T> : IList<T>, IList, INotifyPropertyChanged
    {
        #region Private data

        private readonly object _syncRoot;
        private readonly int _pageSize;
        private readonly Dictionary<int, T[]> _pages;
        private int? _count;

        #endregion

        #region Constructor

        /// <summary>
        /// Initialise une nouvelle instance de VirtualizingCollectionBase
        /// </summary>
        /// <param name="pageSize">Nombre d'éléments par page de données</param>
        protected VirtualizingCollectionBase(int pageSize)
        {
            pageSize.CheckArgumentOutOfRange("pageSize", 0, int.MaxValue);
            _syncRoot = new object();
            _pageSize = pageSize;
            _pages = new Dictionary<int, T[]>();
        }

        #endregion

        #region Implementation of IEnumerable<T>

        /// <summary>
        /// Renvoie un énumérateur pour parcourir les éléments de la collection
        /// </summary>
        /// <returns>Un énumérateur pour parcourir les éléments de la collection</returns>
        public IEnumerator<T> GetEnumerator()
        {
            for (int i = 0; i < Count; i++)
            {
                yield return this[i];
            }
        }

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

        #endregion

        #region Implementation of ICollection<T>

        /// <summary>
        /// Non supporté. Ajoute l'élément spécifié à la collection.
        /// </summary>
        /// <param name="item">Élément à ajouter</param>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        public virtual void Add(T item)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// Non supporté. Vide la collection.
        /// </summary>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        public virtual void Clear()
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// Indique si la collection contient l'élément spécifié
        /// </summary>
        /// <param name="item">Élément dont on veut tester la présence</param>
        /// <returns>true si l'élément est présent dans la collection, sinon false</returns>
        /// <remarks>Renvoie toujours false dans l'implémentation de base.</remarks>
        public virtual bool Contains(T item)
        {
            return false;
        }

        /// <summary>
        /// Copie les éléments de la collection 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 virtual void CopyTo(T[] array, int arrayIndex)
        {
            array.CheckArgumentNull("array");
            arrayIndex.CheckArgumentOutOfRange("arrayIndex", 0, int.MaxValue);
            if (array.Length < Count + arrayIndex)
                throw new ArgumentException(ExceptionMessages.ArrayCapacityInsufficient);
            for (int i = 0; i < Count; i++)
            {
                array[arrayIndex + i] = this[i];
            }
        }

        /// <summary>
        /// Non supporté. Retire l'élément spécifié de la collection.
        /// </summary>
        /// <param name="item">Élément à retirer.</param>
        /// <returns>true si l'élément était présent et a été supprimé, sinon false</returns>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        public virtual bool Remove(T item)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// Renvoie le nombre d'éléments dans la collection
        /// </summary>
        public int Count
        {
            get
            {
                if (_count == null)
                    _count = FetchCount();
                return _count.Value;
            }
        }

        /// <summary>
        /// Indique si la collection est en lecture seule. Renvoie toujours true dans l'implémentation de base.
        /// </summary>
        public virtual bool IsReadOnly
        {
            get { return true; }
        }

        #endregion

        #region Implementation of IList<T>

        /// <summary>
        /// Renvoie la position de l'élément spécifié dans la collection.
        /// </summary>
        /// <param name="item">Élément recherché</param>
        /// <returns>La position de l'élément dans la collection, ou -1 si l'élément n'est pas dans la collection</returns>
        /// <remarks>Renvoie toujours -1 dans l'implémentation de base.</remarks>
        public virtual int IndexOf(T item)
        {
            return -1;
        }

        /// <summary>
        /// Non supporté. Insère l'élément spécifié dans la collection à la position spécifiée.
        /// </summary>
        /// <param name="index">Position à laquelle insérer l'élément</param>
        /// <param name="item">Élément à insérer</param>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        public virtual void Insert(int index, T item)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// Non supporté. Retire l'élément à la position spécifiée
        /// </summary>
        /// <param name="index">Position de l'élément à retirer</param>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        public virtual void RemoveAt(int index)
        {
            throw ReadOnlyException();
        }

        /// <summary>
        /// Obtient l'élément à la position spécifiée. L'accesseur <c>set</c> n'est pas supporté.
        /// </summary>
        /// <param name="index">Position de l'élément à obtenir</param>
        /// <returns>L'élément à la position spécifiée</returns>
        /// <exception cref="System.NotSupportedException">La propriété est affectée et la collection est en lecture seule.</exception>
        public virtual T this[int index]
        {
            get
            {
                index.CheckArgumentOutOfRange("index", 0, Count - 1);

                int indexInPage;
                int pageIndex = Math.DivRem(index, PageSize, out indexInPage);
                T[] page = GetPage(pageIndex);
                return page[indexInPage];
            }
            set { throw ReadOnlyException(); }
        }

        #endregion

        #region Explicit implementation of ICollection

        /// <summary>
        /// Copie les éléments de la collection vers le tableau spécifié
        /// </summary>
        /// <param name="array">Tableau vers lequel les éléments sont copiés</param>
        /// <param name="index">Position dans le tableau à laquelle la copie commence</param>
        void ICollection.CopyTo(Array array, int index)
        {
            CopyTo((T[])array, index);
        }

        /// <summary>
        /// Obtient un objet qui peut être utilisé pour synchroniser l'accès à la collection.
        /// </summary>
        object ICollection.SyncRoot
        {
            get { return _syncRoot; }
        }

        /// <summary>
        /// Obtient une valeur indiquant si l'accès à la collection est synchronisé
        /// </summary>
        bool ICollection.IsSynchronized
        {
            get { return false; }
        }

        #endregion

        #region Explicit implementation of IList

        /// <summary>
        /// Non supporté. Ajoute l'élément spécifié à la collection.
        /// </summary>
        /// <param name="value">Élément à ajouter</param>
        /// <returns>La position à laquelle l'élément a été ajouté</returns>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        int IList.Add(object value)
        {
            Add((T)value);
            return Count;
        }

        /// <summary>
        /// Indique si la collection contient l'élément spécifié
        /// </summary>
        /// <param name="value">Élément dont on veut tester la présence</param>
        /// <returns>true si l'élément est présent dans la collection, sinon false</returns>
        /// <remarks>Renvoie toujours false dans l'implémentation de base.</remarks>
        bool IList.Contains(object value)
        {
            return Contains((T)value);
        }

        /// <summary>
        /// Non supporté. Insère l'élément spécifié dans la collection à la position spécifiée.
        /// </summary>
        /// <param name="index">Position à laquelle insérer l'élément</param>
        /// <param name="value">Élément à insérer</param>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        void IList.Insert(int index, object value)
        {
            Insert(index, (T)value);
        }

        /// <summary>
        /// Non supporté. Retire l'élément spécifié de la collection.
        /// </summary>
        /// <param name="value">Élément à retirer.</param>
        /// <returns>true si l'élément était présent et a été supprimé, sinon false</returns>
        /// <exception cref="System.NotSupportedException">La collection est en lecture seule.</exception>
        void IList.Remove(object value)
        {
            Remove((T)value);
        }

        /// <summary>
        /// Renvoie la position de l'élément spécifié dans la collection.
        /// </summary>
        /// <param name="value">Élément recherché</param>
        /// <returns>La position de l'élément dans la collection, ou -1 si l'élément n'est pas dans la collection</returns>
        /// <remarks>Renvoie toujours -1 dans l'implémentation de base.</remarks>
        int IList.IndexOf(object value)
        {
            return IndexOf((T)value);
        }

        /// <summary>
        /// Obtient l'élément à la position spécifiée. L'accesseur <c>set</c> n'est pas supporté.
        /// </summary>
        /// <param name="index">Position de l'élément à obtenir</param>
        /// <returns>L'élément à la position spécifiée</returns>
        /// <exception cref="System.NotSupportedException">La propriété est affectée et la collection est en lecture seule.</exception>
        object IList.this[int index]
        {
            get { return this[index]; }
            set { this[index] = (T)value; }
        }

        /// <summary>
        /// Indique si la collection est de taille fixe. Renvoie toujours true dans l'implémentation de base.
        /// </summary>
        bool IList.IsFixedSize
        {
            get { return IsReadOnly; }
        }

        #endregion

        #region Implementation of INotifyPropertyChanged

        /// <summary>
        /// Se produit quand une propriété de la collection a changé
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        #region Abstract methods

        /// <summary>
        /// Quand cette méthode est implémentée dans une classe dérivée, obtient les éléments de la plage spécifiée.
        /// </summary>
        /// <param name="start">Position du premier élément à obtenir</param>
        /// <param name="count">Nombre d'éléments à obtenir</param>
        /// <returns>Un tableau contenant les éléments demandés</returns>
        /// <remarks>Les classes dérivées doivent implémenter cette méthode pour récupérer les éléments de la collection à partir d'une source quelconque.</remarks>
        protected abstract T[] FetchItems(int start, int count);

        /// <summary>
        /// Quand cette méthode est implémentée dans une classe dérivée, obtient le nombre total d'éléments de la collection.
        /// </summary>
        /// <returns>Nombre total d'éléments de la collection</returns>
        /// <remarks>Les classes dérivées doivent implémenter cette méthode pour récupérer le nombre d'éléments de la collection à partir d'une source quelconque.</remarks>
        protected abstract int FetchCount();

        #endregion

        #region Public members

        /// <summary>
        /// Invalide les pages en cache dans la collection et le nombre d'éléments.
        /// Le prochain accès à un élément rechargera la page nécessaire, et le nombre d'éléments sera réévalué.
        /// </summary>
        public virtual void Invalidate()
        {
            _count = null;
            _pages.Clear();
            var handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(string.Empty));
        }

        /// <summary>
        /// Obtient le nombre d'éléments par page de données.
        /// </summary>
        public int PageSize
        {
            get { return _pageSize; }
        }

        #endregion

        #region Private implementation

        private static Exception ReadOnlyException()
        {
            throw new NotSupportedException(ExceptionMessages.CollectionIsReadOnly);
        }

        private T[] GetPage(int pageIndex)
        {
            T[] page;
            if (!_pages.TryGetValue(pageIndex, out page))
            {
                int start = pageIndex * PageSize;
                page = FetchItems(start, PageSize);
                _pages[pageIndex] = page;
                RemoveOldPages(pageIndex);
            }
            return page;
        }

        private void RemoveOldPages(int lastLoadedPageIndex)
        {
            var indexesToRemove =
                _pages.Keys
                    .Where(i => i < lastLoadedPageIndex - 1 || i > lastLoadedPageIndex + 1)
                    .ToArray();
            foreach (var index in indexesToRemove)
            {
                _pages.Remove(index);
            }
        }

        #endregion
    }
}