using System;
using System.Data;
using System.Linq;
using System.Reflection;
using Ease.Core.Utility;
using Microsoft.Data.SqlClient;
using System.Linq.Expressions;
using System.Collections.Generic;
using System.IO;
using System.Diagnostics;

namespace Ease.Core.DataAccess
{
    #region DataAccess: Transaction Context

    public class TransactionContext : IDisposable
    {
        #region Declaration & Constructors

        private int _tryCount = 0;
        private SQLSyntax _syntax;
        private Provider _provider;
        private int _commandTimeout;
        private ConnectionContext _contex;
        private IDbConnection _connection;
        private static bool _createSession;
        private IDbTransaction _transaction;

        private TransactionContext()
        {
            _tryCount = 0;
            _contex = null;
            _commandTimeout = 0;
            _createSession = false;
            _syntax = SQLSyntax.SQL;
        }

        #endregion

        #region Properties

        /// <summary>
        /// Current connection
        /// </summary>
        public IDbConnection Connection
        {
            get { return _connection; }
        }

        /// <summary>
        /// Current transation
        /// </summary>
        public IDbTransaction Transaction
        {
            get { return _transaction; }
        }

        /// <summary>
        /// Get or set command timeout if value is 0, uses default command timeout 
        /// </summary>
        public int CommandTimeOut
        {
            get { return _commandTimeout; }
            set { _commandTimeout = value; }
        }

        #endregion

        #region Transaction related functions

        /// <summary>
        /// Start the session without lock the table of database
        /// use only for select query.
        /// </summary>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin()
        {
            TransactionContext tc = new TransactionContext();

            _createSession = false;
            try
            {
                tc.prepareConnection();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            return tc;
        }

        /// <summary>
        /// Start the session with lock the table(s) of database
        /// may be used both action and select query.
        /// </summary>
        /// <param name="createSession">True to create a new session to lock the databse.</param>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin(bool createSession)
        {
            TransactionContext tc = new TransactionContext();

            _createSession = createSession;
            try
            {
                tc.prepareConnection();
            }
            catch
            {
            }

            return tc;
        }

        /// <summary>
        /// Start the session without lock the table of database
        /// use only for select query using connectioncontext.
        /// </summary>
        /// <param name="ctx">Only used when it has to connect other than default database (more than one databse).</param>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin(ConnectionContext ctx)
        {
            TransactionContext tc = new TransactionContext();
            tc._contex = ctx;
            _createSession = false;
            try
            {
                tc.prepareConnection();
            }
            catch
            {
            }

            return tc;
        }

        /// <summary>
        /// Start the session wit lock the table of database
        /// may be used both action and select query.
        /// </summary>
        /// <param name="createSession">True to create a new session to lock the databse.</param>
        /// <param name="ctx">Only used when it has to connect other than default database (more than one databse).</param>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin(bool createSession, ConnectionContext ctx)
        {
            TransactionContext tc = new TransactionContext();

            tc._contex = ctx;
            _createSession = createSession;
            try
            {
                tc.prepareConnection();
            }
            catch
            {
            }


            return tc;
        }

        /// <summary>
        /// Start the session without lock the table of database
        /// use only for select query using connectioncontext.
        /// </summary>
        /// <param name="coneectionString">A valid conntection string.</param>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin(Provider provider, SQLSyntax syntax, string coneectionString)
        {
            TransactionContext tc = new TransactionContext();

            tc._syntax = syntax;
            _createSession = false;
            tc._provider = provider;

            try
            {
                tc.prepareConnection(coneectionString);
            }
            catch
            {
            }

            return tc;
        }

        /// <summary>
        /// Start the session wit lock the table of database may be used both action and select query.
        /// </summary>
        /// <param name="createSession">True to create a new session to lock the databse.</param>
        /// <param name="coneectionString">A valid conntection string.</param>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin(bool createSession, Provider provider, SQLSyntax syntax,
            string coneectionString)
        {
            TransactionContext tc = new TransactionContext();

            tc._syntax = syntax;
            tc._provider = provider;
            _createSession = createSession;

            try
            {
                tc.prepareConnection(coneectionString);
            }
            catch
            {
            }

            return tc;
        }


