package org.litesoft.orsup.base;

import java.util.*;

import org.litesoft.core.*;
import org.litesoft.db.*;
import org.litesoft.encryption.symmetric.*;
import org.litesoft.logger.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.orsup.transact.nonpublic.*;
import org.litesoft.changemanagement.*;
import org.litesoft.changemanagement.nonpublic.*;

public class DataStoreBase extends UnfilteringFinderImpl implements DataStore,
                                                                    UnfilteringFinder
{
    public static final Logger LOGGER = LoggerFactory.getLogger( DataStore.class );

    private ClassToInstanceMapper mC2Imapper = new ClassToInstanceMapperImpl();
    private ChangeListenerManager mChangeListenerManager = ChangeListenerManager.BackDoor.create( new LowLevelChangeListenerManager() );
    private boolean mTablesAreInitializedForTesting = false;

    private TableManager mTableManager;

    protected DataStoreBase( ORPersistenceFormHelpers pPersistenceFormHelpers, MetaDataStore pMetaDataStore )
    {
        super( new ORFacilitatorImpl( pPersistenceFormHelpers, pMetaDataStore, new SymmetricEncryptorManagerImpl(), new TransactionAugmentationManagerImpl(), new TransactionCommitListenerManagerImpl(), new SucceededTransactionCommitListenerManagerImpl(), new TransactionFactoryImpl() ), false );
        mTableManager = new TableManager( getMetaDataStore() );
        getPersistenceHelper().initializeDB(); // This line should follow the previous line
    }

    protected MetaDataRegistry getMetaDataRegistry()
    {
        return (MetaDataRegistry) getMetaDataStore();
    }

    public ChangeListenerManager getChangeListenerManager()
    {
        return mChangeListenerManager;
    }

    public boolean isDemoDataStore()
    {
        return false;
    }

    public UnfilteringFinder getUnfilteredFinder()
    {
        return this;
    }

    public final TableManager getTableManager()
    {
        return mTableManager;
    }

    public final void createAllTables()
            throws DBException
    {
        forEachMetaDataForPOSorted( new MethodDelegate_MetaDataForPO_createTables() );
        clearAllGroups();
    }

    public final void deleteAllRowsAllTables()
            throws DBException
    {
        forEachMetaDataForPODependOrder( new MethodDelegate_MetaDataForPO_deleteAllRows( getPersistenceHelper() ) );
        clearAllGroups();
    }

    public final void dropAllTables()
            throws DBException
    {
        forEachMetaDataForPODependOrder( new MethodDelegate_MetaDataForPO_dropTables() );
        clearAllGroups();
    }

    public final void initializeAllTablesForTesting()
            throws DBException
    {
        MetaDataRegistry zMetaDataRegistry = getMetaDataRegistry();
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized ( zMetaDataRegistry )
        {
            if ( mTableManager.getCreatedOrVerifiedCount() != zMetaDataRegistry.getAllMetaDataForPOs().length )
            {
                dropAllTables();
                createAllTables();
                return;
            }
            deleteAllRowsAllTables();
        }
        mTablesAreInitializedForTesting = true;
    }

    public final boolean tablesAreInitializedForTesting()
    {
        return mTablesAreInitializedForTesting;
    }

    public final void reCreateAllTablesIndices()
            throws DBException
    {
        forEachMetaDataForPOSorted( MethodDelegate_MetaDataForPO_reCreateIndices.INSTANCE );
    }

    /**
     * @see ClassToInstanceMapper getNoInstanceFactories
     */
    public List<NoInstanceFactory<?>> getNoInstanceFactories()
    {
        return mC2Imapper.getNoInstanceFactories();
    }

    /**
     * @see ClassToInstanceMapper setNoInstanceFactory
     */
    public void setNoInstanceFactory( NoInstanceFactory<?> pFactory )
    {
        mC2Imapper.setNoInstanceFactory( pFactory );
    }

    /**
     * @see ClassToInstanceMapper checkGet
     */
    public <T> T checkGet( Class<T> pClass )
            throws IllegalArgumentException
    {
        return mC2Imapper.checkGet( pClass );
    }

    /**
     * @see ClassToInstanceMapper get
     */
    public <T> T get( Class<T> pClass )
            throws IllegalArgumentException, IllegalStateException
    {
        return mC2Imapper.get( pClass );
    }

    /**
     * @see ClassToInstanceMapper set
     */
    public <T, V extends T> void set( Class<T> pClass, V pInstance )
            throws IllegalArgumentException, IllegalStateException
    {
        mC2Imapper.set( pClass, pInstance );
    }

    /**
     * @see ClassToInstanceMapper replace
     */
    public <T, V extends T> void replace( Class<T> pClass, V pInstance )
            throws IllegalArgumentException, IllegalStateException
    {
        mC2Imapper.replace( pClass, pInstance );
    }

    /**
     * @see ClassToInstanceMapper remove
     */
    public <T, V extends T> void remove( Class<T> pClass, V pInstance )
            throws IllegalArgumentException, IllegalStateException
    {
        mC2Imapper.remove( pClass, pInstance );
    }

    /**
     * @see ClassToInstanceMapper clearAllInstances
     */
    public void clearAllInstances()
    {
        mC2Imapper.clearAllInstances();
    }

    private void clearAllGroups()
    {
        getSequenceSource().clearAllGroups();
    }

    private interface MetaDataForPONoParamsMethodDelegate
    {
        void call( ORPersistenceHelper pORPersistenceHelper, MetaDataForPO pMetaDataForPO );

        void fini( ORPersistenceHelper pORPersistenceHelper );
    }

    private void forEachMetaDataForPOSorted( MetaDataForPONoParamsMethodDelegate pDelegate )
    {
        MetaDataForPO[] zMetaDataForPOs = getAllMetaDataForPOs();
        Arrays.sort( zMetaDataForPOs );
        forEachMetaData( zMetaDataForPOs, pDelegate );
    }

    private void forEachMetaDataForPODependOrder( MetaDataForPONoParamsMethodDelegate pDelegate )
    {
        // MetaDataForPO[] zMetaDataForPOs = getMetaDataRegistry().getInReducingDependancyOrderAllMetaDataForPO();
        // MetaDataForPO[] zMetaDataForPOs = getMetaDataRegistry().getInDependancyOrderAllMetaDataForPO();
        MetaDataForPO[] zMetaDataForPOs = getAllMetaDataForPOs();
        forEachMetaData( zMetaDataForPOs, pDelegate );
    }

    private void forEachMetaData( MetaDataForPO[] pMetaDataForPOs, MetaDataForPONoParamsMethodDelegate pDelegate )
    {
        ORPersistenceHelper zORPersistenceHelper = getORPersistenceHelper();
        try
        {
            MetaDataForPO zToFindSeqMD = getPersistenceFormHelpers().getPOmetaDataForPOForSequenceSource();
            MetaDataForPO zFoundSeqMD = null;
            for ( MetaDataForPO metaData : pMetaDataForPOs )
            {
                if ( metaData == zToFindSeqMD )
                {
                    zFoundSeqMD = metaData;
                }
                else
                {
                    pDelegate.call( zORPersistenceHelper, metaData );
                }
            }
            if ( zFoundSeqMD != null )
            {
                pDelegate.call( zORPersistenceHelper, zFoundSeqMD );
            }
        }
        finally
        {
            pDelegate.fini( zORPersistenceHelper );
        }
    }

    private class MethodDelegate_MetaDataForPO_createTables implements MetaDataForPONoParamsMethodDelegate
    {
        public void call( ORPersistenceHelper pORPersistenceHelper, MetaDataForPO pMetaDataForPO )
        {
            pORPersistenceHelper.createTables( mTableManager, pMetaDataForPO );
        }

        public void fini( ORPersistenceHelper pORPersistenceHelper )
        {
        }
    }

    private static class MethodDelegate_MetaDataForPO_deleteAllRows implements MetaDataForPONoParamsMethodDelegate
    {
        private DBconnection mConnection;

        public MethodDelegate_MetaDataForPO_deleteAllRows( PersistenceHelper pPersistenceHelper )
        {
            mConnection = pPersistenceHelper.createConnection();
        }

        public void call( ORPersistenceHelper pORPersistenceHelper, MetaDataForPO pMetaDataForPO )
        {
            pORPersistenceHelper.deleteAllRows( mConnection, pMetaDataForPO );
        }

        public void fini( ORPersistenceHelper pORPersistenceHelper )
        {
            try
            {
                mConnection.commit();
            }
            finally
            {
                mConnection.dispose();
                mConnection = null;
            }
        }
    }

    private class MethodDelegate_MetaDataForPO_dropTables implements MetaDataForPONoParamsMethodDelegate
    {
        public void call( ORPersistenceHelper pORPersistenceHelper, MetaDataForPO pMetaDataForPO )
        {
            pORPersistenceHelper.dropTable( mTableManager, pMetaDataForPO );
        }

        public void fini( ORPersistenceHelper pORPersistenceHelper )
        {
        }
    }

    private static class MethodDelegate_MetaDataForPO_reCreateIndices implements MetaDataForPONoParamsMethodDelegate
    {
        public static final MetaDataForPONoParamsMethodDelegate INSTANCE = new MethodDelegate_MetaDataForPO_reCreateIndices();

        public void call( ORPersistenceHelper pORPersistenceHelper, MetaDataForPO pMetaDataForPO )
        {
            pORPersistenceHelper.reCreateIndices( pMetaDataForPO );
        }

        public void fini( ORPersistenceHelper pORPersistenceHelper )
        {
        }
    }
}