using System;
using System.Data;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using JetBrains.Annotations;
using SDA.DataProvider.Core;

namespace SDA.DataProvider
{
    /// <summary>
    /// Adatbázis-kapcsolat
    /// </summary>
    public class SDAConnection : IDisposable /*, IDbConnection */
    {
        [NotNull]
        internal SDAConnectionWrapper Connection;

        /// <summary>
        /// Előállít egy új adatbázis-kapcsolat példányt.
        /// </summary>
        public SDAConnection()
        {
            if (SDAFactory.Instance == null)
            {
                throw new InvalidOperationException("SDAFactory.Instance");
            }
            Connection = SDAFactory.Instance.CreateConnection();
        }

        /// <summary>
        /// Előállít egy új adatbázis-kapcsolat példányt.
        /// </summary>
        /// <param name="connectionString">Az adatbázis-kapcsolat paramétereit leíró karakterlánc</param>
        public SDAConnection([CanBeNull] string connectionString)
        {
            if (SDAFactory.Instance == null)
            {
                throw new InvalidOperationException("SDAFactory.Instance");
            }
            Connection = SDAFactory.Instance.CreateConnection();
            Connection.ConnectionString = connectionString;
        }

        /// <summary>
        /// Előállít egy új adatbázis-kapcsolat példányt.
        /// </summary>
        /// <param name="databaseType">Az adatbázis típusa.</param>
        /// <param name="connectionString">Az adatbázis-kapcsolat paramétereit leíró karakterlánc.</param>
        public SDAConnection(DatabaseType databaseType, [CanBeNull] string connectionString) : this(databaseType, connectionString, null)
        {
        }

        /// <summary>
        /// Előállít egy új adatbázis-kapcsolat példányt.
        /// </summary>
        /// <param name="databaseType">Az adatbázis típusa.</param>
        /// <param name="connectionString">Az adatbázis-kapcsolat paramétereit leíró karakterlánc.</param>
        /// <param name="commandTimeout">Command timeout-ja.</param>
        public SDAConnection(DatabaseType databaseType, [CanBeNull] string connectionString, int? commandTimeout)
        {
            var factory = SDAFactory.GetByDatabaseType(databaseType, commandTimeout);
            Debug.Assert(factory != null, "factory != null");
            Connection = factory.CreateConnection();
            Debug.Assert(Connection != null, "Connection != null");
            Connection.ConnectionString = connectionString;
        }

        /// <summary>
        /// Megnyitja az adatbázis-kapcsolatot.
        /// </summary>
        public void Open()
        {
            OpenWithRetry(0);
        }

        /// <summary>
        /// Lezárja az adatbáziskapcsolatot.
        /// </summary>
        public void Close()
        {
            Connection.Close();
        }

        /// <summary>
        /// Létrehoz egy - az adatbázis-kapcsolathoz tartozó - adatbázis-parancs objektumot
        /// </summary>
        /// <returns>Egy adatbázis-parancs objektum</returns>
        [NotNull]
        public SDACommand CreateCommand()
        {
            return new SDACommand(Connection.CreateCommand());
        }

        /// <summary>
        /// Létrehoz egy - az adatbázis-kapcsolathoz tartozó - adatbázis-parancs objektumot
        /// </summary>
        /// <param name="commandText">A parancs objektum szövege</param>
        /// <returns>Egy adatbázis-parancs objektum</returns>
        [NotNull]
        [SuppressMessage("ReSharper", "UseObjectOrCollectionInitializer")]
        public SDACommand CreateCommand([CanBeNull] string commandText)
        {
            SDACommandWrapper command = null;
            SDACommand result = null;
            try
            {
                command = Connection.CreateCommand();
                result = new SDACommand(command);
                result.CommandText = commandText;
                return result;
            }
            catch
            {
                command?.Dispose();
                result?.Dispose();
                throw;
            }
        }

        /// <summary>
        /// Adatbázis ügyletet kezdeményez.
        /// </summary>
        /// <returns>Egy adatbázis-ügylet objektum</returns>
        [NotNull]
        public SDATransaction BeginTransaction()
        {
            return new SDATransaction(Connection.BeginTransaction());
        }

