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

import org.litesoft.changemanagement.*;
import org.litesoft.changemanagement.nonpublic.*;
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 java.util.*;

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();
    }

    @Override
    public ChangeListenerManager getChangeListenerManager() {
        return mChangeListenerManager;
    }

    @Override
    public boolean isDemoDataStore() {
        return false;
    }

    @Override
    public UnfilteringFinder getUnfilteredFinder() {
        return this;
    }

    @Override
    public final TableManager getTableManager() {
        return mTableManager;
    }

    @Override
    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();
    }

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

    @Override
    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;
    }

    @Override
    public final boolean tablesAreInitializedForTesting() {
        return mTablesAreInitializedForTesting;
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public final void reCreateAllTablesIndices()
            throws DBException {
        forEachMetaDataForPOSorted( MethodDelegate_MetaDataForPO_reCreateIndices.INSTANCE );
    }

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

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

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

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

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

    /**
     * @see ClassToInstanceMapper forceRegister
     */
    @Override
    public <T, V extends T> void forceRegister( Class<T> pClass, V pInstance ) {
        mC2Imapper.forceRegister( pClass, pInstance );
    }

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

    /**
     * @see ClassToInstanceMapper clearAllInstances
     */
    @Override
    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 {
        @Override
        public void call( ORPersistenceHelper pORPersistenceHelper, MetaDataForPO pMetaDataForPO ) {
            pORPersistenceHelper.createTables( mTableManager, pMetaDataForPO );
        }

        @Override
        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();
        }

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

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

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

        @Override
        public void fini( ORPersistenceHelper pORPersistenceHelper ) {
        }
    }

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

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

        @Override
        public void fini( ORPersistenceHelper pORPersistenceHelper ) {
        }
    }
}