using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Developpez.Dotnet.Data
{
    ///<summary>
    /// Fournit des méthodes d'extension pour la manipulation des datasets
    ///</summary>
    public static class DataSetExtensions
    {
        #region Méthodes d'extension pour IEnumerable

        /// <summary>
        /// Crée une DataTable à partir d'une séquence d'objets
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence à partir de laquelle créer une DataTable</param>
        /// <returns>Une DataTable contenant les données de la séquence source</returns>
        /// <remarks>Les colonnes de la table sont crées à partir des propriétés publiques non-indexées des éléments de la séquence.
        /// Les propriétés de type référence ou Nullable&lt;T&gt; génèrent des colonnes avec AllowDBNull = true. Les propriétés de type
        /// valeur génèrent des colonnes avec AllowDBNull = false</remarks>
        public static DataTable ToDataTable<T>(this IEnumerable<T> source)
        {
            PropertyInfo[] properties = typeof(T).GetProperties()
                                                 .Where(p => p.CanRead && !p.GetIndexParameters().Any())
                                                 .ToArray();

            DataTable table = new DataTable();
            foreach (var p in properties)
            {
                Type type = p.PropertyType;
                bool allowNull = !type.IsValueType;
                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    allowNull = true;
                    type = Nullable.GetUnderlyingType(type);
                }
                DataColumn column = table.Columns.Add(p.Name, type);
                column.AllowDBNull = allowNull;
                column.ReadOnly = !p.CanWrite;
            }

            foreach (var item in source)
            {
                DataRow row = table.NewRow();
                foreach (var p in properties)
                {
                    object value = p.GetValue(item, null) ?? DBNull.Value;
                    row[p.Name] = value;
                }
                table.Rows.Add(row);
            }

            return table;
        }

        #endregion

        #region Méthodes d'extension pour DataTable

        #region Sort

        /// <summary>
        /// Retourne un DataTable trié selon la colonne spécifiée, dans l'ordre croissant
        /// </summary>
        /// <param name="table">DataTable à trier</param>
        /// <param name="column">Colonne selon laquelle trier le DataTable</param>
        /// <returns>Retourne un DataTable trié</returns>
        public static DataTable Sort(this DataTable table, DataColumn column)
        {
            return Sort(table, column.ColumnName);
        }

        /// <summary>
        /// Retourne un DataTable trié selon la colonne et la direction spécifiées
        /// </summary>
        /// <param name="table">DataTable à trier</param>
        /// <param name="column">Colonne selon laquelle trier le DataTable</param>
        /// <param name="direction">Direction selon laquelle trier le DataTable</param>
        /// <returns>Retourne un DataTable trié</returns>
        public static DataTable Sort(this DataTable table, DataColumn column, ListSortDirection direction)
        {
            return Sort(table, column.ColumnName, direction);
        }

        /// <summary>
        /// Retourne un DataTable trié selon la colonne spécifiée, dans l'ordre croissant
        /// </summary>
        /// <param name="table">DataTable à trier</param>
        /// <param name="column">Nom de la colonne selon laquelle trier le DataTable</param>
        /// <returns>Retourne un Datatable trié</returns>
        public static DataTable Sort(this DataTable table, string column)
        {
            return Sort(table, column, ListSortDirection.Ascending);
        }

        /// <summary>
        /// Retourne un DataTable trié selon la colonne et la direction spécifiées
        /// </summary>
        /// <param name="table">DataTable à trier</param>
        /// <param name="column">Nom de la colonne selon laquelle trier le DataTable</param>
        /// <param name="direction">Direction selon laquelle trier le DataTable</param>
        /// <returns>Retourne un DataTable trié</returns>
        public static DataTable Sort(this DataTable table, string column, ListSortDirection direction)
        {
            table.CheckArgumentNull("table");
            column.CheckArgumentNull("column");

            string dir = direction == ListSortDirection.Ascending ? "ASC" : "DESC";
            DataTable ndt = table.Clone();
            int rowCount = table.Rows.Count;
            DataRow[] rows = table.Select(null, column + " " + dir);
            for (int i = 0; i < rowCount; i++)
                ndt.ImportRow(rows[i]);
            return ndt;
        }

        #endregion

        #region ToCsv

        /// <summary>
        /// Retourne une string au format CSV dans laquelle sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <returns>String représentant un DataTable au format CSV</returns>
        public static string ToCsv(this DataTable table)
        {
            return ToCsv(table, ",", true);
        }

        /// <summary>
        /// Retourne une string au format CSV dans laquelle sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <param name="includeHeader">Booléen indiquant si les nom des colonnes doivent être inclues dans le CSV généré</param>
        /// <returns>String représentant un DataTable au format CSV</returns>
        public static string ToCsv(this DataTable table, bool includeHeader)
        {
            return ToCsv(table, ",", includeHeader);
        }

        /// <summary>
        /// Retourne une string au format CSV dans laquelle sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <param name="delimiter">Chaîne représentant le délimiteur à utiliser pour la transformation</param>
        /// <returns>String représentant un DataTable au format CSV</returns>
        public static string ToCsv(this DataTable table, string delimiter)
        {
            return ToCsv(table, delimiter, true);
        }

        /// <summary>
        /// Retourne une string au format CSV dans laquelle sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <param name="delimiter">Chaîne représentant le délimiteur à utiliser pour la transformation</param>
        /// <param name="includeHeader">Booléen indiquant si les nom des colonnes doivent être inclues dans le CSV généré</param>
        /// <returns>String représentant un DataTable au format CSV</returns>
        public static string ToCsv(this DataTable table, string delimiter, bool includeHeader)
        {
            using (var writer = new StringWriter())
            {
                SaveAsCsv(table, writer, delimiter, includeHeader);
                return writer.ToString();
            }
        }

        #endregion

        #region SaveAsCsv
        /// <summary>
        /// Crée un fichier CSV dans lequel sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <param name="delimiter">Chaîne représentant le délimiteur à utiliser pour la transformation</param>
        /// <param name="includeHeader">Booléen indiquant si les nom des colonnes doivent être inclues dans le CSV généré</param>
        /// <param name="filePath">Chemin du fichier dans lequel inscrire le DataTable</param>             
        public static void SaveAsCsv(this DataTable table, string filePath, string delimiter, bool includeHeader)
        {
            table.CheckArgumentNull("table");
            delimiter.CheckArgumentNull("delimiter");
            filePath.CheckArgumentNull("filePath");

            using (FileStream fs = File.Open(filePath, FileMode.OpenOrCreate))
            {
                SaveAsCsv(table, fs, delimiter, includeHeader);
            }
        }

        /// <summary>
        /// Crée un fichier CSV dans lequel sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <param name="delimiter">Chaîne représentant le délimiteur à utiliser pour la transformation</param>
        /// <param name="includeHeader">Booléen indiquant si les nom des colonnes doivent être inclues dans le CSV généré</param>
        /// <param name="stream">stream dans lequel inscrire le DataTable</param>             
        public static void SaveAsCsv(this DataTable table, Stream stream, string delimiter, bool includeHeader)
        {
            table.CheckArgumentNull("table");
            delimiter.CheckArgumentNull("delimiter");
            stream.CheckArgumentNull("stream");

            using (StreamWriter sw = new StreamWriter(stream))
            {
                SaveAsCsv(table, sw, delimiter, includeHeader);
            }
        }

        /// <summary>
        /// Crée un fichier CSV dans lequel sera exporté le DataTable
        /// </summary>
        /// <param name="table">DataTable à partir duquel effectuer la transformation</param>
        /// <param name="delimiter">Chaîne représentant le délimiteur à utiliser pour la transformation</param>
        /// <param name="includeHeader">Booléen indiquant si les nom des colonnes doivent être inclues dans le CSV généré</param>
        /// <param name="textWriter">TextWriter dans lequel inscrire le DataTable</param> 
        public static void SaveAsCsv(this DataTable table, TextWriter textWriter, string delimiter, bool includeHeader)
        {
            table.CheckArgumentNull("table");
            delimiter.CheckArgumentNull("delimiter");
            textWriter.CheckArgumentNull("textWriter");

            StringBuilder result;
            if (includeHeader)
            {
                result = new StringBuilder();
                foreach (DataColumn column in table.Columns)
                {
                    result.Append(column.Caption);
                    result.Append(delimiter);
                }
                result.Length--;
                textWriter.WriteLine(result.ToString());
            }
            foreach (DataRow row in table.Rows)
            {
                result = new StringBuilder();
                foreach (object item in row.ItemArray)
                {
                    if (item is DBNull || string.IsNullOrEmpty(item.ToString()))
                        result.Append(delimiter);
                    else
                    {
                        string itemAsString = item.ToString();
                        itemAsString = itemAsString.Replace("\"", "\"\"");
                        result.Append(itemAsString + delimiter);
                    }
                }
                result.Length--;
                textWriter.WriteLine(result.ToString());
            }
        }

        #endregion

        #endregion
    }
}