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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.ui_1_5.*;

public class InterceptingProxyExternalization implements ExternalizationInterface
{
    private ExternalizationInterface mProxied;
    protected Handler mCommons = new Handler();
    protected Handler mLabelAndInputs = new Handler();
    protected Handler mActions = new Handler();
    protected Handler mErrors = new Handler();

    private InterceptingProxyExternalization( ExternalizationInterface pProxied, Handler pCommons, //
                                              Handler pLabelAndInputs, Handler pAction, Handler pError )
    {
        this( pProxied );
        mCommons.addAll( pCommons );
        mLabelAndInputs.addAll( pLabelAndInputs );
        mActions.addAll( pAction );
        mErrors.addAll( pError );
    }

    public InterceptingProxyExternalization( ExternalizationInterface pProxied )
    {
        mProxied = (pProxied != null) ? pProxied : UnresolvedExternalization.INSTANCE;
    }

    public InterceptingProxyExternalization( ExternalizationInterface pProxied, String... pKeyResolvedPairs )
    {
        this( pProxied );
        add( pKeyResolvedPairs );
    }

    public InterceptingProxyExternalization( ExternalizationInterface pProxied,
                                             Map<String, String> pKeyResolvedPairs )
    {
        this( pProxied );
        add( pKeyResolvedPairs );
    }

    public InterceptingProxyExternalization add( String pKey, String pResolved )
    {
        mCommons.add( pKey, pResolved );
        return this;
    }

    public InterceptingProxyExternalization addTooltip( String pKey, String pResolved )
    {
        mCommons.addTooltip( pKey, pResolved );
        return this;
    }

    public InterceptingProxyExternalization add( String... pKeyResolvedPairs )
    {
        mCommons.add( pKeyResolvedPairs );
        return this;
    }

    public InterceptingProxyExternalization add( Map<String, String> pKeyResolvedPairs )
    {
        mCommons.add( pKeyResolvedPairs );
        return this;
    }

    public InterceptingProxyExternalization addCommon( Entry pEntry )
    {
        mCommons.add( pEntry );
        return this;
    }

    public InterceptingProxyExternalization add( Label pEntry )
    {
        mLabelAndInputs.add( pEntry );
        return this;
    }

    public InterceptingProxyExternalization add( Action pEntry )
    {
        mActions.add( pEntry );
        return this;
    }

    public InterceptingProxyExternalization add( Input pEntry )
    {
        mLabelAndInputs.add( pEntry );
        return this;
    }

    public InterceptingProxyExternalization add( Error pEntry )
    {
        mErrors.add( pEntry );
        return this;
    }

    public InterceptingProxyExternalization add( String pKey, String pResolved, String pTooltip )
    {
        addCommon( new Common( pKey, pResolved, pTooltip ) );
        return this;
    }

    public InterceptingProxyExternalization addLabel( String pLabelID, String pResolved )
    {
        add( new Label( pLabelID, pResolved ) );
        return this;
    }

    public InterceptingProxyExternalization addAction( String pActionID, String pResolved )
    {
        add( new Action( pActionID, pResolved ) );
        return this;
    }

    public InterceptingProxyExternalization addAction( String pActionID, String pResolved, String pTooltip )
    {
        add( new Action( pActionID, pResolved, pTooltip ) );
        return this;
    }

    public InterceptingProxyExternalization addInput( String pInputID, String pResolved )
    {
        add( new Input( pInputID, pResolved ) );
        return this;
    }

    public InterceptingProxyExternalization addInput( String pInputID, String pResolved, String pTooltip )
    {
        add( new Input( pInputID, pResolved, pTooltip ) );
        return this;
    }

    public InterceptingProxyExternalization addError( String pErrorID, String pResolved )
    {
        add( new Error( pErrorID, pResolved ) );
        return this;
    }

    public InterceptingProxyExternalization addAll( Collector pCollector )
    {
        if ( pCollector != null )
        {
            for ( Entry entry : pCollector.getEntries() )
            {
                switch ( entry.getType() )
                {
                    case Common:
                        mCommons.add( entry );
                        break;
                    case Label:
                        mLabelAndInputs.add( entry );
                        break;
                    case Action:
                        mActions.add( entry );
                        break;
                    case Input:
                        mLabelAndInputs.add( entry );
                        break;
                    case Error:
                        mErrors.add( entry );
                        break;
                    default:
                        throw new IllegalStateException( "What is a Entry Type: " + entry.getType() );
                }
            }
        }
        return this;
    }

