package com.temp.client.foundation.widget.input.fieldsupport;

import java.util.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.user.client.ui.*;
import com.temp.client.foundation.util.*;
import com.temp.client.foundation.widget.input.*;
import com.temp.shared.*;
import com.temp.shared.externalization.*;
import com.temp.shared.utils.*;

/**
 * Common abstract helper for both the generated Widget and the Proxied versions of the InputField.
 */
public abstract class AbstractInputField<T> implements InputField<T>
{
    // Required to be set
    private String name;

    // The above must be set/changed BEFORE the widget is attached!

    // Optionally set
    private List<ValueValidator<T>> validators = new ArrayList<ValueValidator<T>>();
    private Set<ChangeListener<T>> changeListeners = new HashSet<ChangeListener<T>>();

    private boolean enabled = true;

    private State visibility = State.Visible;
    private StateInputField currentStyleState;

    private CompleteInputFieldAccessor<T> completeInputFieldAccessor;

    @Override
    public State getVisibility()
    {
        return visibility;
    }

    @Override
    public void setVisibility( State visibility )
    {
        visibility = ObjectUtils.deNull( visibility, State.Visible );
        Panel container = getContainer();
        if ( container != null )
        {
            this.visibility = visibility;
            container.setVisible( visibility != State.Invisible );
            UtilsGwt.setHidden( container, visibility == State.Cloaked );
        }
    }

    // Configuration Methods

    @Override
    public final String getName()
    {
        return name;
    }

    @Override
    public final void setName( String name )
    {
        assertBuildMode( "setName" );
        setValidatedName( Validate.noEmptyIdentifier( "Name", name ) );
    }

    @Override
    public final InputField<T> name( String name )
    {
        assertBuildMode( "name" );
        setValidatedName( Validate.noEmptyIdentifier( "Name", name ) );
        return this;
    }

    protected void setValidatedName( String name )
    {
        this.name = name;
    }

    /**
     * The 'Builder' to 'Run' state transition method fully constructs/populates the InputField's Widget / container.
     *
     * @return this for method chaining
     */
    @Override
    public final InputField<T> init( E13nResolver resolver )
    {
        Validate.notNull( "resolver", resolver );
        if ( name == null )
        {
            throw new IllegalStateException( "Unable to init, Name not set" );
        }
        assertBuildMode( "init" );

        resolver = new OptionallyPrefixingE13nResolver( name, resolver ); // add our name to keys!

        completeInputFieldAccessor = buildActualWidget( resolver );
        completeInputFieldAccessor.init( enabled, // propagate current enabled state
                                         new FocusChangedListener()
                                         {
                                             @Override
                                             public void focusChanged()
                                             {
                                                 processFocusChanged();
                                             }
                                         } );
        completeInputFieldAccessor.getInput().addChangeHandler( new ChangeHandler()
        {
            @Override
            public void onChange( ChangeEvent event )
            {
                processDataChanged();
            }
        } );
        return this;
    }

    @Override
    public final boolean isRunMode()
    {
        return (completeInputFieldAccessor != null);
    }

    @Override
    public final InputField<T> add( ChangeListener<T> changeListener )
    {
        if ( changeListener != null )
        {
            changeListeners.add( changeListener );
        }
        return this;
    }

    @Override
    public final boolean remove( ChangeListener<T> changeListener )
    {
        return (changeListener == null) ? false : changeListeners.remove( changeListener );
    }

    @Override
    public final void removeAllChangeListeners()
    {
        changeListeners.clear();
    }

    @Override
    public final ValueValidator<T>[] getValidators()
    {
        return ObjectUtils.cast( validators.isEmpty() ? ValueValidator.EMPTY_ARRAY : validators.toArray( new ValueValidator[validators.size()] ) );
    }

    @Override
    public final InputField<T> add( ValueValidator<T> validator )
    {
        if ( validator != null )
        {
            validators.add( validator );
            validatorAdded( validator );
        }
        return this;
    }

    @Override
    public final InputField<T> add( ValueValidator<T>... additionalValidators )
    {
        if ( additionalValidators != null )
        {
            for ( ValueValidator<T> validator : additionalValidators )
            {
                add( validator ); // null OK will be filter later
            }
        }
        return this;
    }

    abstract protected void validatorAdded( ValueValidator<T> validator );

    private Enableable getEnableable()
    {
        return completeInputFieldAccessor;
    }

    // Anytime Methods

    // For Enableable

    @Override
    public final boolean isEnabled()
    {
        Enableable enableable = getEnableable();
        return (enableable != null) ? enableable.isEnabled() : enabled;
    }

    @Override
    public final void setEnabled( boolean enable )
    {
        enabled = enable;
        Enableable enableable = getEnableable();
        if ( enableable != null )
        {
            enableable.setEnabled( enable );
        }
    }

    @Override
    public final InputField<T> enable()
    {
        setEnabled( true );
        return this;
    }

    @Override
    public final InputField<T> disable()
    {
        setEnabled( false );
        return this;
    }

    // For Visible

    @Override
    public final boolean isVisible()
    {
        return State.Visible == getVisibility();
    }

    @Override
    public final boolean isCloaked()
    {
        return State.Cloaked == getVisibility();
    }

    @Override
    public final boolean isInvisible()
    {
        return State.Invisible == getVisibility();
    }

    @Override
    public final InputField<T> visible()
    {
        setVisibility( State.Visible );
        return this;
    }

    @Override
    public final InputField<T> cloak()
    {
        setVisibility( State.Visible );
        return this;
    }

