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

import java.sql.*;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.logger.*;
import org.litesoft.orsup.transact.*;

public class TransCommitCollector
{
    public static final Logger LOGGER = LoggerFactory.getLogger( TransCommitCollector.class );

    private Timestamp mTransactionTimeStamp = Timestamps.now();
    private Set<TransCommitEntry> mEntries = new HashSet<TransCommitEntry>();
    private CA_LinkListNode mCommitAugmentors;

    public TransCommitCollector( CA_LinkListNode pCommitAugmentors )
    {
        mCommitAugmentors = pCommitAugmentors;
    }

    public void augment( HistoryAugmentor pHistoryAugmentor )
    {
        for ( TransCommitEntry entry : mEntries )
        {
            entry.augment( pHistoryAugmentor, mTransactionTimeStamp );
        }
    }

    public void add( List<PersistentObjectImpl<?>> pParticipants )
    {
        for ( PersistentObjectImpl participant : pParticipants )
        {
            TransCommitEntry entry = new TransCommitEntry( participant );
            entry.checkShouldProcess_AboutToCommit( mCommitAugmentors, mTransactionTimeStamp );
            if ( !mEntries.add( entry ) )
            {
                LOGGER.error.log( "Duplicate (", participant, ") Entry on add(...)?" );
            }
        }
        for ( int i = 9; i >= 0; i-- )
        {
            boolean changes = false;
            for ( TransCommitEntry entry : mEntries )
            {
                if ( entry.checkShouldProcess_AboutToCommit( mCommitAugmentors, mTransactionTimeStamp ) )
                {
                    changes = true;
                }
            }
            if ( !changes )
            {
                return;
            }
        }
        throw new IllegalStateException( "Pre-Commit Changes did not stabilize" );
    }

    public void justAdd( List<PersistentObjectImpl<?>> pParticipants )
    {
        for ( PersistentObjectImpl participant : pParticipants )
        {
            TransCommitEntry entry = new TransCommitEntry( participant );
            entry.updateChangeNumber();
            if ( !mEntries.add( entry ) )
            {
                LOGGER.error.log( "Duplicate (", participant, ") Entry on add(...)?" );
            }
        }
    }

    public void validateNoChanges( String pWhoToBlame )
    {
        StringBuilder sb = null;
        for ( TransCommitEntry entry : mEntries )
        {
            if ( entry.hasChanged() )
            {
                if ( sb == null )
                {
                    sb = new StringBuilder( pWhoToBlame ).append( " caused changes in the following PO(s):" );
                }
                sb.append( "\n    " ).append( entry.getParticipant() );
            }
        }
        if ( sb != null )
        {
            throw new IllegalStateException( sb.toString() );
        }
    }

    public Set<PersistentObjectImpl> getEntriesToCommit( DataStoreChangeCollector pCollector )
    {
        Set<PersistentObjectImpl> commiting = new HashSet<PersistentObjectImpl>( mEntries.size() );

        for ( TransCommitEntry entry : mEntries )
        {
            PersistentObjectImpl participant = entry.getParticipant();
            if ( participant.isDirty() )
            {
                pCollector.add( participant, entry.getExtraPOinfo() );

                participant.setCommitTimestamps( mTransactionTimeStamp );

                if ( !commiting.add( participant ) )
                {
                    LOGGER.error.log( "Duplicate (", participant, ") Entry on getEntriesToCommit(...)?" );
                }
            }
            else if ( participant.isForcedChangeNotification() )
            {
                pCollector.add( participant, entry.getExtraPOinfo() );
            }
        }
        return commiting;
    }

    public void commitSucceeded( String pTransactionSourceId, SucceededTransactionCommitListener[] pSucceededTransactionCommitListeners, TransParticipantsManager pTransParticipantsManager )
    {

        for ( TransCommitEntry entry : mEntries )
        {
            try
            {
                PersistentObjectImpl.BackDoor.transactionCommitSucceededDropTransactionOn( entry.getParticipant() );
            }
            catch ( RuntimeException ignore )
            {
                LOGGER.error.log( ignore, "successfulCommit?" );
                // We have already succeeded, don't fail now
            }
        }

        for ( SucceededTransactionCommitListener zSucceededTransactionCommitListener : pSucceededTransactionCommitListeners )
        {
            zSucceededTransactionCommitListener.successfulCommitBeforeClear( pTransactionSourceId, mEntries, pTransParticipantsManager );
        }

        for ( TransCommitEntry entry : mEntries )
        {
            try
            {
                PersistentObjectImpl.BackDoor.transactionCommitSucceededClearTransactionalChangesOn( entry.getParticipant() );
            }
            catch ( RuntimeException ignore )
            {
                LOGGER.error.log( ignore, "successfulCommit?" );
                // We have already succeeded, don't fail now
            }
        }
    }
}