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

import org.litesoft.configuration.*;
import org.litesoft.commonfoundation.typeutils.Objects;

import java.util.*;

public class SequenceSourceByGroup implements SequenceSource
{
    private SequenceBlockSource mSequenceBlockSource;

    public SequenceSourceByGroup( SequenceBlockSource pSequenceBlockSource )
    {
        Objects.assertNotNull( "SequenceBlockSource", mSequenceBlockSource = pSequenceBlockSource );
    }

    public synchronized void clearAllGroups()
    {
        mSequenceProxies.clear();
        mSequenceBlockSource.clearAllGroups();
    }

    public synchronized void clear( String pGroup )
    {
        SequenceProxy proxy = mSequenceProxies.remove( pGroup );
        if ( proxy != null )
        {
            proxy.clear();
        }
    }

    public void preallocateNextSequenceNumbers( String pGroup, int pBlockSize, Long pRestartAt )
    {
        getSequenceProxy( pGroup ).preallocateNextSequenceNumbers( (pBlockSize < 1) ? 1 : pBlockSize, pRestartAt );
    }

    public long getNextSequenceNumber( String pGroup, Long pRestartAt )
    {
        return getSequenceProxy( pGroup ).getNextSequenceNumber( pRestartAt );
    }

    public long getNextSequenceNumber( String pGroup )
    {
        return getNextSequenceNumber( pGroup, null );
    }

    public long getNextSequenceNumber( Class pGroup )
    {
        return getNextSequenceNumber( pGroup.getName() );
    }

    private synchronized SequenceProxy getSequenceProxy( String pSequencePoolName )
    {
        SequenceProxy proxy = mSequenceProxies.get( pSequencePoolName );
        if ( proxy == null )
        {
            proxy = new SequenceProxy( pSequencePoolName );
            mSequenceProxies.put( pSequencePoolName, proxy );
        }
        return proxy;
    }

    private Map<String, SequenceProxy> mSequenceProxies = new HashMap<String, SequenceProxy>();

    private class SequenceProxy
    {
        private String mGroup;
        private SequenceBlock mBlock = SequenceBlockImpl.INITIAL;
        private int mBlockSize = 100;

        public SequenceProxy( String pGroup )
        {
            mGroup = pGroup;
            int bs = Configuration.getInteger( pGroup + ".blocksize", -1 );
            if ( bs < 1 )
            {
                bs = Configuration.getInteger( "blocksize", 100 );
            }
            if ( bs > 0 )
            {
                mBlockSize = bs;
            }
        }

        public synchronized void preallocateNextSequenceNumbers( int pBlockSize, Long pRestartAt )
        {
            if ( pBlockSize > mBlock.available() )
            {
                mBlock = SequenceBlockChain.create( mBlock, //
                                                    mSequenceBlockSource.getNextBlock( mGroup, mBlock.getCurBlockEndExclusive(), pBlockSize - mBlock.available(), pRestartAt ) );
            }
        }

        public synchronized void clear()
        {
            mBlock = SequenceBlockImpl.INITIAL;
            mSequenceBlockSource.clear( mGroup );
        }

        public synchronized long getNextSequenceNumber( Long pRestartAt )
        {
            if ( !mBlock.hasMore() )
            {
                mBlock = mSequenceBlockSource.getNextBlock( mGroup, mBlock.getCurBlockEndExclusive(), mBlockSize, pRestartAt );
            }
            return mBlock.next();
        }
    }
}