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

import org.litesoft.core.util.externalization.*;

import com.google.gwt.user.client.ui.*;
import com.temp.client.foundation.util.*;
import com.temp.client.foundation.widget.*;
import com.temp.client.foundation.widget.input.*;
import com.temp.client.foundation.widget.input.support.*;
import com.temp.shared.*;
import com.temp.shared.utils.*;
import com.temp.shared.validators.*;

/**
 * Common abstract helper for the generated Widget versions of the InputField.
 */
public abstract class AbstractGeneratedInputField<T, C extends AbstractGeneratedInputField<T, C>> extends AbstractNonProxyInputField<T, C> implements IsWidget {
    // Optionally set/changed
    private boolean required = false;
    private boolean errorLabel = true;
    private boolean extendedLabel = false;
    private boolean example = false;
    private LabelPosition labelPosition = LabelPosition.Left;

    // Optionally set
    private String helpLink;

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

    private final NamedHorizontalPanel container = new NamedHorizontalPanel();

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

    @Override
    protected Panel getContainer() {
        return container;
    }

    @Override
    public Widget asWidget() {
        return container;
    }

    // Configuration Methods

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

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

    public final LabelPosition getLabelPosition() {
        return labelPosition;
    }

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

    public C labelPosition( LabelPosition labelPosition ) {
        assertBuildMode( "labelPosition" );
        Validate.notNull( "LabelPosition", labelPosition );
        setValidatedLabelPosition( labelPosition );
        return inheritanceLeaf();
    }

    protected void setValidatedLabelPosition( LabelPosition labelPosition ) {
        this.labelPosition = labelPosition;
    }

    public final boolean isRequired() {
        return required;
    }

    public final void setRequired( boolean required ) {
        assertBuildMode( "setRequired" );
        setValidatedRequired( required );
    }

    public C required() {
        assertBuildMode( "required" );
        setValidatedRequired( true );
        return inheritanceLeaf();
    }

    protected void setValidatedRequired( boolean required ) {
        this.required = required;
        if ( required ) {
            setValidatedErrorLabel( true );
        }
    }

    public final boolean isErrorLabel() {
        return errorLabel;
    }

    public final void setErrorLabel( boolean errorLabel ) {
        assertBuildMode( "setErrorLabel" );
        setValidatedErrorLabel( errorLabel );
    }

    public C errorLabel() {
        assertBuildMode( "errorLabel" );
        setValidatedErrorLabel( true );
        return inheritanceLeaf();
    }

    protected void setValidatedErrorLabel( boolean errorLabel ) {
        this.errorLabel = errorLabel;
    }

    public final boolean isExtendedLabel() {
        return extendedLabel;
    }

    public final void setExtendedLabel( boolean extendedLabel ) {
        assertBuildMode( "setExtendedLabel" );
        setValidatedExtendedLabel( extendedLabel );
    }

    public C extendedLabel() {
        assertBuildMode( "extendedLabel" );
        setValidatedExtendedLabel( true );
        return inheritanceLeaf();
    }

    protected void setValidatedExtendedLabel( boolean extendedLabel ) {
        this.extendedLabel = extendedLabel;
    }

    public final boolean isExample() {
        return example;
    }

    public final void setExample( boolean example ) {
        assertBuildMode( "setExample" );
        setValidatedExample( example );
    }

    public C example() {
        assertBuildMode( "example" );
        setValidatedExample( true );
        return inheritanceLeaf();
    }

    protected void setValidatedExample( boolean example ) {
        this.example = example;
    }

    public final String getHelpLink() {
        return helpLink;
    }

    public final void setHelpLink( String helpLink ) {
        assertBuildMode( "setHelpLink" );
        setValidatedHelpLink( StringUtils.noEmpty( helpLink ) );
    }

    public C helpLink( String helpLink ) {
        assertBuildMode( "helpLink" );
        setValidatedHelpLink( StringUtils.noEmpty( helpLink ) );
        return inheritanceLeaf();
    }

    protected void setValidatedHelpLink( String helpLink ) {
        this.helpLink = helpLink;
    }

    // Anytime Methods

    // Widget/Component Accessor Methods

    // Support Methods...

    @Override
    protected void validatorAdded( ValueValidator<T> validator ) {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode();
        if ( fieldAccessor != null ) {
            updateStyle( fieldAccessor );
        }
    }

    @Override
    protected void updateErrorLabel( Widget errorLabel, E13nData error ) {
        String errorText = revolve( "updateErrorLabel", error );
        ((TextLabel) errorLabel).setText( errorText );
        UtilsGwt.setHidden( errorLabel, errorText == null );
    }

