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

import com.google.gwt.user.client.ui.*;
import com.temp.client.foundation.widget.*;
import com.temp.client.foundation.widget.input.fieldsupport.*;
import com.temp.client.foundation.widget.input.support.*;
import com.temp.client.foundation.widget.HelpWidget;
import com.temp.shared.externalization.*;
import com.temp.shared.utils.*;

/**
 * An Input Field that can be instantiated directly or as a widget in a UI Binding file.
 * <p/>
 * It operates in two distinct states:
 * <p/>
 * <li>Builder Mode - Where properties of the final widget are specified (and parts of the widget are NOT accessable)</li>
 * <li>Run Mode - Whare the parts of the Widget are accessable (and the specification properties are NOT changeable)</li>
 * <p/>
 * The transition between the states is one way ('Builder' to 'Run') and is a result of the call to 'init'.
 *
 * @param <T> the data type returned by this InputField
 */
public class InputField<T> extends Composite implements HasName
{
    // Required to be set
    private String name;

    // Optionally set/changed
    private InputType inputType = InputType.String;
    private boolean required = false;
    private boolean errorLabel = true;
    private boolean extendedLabel = false;
    private boolean example = false;
    private LabelPosition labelPosition = LabelPosition.Left;

    // Optionally set
    private Integer maxLength;
    private String helpLink;

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

    private HorizontalPanel container = new HorizontalPanel();
    private CompleteInputFieldAccessor<T> completeInputFieldAccessor;

    public InputField()
    {
        container.add( new Label( "!?!" ) );
        initWidget( container );
    }

    // Configuration Methods

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

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

    public InputField<T> name( String name )
    {
        setName( name );
        return this;
    }

    public String getType()
    {
        return (inputType != null) ? inputType.name() : null;
    }

    public void setType( String type )
    {
        assertBuildMode();
        type = StringUtils.noEmpty( type );
        InputType inputType = ObjectUtils.oneOfToStringIgnoreCase( type, InputType.values() );
        if ( inputType == null )
        {
            throw new IllegalArgumentException( "Unacceptable InputType of: " + type );
        }
        setInputType( inputType );
    }

    public InputType getInputType()
    {
        return inputType;
    }

    public void setInputType( InputType inputType )
    {
        assertBuildMode();
        Validate.notNull( "InputType", this.inputType = inputType );
    }

    public InputField<T> inputType( InputType inputType )
    {
        setInputType( inputType );
        return this;
    }

    public String getLabel()
    {
        return labelPosition.name();
    }

    public void setLabel( String labelPosition )
    {
        assertBuildMode();
        labelPosition = StringUtils.noEmpty( labelPosition );
        LabelPosition position = ObjectUtils.oneOfToStringIgnoreCase( labelPosition, LabelPosition.values() );
        if ( position == null )
        {
            throw new IllegalArgumentException( "Unacceptable LabelPosition of: " + labelPosition );
        }
        setLabelPosition( position );
    }

    public LabelPosition getLabelPosition()
    {
        return labelPosition;
    }

    public void setLabelPosition( LabelPosition labelPosition )
    {
        assertBuildMode();
        Validate.notNull( "LabelPosition", this.labelPosition = labelPosition );
    }

    public InputField<T> labelPosition( LabelPosition labelPosition )
    {
        setLabelPosition( labelPosition );
        return this;
    }

    public boolean isRequired()
    {
        return required;
    }

    public void setRequired( boolean required )
    {
        assertBuildMode();
        this.required = required;
        if ( required )
        {
            setErrorLabel( true );
        }
    }

    public InputField<T> required()
    {
        setRequired( true );
        return this;
    }

    public boolean isErrorLabel()
    {
        return errorLabel;
    }

    public void setErrorLabel( boolean pErrorLabel )
    {
        assertBuildMode();
        errorLabel = pErrorLabel;
    }

    public InputField<T> errorLabel()
    {
        setErrorLabel( true );
        return this;
    }

    public boolean isExtendedLabel()
    {
        return extendedLabel;
    }

    public void setExtendedLabel( boolean pExtendedLabel )
    {
        assertBuildMode();
        extendedLabel = pExtendedLabel;
    }

    public InputField<T> extendedLabel()
    {
        setExtendedLabel( true );
        return this;
    }

    public boolean isExample()
    {
        return example;
    }

    public void setExample( boolean pExample )
    {
        assertBuildMode();
        example = pExample;
    }

    public InputField<T> example()
    {
        setExample( true );
        return this;
    }

    public Integer getMaxLength()
    {
        return maxLength;
    }

