package com.esotericsoftware.scar.support;

import com.esotericsoftware.utils.*;

import java.util.*;

public class ParameterStore {
    private final Map<Object, Object> mData = new HashMap<Object, Object>();
    private final Map<Object, Object> mCachedResponses = new HashMap<Object, Object>();

    public ParameterStore( Map<Object, Object> pData ) {
        if ( pData != null ) {
            Object zValue;
            for ( Object key : pData.keySet() ) {
                if ( null != (zValue = normalizeValue( pData.get( key ) )) ) {
                    putNormalized( normalizeKey( key ), zValue );
                }
            }
        }
    }

    private synchronized Object getNormalized( Object pKey ) {
        return mData.get( pKey );
    }

    private synchronized void putNormalized( Object pKey, Object pValue ) {
        if ( pValue != null ) {
            mData.put( pKey, pValue );
        } else if ( null == mData.remove( pKey ) ) {
            return; // Nothing Changed
        }
        mCachedResponses.remove( pKey );
    }

    public synchronized void applySystemPropertyOverrides() {
        for ( String zKey : Parameter.reservedNames() ) {
            String zValue = System.getProperty( zKey );
            if ( zValue != null ) {
                putNormalized( normalizeKey( zKey ), zValue );
            }
        }
    }

    public synchronized Object[] keys() {
        return mData.keySet().toArray();
    }

    public Object get( Object pKey ) {
        return getNormalized( normalizeKey( pKey ) );
    }

    public void put( Object pKey, Object pValue ) {
        putNormalized( normalizeKey( pKey ), pValue );
    }

    private Object normalizeKey( Object pKey ) {
        if ( pKey instanceof String ) {
            return normalizeKey( pKey.toString() );
        }
        Util.assertNotNull( "key", pKey );
        return pKey;
    }

    private String normalizeKey( String pKey ) {
        Util.assertNotNull( "key", pKey = Util.noEmpty( pKey ) );
        return pKey.toLowerCase();
    }

    private Object normalizeValue( Object pValue ) {
        return (pValue instanceof String) ? Util.noEmpty( pValue.toString() ) : pValue;
    }

    public synchronized String ensureEntry( String pKey, DataConverter<String> pConverter, DataDefaulter<String> pDefaulter ) {
        Object zValue = mData.get( pKey = normalizeKey( pKey ) );
        if ( zValue == null ) {
            return (pDefaulter == null) ? null : putAndReturnValue( pKey, pDefaulter.createDefault() );
        }
        if ( pConverter != null ) {
            String zStrValue = pConverter.convert( zValue );
            if ( zValue.equals( zStrValue ) ) {
                return zStrValue;
            }
            if ( zStrValue != null ) {
                return putAndReturnValue( pKey, zStrValue );
            }
            if ( pDefaulter != null ) {
                return putAndReturnValue( pKey, pDefaulter.createDefault() );
            }
        }
        return zValue.toString(); // return a String form, BUT do not change the map!
    }

    private String putAndReturnValue( String pKey, String pValue ) {
        putNormalized( pKey, pValue );
        return pValue;
    }

    public String ensureEntryAsString( String pKey, final String pDefault ) {
        return ensureEntry( pKey, new DataConverter<String>() {
            @Override
            public String convert( Object zValue ) {
                if ( (zValue instanceof String) ) {
                    return zValue.toString();
                }
                return (zValue != null) ? zValue.toString() : null;
            }
        }, new DataDefaulter<String>() {
            @Override
            public String createDefault() {
                return pDefault;
            }
        } );
    }

    public String ensureEntry( String pKey, DataDefaulter<String> pDefaulter ) {
        return ensureEntry( pKey, null, pDefaulter );
    }

    public String ensureEntry( String pKey, final String pDefault ) {
        return ensureEntry( pKey, new DataDefaulter<String>() {
            @Override
            public String createDefault() {
                return pDefault;
            }
        } );
    }

    public <T> T getCachedWithConversion( Object pKey, DataConverter<T> pConverter ) {
        return getCachedWithConversion( pKey, pConverter, null );
    }

    public synchronized <T> T getCachedWithConversion( Object pKey, DataConverter<T> pConverter, DataDefaulter<T> pDefaulter ) {
        Object zValue = getCachedResponse( pKey );
        if ( zValue != null ) {
            //noinspection unchecked
            return (T) zValue;
        }
        zValue = get( pKey );
        T zConverted = null;
        if ( zValue != null ) {
            zConverted = pConverter.convert( zValue );
        } else if ( pDefaulter != null ) {
            zConverted = pDefaulter.createDefault();
        }
        if ( zConverted != null ) {
            addCachedResponse( pKey, zConverted );
        }
        return zConverted;
    }

    private <T> T getCachedResponse( Object pKey ) {
        //noinspection unchecked
        return (T) mCachedResponses.get( pKey );
    }

    private void addCachedResponse( Object pKey, Object pValue ) {
        mCachedResponses.put( pKey, pValue );
    }
}