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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.core.util.*;
import org.litesoft.uispecification.*;

import com.google.gwt.core.client.*;
import com.google.gwt.dom.client.*;
import com.google.gwt.event.dom.client.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

import java.util.*;

import static org.litesoft.uispecification.FormWidgetAspectCtrl.*;
import static org.litesoft.uispecification.FormWidgetCtrl.*;

public class FormEngine implements ClickHandler {
    public abstract static class CtrlProxy implements Enableable {
        private FormWidgetCtrl mFormWidgetCtrl;

        protected CtrlProxy( FormWidgetCtrl pFormWidgetCtrl ) {
            mFormWidgetCtrl = pFormWidgetCtrl;
        }

        abstract public boolean isHidden();

        abstract public void setHidden( boolean pHide );

        public boolean isVisible( FormState pFormState ) {
            return mFormWidgetCtrl.getVisible().satisfiedBy( pFormState );
        }

        public boolean isEnabled( FormState pFormState ) {
            return mFormWidgetCtrl.getEnable().satisfiedBy( pFormState );
        }

        public boolean isSearchFilter() {
            return mFormWidgetCtrl.isSearchFilter();
        }

        public boolean isEditRequired() {
            return mFormWidgetCtrl.isEditRequired();
        }
    }

    private static final String EDITING_SECTION_TITLE_TEXT = "Edit ";

    public enum Mode {
        Search( true, false, "Search for " ) {
            @Override
            public void update( FormState pFormState ) {
                pFormState.setModeSearch();
            }

            @Override
            public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler ) {
                return ClearButton.factory().disabled().add( pClickHandler ).create();
            }

