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

import org.litesoft.changemanagement.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.db.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.orsup.transact.nonpublic.*;

import java.io.*;
import java.util.*;

public class TransactionImpl extends AbstractFinder implements Transaction,
                                                               TransactionBackdoor
{
    private final TransParticipantsManager mParticipantsManager = new TransParticipantsManager();

    private final NonTransactionalFinder mNonTransactionalFinder;
    private final long mID;
    private final Map<String, Serializable> mXtraData = new HashMap<String, Serializable>();
    private final Map<Object, Object> mProperties = new HashMap<Object, Object>();

    private final HistoryAugmentor mHistoryAugmentor;
    private final TAnodeManager<DA_LinkListNode> mDeleteAugmentors = new TAnodeManager<DA_LinkListNode>();
    private final TAnodeManager<CA_LinkListNode> mCommitAugmentors = new TAnodeManager<CA_LinkListNode>();

    private String mTransactionSourceClassname = null;

    public TransactionImpl( NonTransactionalFinder pNonTransactionalFinder, boolean pAugment )
    {
        super( ORFacilitatorImpl.getInstance( pNonTransactionalFinder ), LOGGER, pNonTransactionalFinder.isIncludingImmortalInactives(), //
               pNonTransactionalFinder.getPOQueryFilterFactory() );
        mNonTransactionalFinder = pNonTransactionalFinder;
        mID = getNextSequenceNumber( "Transactions" );

        HistoryAugmentorFactory zHAfactory = null;
        TransactionAugmentorFactory[] zTAfactories = null;
        if ( pAugment )
        {
            TransactionAugmentationManager zTAM = getTransactionAugmentationManager();
            //noinspection SynchronizationOnLocalVariableOrMethodParameter
            synchronized ( zTAM )
            {
                zHAfactory = zTAM.getHistoryAugmentorFactory();
                zTAfactories = // Grab the current list
                        (zTAM instanceof TransactionAugmentationManagerInternalExtension) ? ((TransactionAugmentationManagerInternalExtension) zTAM).getRawTransactionAugmentorsArray() : zTAM.getTransactionAugmentors();
            }
        }
        mHistoryAugmentor = (zHAfactory != null) ? zHAfactory.createHistoryAugmentor() : null;
        if ( zTAfactories != null )
        {
            for ( TransactionAugmentorFactory zTAFactory : zTAfactories )
            {
                addTransactionAugmentor( zTAFactory );
            }
        }
    }

    @Override
    public final NonTransactionalFinder getNonTransactionalFinder()
    {
        return mNonTransactionalFinder;
    }

    @Override
    public final long getTransactionID()
    {
        return mID;
    }

    @Override
    public final Serializable getXtraData( Class pForKey )
    {
        return (pForKey == null) ? null : mXtraData.get( pForKey.getName() );
    }

    @Override
    public final Transaction setXtraData( Class pForKey, Serializable pData )
    {
        if ( pForKey != null )
        {
            if ( pData == null )
            {
                mXtraData.remove( pForKey.getName() );
            }
            else
            {
                mXtraData.put( pForKey.getName(), pData );
            }
        }
        return this;
    }

    @Override
    public final void addProperty( Object pKey, Object pValue )
    {
        Objects.assertNotNull( "Key", pKey );
        if ( pValue != null )
        {
            mProperties.put( pKey, pValue );
        }
        else
        {
            mProperties.remove( pKey );
        }
    }

    @Override
    public final Object getProperty( Object pKey )
    {
        Objects.assertNotNull( "Key", pKey );
        return mProperties.get( pKey );
    }

    @Override
    public String getTransactionSourceClassname()
    {
        return mTransactionSourceClassname;
    }

    @Override
    public Transaction setTransactionSource( Class pSourceClass )
    {
        mTransactionSourceClassname = (pSourceClass != null) ? pSourceClass.getName() : null;
        return this;
    }

    @Override
    public Transaction addTransactionAugmentor( TransactionAugmentorFactory pTransactionAugmentorFactory )
            throws IllegalStateException
    {
        return (pTransactionAugmentorFactory == null) ? //
               this : //
               addTransactionAugmentor( pTransactionAugmentorFactory.createTransactionAugmentor( this ) );
    }

    @Override
    public Transaction addTransactionAugmentor( TransactionAugmentor pTransactionAugmentor )
            throws IllegalStateException
    {
        if ( pTransactionAugmentor instanceof CommitAugmentor )
        {
            addCommitAugmentor( (CommitAugmentor) pTransactionAugmentor );
        }
        if ( pTransactionAugmentor instanceof DeleteAugmentor )
        {
            addDeleteAugmentor( (DeleteAugmentor) pTransactionAugmentor );
        }
        return this;
    }

    @Override
    public Transaction addCommitAugmentor( CommitAugmentor pCommitAugmentor )
    {
        if ( null != pCommitAugmentor )
        {
            mCommitAugmentors.add( new CA_LinkListNode( pCommitAugmentor ) );
        }
        return this;
    }

    @Override
    public CommitAugmentor[] getCommitAugmentors()
    {
        CA_LinkListNode zHead = mCommitAugmentors.getHead();
        if ( zHead == null )
        {
            return CommitAugmentor.EMPTY_ARRAY;
        }
        CommitAugmentor[] rv = new CommitAugmentor[zHead.getLength()];
        zHead.populate( rv );
        return rv;
    }

    @Override
    public boolean hasCommitAugmentor( Class<? extends CommitAugmentor> pAugmentorClass )
    {
        return mCommitAugmentors.hasAugmentor( pAugmentorClass );
    }

    @Override
    public boolean removeCommitAugmentor( Class<? extends CommitAugmentor> pAugmentorClass )
    {
        return mCommitAugmentors.removeAugmentor( pAugmentorClass );
    }

    @Override
    public Transaction addDeleteAugmentor( DeleteAugmentor pDeleteAugmentor )
            throws IllegalStateException
    {
        if ( null != pDeleteAugmentor )
        {
            if ( !mParticipantsManager.isEmpty() )
            {
                throw new IllegalStateException( "DeleteAugmentor may only be added BEFORE any POs are added to the Transaction" );
            }
            mDeleteAugmentors.add( new DA_LinkListNode( pDeleteAugmentor ) );
        }
        return this;
    }

    @Override
    public DeleteAugmentor[] getDeleteAugmentors()
    {
        DA_LinkListNode zHead = mDeleteAugmentors.getHead();
        if ( zHead == null )
        {
            return DeleteAugmentor.EMPTY_ARRAY;
        }
        DeleteAugmentor[] rv = new DeleteAugmentor[zHead.getLength()];
        zHead.populate( rv );
        return rv;
    }

    @Override
    public boolean hasDeleteAugmentor( Class<? extends DeleteAugmentor> pAugmentorClass )
    {
        return mDeleteAugmentors.hasAugmentor( pAugmentorClass );
    }

    @Override
    public boolean removeDeleteAugmentor( Class<? extends DeleteAugmentor> pAugmentorClass )
    {
        return mDeleteAugmentors.removeAugmentor( pAugmentorClass );
    }

    @Override
    public PersistentObject<?> create( String pPersistedObjectRegistrationName )
            throws DBException
    {
        return getRequiredMetaDataForPO( pPersistedObjectRegistrationName ).createNew( this );
    }

    @SuppressWarnings({"unchecked"}) @Override
    public <T extends PersistentObject> T create( Class<T> pPersistedObjectClass )
            throws DBException
    {
        return (T) create( pPersistedObjectClass.getName() );
    }

    @Override
    public PersistentObject<?> getPersistentObjectFromIdentityMap( PersistentObjectURL pPersistentObjectURL )
    {
        return (pPersistentObjectURL != null) ? mParticipantsManager.get( pPersistentObjectURL ) : null;
    }

    /**
     * Refresh the pPersistedObject into this transaction if it is not already in the Transaction.
     *
     * @param pPersistedObject - Persisted Object to be freshly read (if needed)
     *
     * @return Transactional copy of the latest version read via Transaction (if needed), or Null if the PO is in another Transaction and isNew() OR has been deleted
     *
     * @throws DBException - Exception regarding the OR layer
     */
    @SuppressWarnings({"unchecked"})
    public <T extends PersistentObject> T freshIntoIfNotInTransaction( PersistentObject<T> pPersistedObject )
            throws DBException
    {
        if ( pPersistedObject == null )
        {
            return null;
        }
        PersistentObjectURL url = pPersistedObject.getPersistentObjectURL();
        PersistentObject<?> existing = getPersistentObjectFromIdentityMap( url );
        if ( existing != null )
        {
            return (T) existing;
        }
        // todo: Caches
        return (T) findOne( url );
    }

    /**
     * Refresh the pPersistedObject into this transaction.
     *
     * @param pPersistedObject - Persisted Object to be freshly read
     *
     * @return Transactional copy of the latest version read via Transaction, or Null if the PO is in another Transaction and isNew() OR has been deleted
     *
     * @throws UnsupportedOperationException - if the PO is already in the Transaction
     * @throws DBException                   - Exception regarding the OR layer
     */
    @Override
    public <T extends PersistentObject> T refreshInto( PersistentObject<T> pPersistedObject )
            throws UnsupportedOperationException, DBException
    {
        if ( pPersistedObject == null )
        {
            return null;
        }
        PersistentObjectURL url = pPersistedObject.getPersistentObjectURL();
        PersistentObject<?> existing = getPersistentObjectFromIdentityMap( url );
        if ( existing != null )
        {
            throw new UnsupportedOperationException( pPersistedObject.getDisplayValue() + " already in the Transaction" );
        }
        // todo: Caches
        //noinspection unchecked
        return (T) findOne( url );
    }

    @Override
    public final String getState()
    {
        return mParticipantsManager.getState().toString();
    }

    /**
     * This method returns true if the PO & transaction allows modification.
     * <p/>
     * This Transaction will only return true if it is not in the LL_COMMITING state AND has not been: successfully committed or disposed.
     */
    @Override
    public boolean supportsPOmodification( PersistentObject pPoToModify )
    {
        return mParticipantsManager.getState().supportsPOmodification();
    }

    @Override
    public final boolean isFunctional()
    {
        return mParticipantsManager.getState().isFunctional();
    }

    @Override
    public void dispose()
    {
        mParticipantsManager.dispose();
    }

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

    @Override
    public PersistentObject[] getAllParticipants()
    {
        return mParticipantsManager.getAllParticipants();
    }

    /**
     * Commit changes from a temporary transaction space to the database
     * <p/>
     * This method must be called during an active transaction
     */
    @Override
    public void commit()
            throws ConcurrentPOModificationException, DBException
    {
        LLcommit( mCommitAugmentors.getHead() );
    }

    /**
     * Commit changes from a temporary transaction space to the database
     * <p/>
     * This method must be called during an active transaction
     */
    @Override
    public void commit( CommitAugmentor pCommitAugmentor )
            throws ConcurrentPOModificationException, DBException
    {
        CA_LinkListNode zNode = mCommitAugmentors.getHead();
        if ( pCommitAugmentor != null )
        {
            zNode = new CA_LinkListNode( pCommitAugmentor, zNode );
        }
        LLcommit( zNode );
    }

    /**
     * Under rare circumstances, a POs Key Vvlaues are changed and the Transaction must re-index it!
     * <p/>
     *
     * @param pOrigURL !null
     * @param pNewURL  !null
     */
    @Override
    public void changedURL( PersistentObjectURL pOrigURL, PersistentObjectURL pNewURL )
    {
        mParticipantsManager.changeURL( pOrigURL, pNewURL );
    }

    public void LLcommit( CA_LinkListNode pCommitAugmentors )
            throws ConcurrentPOModificationException, DBException
    {
        List<PersistentObjectImpl<?>> zParticipants = new ArrayList<PersistentObjectImpl<?>>();

        mParticipantsManager.initiateCommitting( zParticipants );

        DataStoreChangeCollector zAllCollector = new DataStoreChangeCollector( getTransactionID(), getTransactionSourceClassname(), mXtraData );
        try
        {
            if ( !zParticipants.isEmpty() )
            {
                TransCommitCollector collector = new TransCommitCollector( pCommitAugmentors );

                collector.add( zParticipants );

                List<PersistentObjectImpl<?>> zAdded;
                while ( !(zAdded = mParticipantsManager.grabAddedParticipantsDuringCommits()).isEmpty() )
                {
                    collector.add( zAdded );
                }
                if ( mHistoryAugmentor != null )
                {
                    collector.augment( mHistoryAugmentor );
                    if ( !(zAdded = mParticipantsManager.grabAddedParticipantsDuringCommits()).isEmpty() )
                    {
                        collector.justAdd( zAdded );
                    }
                    collector.validateNoChanges( "HistoryAugmentor" );
                }
                Set<PersistentObjectImpl> commiting = collector.getEntriesToCommit( zAllCollector );

                if ( !commiting.isEmpty() )
                {
                    mParticipantsManager.transitionToLowLevelCommitting();

                    TransactionCommitListenerManager zManager = getTransactionCommitListenerManager();
                    TransactionCommitListener[] zListeners = // Grab the current list
                            (zManager instanceof TransactionCommitListenerManagerInternalExtension) ? ((TransactionCommitListenerManagerInternalExtension) zManager).getRawTransactionCommitListenersArray() : zManager.getListeners();

                    if ( zListeners.length == 0 )
                    {
                        commitParticipants( commiting );
                    }
                    else
                    {
                        TransactionSuccessfulCommitCallBack[] zCallBacks = new TransactionSuccessfulCommitCallBack[zListeners.length];

                        PersistentObject[] zCommiting = commiting.toArray( new PersistentObject[commiting.size()] );

                        for ( int i = 0; i < zListeners.length; i++ )
                        {
                            try
                            {
                                zCallBacks[i] = zListeners[i].aboutToCommit( zCommiting );
                            }
                            catch ( RuntimeException e )
                            {
                                LOGGER.error.log( e );
                            }
                        }
                        commitParticipants( commiting );

                        for ( TransactionSuccessfulCommitCallBack zCallBack : zCallBacks )
                        {
                            if ( zCallBack != null )
                            {
                                try
                                {
                                    zCallBack.commitSucceeded();
                                }
                                catch ( RuntimeException e )
                                {
                                    LOGGER.error.log( e );
                                }
                            }
                        }
                    }
                }
                SucceededTransactionCommitListenerManager zManager = getSucceededTransactionCommitListenerManager();
                SucceededTransactionCommitListener[] zListeners = // Grab the current list
                        (zManager instanceof SucceededTransactionCommitListenerManagerInternalExtension) ? ((SucceededTransactionCommitListenerManagerInternalExtension) zManager).getRawTransactionCommitListenersArray() : zManager.getListeners();

                collector.commitSucceeded( mTransactionSourceClassname, zListeners, mParticipantsManager );
            }
            mParticipantsManager.successfullyCommitted();
        }
        finally
        {
            mParticipantsManager.clearCommitting();
        }

        if ( zAllCollector.isNotEmpty() )
        {
            ChangeListenerManager.get().notifyAllListeners( zAllCollector.createSet() );
        }
        dispose();
    }

    enum CommitAction
    {
        UPDATE, INSERT, DELETE, DELETE_NEW;

        public static CommitAction get( PersistentObjectImpl pPO )
        {
            return pPO.isNew() ? //
                   (pPO.isDeleteRequested() ? DELETE_NEW : INSERT) : //
                   (pPO.isDeleteRequested() ? DELETE : UPDATE);
        }
    }

    protected void commitParticipants( Set<PersistentObjectImpl> pParticipants )
            throws ConcurrentPOModificationException, DBException
    {
        PersistentObjectImpl[] zPOs = pParticipants.toArray( new PersistentObjectImpl[pParticipants.size()] );
        Arrays.sort( zPOs );
        DBconnection zDBconnection = null;
        try
        {
            zDBconnection = getPersistenceHelper().createConnection();
            zDBconnection.setAutoCommit( false );
            for ( PersistentObjectImpl po : zPOs )
            {
                processCUD( zDBconnection, po );
            }
            zDBconnection.commit();
        }
        finally
        {
            if ( null != zDBconnection )
            {
                zDBconnection.dispose();
            }
        }
    }

    private void processCUD( DBconnection pDBconnection, PersistentObjectImpl pPO )
    {
        CommitAction zCommitAction = CommitAction.get( pPO );
        try
        {
            TransactionPersistenceHelper helper = (TransactionPersistenceHelper) getPersistenceHelper();
            switch ( zCommitAction )
            {
                case INSERT:
                    helper.insert( pDBconnection, pPO, this );
                    return;
                case DELETE:
                    helper.delete( pDBconnection, pPO, this );
                    // fall thru
                case DELETE_NEW:
                    PersistentObjectImpl.BackDoor.justDeletedInTransaction( pPO, pDBconnection );
                    return;
                case UPDATE:
                    helper.update( pDBconnection, pPO, this );
                    return;
                default:
                    break; // Will Throw IllegalStateException
            }
        }
        catch ( DBException e )
        {
            e.setAugmentedMessage( " on " + pPO.getObjectName() + ": " + pPO );
            throw e;
        }
        catch ( ConcurrentPOModificationException e )
        {
            e.setWithPO( pPO );
            throw e;
        }
        throw new IllegalStateException( "Unexpected CommitAction '" + zCommitAction + "' on " + pPO.getObjectName() + ": " + pPO );
    }

    @Override
    protected FindOneCacheResult checkCacheFindOne( String pPersistedObjectRegistrationName, //
                                                    PersistentObjectUniqueKey pPersistentObjectUniqueKey )
            throws DBException
    {
        // 1st we need to check into our transaction...
        PersistentObject<?> po = getPersistentObjectFromIdentityMap( new PersistentObjectURL( pPersistedObjectRegistrationName, pPersistentObjectUniqueKey ) );
        return (po != null) ? new FindOneCacheResult( po ) : null;
    }

    @Override
    public String toString()
    {
        return "Transaction: " + getTransactionID();
    }

    // TransactionBackdoor

    /**
     * When a PO has had its requestDelete() called on it, this method will be called BEFORE
     * any request delete processing occures.
     *
     * @param pPersistentObject that has just had its requestDelete() called on it.
     *
     * @return false if the PO should NOT be deleted!
     */
    @Override
    public boolean getApprovalFromDeleteAugmentors( PersistentObject<?> pPersistentObject )
    {
        boolean rv = true;
        for ( DA_LinkListNode zNode = mDeleteAugmentors.getHead(); zNode != null; zNode = zNode.getNext() )
        {
            if ( !zNode.getDeleteAugmentor().approveDeleteRequest( pPersistentObject ) )
            {
                rv = false;
            }
        }
        return rv;
    }

    @SuppressWarnings("unchecked") @Override
    public <T extends PersistentObjectImpl> T addPO( T pPersistentObject )
    {
        return (T) mParticipantsManager.addPO( pPersistentObject );
    }
}