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

import org.litesoft.commonfoundation.typeutils.gregorian.*;
import org.litesoft.logger.*;
import org.litesoft.orsup.transact.*;

import java.sql.*;
import java.util.*;

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
            }
        }
    }
}