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

namespace Developpez.Dotnet.IO
{
    /// <summary>
    /// Fournit des méthodes d'extension pour les flux
    /// </summary>
    public static class StreamExtensions
    {
        private const int DefaultBufferSize = 4096;


// Contournement d'un bug dans Resharper: la directive #if entre le commentaire de doc et la
// méthode provoque ces deux avertissements (mais le comportement du compilateur est correct)
#pragma warning disable 1587
#pragma warning disable 1591

        /// <summary>
        /// Copie le contenu d'un flux vers le flux spécifié, en utilisant un buffer de 4096 octets.
        /// </summary>
        /// <param name="fromStream">le flux d'origine</param>
        /// <param name="toStream">le flux de destination</param>
        /// <returns>le nombre d'octets copiés</returns>

// La méthode CopyTo a été ajoutée dans .NET 4.0 et ne sera donc plus nécessaire
// Par contre elle est utilisée en interne et doit donc rester présente
#if DOTNET4
        private
#else
        public
#endif
        static int CopyTo(this Stream fromStream, Stream toStream)
        {
            return CopyTo(fromStream, toStream, DefaultBufferSize);
        }

        /// <summary>
        /// Copie le contenu d'un flux vers le flux spécifié, en utilisant un buffer de la taille spécifiée.
        /// </summary>
        /// <param name="fromStream">le flux d'origine</param>
        /// <param name="toStream">le flux de destination</param>
        /// <param name="bufferSize">taille du buffer</param>
        /// <returns>le nombre d'octets copiés</returns>

// La méthode CopyTo a été ajoutée dans .NET 4.0 et ne sera donc plus nécessaire
// Par contre elle est utilisée en interne et doit donc rester présente
#if DOTNET4
        private
#else
        public
#endif
        static int CopyTo(this Stream fromStream, Stream toStream, int bufferSize)
        {
            fromStream.CheckArgumentNull("fromStream");
            toStream.CheckArgumentNull("toStream");
            int totalBytes = 0;
            byte[] buffer = new byte[bufferSize];
            int nRead = 0;
            while ((nRead = fromStream.Read(buffer, 0, buffer.Length)) > 0)
            {
                toStream.Write(buffer, 0, nRead);
                totalBytes += nRead;
            }
            return totalBytes;
        }

#pragma warning restore 1591
#pragma warning restore 1587

        /// <summary>
        /// Copie le contenu d'un flux vers le fichier spécifié, en utilisant un buffer de 4096 octets.
        /// </summary>
        /// <param name="fromStream">le flux d'origine</param>
        /// <param name="path">le chemin du fichier de destination</param>
        /// <returns>le nombre d'octets copiés</returns>
        public static int CopyToFile(this Stream fromStream, string path)
        {
            return fromStream.CopyToFile(path, DefaultBufferSize);
        }

        /// <summary>
        /// Copie le contenu d'un flux vers le fichier spécifié, en utilisant un buffer de la taille spécifiée.
        /// </summary>
        /// <param name="fromStream">le flux d'origine</param>
        /// <param name="path">le chemin du fichier de destination</param>
        /// <param name="bufferSize">taille du buffer</param>
        /// <returns>le nombre d'octets copiés</returns>
        public static int CopyToFile(this Stream fromStream, string path, int bufferSize)
        {
            fromStream.CheckArgumentNull("fromStream");
            path.CheckArgumentNull("path");
            using (FileStream toStream = File.OpenWrite(path))
            {
                return CopyTo(fromStream, toStream, bufferSize);
            }
        }

        ///<summary>
        /// Lit tout le contenu du flux et le renvoie sous forme d'un tableau d'octets.
        ///</summary>
        ///<param name="stream">Le flux à lire</param>
        ///<returns>Un tableau d'octets contenant les données lues à partir du flux.</returns>
        public static byte[] ReadAllBytes(this Stream stream)
        {
            stream.CheckArgumentNull("stream");
            using (var tmp = new MemoryStream())
            {
                stream.CopyTo(tmp);
                return tmp.ToArray();
            }
        }