    private class Handler implements ExternalizationSupport
    {
        public synchronized void addAll( Handler pEntries )
        {
            mEntries.putAll( pEntries.mEntries );
        }

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

        private void LLadd( String pKey, String pResolved )
        {
            mEntries.put( pKey, Entry.normalizeResolved( pResolved ) );
        }

        public synchronized String getEntry( String pKey )
        {
            return mEntries.get( Strings.deNull( pKey ).trim() );
        }

        public String getTooltip( String pKey )
        {
            return getEntry( Strings.deNull( pKey ).trim() + TOOLTIP );
        }

        public String getEntry( String pKey, Handler pCommon )
        {
            String rv = getEntry( pKey );
            return (rv != null) ? rv : pCommon.getEntry( pKey );
        }

        public String getTooltip( String pKey, Handler pCommon )
        {
            String rv = getTooltip( pKey );
            return (rv != null) ? rv : pCommon.getTooltip( pKey );
        }

        public synchronized void add( String pKey, String pResolved )
        {
            LLadd( Strings.assertNotNullNotEmpty( "Key", pKey ), pResolved );
        }

        public synchronized void addTooltip( String pKey, String pResolved )
        {
            LLadd( Strings.assertNotNullNotEmpty( "Key", pKey ) + TOOLTIP, pResolved );
        }

        public synchronized void add( Entry pEntry )
        {
            if ( pEntry != null )
            {
                add( pEntry.getKey(), pEntry.getResolved() );
                String tip = pEntry.getTooltip();
                if ( tip != null )
                {
                    addTooltip( pEntry.getKey(), tip );
                }
            }
        }

        public synchronized void add( String... pKeyResolvedPairs )
        {
            if ( pKeyResolvedPairs != null )
            {
                if ( (pKeyResolvedPairs.length & 1) != 0 )
                {
                    throw new IllegalArgumentException(
                            "KeyResolvedPairs not Pairs, length: " + pKeyResolvedPairs.length );
                }
                for ( int i = 0; i < pKeyResolvedPairs.length; i++ )
                {
                    String key = Strings.noEmpty( pKeyResolvedPairs[i] );
                    if ( key == null )
                    {
                        throw new IllegalArgumentException( "KeyResolvedPair[" + i + "] was null or empty" );
                    }
                    LLadd( key, pKeyResolvedPairs[++i] );
                }
            }
        }

        public synchronized void add( Map<String, String> pKeyResolvedPairs )
        {
            if ( pKeyResolvedPairs != null )
            {
                for ( String keyEntry : pKeyResolvedPairs.keySet() )
                {
                    String key = Strings.noEmpty( keyEntry );
                    if ( key == null )
                    {
                        throw new IllegalArgumentException( "KeyResolvedPair contained a null or empty key" );
                    }
                    LLadd( key, pKeyResolvedPairs.get( keyEntry ) );
                }
            }
        }
    }

    public ExternalizationInterface addContext( String pRootType )
    {
        ExternalizationInterface newEI = mProxied.addContext( pRootType );
        return (mProxied == newEI) ? this : //
               new InterceptingProxyExternalization( newEI, mCommons, mLabelAndInputs, mActions, mErrors );
    }

    public String resolveLabel( String pLabelID )
    {
        String entry = mLabelAndInputs.getEntry( pLabelID, mCommons );
        return (entry != null) ? entry : mProxied.resolveLabel( pLabelID );
    }

    public String resolveAction( String pActionID )
    {
        String entry = mActions.getEntry( pActionID, mCommons );
        return (entry != null) ? entry : mProxied.resolveAction( pActionID );
    }

    public String resolveActionTooltip( String pActionID )
    {
        String entry = mActions.getTooltip( pActionID, mCommons );
        return (entry != null) ? entry : mProxied.resolveActionTooltip( pActionID );
    }

    public String resolveInputTooltip( String pInputID )
    {
        String entry = mLabelAndInputs.getTooltip( pInputID, mCommons );
        return (entry != null) ? entry : mProxied.resolveInputTooltip( pInputID );
    }

    public String resolveError( String pErrorID )
    {
        String entry = mErrors.getEntry( pErrorID, mCommons );
        return (entry != null) ? entry : mProxied.resolveError( pErrorID );
    }
}