    public void setMaxLength( Integer maxLength )
    {
        assertBuildMode();
        this.maxLength = Validate.optionalLength( "MaxLength", maxLength );
    }

    public InputField<T> maxLength( int maxLength )
    {
        setMaxLength( maxLength );
        return this;
    }

    public String getHelpLink()
    {
        return helpLink;
    }

    public void setHelpLink( String helpLink )
    {
        assertBuildMode();
        this.helpLink = StringUtils.noEmpty( helpLink );
    }

    public InputField<T> helpLink( String helpLink )
    {
        setHelpLink( Validate.noEmpty( "HelpLink", helpLink ) );
        return this;
    }

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

    // Anytime Methods

    public boolean isEnabled()
    {
        return true; // TODO: XXX
    }

    public void setEnabled( boolean enable )
    {
        // TODO: XXX
    }

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

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

    public boolean isHidden()
    {
        return true; // TODO: XXX
    }

    public void setHidden( boolean hidden )
    {
        // TODO: XXX
    }

    public InputField<T> hide()
    {
        setHidden( true );
        return this;
    }

    public InputField<T> show()
    {
        setHidden( false );
        return this;
    }

    // Widget Accessor Methods

    public T getCurrentValue()
    {
        return getInput().getValue();
    }

    public Widget getInputWidget()
    {
        return checkRunMode( "getInputWidget" ).getInputWidget();
    }

    public InputWidgetChangeFilter<T> getInput()
    {
        return checkRunMode( "getInput" ).getInput();
    }

    public InputWidgetValidator<T> getValidator()
    {
        return checkRunMode( "getValidator" ).getValidator();
    }

    public TextLabel getLabelLabel()
    {
        return checkRunMode( "getLabelLabel" ).getLabelLabel();
    }

    public TextLabel getExtendedLabel()
    {
        return checkRunMode( "getExtendedLabel" ).getExtendedLabel();
    }

    public TextLabel getExampleLabel()
    {
        return checkRunMode( "getExampleLabel" ).getExampleLabel();
    }

    public TextLabel getErrorLabel()
    {
        return checkRunMode( "getErrorLabel" ).getErrorLabel();
    }

    public HelpWidget getHelpWidget()
    {
        return checkRunMode( "getHelpWidget" ).getHelpWidget();
    }

    // Support Methods...

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

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

    protected CompleteInputFieldAccessor<T> buildActualWidget( E13nResolver pResolver )
    {
        InputFieldAccessor<T> accessor = inputType.createAccessor();
        TextLabel labelTextLabel = null;
        TextLabel extendedTextLabel = null;
        if ( !LabelPosition.None.equals( labelPosition ) )
        {
            labelTextLabel = createWrappingLabel( "labelLabel", true );
            extendedTextLabel = createWrappingLabel( "extendedLabel", extendedLabel );
        }
        TextLabel exampleTextLabel = createWrappingLabel( "exampleLabel", example );
        TextLabel errorTextLabel = createClippingLabel( "errorLabel", errorLabel && (accessor.getValidator() != null) );
        HelpWidget helpWidget = (helpLink != null) ? new HelpWidget().link( helpLink ) : null;
        CompleteInputFieldAccessor<T> completeAccessor = new CompleteInputFieldAccessor<T>( labelTextLabel, //
                                                                                            extendedTextLabel,  //
                                                                                            accessor,  //
                                                                                            helpWidget,  //
                                                                                            exampleTextLabel,  //
                                                                                            errorTextLabel );
        populate( container, completeAccessor );
        return completeAccessor;
    }

    protected final TextLabel createNonWrappingLabel( String styleName, boolean create )
    {
        return create ? new NonWrappingLabel().style( styleName ) : null;
    }

    protected final TextLabel createWrappingLabel( String styleName, boolean create )
    {
        return create ? new WrappingLabel().style( styleName ) : null;
    }

    protected final TextLabel createClippingLabel( String styleName, boolean create )
    {
        return create ? new ClippingLabel().style( styleName ) : null;
    }

    protected void populate( HorizontalPanel container, CompleteInputFieldAccessor<T> completeAccessor )
    {

//        completeAccessor.
//        boolean required = false;
//        boolean errorLabel = true;
//        boolean extendedLabel = false;
//        boolean example = false;
//        LabelPosition labelPosition = LabelPosition.Left;
//
//        // Optionally set
//        Integer maxLength;
//        String helpLink;
//
//        E13nResolverAccessor resolverAccessor;
//        CompleteInputFieldAccessor<T> completeInputFieldAccessor;
    }
}