        /// <summary>
        /// Lit le nombre d'octets spécifié et les renvoie sous forme d'un tableau d'octets.
        /// </summary>
        /// <param name="stream">Le flux à lire</param>
        /// <param name="count">Le nombre d'octets à lire</param>
        /// <returns>Un tableau contenant les octets lus.</returns>
        /// <remarks>Cette méthode bloque jusqu'à ce qu'elle ait lu le nombre d'octets demandé ou que la fin du flux soit atteinte.</remarks>
        public static byte[] ReadBytes(this Stream stream, int count)
        {
            stream.CheckArgumentNull("stream");
            count.CheckArgumentOutOfRange("count", 0, int.MaxValue);
            byte[] buffer = new byte[count];
            int nRead, totalRead = 0;
            while (totalRead < count && (nRead = stream.Read(buffer, totalRead, count - totalRead)) != 0)
            {
                totalRead += nRead;
            }

            if (count > totalRead)
            {
                Array.Resize(ref buffer, totalRead);
            }
            return buffer;
        }

        // TODO: nom à revoir (SuppressClose, KeepOpen ?)
        /// <summary>
        /// Renvoie un wrapper autour d'un flux, qui ignore les demandes de fermeture de façon à éviter la fermeture
        /// du flux lorsque le reader ou writer qui travaille dessus est fermé
        /// </summary>
        /// <param name="stream">Le flux à wrapper</param>
        /// <returns>Un wrapper non-fermable autour de ce flux</returns>
        public static Stream AsNonClosing(this Stream stream)
        {
            stream.CheckArgumentNull("stream");
            return new NonClosingStreamWrapper(stream);
        }

        /// <summary>
        /// Crée un wrapper qui reproduit la sortie d'un flux sur le ou les autres flux spécifiés.
        /// </summary>
        /// <param name="stream">Premier flux</param>
        /// <param name="other">Second flux</param>
        /// <param name="others">Flux supplémentaires</param>
        /// <returns>Un wrapper qui reproduit la sortie de <c>stream</c> sur les autres flux.</returns>
        public static Stream Tee(this Stream stream, Stream other, params Stream[] others)
        {
            var outputStreams = new[] { stream, other }.Concat(others).ToArray();
            if (outputStreams.Any(w => w == null))
                throw new ArgumentNullException();
            if (outputStreams.Any(w => !w.CanWrite))
                throw new ArgumentException(ExceptionMessages.AllStreamsMustBeWritable);

            return new TeeStream(outputStreams);
        }

        // TODO: nom à revoir (GetBytes ?)
        /// <summary>
        /// Renvoie une séquence d'octets lus à partir d'un flux.
        /// </summary>
        /// <param name="stream">Flux à partir duquel lire les données</param>
        /// <param name="bufferSize">Taille de buffer à utiliser pour la lecture</param>
        /// <returns>La séquence d'octets lus à partir du flux</returns>
        public static IEnumerable<byte> AsByteEnumerable(this Stream stream, int bufferSize)
        {
            stream.CheckArgumentNull("stream");
            bufferSize.CheckArgumentOutOfRange("bufferSize", 0, 1024 * 1024 * 1024);
            byte[] buffer = new byte[bufferSize];
            int nRead = 0;
            while ((nRead = stream.Read(buffer, 0, bufferSize)) > 0)
            {
                for (int i = 0; i < nRead; i++)
                {
                    yield return buffer[i];
                }
            }
        }

        /// <summary>
        /// Renvoie une séquence d'octets lus à partir d'un flux.
        /// </summary>
        /// <param name="stream">Flux à partir duquel lire les données</param>
        /// <returns>La séquence d'octets lus à partir du flux</returns>
        public static IEnumerable<byte> AsByteEnumerable(this Stream stream)
        {
            return stream.AsByteEnumerable(DefaultBufferSize);
        }

        // TODO: nom à revoir (GetBlocks ?)
        /// <summary>
        /// Renvoie une séquence de blocs d'octets lus à partir d'un flux.
        /// </summary>
        /// <param name="stream">Flux à partir duquel lire les données</param>
        /// <param name="blockSize">Taille de bloc désirée</param>
        /// <returns>Une séquence de blocs d'octets de la taille spécifiée, lus à partir du flux ; le dernier bloc renvoyé peut être plus court si la fin du flux a été atteinte.</returns>
        public static IEnumerable<byte[]> AsBlockEnumerable(this Stream stream, int blockSize)
        {
            stream.CheckArgumentNull("stream");
            blockSize.CheckArgumentOutOfRange("blockSize", 0, 1024 * 1024 * 1024);
            byte[] buffer = new byte[blockSize];
            int nRead = 0;
            while ((nRead = stream.Read(buffer, 0, blockSize)) > 0)
            {
                byte[] buf2 = new byte[nRead];
                Array.Copy(buffer, buf2, nRead);
                yield return buf2;
            }
        }
    }
}