        /// <summary>
        /// Start the session with lock the table(s) of database
        /// may be used both action and select query.
        /// </summary>
        /// <param name="createSession">True to create a new session to lock the databse.</param>
        /// <param name="svcConfig">Configurion of each object, could found in ServiceTemplate
        /// calling in following base.ServiceConfuguration.</param>
        /// <returns>Return an instance of TransactionContext object.</returns>
        public static TransactionContext Begin(string svcConfig, bool createSession = false)
        {
            TransactionContext tc = new TransactionContext();

            _createSession = createSession;
            tc._contex = new ConnectionContext(svcConfig);
            try
            {
                tc.prepareConnection();
            }
            catch
            {
            }

            return tc;
        }

        /// <summary>
        /// End the session which means that release all resources  
        /// </summary>
        public void End()
        {
            if (_transaction != null)
                _transaction.Commit();

            releaseResources();
        }

        /// <summary>
        /// Release all resources
        /// </summary>
        void releaseResources()
        {
            try
            {
                if (_connection != null && _connection.State == ConnectionState.Open)
                    _connection.Close();

                if (_transaction != null)
                    _transaction.Dispose();

                if (_connection != null)
                    _connection.Dispose();

                _contex = null;
                _connection = null;
                _commandTimeout = 0;
                _transaction = null;
                _createSession = false;

                GC.Collect();
            }
            catch
            {
            }
        }

        #endregion

        #region Command preparation and private function

        void prepareConnection()
        {
            int connectionIdx = 0;
            //####
            //if (Settings.Default != null)
            //    connectionIdx = Settings.Default.Index;

            this.prepareConnection(connectionIdx: connectionIdx);
        }

        void prepareConnection(int connectionIdx)
        {
            if (_connection == null)
            {
                ConnectionFactory cf;
                if (_contex != null)
                {
                    cf = ConnectionFactory.ContextConnection(_contex);
                    _syntax = cf.Syntax;
                    _connection = cf.CreateConnection(_contex);
                }
                else
                {
                    ConnectionFactory.SetConnectionIndex(connectionIdx: connectionIdx);
                    cf = ConnectionFactory.Default;
                    _syntax = cf.Syntax;
                    _connection = cf.CreateConnection();
                }

                cf = null;

                try
                {
                    _connection.Open();
                }
                catch (Microsoft.Data.SqlClient.SqlException e)
                {
                    switch (e.Number)
                    {
                        case 2:
                        case 53:
                        case 258:
                        case 976:
                        case 2702:
                        case 4060:
                        case 10054:
                        case 10060:
                        case 10061:
                        case 11001:
                        case 37002:
                        {
                            int ccIdx = 0;
                            _connection = null;
                            int dsCount = ConnectionFactory.ConnectionCount;
                            if (dsCount > 1)
                            {
                                _tryCount++;
                                if (_tryCount > dsCount)
                                {
                                    throw new Exception(
                                        string.Format("Eorror code: {0} -> {1}", e.ErrorCode, e.Message), e);
                                }
                                else
                                {
                                    if (dsCount <= (connectionIdx + 1))
                                    {
                                        ccIdx = 0;
                                    }
                                    else
                                    {
                                        ccIdx = connectionIdx + 1;
                                    }

                                    //Save Connection Index
                                    //####
                                    //if (Settings.Default != null)
                                    //{
                                    //    Settings.Default.Index = ccIdx;
                                    //    Settings.Default.Save();
                                    //}

                                    //Prepare new connection
                                    this.prepareConnection(connectionIdx: ccIdx);
                                }
                            }
                            else
                            {
                                throw new Exception(string.Format("Eorror code: {0} -> {1}", e.ErrorCode, e.Message),
                                    e);
                            }

                            break;
                        }

                        default:
                            throw new Exception(string.Format("Server: {0} -> {1}", e.Server, e.Message), e);
                    }
                }

                if (_createSession)
                    _transaction = _connection.BeginTransaction(IsolationLevel.ReadCommitted);
            }
        }

