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

import java.sql.*;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.db.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.sequences.*;
import org.litesoft.sql.statements.*;

public class SQLSequenceBlockSource implements SequenceBlockSource
{
    private SQLPersistenceHelper mPersistenceHelper;
    private SimpleFromIdentifier mFromIdentifier;
    private SimpleColumnDefinition mCD_Group;
    private SimpleColumnDefinition mCD_NextValue;

    public SQLSequenceBlockSource( SQLPersistenceHelper pPersistenceHelper, //
                                   SimpleFromIdentifier pFromIdentifier, //
                                   SimpleColumnDefinition pCD_Group, //
                                   SimpleColumnDefinition pCD_NextValue )
    {
        Objects.assertNotNull( "PersistenceHelper", mPersistenceHelper = pPersistenceHelper );
        Objects.assertNotNull( "FromIdentifier", mFromIdentifier = pFromIdentifier );
        Objects.assertNotNull( "CD_Group", mCD_Group = pCD_Group );
        Objects.assertNotNull( "CD_NextValue", mCD_NextValue = pCD_NextValue );
    }

    @Override
    public void clearAllGroups()
    {
        deleteRows( null );
    }

    @Override
    public void clear( String pGroup )
    {
        deleteRows( WhereClauseFactory.INSTANCE.isEqual( mCD_Group, pGroup ) );
    }

    private void deleteRows( WhereClause pWhereClause )
    {
        long rows;
        try
        {
            rows = mPersistenceHelper.rawCount( mFromIdentifier, pWhereClause );
        }
        catch ( WrappedSQLException e )
        {
            return; // Error == Assume No Table!
        }
        if ( rows > 0 )
        {
            mPersistenceHelper.deleteRows( mFromIdentifier, pWhereClause );
        }
    }

    @Override
    public SequenceBlock getNextBlock( String pGroup, long pMinToOffer, long pBlockSize, Long pRestartAt )
    {
        GroupHelper helper = new GroupHelper( pGroup, //
                                              pMinToOffer, //
                                              (pBlockSize < 1) ? 1 : pBlockSize, //
                                              (pRestartAt != null) ? pRestartAt : Long.MAX_VALUE );
        try
        {
            return helper.process();
        }
        finally
        {
            helper.dispose();
        }
    }

    private class GroupHelper implements Disposable
    {
        private String mGroup;
        private long mMinToOffer;
        private long mBlockSize;
        private long mRestartAt;
        private WhereClause mGroupWC;
        private String mQueryCmd;
        private DBException mProblem = null;

        public GroupHelper( String pGroup, long pMinToOffer, long pBlockSize, long pRestartAt )
                throws DBException
        {
            mGroup = pGroup;
            mMinToOffer = pMinToOffer;
            mBlockSize = pBlockSize;
            mRestartAt = (pRestartAt >= (100 * mBlockSize)) ? pRestartAt : (100 * mBlockSize);
            mGroupWC = WhereClauseFactory.INSTANCE.isEqual( mCD_Group, pGroup );
            mQueryCmd = "SELECT " + mCD_NextValue.getColumnName() + //
                        " FROM " + mFromIdentifier.getTableName() + " " + mGroupWC.toSQL();
        }

        @Override
        public void dispose()
        {
        }

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

        public SequenceBlock process()
        {
            SequenceBlock block;
            if ( null == (block = sqlInsertOrUpdate()) )
            {
                if ( null == (block = sqlInsertOrUpdate()) )
                {
                    if ( null == (block = sqlInsertOrUpdate()) )
                    {
                        for ( int i = 0; i < 50; i++ )
                        {
                            try
                            {
                                Thread.sleep( 100 );
                            }
                            catch ( InterruptedException e )
                            {
                                // Whatever...
                            }
                            if ( null != (block = sqlInsertOrUpdate()) )
                            {
                                return block;
                            }
                        }
                        throw mProblem;
                    }
                }
            }
            return block;
        }

        private SequenceBlock sqlInsertOrUpdate()
        {
            Long curNext = getCurNext();
            try
            {
                return (curNext == null) ? insert( mMinToOffer ) : update( curNext );
            }
            catch ( DBException e )
            {
                mProblem = e;
            }
            return null;
        }

        private Long getCurNext()
        {
            JDBCexecuteQuery zQuery = new JDBCexecuteQuery( mPersistenceHelper, mQueryCmd, this );
            try
            {
                zQuery.executeQuery();
                if ( !zQuery.hasNext() )
                {
                    return null;
                }
                Long curNext = zQuery.next().getLong( 1 );

                if ( zQuery.hasNext() )
                {
                    throw new SQLException( "Multiple Records" );
                }
                return curNext;
            }
            catch ( SQLException e )
            {
                throw zQuery.error( e );
            }
            finally
            {
                zQuery.dispose();
            }
        }

        private SequenceBlock insert( long pCurNext )
                throws DBException
        {
            SequenceBlock zSequenceBlock = createSequenceBlock( pCurNext );
            long newNext = zSequenceBlock.getCurBlockEndExclusive();
            return sqlUpdater( zSequenceBlock, "INSERT INTO " + mFromIdentifier.getTableName() + " (" + mCD_Group.getColumnName() + "," + mCD_NextValue.getColumnName() + ") VALUES (" + WhereClauseColumnSupport.makeSqlValue( mCD_Group, false, mGroup ) + "," + newNext + ")" );
        }

        private SequenceBlock update( long pCurNext )
                throws DBException
        {
            WhereClauseFactory f = WhereClauseFactory.INSTANCE;
            WhereClause wc = f.and( mGroupWC, f.isEqual( mCD_NextValue, pCurNext ) );

            SequenceBlock zSequenceBlock = createSequenceBlock( pCurNext );
            long newNext = zSequenceBlock.getCurBlockEndExclusive();
            return sqlUpdater( zSequenceBlock, "UPDATE " + mFromIdentifier.getTableName() + " SET " + mCD_NextValue.getColumnName() + "=" + newNext + " " + wc.toSQL() );
        }

        private SequenceBlock sqlUpdater( SequenceBlock pRetvalOnSuccess, String pCmd )
        {
            JDBCexecuteUpdate updater = new JDBCexecuteUpdate( mPersistenceHelper, pCmd, this );
            int i = updater.executeUpdate( true );
            try
            {
                if ( i != 1 )
                {
                    throw updater.error( new SQLException( "No Rows Effected" ) );
                }
                return pRetvalOnSuccess;
            }
            finally
            {
                updater.dispose();
            }
        }

        private SequenceBlock createSequenceBlock( long pCurNext )
        {
            if ( pCurNext >= mRestartAt )
            {
                pCurNext = (mRestartAt == Long.MAX_VALUE) ? Long.MIN_VALUE : 1;
            }
            long newNext = pCurNext < (mRestartAt - mBlockSize) ? pCurNext + mBlockSize : mRestartAt;
            return new SequenceBlockImpl( pCurNext, newNext );
        }

        @Override
        public String toString()
        {
            return getClass().getSimpleName() + "(" + mGroup + ")";
        }
    }
}