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

import java.util.*;
import java.util.prefs.*;

import org.litesoft.core.util.*;
import org.litesoft.util.*;

public class ConfigAccessorFactoryPreferences implements ConfigDataAccessorFactory
{
    private ConfigDataAccessor mAccessor;

    public ConfigAccessorFactoryPreferences( String pLoadedFrom, ConfigDataAccessor.Level pLevel, Preferences pPrefs )
    {
        Utils.assertNotNull( "Preferences", pPrefs );
        Utils.assertNotNull( "Level", pLevel );
        mAccessor = new ConfigDataAccessorImpl( pLoadedFrom, pLevel, pPrefs );
    }

    public ConfigAccessorFactoryPreferences( String pLoadedFrom, String pPreferenceNodeKey_ApplicationName )
    {
        this( pLoadedFrom, ConfigDataAccessor.Level.MACHINE, Preferences.systemRoot().node( pPreferenceNodeKey_ApplicationName ) );
        // this( pLoadedFrom, ConfigDataAccessor.Level.USER, Preferences.userRoot().node( pPreferenceNodeKey_ApplicationName ) );
    }

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

    private static class ConfigDataAccessorImpl implements ConfigDataAccessor
    {
        private final String mLoadedFrom;
        private final ConfigDataAccessor.Level mLevel;
        private final Preferences mPrefs;
        private final Map<String, String> mRunLevelKeyValues = new HashMap<String, String>();

        public ConfigDataAccessorImpl( String pLoadedFrom, ConfigDataAccessor.Level pLevel, Preferences pPrefs )
        {
            mLoadedFrom = pLoadedFrom;
            mLevel = pLevel;
            mPrefs = pPrefs;
        }

        @Override
        public String loadedFrom()
        {
            return mLoadedFrom;
        }

        @Override
        public String loadedFromDirectory()
        {
            return null;
        }

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

        /**
         * All implementations MUST support RUN level, but may not 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 synchronized void setKeyValue( Level pLevel, String pKey, String pValue )
                throws UnsupportedOperationException
        {
            pKey = Utils.assertNotNullNotEmpty( "Key", pKey );
            Level zLevel = Utils.deNull( pLevel, Level.RUN );
            if ( Level.RUN.equals( zLevel ) )
            {
                if ( pValue == null )
                {
                    mRunLevelKeyValues.remove( pKey );
                }
                else
                {
                    mRunLevelKeyValues.put( pKey, pValue );
                }
                return;
            }
            if ( !zLevel.equals( mLevel ) )
            {
                throw new UnsupportedOperationException( "setKeyValue for Level '" + pLevel + "' not supported" );
            }
            if ( pValue == null )
            {
                try
                {
                    mPrefs.remove( pKey );
                }
                catch ( IllegalStateException e )
                {
                    // No Node so technically already Removed!
                }
            }
            else
            {
                try
                {
                    mPrefs.put( pKey, pValue );
                }
                catch ( IllegalStateException e )
                {
                    throw new PersistenceException( "Unable to setKeyValue( " + mLevel + ", \"" + pKey + "\", " + pValue + " ) keys for Preference Node: " + mPrefs, e );
                }
            }
            try
            {
                mPrefs.flush();
            }
            catch ( BackingStoreException e )
            {
                if ( pValue != null )
                {
                    pValue = "\"" + pValue + "\"";
                }
                throw new PersistenceException( "Unable to setKeyValue( " + mLevel + ", \"" + pKey + "\", " + pValue + " ) keys for Preference Node: " + mPrefs, e );
            }
        }

        @Override
        public synchronized String[] getAllKeys()
        {
            Set<String> zKeys = new HashSet<String>();
            try
            {
                String[] zPrefKeys = mPrefs.keys();
                zKeys.addAll( Arrays.asList( zPrefKeys ) );
            }
            catch ( BackingStoreException e )
            {
                throw new PersistenceException( "Unable to get keys for Preference Node: " + mPrefs, e );
            }
            catch ( IllegalStateException e )
            {
                // No Node == No Keys!
            }

            zKeys.addAll( mRunLevelKeyValues.keySet() );

            return zKeys.toArray( new String[zKeys.size()] );
        }

        /**
         * @param pKey not null or empty
         *
         * @return null if not found or value associated with key
         */
        @Override
        public synchronized String getString( String pKey )
        {
            pKey = Utils.assertNotNullNotEmpty( "Key", pKey );
            String rv = mRunLevelKeyValues.get( pKey );
            if ( rv == null )
            {
                try
                {
                    rv = mPrefs.get( pKey, null );
                }
                catch ( IllegalStateException e )
                {
                    // No Node == No Value -> null!
                }
            }
            return rv;
        }
    }
}