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

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

import java.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( Confirm.isNotNull( "ProxyForAccessorFactory", pProxyForAccessorFactory ), null );
    }

    public ServerConfigDataAccessorFactoryProxy( ConfigDataAccessor pProxyForAccessor ) {
        this( null, Confirm.isNotNull( "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 = ConstrainTo.significantOrNull( Utils.toString( zEntry.getKey() ) );
                    String zValue = ConstrainTo.significantOrNull( 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 : ConstrainTo.firstNonNull( 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 );
        }
    }
}