// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.sql.statements;

import java.sql.*;

import org.litesoft.core.typeutils.*;
import org.litesoft.db.*;
import org.litesoft.logger.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.sql.*;

public abstract class JDBCexecutor // implements Disposable
{
    protected enum STATE
    {
        READY_PROVIDED, READY_CREATE, DISPOSED
    }

    private static final Logger LOGGER = LoggerFactory.getLogger( JDBCexecutor.class );

    private SQLPersistenceHelper mPersistenceHelper;
    private DBconnection mDBconnection = null;
    private Statement mStatement = null;
    protected String mCmd;
    protected STATE mState;
    protected Object mLoggingContext;

    public void assumeOwnershipOf( DBconnection pDBconnection )
    {
        if ( !STATE.READY_CREATE.equals( mState ) || (mDBconnection != null) )
        {
            // Note: this is an Error so that we do NOT need to do resource clean-up
            throw new Error( "Assume Ownership of a DBconnection not currently allowed" );
        }
        mDBconnection = pDBconnection;
    }

    private DBconnection getDBconnection()
    {
        validate();
        if ( mDBconnection == null )
        {
            if ( !STATE.READY_CREATE.equals( mState ) )
            {
                throw new Error( "Unable to create DBconnection" );
            }
            try
            {
                mDBconnection = mPersistenceHelper.createConnection();
            }
            catch ( DBException e )
            {
                logException( mCmd, e );
                throw e;
            }
        }
        return mDBconnection;
    }

    protected void closeCreatedConnection()
    {
        validate();
        if ( STATE.READY_CREATE.equals( mState ) && (mDBconnection != null) )
        {
            mDBconnection.dispose();
            mDBconnection = null;
        }
    }

    protected void closeStatement()
    {
        validate();
        try
        {
            if ( mStatement != null )
            {
                mStatement.close();
            }
        }
        catch ( SQLException eatit )
        {
            // Whatever...
            logException( mCmd, eatit );
        }
        finally
        {
            mStatement = null;
        }
    }

    protected void releaseResources()
    {
        validate();
        closeStatement();
        closeCreatedConnection();
    }

    public void dispose()
    {
        if ( !isDisposed() )
        {
            releaseResources();
        }
        mDBconnection = null;
        mState = STATE.DISPOSED;
    }

    public boolean isDisposed()
    {
        return !STATE.READY_CREATE.equals( mState ) && !STATE.READY_PROVIDED.equals( mState );
    }

    protected void validate()
    {
        if ( isDisposed() )
        {
            throw new IllegalStateException( "Attempt to use a disposed JDBCexecutor" );
        }
    }

    public WrappedSQLException error( SQLException pError )
    {
        return mPersistenceHelper.getHelper().wrapSQLException( pError );
    }

    private JDBCexecutor( String pCmd, STATE pState, Object pLoggingContext, //
                          SQLPersistenceHelper pPersistenceHelper, DBconnection pDBconnection )
    {
        mCmd = Strings.assertNotNullNotEmpty( "Cmd", pCmd );
        mState = pState;
        mLoggingContext = pLoggingContext;
        mPersistenceHelper = pPersistenceHelper;
        mDBconnection = pDBconnection;
    }

    protected JDBCexecutor( SQLPersistenceHelper pPersistenceHelper, DBconnection pDBconnection, String pCmd, Object pLoggingContext )
    {
        this( pCmd, STATE.READY_PROVIDED, pLoggingContext, pPersistenceHelper, pDBconnection );
        Objects.assertNotNull( "DBconnection", mDBconnection );
    }

    protected JDBCexecutor( SQLPersistenceHelper pPersistenceHelper, String pCmd, Object pLoggingContext )
    {
        this( pCmd, STATE.READY_CREATE, pLoggingContext, pPersistenceHelper, null );
        Objects.assertNotNull( "PersistenceHelper", mPersistenceHelper );
    }

    /**
     * Logs the pCmd String at "TRACE" or "DEBUG" level.
     *
     * @param pCmd
     */
    @SuppressWarnings({"ThrowableInstanceNeverThrown"})
    protected void logCommand( String pCmd )
    {
        AbstractLogger zLogger = LOGGER.trace();
        if ( zLogger.isEnabled() )
        {
            zLogger.log( new Exception(), pCmd, mLoggingContext );
        }
        else
        {
            LOGGER.debug().log( pCmd, mLoggingContext );
        }
    }

    /**
     * Logs the pCmd and pThrowable at "ERROR" level.
     *
     * @param pCmd
     * @param pThrowable
     */
    protected void logException( String pCmd, Throwable pThrowable )
    {
        LOGGER.error.log( pThrowable, pCmd, mLoggingContext );
    }

    protected Connection getConnection()
    {
        validate();
        return ((SQLDBconnection) getDBconnection()).getConnection();
    }

    protected Statement getStatement()
    {
        validate();
        if ( mStatement == null )
        {
            try
            {
                mStatement = getConnection().createStatement();
            }
            catch ( SQLException e )
            {
                throw new WrappedSQLException( e );
            }
        }
        return mStatement;
    }

    protected void commit( boolean pCommit )
    {
        validate();
        if ( STATE.READY_CREATE.equals( mState ) || pCommit )
        {
            mDBconnection.commit();
        }
    }

    @Override
    protected void finalize()
            throws Throwable
    {
        dispose();
        super.finalize();
    }
}