    @Override
    public final InputField<T> invisible()
    {
        setVisibility( State.Invisible );
        return this;
    }

    // Only callable in Run Mode

    @Override
    public final void reset()
    {
        checkRunMode( "reset" ).getInput().setValue( null );
    }

    @Override
    public final T setCurrentValue( T value )
    {
        InputWidgetChangeFilter<T> input = checkRunMode( "setCurrentValue" ).getInput();
        input.setValue( value );
        return input.getValue();
    }

    @Override
    public final T getCurrentValue()
    {
        return checkRunMode( "getCurrentValue" ).getInput().getValue();
    }

    @Override
    public final T getBaseValue()
    {
        return checkRunMode( "getBaseValue" ).getInput().getBaseValue();
    }

    @Override
    public final void revert()
    {
        InputWidgetChangeFilter<T> input = checkRunMode( "revert" ).getInput();
        input.setValue( input.getBaseValue() );
    }

    @Override
    public final boolean isChanged()
    {
        return checkRunMode( "isChanged" ).getInput().isChanged();
    }

    @Override
    public final Boolean isFocused()
    {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( "isFocused" );
        Boolean focused = fieldAccessor.isFocused();
        return Boolean.TRUE.equals( focused ) ? isVisible() : focused;
    }

    @Override
    public final boolean isErrored()
    {
        return (null != checkRunMode( "isErrored" ).getValidator().getErrorData());
    }

    @Override
    public final boolean validate()
    {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( "validate" );
        E13nData error = fieldAccessor.getValidator().validate();
        updateStyle( fieldAccessor );
        updateErrorLabel( fieldAccessor.getErrorLabel(), error );
        return (error == null);
    }

    @Override
    public final boolean setFocused()
    {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( "setFocused" );
        return isVisible() && fieldAccessor.setFocused();
    }

    @Override
    public final E13nResolver getE13nResolver()
    {
        return checkRunMode( "E13nResolver" ).getE13nResolver();
    }

    @Override
    public final Widget getInputWidget()
    {
        return checkRunMode( "InputWidget" ).getInputWidget();
    }

    @Override
    public final InputWidgetChangeFilter<T> getInput()
    {
        return checkRunMode( "Input" ).getInput();
    }

    @Override
    public final InputWidgetValidator<T> getValidator()
    {
        return checkRunMode( "Validator" ).getValidator();
    }

    @Override
    public final Widget getLabelLabel()
    {
        return checkRunMode( "LabelLabel" ).getLabelLabel();
    }

    @Override
    public final Widget getExtendedLabel()
    {
        return checkRunMode( "ExtendedLabel" ).getExtendedLabel();
    }

    @Override
    public final Widget getExampleLabel()
    {
        return checkRunMode( "ExampleLabel" ).getExampleLabel();
    }

    @Override
    public final Widget getErrorLabel()
    {
        return checkRunMode( "ErrorLabel" ).getErrorLabel();
    }

    @Override
    public final Widget getHelpWidget()
    {
        return checkRunMode( "HelpWidget" ).getHelpWidget();
    }

    // Support Methods...

    protected void processDataChanged()
    {
        updateStyle( checkRunMode( "processDataChanged" ) );
        for ( ChangeListener<T> zListener : changeListeners )
        {
            zListener.changed( this );
        }
    }

    protected void processFocusChanged()
    {
        updateStyle( checkRunMode( "processFocusChanged" ) );
    }

    protected void updateStyle( CompleteInputFieldAccessor<T> fieldAccessor )
    {
        updateStyle( StateInputField.BASE //
                             .errored( fieldAccessor.getValidator().getErrorData() != null ) //
                             .focused( Boolean.TRUE.equals( fieldAccessor.isFocused() ) ) //
                             .changed( fieldAccessor.getInput().isChanged() ) );
    }

    protected void updateStyle( StateInputField state )
    {
        state = ObjectUtils.deNull( state, StateInputField.BASE );
        if ( state != currentStyleState )
        {
            Panel panel = getContainer();
            if ( panel != null )
            {
                if ( currentStyleState != null )
                {
                    panel.removeStyleName( currentStyleState.toCSS() );
                }
                panel.addStyleName( state.toCSS() );
            }
            currentStyleState = state;
        }
    }

    protected String revolve( String method, E13nData error )
    {
        if ( error != null )
        {
            CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( method );
            String resolved = fieldAccessor.getE13nResolver().resolve( error );
            return StringUtils.noEmpty( StringUtils.convertNBSPsToSpaces( resolved ) );
        }
        return null;
    }

    protected final void assertBuildMode( String method )
    {
        if ( completeInputFieldAccessor != null )
        {
            throw new IllegalStateException( "Unable to process method '" + method + "' of InputField Named '" + name + "', because no longer in Build Mode (init has already been called)" );
        }
    }

    protected final CompleteInputFieldAccessor<T> checkRunMode( String method )
    {
        if ( completeInputFieldAccessor == null )
        {
            throw new IllegalStateException( "Unable to access component/method '" + method + "' of InputField Named '" + name + "', because not in Run Mode (init NOT called)" );
        }
        return completeInputFieldAccessor;
    }

    protected final CompleteInputFieldAccessor<T> checkRunMode()
    {
        return completeInputFieldAccessor;
    }

    abstract protected Panel getContainer();

    abstract protected void updateErrorLabel( Widget errorLabel, E13nData error );

    abstract protected CompleteInputFieldAccessor<T> buildActualWidget( E13nResolver resolver );
}