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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.exceptions.*;

import java.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 = Confirm.significant( "Key", pKey );
        Level zLevel = ConstrainTo.notNull( 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 = Confirm.significant( "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 = ConstrainTo.significantOrNull( pKeyPrefix )) ) {
            pValue = ConstrainTo.notNull( pValue );
            for ( String zKey : getAllKeys() ) {
                if ( zKey.startsWith( pKeyPrefix ) ) {
                    setKeyValue( Level.RUN, zKey, pValue );
                }
            }
        }
    }
}