    protected CompleteInputFieldAccessor<T> buildActualWidget( E13nResolver resolver ) {
        container.setName( getName() );
        namedWidgets.add( container );

        InputFieldAccessor<T> accessor = createBaseAccessor();
        InputWidgetValidator<T> validator = accessor.getValidator();

        TextLabel labelTextLabel = null;
        TextLabel extendedTextLabel = null;
        if ( !LabelPosition.None.equals( labelPosition ) ) {
            labelTextLabel = createWrappingLabel( "labelLabel", true, resolver, "field-label" );
            extendedTextLabel = createWrappingLabel( "extendedLabel", extendedLabel, resolver, "field-extendedLabel" );
        }
        TextLabel exampleTextLabel = createWrappingLabel( "exampleLabel", example, resolver, "field-example" );
        TextLabel errorTextLabel = null;
        if ( validator != null ) {
            errorTextLabel = createClippingLabel( "field-error", errorLabel );
            if ( required ) {
                addTo( validator, RequiredValueValidator.INSTANCE );
            }
            augmentValidator( validator );
            validator.addValidators( getValidators() );
        }
        HelpWidget helpWidget = (helpLink != null) ? createHelpWidget() : null;
        CompleteInputFieldAccessor<T> completeAccessor = new CompleteInputFieldAccessor<T>( resolver, //
                                                                                            labelTextLabel, //
                                                                                            extendedTextLabel, //
                                                                                            accessor, //
                                                                                            helpWidget, //
                                                                                            exampleTextLabel, //
                                                                                            errorTextLabel );
        populate( container, completeAccessor );
        return completeAccessor;
    }

    protected HelpWidget createHelpWidget() {
        return addNamedWidgetWithNameExtension( new HelpWidget().link( helpLink ), "helpWidget" );
    }

    @SuppressWarnings("UnusedParameters")
    protected void augmentValidator( InputWidgetValidator<T> validator ) {
    }

    @SuppressWarnings("unchecked")
    protected void addTo( InputWidgetValidator<T> validator, ValueValidator valueValidator ) {
        validator.addValidator( valueValidator );
    }

    protected final TextLabel createWrappingLabel( String styleName, boolean create, E13nResolver resolver, String resolveKey ) {
        if ( create ) {
            String text = resolver.resolve( resolveKey );
            if ( text != null ) {
                return addNamedWidgetWithStyle( new WrappingLabel( text ), styleName );
            }
        }
        return null;
    }

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

    private TextLabel createRequiredLabel() {
        return addNamedWidgetWithStyle( new NonWrappingLabel( required ? " * " : "   ", true ), "requiredSpacer" );
    }

    protected void populate( HorizontalPanel container, CompleteInputFieldAccessor<T> completeAccessor ) {
        container.clear(); // Remove "Stand In"
        container.addStyleName( ObjectUtils.getSimpleClassName( this ) ); // Add Style on Container for Cascade customization!

        container.setHorizontalAlignment( HasHorizontalAlignment.ALIGN_LEFT );
        container.setVerticalAlignment( HasVerticalAlignment.ALIGN_TOP );

        VerticalPanel labelPanel = null;
        VerticalPanel centerPanel = UtilsGwt.vertical( "fieldCenter" );

        HelpWidget helpWidget = completeAccessor.getHelpWidget();

        switch ( labelPosition ) {
            default:
            case Left:
                container.add( labelPanel = UtilsGwt.vertical( "fieldLeft" ) );
                labelPanel.add( completeAccessor.getLabelLabel() );
                container.add( createRequiredLabel() );
                container.add( centerPanel );
                break;
            case Top:
                container.add( labelPanel = centerPanel );
                labelPanel.add( UtilsGwt.horizontal( completeAccessor.getLabelLabel(), createRequiredLabel() ) );
                break;
            case Right:
                container.add( centerPanel );
                container.add( labelPanel = UtilsGwt.vertical( "fieldRight" ) );
                labelPanel.add( UtilsGwt.horizontal( completeAccessor.getLabelLabel(), createRequiredLabel(), helpWidget ) );
                helpWidget = null;
                break;
            case None:
                break;
        }
        UtilsGwt.add( labelPanel, completeAccessor.getExtendedLabel() );

        // Add HelpWidget
        if ( helpWidget != null ) {
            container.add( UtilsGwt.add( UtilsGwt.vertical( "fieldRight" ), helpWidget ) );
        }

        // populate the Center
        centerPanel.add( completeAccessor.getInputWidget() );
        UtilsGwt.add( centerPanel, completeAccessor.getExampleLabel() );
        UtilsGwt.add( centerPanel, completeAccessor.getErrorLabel() );
    }

    protected <W extends Widget & HasName> InputFieldAccessor<T> createBaseAccessor( InputWidgetValueAdapter<T> valueAdapter, W inputWidget, String style,
                                                                                     Focusable... focusables ) {
        InputWidgetValidator<T> validator = new InputWidgetValidator<T>( valueAdapter );
        InputWidgetChangeFilter<T> input = new InputWidgetChangeFilter<T>( validator );
        return new InputFieldAccessor<T>( input, validator, valueAdapter, addNamedWidgetWithStyle( inputWidget, style ), focusables );
    }

    abstract protected InputFieldAccessor<T> createBaseAccessor();
}