using FreeSql;
using SafeObjectPool;
using System;
using System.Data;
using System.Data.Common;
using System.Threading;

class BaseEntityUnitOfWork : IUnitOfWork
{
    internal readonly static AsyncLocal<IUnitOfWork> _asyncUow = new AsyncLocal<IUnitOfWork>();

    protected IFreeSql _fsql;
    protected Object<DbConnection> _conn;
    protected DbTransaction _tran;

    public BaseEntityUnitOfWork(IFreeSql fsql)
    {
        _fsql = fsql;
        _asyncUow.Value = this;
    }

    void ReturnObject()
    {
        _fsql.Ado.MasterPool.Return(_conn);
        _tran = null;
        _conn = null;
        _asyncUow.Value = null;
    }


    /// <summary>
    /// 是否启用工作单元
    /// </summary>
    public bool Enable { get; private set; } = true;

    /// <summary>
    /// 禁用工作单元
    /// <exception cref="Exception"></exception>
    /// <para></para>
    /// 若已开启事务（已有Insert/Update/Delete操作），调用此方法将发生异常，建议在执行逻辑前调用
    /// </summary>
    public void Close()
    {
        if (_tran != null)
            throw new Exception("已开启事务，不能禁用工作单元");

        Enable = false;
    }

    public void Open() =>
        Enable = true;

    public IsolationLevel? IsolationLevel { get; set; }

    public DbTransaction GetOrBeginTransaction(bool isCreate = true)
    {

        if (_tran != null) return _tran;
        if (isCreate == false) return null;
        if (!Enable) return null;
        if (_conn != null) _fsql.Ado.MasterPool.Return(_conn);

        _conn = _fsql.Ado.MasterPool.Get();
        try
        {
            _tran = IsolationLevel == null ?
                _conn.Value.BeginTransaction() :
                _conn.Value.BeginTransaction(IsolationLevel.Value);
        }
        catch
        {
            ReturnObject();
            throw;
        }
        return _tran;
    }

    public void Commit()
    {
        if (_tran != null)
        {
            try
            {
                _tran.Commit();
            }
            finally
            {
                ReturnObject();
            }
        }
    }
    public void Rollback()
    {
        if (_tran != null)
        {
            try
            {
                _tran.Rollback();
            }
            finally
            {
                ReturnObject();
            }
        }
    }
    ~BaseEntityUnitOfWork()
    {
        this.Dispose();
    }
    bool _isdisposed = false;
    public void Dispose()
    {
        if (_isdisposed) return;
        _isdisposed = true;
        try
        {
            this.Rollback();
        }
        finally
        {
            GC.SuppressFinalize(this);
        }
    }
}