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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.db.*;
import org.litesoft.logger.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.sql.*;

import java.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 = Confirm.significant( "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 );
        Confirm.isNotNull( "DBconnection", mDBconnection );
    }

    protected JDBCexecutor( SQLPersistenceHelper pPersistenceHelper, String pCmd, Object pLoggingContext ) {
        this( pCmd, STATE.READY_CREATE, pLoggingContext, pPersistenceHelper, null );
        Confirm.isNotNull( "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();
    }
}