        /// <summary>
        /// Adatbázis ügyletet kezdeményez.
        /// </summary>
        /// <param name="isolationLevel">Elválasztás szintje</param>
        /// <returns>Egy adatbázis-ügylet objektum</returns>
        [NotNull]
        public SDATransaction BeginTransaction(IsolationLevel isolationLevel)
        {
            return new SDATransaction(Connection.BeginTransaction(isolationLevel));
        }

        /// <summary>
        /// Létrehoz egy <see cref="SDABulkAdapter"/>-t nagyon gyors
        /// adatbeszúrásokhoz.
        /// </summary>
        /// <param name="transaction">
        /// Opcionális <see cref="SDATransaction"/> objektum, ha nincs megadva,
        /// akkor a bulk művelet _nem_ fut tranzakcióban, azaz ha megáll egy
        /// hiba miatt, akkor a már beszúrt sorok nem görgetődnek vissza!
        /// Viszont ha a kapcsolaton már van aktív tranzakció, akkor azt
        /// kötelező megadni a bulk insertnek is.
        /// </param>
        /// <returns>
        /// Egy új <see cref="SDABulkAdapter"/>.
        /// </returns>
        [NotNull]
        public SDABulkAdapter CreateBulkAdapter(SDATransaction transaction = null)
        {
            return Connection.CreateBulkAdapter(transaction);
        }

        /// <summary>
        /// Üresre törli az adatbázis-szerver connection pool-ját.
        /// </summary>
        /// <param name="all">
        /// True érték esetén az összes pool-t alaphelyzetbe hozza,
        /// False érték esetén csak az adott kapcsolathoz tartozót.
        /// </param>
        public void ResetConnectionPool(bool all = false)
        {
            Connection.ResetConnectionPool(all);
        }

        /// <summary>
        /// Az adatbázis-kapcsolat paramétereit leíró karakterlánc.
        /// </summary>
        [CanBeNull]
        public string ConnectionString
        {
            get
            {
                return Connection.ConnectionString;
            }
            set
            {
                Connection.ConnectionString = value;
            }
        }

        /// <summary>
        /// Az adatbázis-kapcsolat állapota.
        /// </summary>
        public ConnectionState State => Connection.State;

        bool _disposed;

        /// <summary>
        /// Explicit destruktor.
        /// </summary>
        /// <param name="disposing">Programozott felszabadítás?</param>
        protected virtual void Dispose(bool disposing)
        {
            if (_disposed)
            {
                return;
            }
            if (disposing)
            {
                Connection.Dispose();
                SDAConnectionDiagnostics.DecrementActiveConnections();
            }
            _disposed = true;
        }

        /// <summary>
        /// Eldobja az objektumot.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        //#region IDbConnection Members

        //public void ChangeDatabase(string databaseName)
        //{
        //}

        //IDbTransaction IDbConnection.BeginTransaction(System.Data.IsolationLevel il)
        //{
        //    return BeginTransaction(il);
        //}

        //IDbTransaction IDbConnection.BeginTransaction()
        //{
        //    return BeginTransaction();
        //}

        //IDbCommand IDbConnection.CreateCommand()
        //{
        //    throw new NotImplementedException();
        //    return CreateCommand();
        //}

        //public string Database
        //{
        //    get { return m_Connection.Database; }
        //}

        //public int ConnectionTimeout
        //{
        //    get { return m_Connection.ConnectionTimeout; }
        //}

        //#endregion

        #region Újrapróbálkozás

        void OpenWithRetry(int tries)
        {
            try
            {
                Connection.Open();
                SDAConnectionDiagnostics.IncrementActiveConnections();
            }
            catch (SDADataProviderException exception)
            {
                if ((exception.MustRetry) && (tries < Configuration.MaxTries))
                {
                    OpenWithRetry(tries + 1);
                }
                else
                {
                    throw;
                }
            }
        }

        #endregion
    }
}