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

import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.event.dom.client.ChangeHandler;
import com.google.gwt.user.client.ui.HasEnabled;
import com.google.gwt.user.client.ui.HasName;
import com.google.gwt.user.client.ui.Widget;
import com.temp.client.foundation.widget.NameToID;
import com.temp.client.foundation.widget.input.InputField;
import com.temp.shared.ValueValidator;
import org.litesoft.core.util.externalization.E13nData;
import org.litesoft.core.util.externalization.E13nResolver;
import org.litesoft.core.util.externalization.OptionallyPrefixingE13nResolver;
import com.temp.shared.utils.ObjectUtils;
import com.temp.shared.utils.StringUtils;
import com.temp.shared.utils.Validate;

import java.util.ArrayList;
import java.util.List;

/**
 * Common abstract helper for both the generated Widget and the Proxied versions of the InputField.
 */
public abstract class AbstractNonProxyInputField<T, C extends AbstractNonProxyInputField<T, C>> extends AbstractInputField<T, C> {
    // 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 CompleteInputFieldAccessor<T> completeInputFieldAccessor;

    protected final List<HasName> namedWidgets = new ArrayList<HasName>();

    // Configuration Methods

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

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

    public final C name(String name) {
        assertBuildMode("name");
        setValidatedName(Validate.noEmptyIdentifier("Name", name));
        return inheritanceLeaf();
    }

    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
     * @param parentResolver
     */
    @Override
    public final void init(E13nResolver parentResolver) {
        Validate.notNull("resolver", parentResolver);
        if (name == null) {
            throw new IllegalStateException("Unable to init, Name not set");
        }
        assertBuildMode("init");

        E13nResolver resolver = new OptionallyPrefixingE13nResolver(name, parentResolver); // 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();
            }
        });
    }

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

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

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

    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);

    protected final HasEnabled getEnableable() {
        return completeInputFieldAccessor;
    }

    // Anytime Methods

    // Only callable in Run Mode

    @Override
    public final void reset() {
        updateCurrentValue( checkRunMode( "reset" ), null );
    }

    @Override
    public final T setCurrentValue(T value) {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( "setCurrentValue" );
        updateCurrentValue( fieldAccessor, value );
        return fieldAccessor.getInput().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() {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( "revert" );
        updateCurrentValue( fieldAccessor, fieldAccessor.getInput().getBaseValue() );
    }

    protected final void updateCurrentValue(CompleteInputFieldAccessor<T> fieldAccessor, T value) {
        fieldAccessor.getInput().setValue( value );
        clearError(fieldAccessor);
    }

    protected final void clearError( CompleteInputFieldAccessor<T> fieldAccessor )
    {
        updateErrorLabel( fieldAccessor.getErrorLabel(), null );
    }

    @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 E13nData getErrorData() {
        return checkRunMode("getErrorData").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();
    }

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

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

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

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

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

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

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

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

    @Override
    public NameToID addNamedWidgetsTo(NameToID nameToID) {
        assertRunMode("addNamedWidgetsTo");
        return nameToID.add(namedWidgets);
    }

    // Support Methods...

    protected final <W extends Widget & HasName> W addNamedWidgetWithStyle(W widget, String style) {
        widget.addStyleName(style);
        return addNamedWidgetWithNameExtension(widget, style);
    }

    protected final <W extends HasName> W addNamedWidgetWithNameExtension(W widget, String nameExtension) {
        widget.setName(getName() + "_" + nameExtension);
        return addNamedWidget(widget);
    }

    protected final <W extends HasName> W addNamedWidget(W widget) {
        namedWidgets.add(widget);
        return widget;
    }

    protected void processDataChanged() {
        CompleteInputFieldAccessor<T> fieldAccessor = checkRunMode( "processDataChanged" );
        updateStyle( fieldAccessor );
        clearError( fieldAccessor );
        notifyChangeListeners();
    }

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

    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 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 CompleteInputFieldAccessor<T> checkRunMode(String method) {
        assertRunMode(method);
        return completeInputFieldAccessor;
    }

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

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

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