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

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Fournit des méthodes d'extension pour la manipulation de tableaux
    /// </summary>
    public static class ArrayExtensions
    {
        #region Jagged and multidimensional arrays

        /// <summary>
        /// Renvoie une séquence contenant les lignes d'un tableau bidimensionnel.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau bidimensionnel dont on veut obtenir les lignes.</param>
        /// <returns>Une séquence contenant les lignes du tableau</returns>
        public static IEnumerable<T[]> GetRows<T>(this T[,] array)
        {
            array.CheckArgumentNull("array");
            return array.GetRowsImpl();
        }

        private static IEnumerable<T[]> GetRowsImpl<T>(this T[,] array)
        {
            int rows = array.GetLength(0);
            int columns = array.GetLength(1);
            for (int i = 0; i < rows; i++)
            {
                T[] row = new T[columns];
                for (int j = 0; j < columns; j++)
                {
                    row[j] = array[i, j];
                }
                yield return row;
            }
        }

        /// <summary>
        /// Renvoie un tableau en escalier avec le même contenu que le tableau bidimensionnel spécifié.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau bidimensionnel à convertir</param>
        /// <returns>Un tableau en escalier avec le même contenu que le tableau bidimensionnel spécifié.</returns>
        public static T[][] ToJaggedArray<T>(this T[,] array)
        {
            return array.GetRows().ToArray();
        }

        /// <summary>
        /// Renvoie un tableau bidimensionnel avec le même contenu que le tableau en escalier spécifié.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="jaggedArray">Tableau en escalier à convertir.</param>
        /// <returns>Un tableau bidimensionnel avec le même contenu que le tableau en escalier spécifié.</returns>
        /// <remarks>Le nombre de colonnes est déterminé en recherchant la plus longue ligne du tableau en escalier.
        /// Pour de meilleures performances, si vous savez que toutes les lignes ont la même longueur, utilisez la
        /// surcharge prenant un paramètre <c>bool useFirstLineLength</c>.</remarks>
        public static T[,] ToBidimensionalArray<T>(this T[][] jaggedArray)
        {
            return jaggedArray.ToBidimensionalArray(false);
        }

        /// <summary>
        /// Renvoie un tableau bidimensionnel avec le même contenu que le tableau en escalier spécifié.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="jaggedArray">Tableau en escalier à convertir.</param>
        /// <param name="useFirstLineLength">true pour utiliser la longueur de la première ligne comme nombre de colonnes, false pour rechercher la ligne la plus longue.</param>
        /// <returns>Un tableau bidimensionnel avec le même contenu que le tableau en escalier spécifié.</returns>
        /// <remarks>Si <c>useFirstLineLength</c> vaut false, le nombre de colonnes est déterminé en recherchant la plus longue ligne
        /// du tableau en escalier. Pour de meilleures performances, si vous savez que toutes les lignes ont la même longueur, passez true
        /// pour le paramètre <c>useFirstLineLength</c> (une exception sera alors levée si une ligne est plus longue que la première).</remarks>
        public static T[,] ToBidimensionalArray<T>(this T[][] jaggedArray, bool useFirstLineLength)
        {
            jaggedArray.CheckArgumentNull("jaggedArray");

            int rows = jaggedArray.Length;
            int columns;

            if (useFirstLineLength && jaggedArray.Length != 0)
                columns = jaggedArray[0].Length;
            else
                columns = jaggedArray.Select(row => row.Length).DefaultIfEmpty().Max();

            T[,] array = new T[rows, columns];
            for (int i = 0; i < rows; i++)
            {
                T[] row = jaggedArray[i];
                int cols = row.Length;

                for (int j = 0; j < cols; j++)
                {
                    array[i, j] = row[j];
                }
            }
            return array;
        }

        #endregion

        #region ArraySegment related methods

        /// <summary>
        /// Renvoie le segment demandé d'un tableau
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau dont on veut obtenir un segment</param>
        /// <param name="from">Index de début du segment</param>
        /// <param name="count">Nombre d'éléments dans le segment</param>
        /// <returns>Le segment demandé du tableau</returns>
        public static ArraySegment<T> GetSegment<T>(this T[] array, int from, int count)
        {
            return new ArraySegment<T>(array, from, count);
        }

        /// <summary>
        /// Renvoie un segment d'un tableau à partir de la position spécifiée
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau dont on veut obtenir un segment</param>
        /// <param name="from">Index de début du segment</param>
        /// <returns>Le segment de tableau qui commence à la position spécifiée</returns>
        public static ArraySegment<T> GetSegment<T>(this T[] array, int from)
        {
            return GetSegment(array, from, array.Length - from);
        }

        /// <summary>
        /// Renvoie un segment de tableau représentant la totalité du tableau
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau dont on veut obtenir un segment</param>
        /// <returns>Un segment représentant la totalité du tableau</returns>
        public static ArraySegment<T> GetSegment<T>(this T[] array)
        {
            return new ArraySegment<T>(array);
        }

        /// <summary>
        /// Renvoie un nouveau tableau à partir d'un segment de tableau
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="arraySegment">Segment de tableau à partir duquel est créé le nouveau tableau</param>
        /// <returns>Un tableau contenant tous les éléments du segment d'origine</returns>
        public static T[] ToArray<T>(this ArraySegment<T> arraySegment)
        {
            T[] array = new T[arraySegment.Count];
            Array.Copy(arraySegment.Array, arraySegment.Offset, array, 0, arraySegment.Count);
            return array;
        }

        /// <summary>
        /// Renvoie une séquence qui énumère les éléments d'un segment de tableau
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="arraySegment">Segment de tableau à énumérer</param>
        /// <returns>Une séquence correspondant aux éléments du segment de tableau</returns>
        public static IEnumerable<T> AsEnumerable<T>(this ArraySegment<T> arraySegment)
        {
            return arraySegment.Array.Skip(arraySegment.Offset).Take(arraySegment.Count);
        }

        /// <summary>
        /// Renvoie un wrapper <see cref="IList{T}"/> pour un <see cref="ArraySegment{T}"/>.
        /// </summary>
        /// <typeparam name="T">Type des éléments du segment de tableau</typeparam>
        /// <param name="arraySegment">Segment de tableau pour lequel on veut obtenir un wrapper</param>
        /// <returns>Un wrapper <see cref="IList{T}"/> pour le segment de tableau</returns>
        public static IList<T> AsList<T>(this ArraySegment<T> arraySegment)
        {
            return new ArraySegmentList<T>(arraySegment);
        }
        
        private class ArraySegmentList<T> : IList<T>
        {
            private readonly ArraySegment<T> _segment;

            public ArraySegmentList(ArraySegment<T> segment)
            {
                _segment = segment;
            }

            #region Implementation of IEnumerable

            public IEnumerator<T> GetEnumerator()
            {
                for (int i = 0; i < Count; i++)
                {
                    yield return this[i];
                }
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }

            #endregion

            #region Implementation of ICollection<T>

            public void Add(T item)
            {
                throw FixedLengthException();
            }

            public void Clear()
            {
                throw FixedLengthException();
            }

            public bool Contains(T item)
            {
                return this.AsEnumerable().Contains(item);
            }

            public void CopyTo(T[] array, int arrayIndex)
            {
                Array.Copy(_segment.Array, _segment.Offset, array, arrayIndex, _segment.Count);
            }

            public bool Remove(T item)
            {
                throw FixedLengthException();
            }

            public int Count { get { return _segment.Count; } }
            public bool IsReadOnly { get { return false; } }

            #endregion

            #region Implementation of IList<T>

            public int IndexOf(T item)
            {
                int arrayIndex = Array.IndexOf(_segment.Array, item, _segment.Offset, _segment.Count);
                if (arrayIndex != -1)
                    return arrayIndex - _segment.Offset;
                return -1;
            }

            public void Insert(int index, T item)
            {
                throw FixedLengthException();
            }

            public void RemoveAt(int index)
            {
                throw FixedLengthException();
            }

            public T this[int index]
            {
                get { return _segment.Array[index + _segment.Offset]; }
                set { _segment.Array[index + _segment.Offset] = value; }
            }

            #endregion

            private Exception FixedLengthException()
            {
                return new InvalidOperationException(ExceptionMessages.CollectionFixedSize);
            }
        }

        #endregion

        #region ShiftLeft, ShiftRight

        /// <summary>
        /// Décale les éléments d'un tableau d'une position vers la gauche,
        /// en remplaçant le dernier élément par la valeur par défaut du type
        /// des éléments du tableau. Cette méthode ne modifie pas le tableau d'origine
        /// mais renvoie un nouveau tableau.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau à décaler</param>
        /// <returns>Une copie décalée du tableau d'origine</returns>
        public static T[] ShiftLeft<T>(this T[] array)
        {
            return array.ShiftLeft(default(T));
        }

        /// <summary>
        /// Décale les éléments d'un tableau d'une position vers la gauche,
        /// en remplaçant le dernier élément par la valeur spécifiée.
        /// Cette méthode ne modifie pas le tableau d'origine mais renvoie un
        /// nouveau tableau.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau à décaler</param>
        /// <param name="value">Valeur à insérer à la fin du tableau</param>
        /// <returns>Une copie décalée du tableau d'origine</returns>
        public static T[] ShiftLeft<T>(this T[] array, T value)
        {
            T[] newArray = new T[array.Length];
            Array.Copy(array, 1, newArray, 0, array.Length - 1);
            newArray[array.Length - 1] = value;
            return newArray;
        }

        /// <summary>
        /// Décale les éléments d'un tableau d'une position vers la droite,
        /// en remplaçant le premier élément par la valeur par défaut du type
        /// des éléments du tableau. Cette méthode ne modifie pas le tableau d'origine
        /// mais renvoie un nouveau tableau.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau à décaler</param>
        /// <returns>Une copie décalée du tableau d'origine</returns>
        public static T[] ShiftRight<T>(this T[] array)
        {
            return array.ShiftRight(default(T));
        }

        /// <summary>
        /// Décale les éléments d'un tableau d'une position vers la droite,
        /// en remplaçant le premier élément par la valeur spécifiée.
        /// Cette méthode ne modifie pas le tableau d'origine mais renvoie un
        /// nouveau tableau.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau à décaler</param>
        /// <param name="value">Valeur à insérer au début du tableau</param>
        /// <returns>Une copie décalée du tableau d'origine</returns>
        public static T[] ShiftRight<T>(this T[] array, T value)
        {
            T[] newArray = new T[array.Length];
            Array.Copy(array, 0, newArray, 1, array.Length - 1);
            newArray[0] = value;
            return newArray;
        }

        #endregion

        #region RotateLeft, RotateRight

        /// <summary>
        /// Effectue une rotation d'un tableau d'une position vers la gauche.
        /// Cette méthode ne modifie pas le tableau d'origine mais renvoie un
        /// nouveau tableau.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau sur lequel effectuer une rotation</param>
        /// <returns>Une copie du tableau d'origine sur laquelle une rotation a été effectuée</returns>
        public static T[] RotateLeft<T>(this T[] array)
        {
            return array.ShiftLeft(array.First());
        }

        /// <summary>
        /// Effectue une rotation d'un tableau d'une position vers la droite.
        /// Cette méthode ne modifie pas le tableau d'origine mais renvoie un
        /// nouveau tableau.
        /// </summary>
        /// <typeparam name="T">Type des éléments du tableau</typeparam>
        /// <param name="array">Tableau sur lequel effectuer une rotation</param>
        /// <returns>Une copie du tableau d'origine sur laquelle une rotation a été effectuée</returns>
        public static T[] RotateRight<T>(this T[] array)
        {
            return array.ShiftRight(array.Last());
        }

        #endregion

    }
}