using System;
using System.Data.Common;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace Developpez.Dotnet.Data
{
    /// <summary>
    /// Fournit des méthodes d'extension pour faciliter l'utilisation des classes ADO.NET
    /// </summary>
    public static class DataExtensions
    {
        #region Méthodes d'extension pour DbConnection

        /// <summary>
        /// Crée une commande à partir d'une connection et d'une requête
        /// </summary>
        /// <param name="connection">La connection</param>
        /// <param name="commandText">Le texte de la requête</param>
        /// <returns>Une commande pour la connexion et la requête spécifiées</returns>
        public static DbCommand CreateCommand(this DbConnection connection, string commandText)
        {
            DbCommand command = connection.CreateCommand();
            command.CommandText = commandText;
            return command;
        }

        #endregion

        #region Méthodes d'extension pour DbCommand

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType)
        {
            return AddParameter(command, name, dbType, 0, ParameterDirection.Input);
        }

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <param name="size">La taille du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, int size)
        {
            return AddParameter(command, name, dbType, size, ParameterDirection.Input);
        }

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <param name="direction">La direction du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, ParameterDirection direction)
        {
            DbParameter parameter = command.CreateParameter();
            parameter.ParameterName = name;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            command.Parameters.Add(parameter);
            return parameter;
        }

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <param name="size">La taille du paramètre</param>
        /// <param name="direction">La direction du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, int size, ParameterDirection direction)
        {
            DbParameter parameter = command.CreateParameter();
            parameter.ParameterName = name;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            parameter.Size = size;
            command.Parameters.Add(parameter);
            return parameter;
        }

        #endregion

        #region Méthodes d'extension pour IDataRecord

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Boolean
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static bool GetBoolean(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetBoolean(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Byte
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static byte GetByte(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetByte(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Char
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static char GetChar(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetChar(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que DateTime
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static DateTime GetDateTime(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDateTime(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Decimal
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static decimal GetDecimal(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDecimal(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Double
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static double GetDouble(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDouble(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Float
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static float GetFloat(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetFloat(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Guid
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static Guid GetGuid(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetGuid(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int16
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static short GetInt16(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetInt16(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int32
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static int GetInt32(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetInt32(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int64
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static long GetInt64(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetInt64(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que String
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static string GetString(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetString(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static object GetValue(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetValue(i);
        }

        /// <summary>
        /// Lit un flux binaire de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à lire</param>
        /// <param name="dataOffset">La position à laquelle commence la lecture dans la colonne</param>
        /// <param name="buffer">Le buffer de destination</param>
        /// <param name="bufferOffset">La position à laquelle commence l'écriture dans le buffer</param>
        /// <param name="length">Le nombre maximum d'octets à lire</param>
        /// <returns>Le nombre d'octets lus</returns>
        public static long GetBytes(this IDataRecord record, string name, long dataOffset, byte[] buffer, int bufferOffset, int length)
        {
            int i = record.GetOrdinal(name);
            return record.GetBytes(i, dataOffset, buffer, bufferOffset, length);
        }

        /// <summary>
        /// Lit un flux de caractères de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à lire</param>
        /// <param name="dataOffset">La position à laquelle commence la lecture dans la colonne</param>
        /// <param name="buffer">Le buffer de destination</param>
        /// <param name="bufferOffset">La position à laquelle commence l'écriture dans le buffer</param>
        /// <param name="length">Le nombre maximum de caractères à lire</param>
        /// <returns>Le nombre de caractères lus</returns>
        public static long GetChars(this IDataRecord record, string name, long dataOffset, char[] buffer, int bufferOffset, int length)
        {
            int i = record.GetOrdinal(name);
            return record.GetChars(i, dataOffset, buffer, bufferOffset, length);
        }

        /// <summary>
        /// Indique si la colonne spécifiée a la valeur DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à lire</param>
        /// <returns>True si la colonne vaut DBNull, false sinon</returns>
        public static bool IsDBNull(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i);
        }

        /// <summary>
        /// Renvoie le nom du type de données de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne dont on veut obtenir le type de données</param>
        /// <returns>Le nom du type de données de la colonne</returns>
        public static string GetDataTypeName(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDataTypeName(i);
        }

        /// <summary>
        /// Renvoie le type .NET de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne dont on veut obtenir le type .NET</param>
        /// <returns>Le nom type .NET de la colonne</returns>
        public static Type GetFieldType(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetFieldType(i);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="ordinal">L'index de la colonne à récupérer</param>
        /// <param name="tryConvert">true pour tenter de convertir la valeur si elle n'est pas de type T ; false pour effectuer un cast direct</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, int ordinal, bool tryConvert)
        {
            if (tryConvert)
                return ConvertT<T>.Convert(record[ordinal]);
            else
                return UnboxT<T>.Unbox(record[ordinal]);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="ordinal">L'index de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, int ordinal)
        {
            return record.Field<T>(ordinal, false);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="tryConvert">true pour tenter de convertir la valeur si elle n'est pas de type T ; false pour effectuer un cast direct</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, string name, bool tryConvert)
        {
            int i = record.GetOrdinal(name);
            return record.Field<T>(i, tryConvert);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.Field<T>(i, false);
        }

        #region Classes utilitaires UnboxT<T> pour convertir les valeurs de champ

        // Tiré de la classe System.Data.DataRowExtensions de .NET 3.5
        private static class UnboxT<T>
        {
            internal static readonly Converter<object, T> Unbox;

            static UnboxT()
            {
                Unbox = Create(typeof(T));
            }

            private static Converter<object, T> Create(Type type)
            {
                if (!type.IsValueType)
                {
                    return new Converter<object, T>(ReferenceField);
                }
                if ((type.IsGenericType && !type.IsGenericTypeDefinition) && (typeof(Nullable<>) == type.GetGenericTypeDefinition()))
                {
                    return (Converter<object, T>)Delegate.CreateDelegate(typeof(Converter<object, T>), typeof(UnboxT<T>).GetMethod("NullableField", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new Type[] { type.GetGenericArguments()[0] }));
                }
                return new Converter<object, T>(ValueField);
            }

            private static TElem? NullableField<TElem>(object value) where TElem : struct
            {
                if (DBNull.Value == value)
                {
                    return null;
                }
                return new TElem?((TElem)value);
            }

            private static T ReferenceField(object value)
            {
                if (DBNull.Value != value)
                {
                    return (T)value;
                }
                return default(T);
            }

            private static T ValueField(object value)
            {
                if (DBNull.Value == value)
                {
                    throw new InvalidCastException(string.Format(ExceptionMessages.InvalidCastFromTo, typeof(DBNull), typeof(T)));
                }
                return (T)value;
            }
        }

        private static class ConvertT<T>
        {
            internal static readonly Converter<object, T> Convert;

            static ConvertT()
            {
                Convert = Create(typeof(T));
            }

            private static Converter<object, T> Create(Type type)
            {
                if (!type.IsValueType)
                {
                    return new Converter<object, T>(ReferenceField);
                }
                if ((type.IsGenericType && !type.IsGenericTypeDefinition) && (typeof(Nullable<>) == type.GetGenericTypeDefinition()))
                {
                    return (Converter<object, T>)Delegate.CreateDelegate(typeof(Converter<object, T>), typeof(ConvertT<T>).GetMethod("NullableField", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new Type[] { type.GetGenericArguments()[0] }));
                }
                return new Converter<object, T>(ValueField);
            }

            private static TElem? NullableField<TElem>(object value) where TElem : struct
            {
                if (null == value || DBNull.Value == value)
                {
                    return null;
                }
                TElem nonNullValue = (TElem)System.Convert.ChangeType(value, typeof(TElem));
                return new TElem?(nonNullValue);
            }

            private static T ReferenceField(object value)
            {
                if (null != value && DBNull.Value != value)
                {
                    return (T)System.Convert.ChangeType(value, typeof(T));
                }
                return default(T);
            }

            private static T ValueField(object value)
            {
                if (DBNull.Value == value)
                {
                    throw new InvalidCastException(string.Format(ExceptionMessages.InvalidCastFromTo, typeof(DBNull), typeof(T)));
                }
                if (null == value)
                {
                    throw new InvalidCastException(ExceptionMessages.InvalidCastFromNullToValueType);
                }
                return (T)System.Convert.ChangeType(value, typeof(T));
            }
        }

        #endregion

        #endregion

        #region Méthodes d'extension pour DbDataReader

        /// <summary>
        /// Renvoie un DbDataReader comme une séquence de IDataRecord
        /// </summary>
        /// <param name="reader">Le DbDataReader à énumérer</param>
        /// <returns>Une séquence de IDataRecord</returns>
        public static IEnumerable<IDataRecord> AsEnumerable(this DbDataReader reader)
        {
            return reader.Cast<IDataRecord>();
        }

        #endregion

        #region Méthodes d'extension pour DbDataAdapter

        /// <summary>
        /// Ajoute un handler d'évènement RowUpdating à un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel ajouter un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à ajouter</param>
        public static void AddRowUpdatingHandler(this DbDataAdapter adapter, EventHandler<RowUpdatingEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            AddEventHandler(adapter, "RowUpdating", handler);
        }

        /// <summary>
        /// Ajoute un handler d'évènement RowUpdated à un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel ajouter un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à ajouter</param>
        public static void AddRowUpdatedHandler(this DbDataAdapter adapter, EventHandler<RowUpdatedEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            AddEventHandler(adapter, "RowUpdated", handler);
        }

        /// <summary>
        /// Enlève un handler d'évènement RowUpdating d'un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel enlever un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à enlever</param>
        public static void RemoveRowUpdatingHandler(this DbDataAdapter adapter, EventHandler<RowUpdatingEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            RemoveEventHandler(adapter, "RowUpdating", handler);
        }

        /// <summary>
        /// Enlève un handler d'évènement RowUpdated d'un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel enlever un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à enlever</param>
        public static void RemoveRowUpdatedHandler(this DbDataAdapter adapter, EventHandler<RowUpdatedEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            RemoveEventHandler(adapter, "RowUpdated", handler);
        }

        private static void AddEventHandler(object target, string eventName, Delegate handler)
        {
            Type targetType = target.GetType();
            EventInfo evt = targetType.GetEvent(eventName);
            if (evt == null)
            {
                throw new InvalidOperationException(string.Format(ExceptionMessages.TypeDoesntImplementEvent, targetType, eventName));
            }
            evt.AddEventHandler(target, ChangeType(evt.EventHandlerType, handler));
        }

        private static void RemoveEventHandler(object target, string eventName, Delegate handler)
        {
            Type targetType = target.GetType();
            EventInfo evt = targetType.GetEvent(eventName);
            if (evt == null)
            {
                throw new InvalidOperationException(string.Format(ExceptionMessages.TypeDoesntImplementEvent, targetType, eventName));
            }
            evt.RemoveEventHandler(target, ChangeType(evt.EventHandlerType, handler));
        }

        private static Delegate ChangeType(Type targetType, Delegate d)
        {
            return Delegate.CreateDelegate(targetType, d.Target, d.Method);
        }

        #endregion
    }
}