// 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.typeutils.Objects;

public abstract class Configuration
{
    private static Configuration sConfiguration = null;
    private static Set<ConfigLoadedListener> sConfigLoadedListeners = new HashSet<ConfigLoadedListener>();

    public synchronized static boolean isInstantiated()
    {
        return (sConfiguration != null);
    }

    public synchronized static void chkInstantiated()
    {
        if ( sConfiguration == null )
        {
            throw new IllegalStateException( "Configuration never Initialized" );
        }
    }

    public synchronized static void clear()
    {
        sConfiguration = null;
    }

    private synchronized static void setInstantiated( Configuration pConfiguration )
    {
        if ( sConfiguration != null )
        {
            throw new IllegalStateException( "Attempt to multi-define the Configuration" );
        }
        sConfiguration = pConfiguration;
    }

    private static synchronized Configuration getInstance()
    {
        chkInstantiated();
        return sConfiguration;
    }

    protected static synchronized ConfigDataAccessor getConfigDataAccessor()
    {
        return getInstance().insureConfigDataAccessorInstantiated();
    }

    /**
     * only called from synchronized static block!
     */
    private ConfigDataAccessor insureConfigDataAccessorInstantiated()
    {
        if ( mAccessor == null )
        {
            mAccessor = mFactory.createConfigDataAccessor();
            mFactory = null; // Release it
            notifyJustLoadedListeners();
        }
        return mAccessor;
    }

    /**
     * only called from synchronized static block!
     */
    protected boolean isLoaded()
    {
        return (mAccessor != null);
    }

    /**
     * only called from synchronized static block!
     */
    private static boolean isInstantiatedAndLoaded()
    {
        return isInstantiated() && getInstance().isLoaded();
    }

    public synchronized static void add( ConfigLoadedListener pConfigLoadedListener )
    {
        if ( isInstantiatedAndLoaded() )
        {
            throw new IllegalStateException( "May not add a ConfigLoadedListener AFTER the Configuration is already loaded" );
        }
        if ( pConfigLoadedListener != null )
        {
            sConfigLoadedListeners.add( pConfigLoadedListener );
        }
    }

    /**
     * only called from synchronized static block!
     */
    private static void notifyJustLoadedListeners()
    {
        for ( ConfigLoadedListener listener : sConfigLoadedListeners )
        {
            listener.configurationJustLoaded();
        }
        sConfigLoadedListeners.clear();
    }

    protected ConfigDataAccessor mAccessor = null;
    private ConfigDataAccessorFactory mFactory;

    protected Configuration( ConfigDataAccessorFactory pFactory )
    {
        Objects.assertNotNull( "ConfigDataAccessorFactory", mFactory = pFactory );
        setInstantiated( this );
    }

    public static String[] getAllKeys()
    {
        return getConfigDataAccessor().getAllKeys();
    }

    public static Map<String, String> getCompleteConfigMap()
    {
        Map<String, String> config = new HashMap<String, String>();
        String[] keys = getConfigDataAccessor().getAllKeys();
        for ( String zKey : keys )
        {
            config.put( zKey, getString( zKey ) );
        }
        return config;
    }

    /**
     * @return !null - source of Config data.
     */
    public static String loadedFrom()
    {
        return getConfigDataAccessor().loadedFrom();
    }

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

    /**
     * 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
     */
    public static void setKeyValue( ConfigDataAccessor.Level pLevel, String pKey, String pValue )
            throws UnsupportedOperationException
    {
        getConfigDataAccessor().setKeyValue( pLevel, pKey, pValue );
    }

    /**
     * @param pKey not null or empty
     *
     * @return null if not found or value associated with key
     */
    public static String getString( String pKey )
    {
        return getConfigDataAccessor().getString( pKey );
    }

    /**
     * @param pKey not null or empty
     *
     * @return "" if not found or value associated with key, trimmed
     */
    public static String getStringTrimmed( String pKey )
    {
        return Strings.deNull( getString( pKey ) ).trim();
    }

    /**
     * @param pKey not null or empty
     *
     * @return !null / !"" value associated with key, trimmed
     */
    public static String getStringRequired( String pKey )
    {
        String value = getStringTrimmed( pKey );
        if ( value.length() != 0 )
        {
            return value;
        }
        throw new IllegalStateException( loadedFrom() + " should have a entry that defines: " + pKey );
    }

    /**
     * @param pKey not null or empty
     *
     * @return pDefault if not found (or empty) or value associated with key
     */
    public static String getString( String pKey, String pDefault )
    {
        String value = getStringTrimmed( pKey );
        return (value.length() != 0) ? value : pDefault;
    }

    /**
     * @param pKey not null or empty
     *
     * @return true or false as the trimmed value associated with key indicates, or pDefault if it is not parsable
     */
    public static boolean getBoolean( String pKey, boolean pDefault )
    {
        String value = getStringTrimmed( pKey );
        if ( value.length() != 0 )
        {
            return Boolean.valueOf( value );
        }
        return pDefault;
    }

    /**
     * @param pKey not null or empty
     *
     * @return parseInt of the trimmed value associated with key, or pDefault if it is not parsable
     */
    public static int getInteger( String pKey, int pDefault )
    {
        String value = getStringTrimmed( pKey );
        if ( value.length() != 0 )
        {
            try
            {
                return Integer.parseInt( value );
            }
            catch ( NumberFormatException e )
            {
                // Whatever...
            }
        }
        return pDefault;
    }

    public static class CachedConfigInt
    {
        private String mKey;
        private int mDefault;
        private Integer mValue = null;

        public CachedConfigInt( String pKey, int pDefault )
        {
            mKey = pKey;
            mDefault = pDefault;
        }

        public synchronized int getInteger()
        {
            if ( mValue == null )
            {
                mValue = Configuration.getInteger( mKey, mDefault );
            }
            return mValue;
        }
    }
}