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

import java.io.*;
import java.util.*;

import org.litesoft.core.typeutils.*;

public class HintManager implements Hintable,
                                    Serializable
{
    private static final long serialVersionUID = 1L;

    public static final HintManager NULL = new NullHintManager();

    public HintManager addAll( Hintable pHintable )
    {
        return ((pHintable != null) && pHintable.anyHints()) ? LLaddAll( pHintable.getHints() ) : this;
    }

    public HintManager addAll( Hint[] pHints )
    {
        return (pHints != null) ? LLaddAll( pHints ) : this;
    }

    private HintManager LLaddAll( Hint[] pHints )
    {
        HintManager rv = this;
        for ( int i = 0; i < pHints.length; i++ )
        {
            Hint hint = pHints[i];
            if ( hint != null )
            {
                (rv = rv.aboutToAdd()).addHint( hint );
            }
        }
        return rv;
    }

    private Map<String, Hint> mNamesToHints = new HashMap<String, Hint>();

    public HintManager aboutToAdd()
    {
        return this;
    }

    public boolean anyHints()
    {
        return !mNamesToHints.isEmpty();
    }

    private transient Hint[] mHintsAsArray = null;

    /**
     * @return !null and No Nulls
     */
    public synchronized Hint[] getHints()
    {
        if ( mHintsAsArray == null )
        {
            mHintsAsArray = mNamesToHints.isEmpty() ? EMPTY_ARRAY : toArray();
        }
        return mHintsAsArray;
    }

    private Hint[] toArray()
    {
        Hint[] rv = new Hint[mNamesToHints.size()];
        int rvAt = 0;
        for ( Iterator<Hint> it = mNamesToHints.values().iterator(); it.hasNext(); )
        {
            rv[rvAt++] = it.next();
        }
        return rv;
    }

    /**
     * Return the value associated with pName if any.
     *
     * @param pName !null or empty
     *
     * @return null or value associated with pName
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public String getHintValue( String pName )
            throws IllegalArgumentException
    {
        Hint cur = mNamesToHints.get( Strings.assertNotNullNotEmpty( "Name", pName ) );
        return (cur != null) ? cur.getValue() : null;
    }

    /**
     * Return the value associated with pName if any.
     *
     * @param pName !null or empty
     * @param pDefaultIfNullOrEmpty return value if the normally found value was null or empty
     *
     * @return value associated with pName or default if the normally found value was null or empty
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public String getHintValue( String pName, String pDefaultIfNullOrEmpty )
            throws IllegalArgumentException
    {
        String rv = getHintValue( pName );
        return Strings.isNotNullOrEmpty( rv ) ? rv : pDefaultIfNullOrEmpty;
    }

    /**
     * Add the Hint (if pValue is not null or empty) and return any previous Hint's Value with the same pName
     *
     * @param pName !null or empty
     *
     * @return null or previous Hint's Value with the same pName
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public String addHint( String pName, String pValue )
            throws IllegalArgumentException
    {
        if ( null == (pValue = Strings.noEmpty( pValue )) )
        {
            return null;
        }
        return addHint( new Hint( pName, pValue ) );
    }

    /**
     * Add the Hint (if it was not null) and return any previous Hint's Value with the same Hint Name
     *
     * @return null or previous Hint's Value with the same Hint Name
     */
    public synchronized String addHint( Hint pHint )
    {
        if ( pHint != null )
        {
            mHintsAsArray = null;
            Hint prev = mNamesToHints.put( pHint.getName(), pHint );
            if ( prev != null )
            {
                return prev.getValue();
            }
        }
        return null;
    }

    /**
     * Remove the Hint indicated by pName and return its Value
     *
     * @param pName !null or empty
     *
     * @return null if not found or removed Hint's Value
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public synchronized String removeHint( String pName )
            throws IllegalArgumentException
    {
        Hint prev = mNamesToHints.remove( Strings.assertNotNullNotEmpty( "Name", pName ) );
        if ( (prev != null) )
        {
            mHintsAsArray = null;
            return prev.getValue();
        }
        return null;
    }

    public static class NullHintManager extends HintManager
    {
        private static final long serialVersionUID = 1L;

        public HintManager aboutToAdd()
        {
            return new HintManager();
        }

        public String addHint( Hint pHint )
        {
            throw new IllegalStateException( "Attempt to add a Hint to the NULL HintManager" );
        }
    }
}