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

import org.litesoft.core.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.logger.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.nonpublic.*;

import java.util.*;

public class DemoDataStoreManager
{
    public class Struct
    {
        private DataStore mDataStore;
        private boolean mEmptyDemo;

        public Struct( DataStore pDataStore, boolean pEmptyDemo )
        {
            mDataStore = pDataStore;
            mEmptyDemo = pEmptyDemo;
        }

        public DataStore getDataStore()
        {
            return mDataStore;
        }

        public boolean isEmptyDemo()
        {
            return mEmptyDemo;
        }
    }

    public static class NoMoreDemoDataStoresAvailableException extends IllegalStateException
    {
        public NoMoreDemoDataStoresAvailableException( String pMessage )
        {
            super( pMessage );
        }
    }

    public static Struct getDemoDS( ContextID pContextID )
    {
        Objects.assertNotNull( "ContextID", pContextID );
        DemoDataStoreManager zManager = sInstance;
        if ( zManager == null )
        {
            throw new Error( "DemoDataStoreManager not created, but attempt to get a Demo DataStore" );
        }
        return zManager.getDSfor( pContextID );
    }

    private static Logger LOGGER = LoggerFactory.getLogger( DemoDataStoreManager.class );

    private static volatile DemoDataStoreManager sInstance = null;

    private DataStore mMasterDataStore;
    private MetaDataRegistry mMetaDataRegistry;
    private int mMaxDemoDataStores;

    private Map<String, DS> mDataStoresByName = new HashMap<String, DS>();
    private Map<ContextID, DS> mInUseDataStores = new HashMap<ContextID, DS>();
    private Stack<DS> mAvailableDataStores = new Stack<DS>();

    public DemoDataStoreManager( DataStore pMasterDataStore, MetaDataRegistry pMetaDataRegistry, int pMaxDemoDataStores )
    {
        mMasterDataStore = pMasterDataStore;
        mMetaDataRegistry = pMetaDataRegistry;
        mMaxDemoDataStores = pMaxDemoDataStores;
        sInstance = this;
    }

    private synchronized Struct getDSfor( ContextID pContextID )
    {
        DS zDS = mInUseDataStores.get( pContextID );
        if ( zDS != null )
        {
            return new Struct( zDS, false );
        }
        if ( !mAvailableDataStores.isEmpty() )
        {
            zDS = mAvailableDataStores.pop();
        }
        else
        {
            int zCurCount = mDataStoresByName.size();
            if ( zCurCount == mMaxDemoDataStores )
            {
                throw new NoMoreDemoDataStoresAvailableException( "Demo System Unavailable, Only " + mMaxDemoDataStores + " Simultaneous Demo Users Supported" );
            }
            zDS = new DS( mMasterDataStore, mMetaDataRegistry, "demo_" + zCurCount );
            mDataStoresByName.put( zDS.getDBname(), zDS );
        }
        DS zPrevDS = mInUseDataStores.put( pContextID, zDS );
        if ( zPrevDS != null )
        {
            LOGGER.error.log( "Duplicate Demo DataStore request from: " + pContextID );
            makeAvailable( zPrevDS );
        }
        zDS.setContextID( pContextID );
        return new Struct( zDS, true );
    }

    private synchronized void releaseDS( ContextID pContextID )
    {
        DS zDS = mInUseDataStores.remove( pContextID );
        if ( zDS != null )
        {
            makeAvailable( zDS );
        }
    }

    private void makeAvailable( DS pDS )
    {
        pDS.setContextID( null );
        pDS.initializeAllTablesForTesting();
        pDS.clearAllInstances();
        pDS.getChangeListenerManager().clearAllListeners();
        mAvailableDataStores.push( pDS );
    }

    private class DS extends DataStoreBaseSQL implements Disposable
    {
        private ContextID mContextID = null;
        private String mDBname;

        public DS( DataStore pMasterDataStore, MetaDataStore pMetaDataStore, final String pDBname )
        {
            super( createPersistenceFormHelpers( new SQLDBconnectionProvider()
            {
                @Override
                protected void setupDB()
                {
                    new org.hsqldb.jdbcDriver(); // Force Registration

                    createDriver( "jdbc:hsqldb:mem:" + pDBname, "sa", "" );
                }
            } ), pMetaDataStore );

            mDBname = pDBname;

            createAllTables();

            List<NoInstanceFactory<?>> zFactories = pMasterDataStore.getNoInstanceFactories();
            for ( NoInstanceFactory<?> zFactory : zFactories )
            {
                setNoInstanceFactory( zFactory );
            }
        }

        public ContextID getContextID()
        {
            return mContextID;
        }

        public void setContextID( ContextID pContextID )
        {
            mContextID = pContextID;
        }

        public String getDBname()
        {
            return mDBname;
        }

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

        @Override
        public void dispose()
        {
            releaseDS( mContextID );
        }
    }
}