using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Common;

namespace ChadSoft.DataAccess
{
    public abstract class Database
    {
        internal const CommandType DefaultCommandType = CommandType.Text;
        internal const string DefaultDatabaseNameAppSetting = "DefaultDatabaseName";
        protected string connectionName;

        protected Database()
            : this(ConfigurationManager.AppSettings[DefaultDatabaseNameAppSetting])
        {
        }

        protected Database(string connectionName)
        {
            if (string.IsNullOrEmpty(connectionName))
                throw new ArgumentNullException("connectionName", "Please provide a database connection name.");
            this.connectionName = connectionName;
        }

        /// <summary>
        /// Executes the specified command text as a nonquery.
        /// </summary>
        /// <param name="commandText">The command text.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public int ExecuteNonQuery(string commandText)
        {
            return ExecuteNonQuery(commandText, null);
        }

        /// <summary>
        /// Executes the specified command text as a non query.
        /// </summary>
        /// <param name="commandText">The command text.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public int ExecuteNonQuery(string commandText, IDictionary<string, object> parameters)
        {
            return ExecuteNonQuery(commandText, DefaultCommandType, parameters);
        }

        /// <summary>
        /// Executes the specified command text as a non query.
        /// </summary>
        /// <param name="commandText">The command text.</param>
        /// <param name="commandType">Type of the command.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public int ExecuteNonQuery(string commandText, CommandType commandType, IDictionary<string, object> parameters)
        {
            return Execute(commandText, commandType, parameters, (cmd => cmd.ExecuteNonQuery()));
        }


        /// <summary>
        /// Executes the specified command text as a scalar.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public T ExecuteScalar<T>(string commandText)
        {
            return ExecuteScalar<T>(commandText, null);
        }

        /// <summary>
        /// Executes the specified command text as a scalar.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public T ExecuteScalar<T>(string commandText, IDictionary<string, object> parameters)
        {
            return ExecuteScalar<T>(commandText, DefaultCommandType, parameters);
        }

        /// <summary>
        /// Executes the specified command text as a scalar.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="commandType">Type of the command.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public T ExecuteScalar<T>(string commandText, CommandType commandType, IDictionary<string, object> parameters)
        {
            return Execute(commandText, commandType, parameters, (cmd => (T)cmd.ExecuteScalar()));
        }


        /// <summary>
        /// Executes the specified command text as a reader.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="conversionFunction">The conversion function.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public T ExecuteReader<T>(string commandText, Func<DbDataReader, T> conversionFunction)
        {
            return ExecuteReader(commandText, null, conversionFunction);
        }

        /// <summary>
        /// Executes the specified command text as a reader.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="conversionFunction">The conversion function.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public T ExecuteReader<T>(string commandText, IDictionary<string, object> parameters, Func<DbDataReader, T> conversionFunction)
        {
            return ExecuteReader(commandText, DefaultCommandType, parameters, conversionFunction);
        }

        /// <summary>
        /// Executes the specified command text as a reader.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="commandType">Type of the command.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="conversionFunction">The conversion function.</param>
        /// <returns>The strongly-typed result of the query</returns>
        public T ExecuteReader<T>(string commandText, CommandType commandType, IDictionary<string, object> parameters, Func<DbDataReader, T> conversionFunction)
        {
            var cmd = new DbDataReaderToObjectCommand<T>(conversionFunction);
            return Execute<T>(commandText, commandType, parameters, cmd.Execute);
        }


        /// <summary>
        /// Executes the specified command text.
        /// </summary>
        /// <param name="commandText">The command text.</param>
        /// <param name="commandType">Type of the command.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="resultProcessor">The result processor.</param>
        /// <returns>The result of the <paramref name="resultProcessor"/></returns>
        public object Execute(string commandText, CommandType commandType, IDictionary<string, object> parameters, Func<DbCommand, object> resultProcessor)
        {
            return Execute(commandText, commandType, parameters, resultProcessor);
        }

        /// <summary>
        /// Executes the specified command text.
        /// </summary>
        /// <typeparam name="T">The query's result type</typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="commandType">Type of the command.</param>
        /// <param name="parameters">The parameters.</param>
        /// <param name="resultProcessor">The result processor.</param>
        /// <returns>The result of the <paramref name="resultProcessor"/></returns>
        public abstract T Execute<T>(string commandText, CommandType commandType, IDictionary<string, object> parameters, Func<DbCommand, T> resultProcessor);

        /// <summary>
        /// Gets the connection string.
        /// </summary>
        /// <returns>Connection string to the database</returns>
        protected string GetConnectionString()
        {
            var connectionInfo = ConfigurationManager.ConnectionStrings[connectionName];
            return connectionInfo.ConnectionString;
        }

        private class DbDataReaderToObjectCommand<T>
        {
            private readonly Func<DbDataReader, T> conversionFunction;

            public DbDataReaderToObjectCommand(Func<DbDataReader, T> conversionFunction)
            {
                this.conversionFunction = conversionFunction;
            }

            public T Execute(DbCommand command)
            {
                using (var reader = command.ExecuteReader())
                    return conversionFunction(reader);
            }
        }
    }
}