        public DataSet ExecuteDataSet(string v, int allowDeducID, object p1, object p2, int payrollTypeID)
        {
            throw new NotImplementedException();
        }

        void prepareConnection(string connectionString)
        {
            if (_connection == null)
            {
                _connection = ConnectionFactory.CreateConnection(_provider, _syntax, connectionString)
                    .CreateConnection();
                try
                {
                    _connection.Open();
                }
                catch (Microsoft.Data.SqlClient.SqlException e)
                {
                    throw new Exception(string.Format("Server: {0} -> {1}", e.Server, e.Message), e);
                }

                if (_createSession)
                    _transaction = _connection.BeginTransaction(IsolationLevel.ReadCommitted);
            }
        }

        /// <summary>
        /// Create command using current connection and/or transanction.
        /// </summary>
        /// <param name="command">Valid command object.</param>
        public void PrepareCommand(IDbCommand command)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(PrepareCommand).");

            if (_connection != null)
                command.Connection = _connection;

            if (_transaction != null)
                command.Transaction = _transaction;
        }

        #endregion

        #region Execute NonQuery

        /// <summary>
        /// Execute a SqlCommand (that returns no resultset) against the database specified 
        /// in the configuration file.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  ExecuteNonQuery("INSERT INTO TableName(fld1, fld2, fld3) VALUES(%s, %n, %d)", valu1, value2, valu3);
        /// </remarks>
        /// <param name="args">Comm delimitted value.</param>
        /// <param name="commandText">T-SQL command.</param>
        public void ExecuteNonQuery(string commandText, params object[] args)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteNonQuery).");

            commandText = SQLParser.MakeSQL(_syntax, commandText, args);
            if (_transaction != null)
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).ExecuteNonQuery(_commandTimeout, _transaction,
                        CommandType.Text, commandText);
                else
                    TransactionFactory.Default.ExecuteNonQuery(_commandTimeout, _transaction, CommandType.Text,
                        commandText);
            }
            else
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).ExecuteNonQuery(_commandTimeout, _connection,
                        CommandType.Text, commandText);
                else
                    TransactionFactory.Default.ExecuteNonQuery(_commandTimeout, _connection, CommandType.Text,
                        commandText);
            }
        }

        /// <summary>
        /// Execute a SqlCommand (that returns no resultset) against the database specified in
        /// the app configuration file.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  ExecuteNonQuery(CommandType.StoredProcedure, "SpName", new SqlParameter("@UserID", 24));.
        ///  ExecuteNonQuery(CommandType.Text, "INSERT INTO TableName(Fld1) VALUES(?)", new SqlParameter("@Date", '1 Jan 2007'));
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        public void ExecuteNonQuery(CommandType commandType, string commandText, IDataParameter[] commandParametes)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteNonQuery).");


            if (_transaction != null)
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).ExecuteNonQuery(_commandTimeout, _transaction,
                        commandType, commandText, commandParametes);
                else
                    TransactionFactory.Default.ExecuteNonQuery(_commandTimeout, _transaction, commandType, commandText,
                        commandParametes);
            }
            else
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).ExecuteNonQuery(_commandTimeout, _connection,
                        commandType, commandText, commandParametes);
                else

                    TransactionFactory.Default.ExecuteNonQuery(_commandTimeout, _connection, commandType, commandText,
                        commandParametes);
            }
        }

        /// <summary>
        /// Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
        /// the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
        /// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        /// </summary>
        /// <remarks>
        /// This method provides no access to output parameters or the stored procedure's return value parameter.
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.).</param>
        /// <param name="spName">The name of the stored prcedure.</param>
        /// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure.</param>
        public void ExecuteNonQuery(CommandType commandType, string spName, params object[] parameterValues)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteNonQuery).");

            if (_transaction != null)
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteNonQuery(_commandTimeout, _transaction, spName, parameterValues);
                else
                    TransactionFactory.Default.ExecuteNonQuery(_commandTimeout, _transaction, spName, parameterValues);
            }
            else
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteNonQuery(_commandTimeout, _connection, spName, parameterValues);
                else
                    TransactionFactory.Default.ExecuteNonQuery(_commandTimeout, _connection, spName, parameterValues);
            }
        }

        #endregion

        #region Generate ID

        /// <summary>
        /// This function return integer value according to the parameter. 
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  IDataReader iReader = GenerateID("Users", "UswerID");.
        /// </remarks>
        /// <param name="tableName">A valid table name which is exit in the database</param>
        /// <param name="fieldName">A valid field name of the table</param>
        /// <returns>Retun 4 bytes integer value</returns>
        public int GenerateID(string tableName, string fieldName)
        {
            return this.GenerateID(tableName, fieldName, string.Empty);
        }

        /// <summary>
        /// This function return integer value according to the parameter.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  IDataReader iReader = GenerateID("Users", "UswerID", "WHERE UswerID>100 AND CreatedDate='1 Jan 2009'");.
        /// </remarks>
        /// <param name="tableName">A valid table name which is exist in the database.</param>
        /// <param name="fieldName">A valid field name of the table.</param>
        /// <param name="sqlClause">Any valid where clause.</param>
        /// <returns>Retun 4 bytes integer value.</returns>
        public int GenerateID(string tableName, string fieldName, string whereClause)
        {
            object maxID = this.ExecuteScalar("SELECT MAX(%q) FROM %q %q", fieldName, tableName, whereClause);

            if (maxID == null || maxID == DBNull.Value)
            {
                maxID = 1;
            }
            else
            {
                maxID = Convert.ToInt32(maxID) + 1;
                if ((int)maxID <= 0)
                    maxID = 1;
            }

            return Convert.ToInt32(maxID);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="objectID"></param>
        /// <param name="itemID"></param>
        /// <param name="forYear"></param>
        /// <param name="forMonth"></param>
        /// <param name="forDate"></param>
        /// <returns></returns>
        private int GetNewID(string objectID, string itemID, short? forYear, int? forMonth, DateTime? forDate)
        {
            SqlParameter[] p = new SqlParameter[6];
            p[0] = new SqlParameter("@ObjectID", SqlDbType.VarChar, 255);
            p[0].Direction = ParameterDirection.Input;
            p[0].Value = objectID;

            p[1] = new SqlParameter("@ItemID", SqlDbType.VarChar, 255);
            p[1].Direction = ParameterDirection.Input;
            p[1].Value = itemID;

            p[2] = new SqlParameter("@IDForYear", SqlDbType.Int);
            p[2].Direction = ParameterDirection.Input;
            p[2].Value = forYear;

            p[3] = new SqlParameter("@IDForMonth", SqlDbType.Int);
            p[3].Direction = ParameterDirection.Input;
            p[3].Value = forMonth;

            p[4] = new SqlParameter("@IDForDate", SqlDbType.DateTime);
            p[4].Direction = ParameterDirection.Input;
            p[4].Value = forDate;

            p[5] = new SqlParameter("@NewID", SqlDbType.Int);
            p[5].Direction = ParameterDirection.Output;
            p[5].Value = 0;

            this.ExecuteNonQuery(CommandType.StoredProcedure, "[dbo].[GetID]", p);

            int newID = 0;
            if (p[5].Value != null && p[5].Value != DBNull.Value)
                newID = Convert.ToInt32(p[5].Value);

            return newID;
        }

        /// <summary>
        /// Generate Sequence no
        /// </summary>
        /// <param name="objectID">Any valid string</param>
        /// <param name="itemID">Any valid string</param>
        /// <param name="forYear">Yearly initialize the serial</param>
        /// <returns>Return new ID</returns>
        public int GetNewID(string objectID, string itemID, short forYear)
        {
            return this.GetNewID(objectID, itemID, forYear, null, null);
        }

        /// <summary>
        /// Generate Sequence no
        /// </summary>
        /// <param name="objectID">Any valid string</param>
        /// <param name="itemID">Any valid string</param>
        /// <param name="forMonth">Monthly initialize the serial</param>
        /// <returns>Return new ID</returns>
        public int GetNewID(string objectID, string itemID, int forMonth)
        {
            return this.GetNewID(objectID, itemID, null, forMonth, null);
        }

        /// <summary>
        /// Generate Sequence no
        /// </summary>
        /// <param name="objectID">Any valid string</param>
        /// <param name="itemID">Any valid string</param>
        /// <param name="forDate">Daily initialize the serial</param>
        /// <returns>Return new ID</returns>
        public int GetNewID(string objectID, string itemID, DateTime forDate)
        {
            return this.GetNewID(objectID, itemID, null, null, forDate);
        }

        /// <summary>
        /// Return newID of integer type, without maintain yearly serial 
        /// </summary>
        /// <param name="objectID">Any valid string</param>
        /// <param name="itemID">Any valid string</param>
        /// <returns>Return the newID</returns>
        public int GetNewID(string objectID, string itemID)
        {
            return this.GetNewID(objectID, itemID, null, null, null);
        }

        #endregion

        #region Execute Reader

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
        /// the app configuration. 
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  IDataReader iReader = ExecuteReader("SELECT * FROM TableName WHERE ID=%n AND Date=%d", id, date);.
        /// </remarks>
        /// <param name="commandText">T-SQL command.</param>
        /// <param name="args">Comma delimited values.</param>
        /// <returns>A IDataReader containing the resultset generated by the command.</returns>
        public IDataReader ExecuteReader(string commandText, params object[] args)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteReader).");

            commandText = SQLParser.MakeSQL(_syntax, commandText, args);
            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteReader(_commandTimeout, _transaction, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteReader(_commandTimeout, _transaction, CommandType.Text,
                        commandText);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteReader(_commandTimeout, _connection, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteReader(_commandTimeout, _connection, CommandType.Text,
                        commandText);
            }
        }

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset) against the database specified in the app configuration 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  IDataReader iReader = ExecuteReader(CommandType.StoredProcedure, "GetUsers", new IDataParameter("@OwnerID", -9));.
        ///  IDataReader iReader = ExecuteReader(CommandType.Text, "SELECT * FROM TableName WHERE Date=?", new SqlParameter("@Date", '1 Jan 2007'));
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.).</param>
        /// <param name="commandText">The stored procedure name or T-SQL command.</param>
        /// <param name="commandParameters">An array of IDataParameter used to execute the command.</param>
        /// <returns>A IDataReader containing the resultset generated by the command.</returns>
        public IDataReader ExecuteReader(CommandType commandType, string commandText,
            params IDataParameter[] commandParameters)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteReader).");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteReader(_commandTimeout,
                        _transaction, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteReader(_commandTimeout, _transaction, commandType,
                        commandText, commandParameters);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteReader(_commandTimeout,
                        _connection, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteReader(_commandTimeout, _connection, commandType,
                        commandText, commandParameters);
            }
        }

        /// <summary>
        /// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
        /// the app configuration using the provided parameter values.  This method will query the database to discover the parameters for the 
        /// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        /// </summary>
        /// <remarks>
        /// This method provides no access to output parameters or the stored procedure's return value parameter.
        /// e.g.:  
        ///  IDataReader iReader = ExecuteReader("GetUsers", -9, 20);
        /// </remarks>
        /// <param name="spName">The name of the stored procedure.</param>
        /// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure.</param>
        /// <returns>A IDataReader containing the resultset generated by the command</returns>
        public IDataReader ExecuteReader(CommandType commandType, string spName, params object[] parameterValues)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteReader).");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteReader(_commandTimeout, _transaction, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteReader(_commandTimeout, _transaction, spName,
                        parameterValues);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteReader(_commandTimeout, _connection, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteReader(_commandTimeout, _connection, spName,
                        parameterValues);
            }
        }

        #endregion

        #region Execute Scalar

        /// <summary>
        /// Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in 
        /// the app configuration. 
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int ttCount = (int)ExecuteScalar("SELECT COUNT(*) FROM TableName");.
        /// </remarks>
        /// <param name="commandText">T-SQL command.</param>
        /// <param name="args">Comma delimited values.</param>
        /// <returns>An object containing the value in the 1x1 resultset generated by the command.</returns>
        public object ExecuteScalar(string commandText, params object[] args)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteScalar).");

            commandText = SQLParser.MakeSQL(_syntax, commandText, args);
            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteScalar(_commandTimeout, _transaction, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteScalar(_commandTimeout, _transaction, CommandType.Text,
                        commandText);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteScalar(_commandTimeout, _connection, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteScalar(_commandTimeout, _connection, CommandType.Text,
                        commandText);
            }
        }

        /// <summary>
        /// Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in the app configuration
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int ttCount = (int)ExecuteScalar(CommandType.StoredProcedure, "GetNoOfTT", new SqlParameter("@Date", '1 Jan 2007'));
        ///  int ttCount = (int)ExecuteScalar(CommandType.Text, "SELECT COUNT(*) FROM TableName WHERE Date=?", new SqlParameter("@Date", '1 Jan 2007'));
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">An array of IDataParameter used to execute the command</param>
        /// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        public object ExecuteScalar(CommandType commandType, string commandText,
            params IDataParameter[] commandParameters)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteScalar).");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteScalar(_commandTimeout,
                        _transaction, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteScalar(_commandTimeout, _transaction, commandType,
                        commandText, commandParameters);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteScalar(_commandTimeout,
                        _connection, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteScalar(_commandTimeout, _connection, commandType,
                        commandText, commandParameters);
            }
        }

        /// <summary>
        /// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
        /// the app configuration using the provided parameter values.  This method will query the database to discover the parameters for the 
        /// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        /// </summary>
        /// <remarks>
        /// This method provides no access to output parameters or the stored procedure's return value parameter.
        /// /// e.g.:  
        ///  int ttCount = (int)ExecuteScalar("GetNoOfTT", 24, 36);
        /// </remarks>
        /// <param name="spName">The name of the stored procedure</param>
        /// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        /// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        public object ExecuteScalar(CommandType commandType, string spName, params object[] parameterValues)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(ExecuteScalar).");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteScalar(_commandTimeout, _transaction, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteScalar(_commandTimeout, _transaction, spName,
                        parameterValues);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteScalar(_commandTimeout, _connection, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteScalar(_commandTimeout, _connection, spName,
                        parameterValues);
            }
        }

        #endregion


        #region Execute DataTable

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
        /// the app configuration. 
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset("SELECT * FROM TableName WHERE ID=%n AND Date=%d",1, '1 Jan 2007');
        /// </remarks>
        /// <param name="commandText">T-SQL command</param>
        /// <returns>A dataset containing the resultset generated by the command</returns>
        public DataTable ExecuteDataTable(string commandText, params object[] args)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("Connection is already closed");

            commandText = SQLParser.MakeSQL(_syntax, commandText, args);
            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataTable(_commandTimeout, _transaction, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteDataTable(_commandTimeout, _transaction, CommandType.Text,
                        commandText);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataTable(_commandTimeout, _connection, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteDataTable(_commandTimeout, _connection, CommandType.Text,
                        commandText);
            }
        }

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset) against the database specified in the app configuration
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset(CommandType.StoredProcedure, "GetUsers", new SqlParameter("@OwnerID", -9));
        ///  DataSet ds = ExecuteDataset(CommandType.Text, "SELECT * FROM Users WHERE OwnerID = ?", new SqlParameter("@OwnerID", -9));
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        /// <returns>A dataset containing the resultset generated by the command</returns>
        public DataTable ExecuteDataTable(CommandType commandType, string commandText,
            params IDataParameter[] commandParameters)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("Connection is already closed");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteDataTable(_commandTimeout,
                        _transaction, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteDataTable(_commandTimeout, _transaction, commandType,
                        commandText, commandParameters);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteDataTable(_commandTimeout,
                        _connection, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteDataTable(_commandTimeout, _connection, commandType,
                        commandText, commandParameters);
            }
        }

        /// <summary>
        /// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
        /// the app configuration using the provided parameter values.  This method will query the database to discover the parameters for the 
        /// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        /// </summary>
        /// <remarks>
        /// This method provides no access to output parameters or the stored procedure's return value parameter.
        /// 
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset("GetUsers", -9);
        /// </remarks>
        /// <param name="spName">The name of the stored procedure</param>
        /// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        /// <returns>A dataset containing the resultset generated by the command</returns>
        public DataTable ExecuteDataTable(CommandType commandType, string spName, params object[] parameterValues)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("Connection is already closed");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataTable(_commandTimeout, _transaction, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteDataTable(_commandTimeout, _transaction, spName,
                        parameterValues);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataTable(_commandTimeout, _connection, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteDataTable(_commandTimeout, _connection, spName,
                        parameterValues);
            }
        }

        #endregion

        #region Execute Dataset

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
        /// the app configuration. 
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset("SELECT * FROM TableName WHERE ID=%n AND Date=%d",1, '1 Jan 2007');
        /// </remarks>
        /// <param name="commandText">T-SQL command</param>
        /// <returns>A dataset containing the resultset generated by the command</returns>
        public DataSet ExecuteDataSet(string commandText, params object[] args)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("Connection is already closed");

            commandText = SQLParser.MakeSQL(_syntax, commandText, args);
            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataset(_commandTimeout, _transaction, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteDataset(_commandTimeout, _transaction, CommandType.Text,
                        commandText);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataset(_commandTimeout, _connection, CommandType.Text, commandText);
                else
                    return TransactionFactory.Default.ExecuteDataset(_commandTimeout, _connection, CommandType.Text,
                        commandText);
            }
        }

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset) against the database specified in the app configuration
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset(CommandType.StoredProcedure, "GetUsers", new SqlParameter("@OwnerID", -9));
        ///  DataSet ds = ExecuteDataset(CommandType.Text, "SELECT * FROM Users WHERE OwnerID = ?", new SqlParameter("@OwnerID", -9));
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        /// <returns>A dataset containing the resultset generated by the command</returns>
        public DataSet ExecuteDataSet(CommandType commandType, string commandText,
            params IDataParameter[] commandParameters)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("Connection is already closed");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteDataset(_commandTimeout,
                        _transaction, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteDataset(_commandTimeout, _transaction, commandType,
                        commandText, commandParameters);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex).ExecuteDataset(_commandTimeout,
                        _connection, commandType, commandText, commandParameters);
                else
                    return TransactionFactory.Default.ExecuteDataset(_commandTimeout, _connection, commandType,
                        commandText, commandParameters);
            }
        }

        /// <summary>
        /// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
        /// the app configuration using the provided parameter values.  This method will query the database to discover the parameters for the 
        /// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        /// </summary>
        /// <remarks>
        /// This method provides no access to output parameters or the stored procedure's return value parameter.
        /// 
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset("GetUsers", -9);
        /// </remarks>
        /// <param name="spName">The name of the stored procedure</param>
        /// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        /// <returns>A dataset containing the resultset generated by the command</returns>
        public DataSet ExecuteDataSet(CommandType commandType, string spName, params object[] parameterValues)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("Connection is already closed");

            if (_transaction != null)
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataset(_commandTimeout, _transaction, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteDataset(_commandTimeout, _transaction, spName,
                        parameterValues);
            }
            else
            {
                if (_contex != null)
                    return TransactionFactory.ContextTransactionHelper(_contex)
                        .ExecuteDataset(_commandTimeout, _connection, spName, parameterValues);
                else
                    return TransactionFactory.Default.ExecuteDataset(_commandTimeout, _connection, spName,
                        parameterValues);
            }
        }

        #endregion

        #region Fill Dataset

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
        /// the connection string. 
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  FillDataset(ds, new string[] {"orders"}, "SELECT * FROM Users WHERE OwnerID=%n AND CreateDate=%d", -9, '1 Jan 2007');
        /// </remarks>
        /// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
        /// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
        /// by a user defined name (probably the actual table name)</param>
        /// <param name="commandText">T-SQL command</param>
        /// <param name="args">Comma delimited values</param>
        public void FillDataset(DataSet dataSet, string[] tableNames, string commandText, params object[] args)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(FillDataset).");

            commandText = SQLParser.MakeSQL(_syntax, commandText, args);
            if (_transaction != null)
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).FillDataset(_commandTimeout, _transaction,
                        CommandType.Text, commandText, dataSet, tableNames);
                else
                    TransactionFactory.Default.FillDataset(_commandTimeout, _transaction, CommandType.Text, commandText,
                        dataSet, tableNames);
            }
            else
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).FillDataset(_commandTimeout, _connection,
                        CommandType.Text, commandText, dataSet, tableNames);
                else
                    TransactionFactory.Default.FillDataset(_commandTimeout, _connection, CommandType.Text, commandText,
                        dataSet, tableNames);
            }
        }

        /// <summary>
        /// Execute a SqlCommand (that returns a resultset) against the database specified in the app configuration 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  FillDataset(CommandType.StoredProcedure, "GetUsers", ds, new string[] {"Users"}, new SqlParameter("@OwnerID", -9));
        ///  FillDataset(CommandType.Tex, "SELECT * FROM Users WHERE OwnerID = ?", ds, new string[] {"Users"}, new SqlParameter("@OwnerID", -9));
        /// </remarks>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name or T-SQL command</param>
        /// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
        /// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
        /// by a user defined name (probably the actual table name)
        /// </param>
        /// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        public void FillDataset(CommandType commandType, string commandText, DataSet dataSet, string[] tableNames,
            params IDataParameter[] commandParameters)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(FillDataset).");

            if (_transaction != null)
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).FillDataset(_commandTimeout, _transaction,
                        commandType, commandText, dataSet, tableNames, commandParameters);
                else
                    TransactionFactory.Default.FillDataset(_commandTimeout, _transaction, commandType, commandText,
                        dataSet, tableNames, commandParameters);
            }
            else
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).FillDataset(_commandTimeout, _connection,
                        commandType, commandText, dataSet, tableNames, commandParameters);
                else
                    TransactionFactory.Default.FillDataset(_commandTimeout, _connection, commandType, commandText,
                        dataSet, tableNames, commandParameters);
            }
        }

        /// <summary>
        /// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
        /// the app configuration using the provided parameter values.  This method will query the database to discover the parameters for the 
        /// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        /// </summary>
        /// <remarks>
        /// This method provides no access to output parameters or the stored procedure's return value parameter.
        /// 
        /// e.g.:  
        ///  FillDataset(CommandType.StoredProcedure, "GetUsers", ds, new string[] {"Users"}, 24);
        /// </remarks>
        /// <param name="commandType">The CommandType stored procedure</param>
        /// <param name="spName">The name of the stored procedure</param>
        /// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
        /// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
        /// by a user defined name (probably the actual table name)
        /// </param>    
        /// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        public void FillDataset(string spName, DataSet dataSet, string[] tableNames, params object[] parameterValues)
        {
            if (_connection == null && _transaction == null)
                throw new Exception("There is no connection to prepare command(FillDataset).");

            if (_transaction != null)
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).FillDataset(_commandTimeout, _transaction,
                        spName, dataSet, tableNames, parameterValues);
                else
                    TransactionFactory.Default.FillDataset(_commandTimeout, _transaction, spName, dataSet, tableNames,
                        parameterValues);
            }
            else
            {
                if (_contex != null)
                    TransactionFactory.ContextTransactionHelper(_contex).FillDataset(_commandTimeout, _connection,
                        spName, dataSet, tableNames, parameterValues);
                else
                    TransactionFactory.Default.FillDataset(_commandTimeout, _connection, spName, dataSet, tableNames,
                        parameterValues);
            }
        }

        #endregion

        #region Error Handler

        /// <summary>
        /// This function handles all type of error related to SQL command
        /// </summary>
        public void HandleError()
        {
            if (_transaction != null)
            {
                try
                {
                    _transaction.Rollback();
                }
                catch
                {
                }
            }

            releaseResources();
        }

        #endregion

        #region Dispose

        /// <summary>
        /// Release all resources
        /// </summary>
        public void Dispose()
        {
            releaseResources();
        }

        #endregion
    }

    #endregion
}