// 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.util.*;

public class ServerConfigDataAccessorFactoryProxy implements ConfigDataAccessorFactory
{
    private final ConfigDataAccessorFactory mProxyForAccessorFactory;
    private final ConfigDataAccessor mProxyForAccessor;

    private ServerConfigDataAccessorFactoryProxy( ConfigDataAccessorFactory pFactory, ConfigDataAccessor pAccessor )
    {
        mProxyForAccessorFactory = pFactory;
        mProxyForAccessor = pAccessor;
    }

    public ServerConfigDataAccessorFactoryProxy( ConfigDataAccessorFactory pProxyForAccessorFactory )
    {
        this( Objects.assertNotNull( "ProxyForAccessorFactory", pProxyForAccessorFactory ), null );
    }

    public ServerConfigDataAccessorFactoryProxy( ConfigDataAccessor pProxyForAccessor )
    {
        this( null, Objects.assertNotNull( "ProxyForAccessor", pProxyForAccessor ) );
    }

    @Override
    public ConfigDataAccessor createConfigDataAccessor()
    {
        return new ConfigDataAccessorProxy( (mProxyForAccessorFactory == null) ? mProxyForAccessor : mProxyForAccessorFactory.createConfigDataAccessor() );
    }

    private static class ConfigDataAccessorProxy implements ConfigDataAccessor
    {
        private final ConfigDataAccessor mProxyFor;
        private Map<String, String> mSystemKeyValues = new HashMap<String, String>();

        private ConfigDataAccessorProxy( ConfigDataAccessor pProxyFor )
        {
            mProxyFor = pProxyFor;
            try
            {
                mSystemKeyValues.putAll( System.getenv() );
            }
            catch ( SecurityException e )
            {
                System.err.println( "Unable to access Environment Variables" );
            }
            try
            {
                Properties properties = System.getProperties();
                for ( Map.Entry<Object, Object> zEntry : properties.entrySet() )
                {
                    String zKey = Strings.noEmpty( Utils.toString( zEntry.getKey() ) );
                    String zValue = Strings.noEmpty( Utils.toString( zEntry.getValue() ) );
                    if ( (zKey != null) && (zValue != null) )
                    {
                        mSystemKeyValues.put( zKey, zValue );
                    }
                }
            }
            catch ( SecurityException e )
            {
                System.err.println( "Unable to access System Properties" );
            }
        }

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

        @Override
        public String[] getAllKeys()
        {
            Set<String> keys = new HashSet<String>( mSystemKeyValues.keySet() ); // Copy it for Mutation
            keys.addAll( Arrays.asList( mProxyFor.getAllKeys() ) );
            return keys.toArray( new String[keys.size()] );
        }

        @Override
        public String loadedFrom()
        {
            return mProxyFor.loadedFrom();
        }

        @Override
        public String loadedFromDirectory()
        {
            return mProxyFor.loadedFromDirectory();
        }

        @Override
        public Level[] getSetableSupportedLevels()
        {
            return mProxyFor.getSetableSupportedLevels();
        }

        @Override
        public void setKeyValue( Level pLevel, String pKey, String pValue )
                throws UnsupportedOperationException
        {
            synchronized ( mProxyFor )
            {
                mProxyFor.setKeyValue( pLevel, pKey, pValue ); // Will validate pKey
                mSkipKeysEqual.add( pKey );
            }
        }

        @Override
        public void overrideAllStartingWith( String pKeyPrefix, String pValue )
        {
            synchronized ( mProxyFor )
            {
                mProxyFor.overrideAllStartingWith( pKeyPrefix, pValue ); // Will validate pKeyPrefix
                mSkipKeysStartsWith.add( pKeyPrefix );
            }
        }

        @Override
        public String getString( String pKey )
        {
            synchronized ( mProxyFor )
            {
                String zValue = mProxyFor.getString( pKey ); // Will validate pKey
                return skip( pKey ) ? zValue : Strings.deNull( getSystemString( pKey ), zValue );
            }
        }

        private Set<String> mSkipKeysEqual = new HashSet<String>();
        private Set<String> mSkipKeysStartsWith = new HashSet<String>();

        private boolean skip( String pKey )
        {
            if ( mSkipKeysEqual.contains( pKey ) )
            {
                return true;
            }
            for ( String zKeyPrefix : mSkipKeysStartsWith )
            {
                if ( pKey.startsWith( zKeyPrefix ) )
                {
                    return true;
                }
            }
            return false;
        }

        private String getSystemString( String pKey )
        {
            return mSystemKeyValues.get( pKey );
        }
    }
}