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

import java.util.*;

import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;

public abstract class AbstractConfigDataAccessor implements ConfigDataAccessor
{
    private final String mLoadedFromDirectory;
    private final String mLoadedFrom;
    private final Level mOtherSettableLevel;
    private final Level[] mSetableSupportedLevels;
    protected final Map<String, String> mRunLevelKeyValues = new HashMap<String, String>();

    protected AbstractConfigDataAccessor( String pLoadedFromDirectory, String pLoadedFrom, Level pOtherSettableLevel )
    {
        mLoadedFromDirectory = pLoadedFromDirectory;
        mLoadedFrom = pLoadedFrom;
        mSetableSupportedLevels = (null == (mOtherSettableLevel = pOtherSettableLevel)) ? //
                                  new Level[]{Level.RUN} : //
                                  new Level[]{Level.RUN, pOtherSettableLevel};
    }

    @Override
    public final ConfigDataAccessor createConfigDataAccessor()
    {
        return this;
    }

    @Override
    public final String loadedFrom()
    {
        return mLoadedFrom;
    }

    @Override
    public final String loadedFromDirectory()
    {
        return mLoadedFromDirectory;
    }

    /**
     * All implementations MUST support RUN level, but may not support other levels
     *
     * @return an array with at least 1 (RUN) entry
     */
    @Override
    public final Level[] getSetableSupportedLevels()
    {
        return mSetableSupportedLevels;
    }

    /**
     * All implementations MUST support RUN level, but do not have to support other levels
     *
     * @param pLevel null interpreted as RUN
     * @param pKey   not null or empty
     * @param pValue null means remove
     *
     * @throws UnsupportedOperationException if requested level not supported
     */
    @Override
    public final synchronized void setKeyValue( Level pLevel, String pKey, String pValue )
            throws UnsupportedOperationException
    {
        pKey = Strings.assertNotNullNotEmpty( "Key", pKey );
        Level zLevel = Objects.deNull( pLevel, Level.RUN );
        if ( Level.RUN.equals( zLevel ) )
        {
            if ( pValue == null )
            {
                mRunLevelKeyValues.remove( pKey );
            }
            else
            {
                mRunLevelKeyValues.put( pKey, pValue );
            }
            return;
        }
        if ( !zLevel.equals( mOtherSettableLevel ) )
        {
            throw new UnsupportedOperationException( "setKeyValue for Level '" + pLevel + "' not supported" );
        }
        try
        {
            setOtherLevelKeyValue( pKey, pValue );
        }
        catch ( RuntimeException e )
        {
            throw new PersistenceException( "Unable to setKeyValue( " + pLevel + ", \"" + pKey + "\", " + pValue + " )" + getExceptionPlus(), e );
        }
    }

    abstract protected String getExceptionPlus();

    abstract protected void setOtherLevelKeyValue( String pKey, String pValue );

    @Override
    public final synchronized String[] getAllKeys()
    {
        Set<String> zKeys;
        try
        {
            zKeys = new HashSet<String>( Arrays.asList( getBaseKeys() ) );
        }
        catch ( RuntimeException e )
        {
            throw new PersistenceException( "Unable to getAllKeys()" + getExceptionPlus(), e );
        }
        zKeys.addAll( mRunLevelKeyValues.keySet() );
        return zKeys.toArray( new String[zKeys.size()] );
    }

    protected abstract String[] getBaseKeys();

    /**
     * @param pKey not null or empty
     *
     * @return null if not found or value associated with key
     */
    @Override
    public final synchronized String getString( String pKey )
    {
        pKey = Strings.assertNotNullNotEmpty( "Key", pKey );
        String rv = mRunLevelKeyValues.get( pKey );
        try
        {
            return (rv != null) ? rv : getBaseValue( pKey );
        }
        catch ( RuntimeException e )
        {
            throw new PersistenceException( "Unable to getString( \"" + pKey + "\" )" + getExceptionPlus(), e );
        }
    }

    protected abstract String getBaseValue( String pKey );

    @Override
    public final synchronized void overrideAllStartingWith( String pKeyPrefix, String pValue )
    {
        if ( null != (pKeyPrefix = Strings.noEmpty( pKeyPrefix )) )
        {
            pValue = Strings.deNull( pValue );
            for ( String zKey : getAllKeys() )
            {
                if ( zKey.startsWith( pKeyPrefix ) )
                {
                    setKeyValue( Level.RUN, zKey, pValue );
                }
            }
        }
    }
}