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

import org.litesoft.commonfoundation.typeutils.Objects;
import java.util.*;

import org.litesoft.orsup.base.*;

public class TransParticipantsManager
{
    protected final Map<PersistentObjectURL, PersistentObjectImpl<?>> mParticipants = new HashMap<PersistentObjectURL, PersistentObjectImpl<?>>();

    private List<PersistentObjectImpl<?>> mAddedParticipantDuringCommits = null;
    private TransState mState = TransState.ACTIVE;

    public synchronized boolean isEmpty()
    {
        return mParticipants.isEmpty();
    }

    public synchronized PersistentObjectImpl<?> get( PersistentObjectURL pPersistentObjectURL )
    {
        return mParticipants.get( pPersistentObjectURL );
    }

    private void clear()
    {
        mParticipants.clear();
        mAddedParticipantDuringCommits = null;
    }

    public synchronized TransState getState()
    {
        return mState;
    }

    public synchronized void dispose()
    {
        validateNotCommitting( "dispose" );
        mState = mState.dispose();
        for ( PersistentObjectImpl participant : mParticipants.values() )
        {
            try
            {
                PersistentObjectImpl.BackDoor.disposeTransactionOn( participant );
            }
            catch ( RuntimeException ignore )
            {
                TransactionImpl.LOGGER.error.log( ignore, "dipose?" );
                // Whatever!
            }
        }
        clear();
    }

    public synchronized void initiateCommitting( List<PersistentObjectImpl<?>> pParticipantsListToPopulate )
    {
        validateNotCommitting( "commit" );
        mState = mState.commitInit();
        mAddedParticipantDuringCommits = new ArrayList<PersistentObjectImpl<?>>();
        pParticipantsListToPopulate.addAll( mParticipants.values() );
    }

    public synchronized void transitionToLowLevelCommitting()
    {
        mState = mState.commitLowLevel();
    }

    public synchronized void successfullyCommitted()
    {
        mState = mState.commitSucceeded();
        clear();
    }

    public synchronized void clearCommitting()
    {
        mState = mState.clearCommitting();
        mAddedParticipantDuringCommits = null;
    }

    public synchronized PersistentObjectImpl<?> addPO( PersistentObjectImpl<?> pPersistentObject )
    {
        validateFunctional( "add a" );
        validateSupportsPOmodification( "add a" );
        PersistentObjectURL poURL = pPersistentObject.getPersistentObjectURL();
        PersistentObjectImpl<?> existing = mParticipants.get( poURL );
        if ( existing != null )
        {
            return existing;
        }
        mParticipants.put( poURL, pPersistentObject );
        if ( mAddedParticipantDuringCommits != null )
        {
            mAddedParticipantDuringCommits.add( pPersistentObject );
        }
        return pPersistentObject;
    }

    public synchronized PersistentObject[] getAllParticipants()
    {
        return mParticipants.values().toArray( new PersistentObject[mParticipants.size()] );
    }

    public synchronized List<PersistentObjectImpl<?>> grabAddedParticipantsDuringCommits()
    {
        List<PersistentObjectImpl<?>> rv = mAddedParticipantDuringCommits;
        mAddedParticipantDuringCommits = new ArrayList<PersistentObjectImpl<?>>();
        return rv;
    }

    public synchronized void changeURL( PersistentObjectURL pOrigURL, PersistentObjectURL pNewURL )
    {
        Objects.assertNotNull( "OrigURL", pOrigURL );
        Objects.assertNotNull( "NewURL", pNewURL );
        validateNotCommitting( "changeURL" );
        validateSupportsPOmodification( "change a URL on a" );
        validateFunctional( "change a URL on a" );

        PersistentObjectImpl<?> zPO = mParticipants.remove( pOrigURL );
        if ( zPO != null )
        {
            mParticipants.put( pNewURL, zPO );
        }
    }

    public synchronized void validateNotCommitting( String pWhatCalled )
    {
        if ( mAddedParticipantDuringCommits != null )
        {
            throw new IllegalStateException( "May not call '" + pWhatCalled + "' during the commit process" );
        }
    }

    private void validateSupportsPOmodification( String pWhat ) // called under synchronized
    {
        if ( !mState.supportsPOmodification() )
        {
            throw new IllegalStateException( "Attempt to " + pWhat + " PersistentObject to a transaction during Low Level Commit state" );
        }
    }

    private void validateFunctional( String pWhat ) // called under synchronized
    {
        if ( !mState.isFunctional() )
        {
            throw new IllegalStateException( "Attempt to " + pWhat + " PersistentObject to a Disposed or Successfully Committed transaction" );
        }
    }
}