using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Xml;
using System.Xml.Serialization;

namespace ChadSoft.DataAccess
{
    public sealed class SqlDatabase : Database
    {
        public SqlDatabase()
        {
        }
        public SqlDatabase(string connectionName) : base(connectionName)
        {
        }

        /// <summary>
        /// Executes the XML reader.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        /// <remarks>
        /// The default CommandType for this method is StoredProcedure
        /// (as opposed to the other ExecuteX() methods, where it is Text)
        /// </remarks>
        public T ExecuteXmlReader<T>(string commandText, IDictionary<string, object> parameters)
        {
            return ExecuteXmlReader<T>(commandText, CommandType.StoredProcedure, parameters);
        }

        /// <summary>
        /// Executes the XML reader.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="commandText">The command text.</param>
        /// <param name="commandType">Type of the command.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        public T ExecuteXmlReader<T>(string commandText, CommandType commandType, IDictionary<string, object> parameters)
        {
            var serializer = new XmlSerializer(typeof(T));
            return ExecuteXmlReader(commandText, commandType, parameters, rdr => (T)serializer.Deserialize(rdr));
        }

        /// <summary>
        /// Executes the XML reader.
        /// </summary>
        /// <typeparam name="T"></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></returns>
        public T ExecuteXmlReader<T>(string commandText, CommandType commandType, IDictionary<string, object> parameters, Func<XmlReader, T> conversionFunction)
        {
            var cmd = new XmlReaderToObjectCommand<T>(conversionFunction);
            return Execute<T>(commandText, commandType, parameters, cmd.Execute);
        }

        /// <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 override T Execute<T>(string commandText, CommandType commandType, IDictionary<string, object> parameters, Func<DbCommand, T> resultProcessor)
        {
            using (var connection = new SqlConnection(GetConnectionString()))
            {
                using (var command = new SqlCommand(commandText, connection))
                {
                    command.CommandType = commandType;
                    populateParameters(command, parameters);
                    connection.Open();
                    return resultProcessor(command);
                }
            }
        }

        private static void populateParameters(SqlCommand command, IDictionary<string, object> parameters)
        {
            if (parameters == null) return;

            foreach (var name in parameters.Keys)
                command.Parameters.AddWithValue(name, parameters[name]);
        }
    }

    internal class XmlReaderToObjectCommand<T>
    {
        private readonly Func<XmlReader, T> conversionFunction;

        public XmlReaderToObjectCommand(Func<XmlReader, T> conversionFunction)
        {
            this.conversionFunction = conversionFunction;
        }

        public T Execute(DbCommand command)
        {
            var sqlCommand = command as SqlCommand;
            if (sqlCommand == null)
                throw new ApplicationException("Command is not a SqlCommand!");

            using (var reader = sqlCommand.ExecuteXmlReader())
                return conversionFunction(reader);
        }
    }
}