            @Override
            public boolean isEditRequired( CtrlProxy pCtrlProxy ) {
                return false;
            }
        },
        NewFromSearch( true, false, "Create " ) {
            @Override
            public void update( FormState pFormState ) {
                pFormState.setModeEditNew();
            }

            @Override
            public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler ) {
                return SearchButton.factory().add( pClickHandler ).create();
            }
        },
        EditFromSearch( true, true, EDITING_SECTION_TITLE_TEXT ) {
            @Override
            public void update( FormState pFormState ) {
                pFormState.setModeEditExisting();
            }

            @Override
            public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler ) {
                return SearchButton.factory().add( pClickHandler ).create();
            }
        },
        EditRegular( false, true, EDITING_SECTION_TITLE_TEXT ) {
            @Override
            public void update( FormState pFormState ) {
                pFormState.setModeEditExisting();
            }

            @Override
            public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler ) {
                return null;
            }
        },
        ViewFromSearch( false, true, "Confirm " ) {
            @Override
            public void update( FormState pFormState ) {
                pFormState.setModeView();
            }

            @Override
            public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler ) {
                return SearchButton.factory().add( pClickHandler ).create();
            }

            @Override
            public boolean isEditRequired( CtrlProxy pCtrlProxy ) {
                return false;
            }
        },
        ViewRegular( false, true, "" ) {
            @Override
            public void update( FormState pFormState ) {
                pFormState.setModeView();
            }

            @Override
            public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler ) {
                return null;
            }

            @Override
            public boolean isEditRequired( CtrlProxy pCtrlProxy ) {
                return false;
            }
        };

        private boolean mMonitorSearchFields, mClearFields;
        private String mSectionTitleText;

        Mode( boolean pMonitorSearchFields, boolean pClearFields, String pSectionTitleText ) {
            mMonitorSearchFields = pMonitorSearchFields;
            mClearFields = pClearFields;
            mSectionTitleText = pSectionTitleText;
        }

        abstract public void update( FormState pFormState );

        public boolean isEditing() {
            return EDITING_SECTION_TITLE_TEXT.equals( mSectionTitleText );
        }

        public boolean isVisible( CtrlProxy pCtrlProxy, FormState pFormState ) {
            return pCtrlProxy.isVisible( pFormState );
        }

        public boolean isEnabled( CtrlProxy pCtrlProxy, FormState pFormState ) {
            return pCtrlProxy.isEnabled( pFormState );
        }

        public boolean isSearchFilter( CtrlProxy pCtrlProxy ) {
            return mMonitorSearchFields && pCtrlProxy.isSearchFilter();
        }

        public boolean isEditRequired( CtrlProxy pCtrlProxy ) {
            return pCtrlProxy.isEditRequired();
        }

        public final boolean shouldMonitorSearchFields() {
            return mMonitorSearchFields;
        }

        public final boolean shouldClearFields() {
            return mClearFields;
        }

        public final String getSectionTitleText() {
            return mSectionTitleText;
        }

        abstract public ButtonBase createSectionTitleRightButton( ClickHandler pClickHandler );
    }

    private FormState mFormState = new FormState();

    private List<ButtonBase> mDefaultButtons = new ArrayList<ButtonBase>();

    private LeftCenterRightHorizontalPanel mSectionTitlePanel = null;
    private OurLabel mSectionTitleLabel = null;
    private ButtonBase mSectionTitleButton = null;
    private String mSectionTitlePrefix, mSectionTitleSuffix;
    private Map<Mode, String> mSectionTitleCustomText = null;

    protected WidgetCtrlMap mWidgetCtrlMap;
    protected Mode mMode;
    private IFormComponent.Listener.Factory mListenerFactory;

    public FormEngine( WidgetCtrlMap pWidgetCtrlMap, Mode pInitialMode, IFormComponent.Listener.Factory pListenerFactory ) {
        Objects.assertNotNull( "WidgetCtrlMap", mWidgetCtrlMap = pWidgetCtrlMap );
        mMode = (pInitialMode != null) ? pInitialMode : Mode.ViewRegular;
        mListenerFactory = (pListenerFactory != null) ? pListenerFactory : NoOpFormListenerFactory.INSTANCE;
    }

    public boolean isEditRequired( String pName ) {
        return mWidgetCtrlMap.get( pName ).isEditRequired();
    }

    public boolean isSearchFilter( String pName ) {
        return mWidgetCtrlMap.get( pName ).isSearchFilter();
    }

    public boolean isUnique( String pName ) {
        return mWidgetCtrlMap.get( pName ).isUnique();
    }

    public void setSectionTitleCustomText( Mode pMode, String pText ) {
        Objects.assertNotNull( "Mode", pMode );
        if ( pText == null ) {
            if ( mSectionTitleCustomText != null ) {
                mSectionTitleCustomText.remove( pMode );
            }
            return;
        }
        if ( mSectionTitleCustomText == null ) {
            mSectionTitleCustomText = new HashMap<Mode, String>();
        }
        mSectionTitleCustomText.put( pMode, pText );
    }

    /**
     * May only create a SINGLE Section Title
     */
    public Widget createSectionTitle( String pPrefix, String pSuffix ) {
        mSectionTitlePrefix = Strings.deNull( pPrefix );
        mSectionTitleSuffix = Strings.deNull( pSuffix );
        mSectionTitleLabel = new OurLabel( getSectionTitleText(), false );
        mSectionTitlePanel = new LeftCenterRightHorizontalPanel().style( "SectionTitle" );
        mSectionTitlePanel.addCenter( mSectionTitleLabel );
        mSectionTitlePanel.addRight( createSectionTitleModeButton() );
        return mSectionTitlePanel;
    }

    private void LLsectionTitleUpdate() {
        if ( mSectionTitlePanel != null ) {
            String zText = getSectionTitleText();
            Widget zWidget = createSectionTitleModeButton();
            mSectionTitleLabel.setText( zText );
            mSectionTitlePanel.getRightContainer().clear();
            mSectionTitlePanel.addRight( zWidget );
            mSectionTitlePanel.relayoutFromHereDown();
        }
    }

    private void LLsectionTitleOnChange( boolean pAnyChanges ) {
        if ( Mode.Search.equals( mMode ) && (mSectionTitleButton != null) ) {
            mSectionTitleButton.setEnabled( pAnyChanges );
        }
    }

    @Override
    public void onClick( ClickEvent event ) {
        if ( Mode.Search.equals( mMode ) ) // Clear Button
        {
            resetForm();
            LLsectionTitleOnChange( mFormState.hasChanges() );
        } else // Search Button
        {
            setMode( Mode.Search );
        }
    }

    private Widget createSectionTitleModeButton() {
        mSectionTitleButton = mMode.createSectionTitleRightButton( this );
        return (mSectionTitleButton != null) ? mSectionTitleButton : new TransparentImage();
    }

    private String getSectionTitleText() {
        return mSectionTitlePrefix + getSectionTitleModeText() + mSectionTitleSuffix;
    }

    private String getSectionTitleModeText() {
        if ( mSectionTitleCustomText != null ) {
            String rv = mSectionTitleCustomText.get( mMode );
            if ( rv != null ) {
                return rv;
            }
        }
        return mMode.getSectionTitleText();
    }

    /**
     * May only create a SINGLE Section Title
     */
    public Widget createSectionTitle( String pSuffix ) {
        return createSectionTitle( "", pSuffix );
    }

    public final void resetForm() {
        LLresetForm( true );
    }

    protected void LLresetForm( boolean pResetAllValues ) {
        LLresetComponents( pResetAllValues );
        setFocus();
    }

    protected void LLresetComponents( boolean pResetAllValues ) {
        Collection<ProxyExtendedListener> zListeners = mListeners.values();
        for ( ProxyExtendedListener zListener : zListeners ) {
            if ( pResetAllValues || !mMode.isSearchFilter( zListener ) ) {
                zListener.reset( Mode.Search == mMode ); // Search toOrig, everyone else toLastSetValue
            } else {
                zListener.makeNonOrigChanged();
            }
        }
        mFormState.setErrorChangeState( scanForErrorChangeState( zListeners ) );
        LLupdateControls();
    }

    public void setFocus() {
        Scheduler.get().scheduleDeferred( mFocusCommand );
    }

    private Command mFocusCommand = new Command() {
        @Override
        public void execute() {
            for ( IFormComponent zComponent : mComponents ) {
                if ( !UtilsGwt.isHidden( (Widget) zComponent ) ) // todo: this does NOT check the Hierarchy for Visibility!!!
                {
                    if ( zComponent.isEnabled() ) {
                        zComponent.setFocus();
                        return;
                    }
                }
            }
            for ( ButtonBase zButton : mDefaultButtons ) {
                if ( zButton.isEnabled() ) {
                    zButton.setFocus( true );
                    return;
                }
            }
            if ( mSectionTitleButton != null ) {
                mSectionTitleButton.setFocus( true );
            }
        }
    };

    protected final void updateHiders( String pComponentName ) {
        Hider zHider = mNamedHiders.get( pComponentName );
        if ( zHider != null ) {
            zHider.update();
        }
    }

    protected Map<String, Hider> mNamedHiders = new HashMap<String, Hider>();

    private void register( String pComponentName, HiderBridgeBridge pBridge ) {
        Hider zExistingHider = mNamedHiders.get( pComponentName );
        if ( zExistingHider == null ) {
            mNamedHiders.put( pComponentName, pBridge );
        } else {
            mNamedHiders.put( pComponentName, new HiderPair( pBridge, zExistingHider ) );
        }
    }

    protected List<CtrlProxy> mCtrlProxys = new ArrayList<CtrlProxy>();
    protected Map<String, CtrlProxy> mNamedCtrlProxys = new HashMap<String, CtrlProxy>();

    private void register( String pName, CtrlProxy pCtrlProxy ) {
        mCtrlProxys.add( pCtrlProxy );
        if ( pName != null ) {
            mNamedCtrlProxys.put( pName, pCtrlProxy );
        }
    }

    protected List<IFormComponent> mComponents = new ArrayList<IFormComponent>();
    protected Map<String, IFormComponent> mNamedComponents = new HashMap<String, IFormComponent>();
    protected Map<IFormComponent, String> mComponentNames = new HashMap<IFormComponent, String>();
    protected Map<IFormComponent, ProxyExtendedListener> mListeners = new HashMap<IFormComponent, ProxyExtendedListener>();

    private void register( String pName, FormWidgetCtrl pFormWidgetCtrl, IFormComponent pComponent, IFormComponent.Listener pListener ) {
        ProxyExtendedListener zExt = new ProxyExtendedListener( pName, pListener, pFormWidgetCtrl );
        register( pName, zExt );
        mComponents.add( pComponent );
        mListeners.put( pComponent, zExt );
        pComponent.addFormComponentListener( zExt );
        if ( pName != null ) {
            addNamedComponent( pName, pComponent );
        }
    }

    protected void addNamedComponent( String pName, IFormComponent pComponent ) {
        mNamedComponents.put( pName, pComponent );
        mComponentNames.put( pComponent, pName );
    }

    public Set<String> getNamedComponentNames() {
        return new HashSet<String>( mNamedComponents.keySet() );
    }

    public String getComponentName( IFormComponent pComponent ) {
        return mComponentNames.get( pComponent );
    }

    public IFormComponent getNamedComponent( String pName ) {
        return mNamedComponents.get( pName );
    }

    public IFormComponent getRequiredNamedComponent( String pName ) {
        IFormComponent zComponent = getNamedComponent( pName );
        if ( zComponent == null ) {
            throw new NoSuchElementException( "No Form Component w/ name: " + pName );
        }
        return zComponent;
    }

    public Object getNamedComponentValue( String pName )
            throws NoSuchElementException {
        return mListeners.get( getRequiredNamedComponent( pName ) ).getCurValue();
    }

    public void setNamedComponentValue( String pName, Object pValue )
            throws NoSuchElementException {
        mListeners.get( getRequiredNamedComponent( pName ) ).setCurValue( pValue );
        updateControls();
    }

    public void setNamedComponentValueAsUser( String pName, Object pValue )
            throws NoSuchElementException {
        IFormComponent zComponent = getRequiredNamedComponent( pName );
        ProxyExtendedListener zListener = mListeners.get( zComponent );
        zListener.setCurValueAsUser( pValue );
        updateControls();
    }

    public void setNamedComponentError( String pName, String pError )
            throws NoSuchElementException {
        getRequiredNamedComponent( pName ).setError( pError );
        updateControls();
    }

    public void setNamedComponentEnabled( String pName, boolean pEnabled )
            throws NoSuchElementException {
        getRequiredNamedComponent( pName ).setEnabled( pEnabled );
        updateControls();
    }

    public void setNamedComponentChanged( String pName, boolean pChanged ) {
        IFormComponent zComponent = getRequiredNamedComponent( pName );
        zComponent.setValueChanged( pChanged );
        LLchangeOccurredOn( pName, zComponent, pChanged );
        updateControls();
    }

    private boolean updateControls() {
        ErrorChangeState zOrigErrorChangeState = mFormState.getErrorChangeState();
        ErrorChangeState zNewErrorChangeState = mFormState.setErrorChangeState( scanForErrorChangeState( mListeners.values() ) );

        if ( zOrigErrorChangeState != zNewErrorChangeState ) {
            LLupdateControls();
        }
        return (zOrigErrorChangeState.hasChanges() != zNewErrorChangeState.hasChanges());
    }

    private void LLupdateControls() {
        for ( CtrlProxy zCtrlProxy : mCtrlProxys ) {
            if ( mMode.isVisible( zCtrlProxy, mFormState ) ) {
                zCtrlProxy.setHidden( false );
                zCtrlProxy.setEnabled( mMode.isEnabled( zCtrlProxy, mFormState ) );
            } else {
                zCtrlProxy.setHidden( true );
                zCtrlProxy.setEnabled( false );
            }
        }
    }

    private Widget addHideable( String pName, FormWidgetCtrl pFormWidgetCtrl, Widget pWidget ) {
        register( pName, new WidgetCtrlProxy( pWidget, pFormWidgetCtrl ) );
        return pWidget;
    }

    public Widget addHideable( String pName, Widget pWidget ) {
        return addHideable( pName, mWidgetCtrlMap.get( pName ), pWidget );
    }

    public Widget addHideable( FormWidgetCtrl pFormWidgetCtrl, Widget pWidget ) {
        return addHideable( null, pFormWidgetCtrl, pWidget );
    }

    public Widget addComponentDrivenHideable( Widget pWidget, String pComponentName, HiderBridge pHiderBridge ) {
        Objects.assertNotNull( "Widget", pWidget );
        Objects.assertNotNull( "ComponentName", pComponentName );
        Objects.assertNotNull( "HiderBridge", pHiderBridge );
        register( pComponentName, new HiderBridgeBridge( pWidget, pHiderBridge, getRequiredNamedComponent( pComponentName ) ) );
        return pWidget;
    }

    private FocusWidget addControlled( String pName, FormWidgetCtrl pFormWidgetCtrl, FocusWidget pWidget ) {
        register( pName, new FocusWidgetCtrlProxy( pWidget, pFormWidgetCtrl ) );
        return pWidget;
    }

    public FocusWidget addControlled( FormWidgetCtrl pFormWidgetCtrl, FocusWidget pWidget ) {
        return addControlled( null, pFormWidgetCtrl, pWidget );
    }

    public FocusWidget addControlled( String pName, FocusWidget pWidget ) {
        return addControlled( pName, mWidgetCtrlMap.get( pName ), pWidget );
    }

    private ButtonBase addButton( String pName, FormWidgetCtrl pFormWidgetCtrl, ButtonBase pButton ) {
        addControlled( pName, pFormWidgetCtrl, pButton );
        return pButton;
    }

    public ButtonBase addButton( FormWidgetCtrl pFormWidgetCtrl, ButtonBase pButton ) {
        return addButton( null, pFormWidgetCtrl, pButton );
    }

    public ButtonBase addButton( boolean pDefault, FormWidgetCtrl pFormWidgetCtrl, ButtonBase pButton ) {
        if ( pDefault ) {
            mDefaultButtons.add( pButton );
        }
        return addButton( pFormWidgetCtrl, pButton );
    }

    public ButtonBase addButton( String pName, ButtonBase pButton ) {
        return addButton( pName, mWidgetCtrlMap.get( pName ), pButton );
    }

    public ButtonBase addEditChangeButton( ButtonBase pButton ) {
        return addButton( Visible( Edit ).enable( Edit_Changes ), pButton );
    }

    public ButtonBase addEditRevertButton( ButtonBase pButton ) {
        pButton.addClickHandler( new ClickHandler() {
            @Override
            public void onClick( ClickEvent event ) {
                resetForm();
            }
        } );
        return addButton( Visible( Edit_Existing ).enable( Edit_Existing_Changes ), pButton );
    }

    public ButtonBase addEditSubmitButton( ButtonBase pButton ) {
        return addEditSubmitButton( false, pButton );
    }

    public ButtonBase addEditSubmitButton( boolean pDefault, ButtonBase pButton ) {
        return addButton( pDefault, Visible( Edit ).enable( Edit_NoErrors_Changes ), pButton );
    }

    public ButtonBase addEditSubmitNextButton( boolean pDefault, ViewDef pTarget, UriFragmentIdParams.ScreenParamsFactory pFactory ) {
        return addEditSubmitButton( pDefault, NextButton.factory().add( pTarget, pFactory ).create() );
    }

    public ButtonBase addExistingUnchangedButton( boolean pDefault, ButtonBase pButton ) {
        return addButton( pDefault, Visible( Existing ).enable( Existing_NoChanges ), pButton );
    }

    public ButtonBase addExistingUnchangedNextButton( boolean pDefault, ViewDef pTarget ) {
        return addExistingUnchangedButton( pDefault, NextButton.factory().add( pTarget ).create() );
    }

    public ButtonBase addExistingUnchangedNextButton( boolean pDefault, ViewDef pTarget, UriFragmentIdParams.ScreenParamsFactory pFactory ) {
        return addExistingUnchangedButton( pDefault, NextButton.factory().add( pTarget, pFactory ).create() );
    }

    private AbstractFormElement add( String pName, FormWidgetCtrl pFormWidgetCtrl, AbstractFormElement pField ) {
        register( pName, pFormWidgetCtrl, pField, mListenerFactory.createListenerFor( pName, pField ) );
        return pField;
    }

    public AbstractFormElement add( FormWidgetCtrl pFormWidgetCtrl, AbstractFormElement pField ) {
        return add( null, pFormWidgetCtrl, pField );
    }

    public AbstractFormElement add( String pName, boolean pRequired, AbstractFormElement pField ) {
        FormWidgetCtrl zFormWidgetCtrl = mWidgetCtrlMap.get( pName );
        if ( pRequired ) {
            zFormWidgetCtrl = zFormWidgetCtrl.required();
        }
        return add( pName, zFormWidgetCtrl, pField );
    }

    public AbstractFormElement add( String pName, AbstractFormElement pField ) {
        return add( pName, false, pField );
    }

    public AbstractFormElement add( AbstractFormElement pField ) {
        return add( null, false, pField );
    }

    public void initialize() {
        setMode( mMode );
    }

    public Mode getMode() {
        return mMode;
    }

    public void setMode( Mode pMode ) {
        (mMode = (pMode != null) ? pMode : Mode.ViewRegular).update( mFormState );
        LLsectionTitleUpdate();
        LLresetForm( mMode.shouldClearFields() );
        LLsectionTitleOnChange( mFormState.hasChanges() );
    }

    private void LLchangeOccurredOn( String pName, IFormComponent pComponent, boolean pChanged ) {
        changeOccurredOn( pName, pComponent, pChanged );
        updateHiders( pName );
        if ( updateControls() ) {
            LLsectionTitleOnChange( mFormState.hasChanges() );
        }
    }

    protected void changeOccurredOn( String pName, IFormComponent pComponent, boolean pChanged ) {
    }

    protected void blurOccurredOn( String pName, IFormComponent pComponent ) {
    }

    protected void focusOccuredOn( String pName, IFormComponent pComponent ) {
    }

    protected void enterPressedOn( String pName, IFormComponent pComponent, KeyboardKeyModifier pModifiers ) {
        for ( ButtonBase zButton : mDefaultButtons ) {
            if ( zButton.isEnabled() ) {
                DomEvent.fireNativeEvent( Document.get().createClickEvent( 0, 0, 0, 0, 0, false, false, false, false ), zButton );
            }
        }
    }

    public ErrorChangeState scanForErrorChangeState( Collection<ProxyExtendedListener> pListeners ) {
        ErrorChangeState zErrorChangeState = ErrorChangeState.NoErrors_NoChanges;
        for ( ProxyExtendedListener zListener : pListeners ) {
            if ( ErrorChangeState.Errors_Changes == (zErrorChangeState = zErrorChangeState.mergeToTrueFrom( zListener )) ) {
                break;
            }
        }
        return zErrorChangeState;
    }

    private static class WidgetCtrlProxy extends CtrlProxy {
        protected Widget mWidget;

        public WidgetCtrlProxy( Widget pWidget, FormWidgetCtrl pFormWidgetCtrl ) {
            super( pFormWidgetCtrl );
            mWidget = pWidget;
        }

        @Override
        public boolean isHidden() {
            return (mWidget != null) && UtilsGwt.isHidden( mWidget );
        }

        @Override
        public void setHidden( boolean pHide ) {
            if ( mWidget != null ) {
                UtilsGwt.setHidden( mWidget, pHide );
            }
        }

        @Override
        public boolean isEnabled() {
            return false;
        }

        @Override
        public void setEnabled( boolean pEnabled ) {
        }

        @Override
        public String toString() {
            return "Widget: " + ClassName.simple( mWidget );
        }
    }

    private static class FocusWidgetCtrlProxy extends CtrlProxy {
        private FocusWidget mWidget;

        public FocusWidgetCtrlProxy( FocusWidget pWidget, FormWidgetCtrl pFormWidgetCtrl ) {
            super( pFormWidgetCtrl );
            mWidget = pWidget;
        }

        @Override
        public boolean isHidden() {
            return (mWidget != null) && UtilsGwt.isHidden( mWidget );
        }

        @Override
        public void setHidden( boolean pHide ) {
            if ( mWidget != null ) {
                UtilsGwt.setHidden( mWidget, pHide );
            }
        }

        @Override
        public boolean isEnabled() {
            return (mWidget != null) && mWidget.isEnabled();
        }

        @Override
        public void setEnabled( boolean pEnabled ) {
            if ( mWidget != null ) {
                mWidget.setEnabled( pEnabled );
            }
        }

        @Override
        public String toString() {
            return "FocusWidget: " + ClassName.simple( mWidget );
        }
    }

    protected class ProxyExtendedListener extends CtrlProxy implements IFormComponent.Listener,
                                                                       ErrorChangeProvider {
        private String mName;
        private IFormComponent.Listener mProxied;
        private IFormComponent mComponent;
        private Object mOrigValue, mCurValue, mLastSetValue = null;
        boolean mLSVvalid = false;
        private boolean mChanged = false;

        public ProxyExtendedListener( String pName, IFormComponent.Listener pProxied, FormWidgetCtrl pFormWidgetCtrl ) {
            super( pFormWidgetCtrl );
            mName = pName;
            mProxied = (pProxied != null) ? pProxied : NoOpFormListener.INSTANCE;
        }

        private void clearLSV() {
            mLSVvalid = false;
            mLastSetValue = null;
        }

        private void setLSV( Object pLastSetValue ) {
            mLSVvalid = true;
            mLastSetValue = pLastSetValue;
        }

        private Object getBaseValue() {
            return mLSVvalid ? mLastSetValue : mOrigValue;
        }

        public boolean isChanged() {
            return mChanged;
        }

        public boolean isErrored() {
            return (mComponent != null) && mComponent.hasError();
        }

        public Object getCurValue() {
            return mCurValue;
        }

        public Object getOrigValue() {
            return mOrigValue;
        }

        @Override
        public void add( IFormComponent pComponent ) {
            mProxied.add( mComponent = pComponent );
            mOrigValue = mCurValue = getComponentCurrentValue();
            mChanged = false;
        }

        @Override
        public void remove( IFormComponent pComponent ) {
            mProxied.remove( pComponent );
            if ( pComponent == mComponent ) {
                mComponent = null;
            }
        }

        public void reset( boolean pToOrig ) {
            if ( pToOrig ) {
                clearLSV();
                LLreset( mOrigValue );
            } else {
                LLreset( getBaseValue() );
            }
        }

        private void LLreset( Object pResetToValue ) {
            if ( mComponent != null ) {
                mComponent.setCurrentValue( mCurValue = pResetToValue );
                adjustComponentState();
                updateHiders( mName );
            }
        }

        public void makeNonOrigChanged() {
            clearLSV();
            if ( mComponent != null ) {
                adjustComponentState();
            }
        }

        @Override
        public void changeOccurred() {
            if ( mComponent != null ) {
                mCurValue = getComponentCurrentValue();
                adjustComponentState();
                mProxied.changeOccurred();
                LLchangeOccurredOn( mName, mComponent, mChanged );
            }
        }

        @Override
        public void blurOccurred() {
            if ( mComponent != null ) {
                mComponent.setFocused( false );
                mProxied.blurOccurred();
                blurOccurredOn( mName, mComponent );
            }
        }

        @Override
        public void focusOccured() {
            if ( mComponent != null ) {
                mComponent.setFocused( true );
                mProxied.focusOccured();
                focusOccuredOn( mName, mComponent );
            }
        }

        @Override
        public void enterPressed( KeyboardKeyModifier pModifiers ) {
            if ( mComponent != null ) {
                mProxied.enterPressed( pModifiers );
                enterPressedOn( mName, mComponent, pModifiers );
            }
        }

        public void setCurValue( Object pNewValue ) {
            if ( mComponent != null ) {
                mComponent.setCurrentValue( pNewValue );
                setLSV( mCurValue = getComponentCurrentValue() );
                adjustComponentState();
                updateHiders( mName );
            }
        }

        public void setCurValueAsUser( Object pNewValue ) {
            if ( mComponent != null ) {
                mComponent.setCurrentValue( pNewValue );
                changeOccurred();
            }
        }

        @Override
        public boolean isHidden() {
            return (mComponent != null) && UtilsGwt.isHidden( (Widget) mComponent );
        }

        @Override
        public void setHidden( boolean pHide ) {
            if ( mComponent != null ) {
                UtilsGwt.setHidden( (Widget) mComponent, pHide );
            }
        }

        @Override
        public boolean isEnabled() {
            return (mComponent != null) && mComponent.isEnabled();
        }

        @Override
        public void setEnabled( boolean pEnabled ) {
            if ( mComponent != null ) {
                mComponent.setEnabled( pEnabled );
            }
        }

        private Object getComponentCurrentValue() {
            Object zValue = mComponent.getCurrentValue();
            if ( zValue instanceof SimpleKeyValuePair ) {
                zValue = ((SimpleKeyValuePair) zValue).getKey();
            }
            return zValue;
        }

        private void adjustComponentState() {
            mComponent.setValueChanged( mChanged = !Objects.areNonArraysEqual( getBaseValue(), mCurValue ) );
            mComponent.setError( errorIfRequired() );
        }

        private String errorIfRequired() {
            return (mMode.isEditRequired( this ) && isEmpty()) ? "Required Field" : null;
        }

        public boolean isEmpty() {
            if ( mCurValue != null ) {
                if ( !(mCurValue instanceof String) || (mCurValue.toString().trim().length() != 0) ) {
                    return false;
                }
            }
            return true;
        }

        @Override
        public String toString() {
            return "Field: " + mName;
        }
    }

    private interface Hider {
        public void update();
    }

    private static class HiderPair implements Hider {
        private Hider mHider1, mHider2;

        private HiderPair( Hider pHider1, Hider pHider2 ) {
            mHider1 = pHider1;
            mHider2 = pHider2;
        }

        @Override
        public void update() {
            mHider1.update();
            mHider2.update();
        }
    }

    private static class HiderBridgeBridge implements Hider {
        private Widget mWidget;
        private HiderBridge mHiderBridge;
        private IFormComponent mComponent;

        private HiderBridgeBridge( Widget pWidget, HiderBridge pHiderBridge, IFormComponent pComponent ) {
            mWidget = pWidget;
            mHiderBridge = pHiderBridge;
            mComponent = pComponent;
            update();
        }

        @Override
        public void update() {
            Object zCurrentValue = mComponent.getCurrentValue();
            boolean zHide = mHiderBridge.shouldBeHidden( zCurrentValue );
            UtilsGwt.setHidden( mWidget, zHide );
        }
    }
}