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

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

import java.util.*;

/**
 * Common abstract helper for both the generated Widget and the Proxied versions of the InputField.
 */
public abstract class AbstractInputField<T, C extends AbstractInputField<T, C>> implements InputField<T> {
    // Optionally set
    private Set<ChangeListener<T>> changeListeners = new HashSet<ChangeListener<T>>();
    private Set<FocusChangedListener> focusChangeListeners = new HashSet<FocusChangedListener>();

    protected boolean enabled = true;

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

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

    @Override
    public final 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 InputField<T> add( FocusChangedListener focusChangedListener ) {

        if ( focusChangedListener != null ) {
            focusChangeListeners.add( focusChangedListener );
        }
        return this;
    }

    @Override
    public final boolean remove( FocusChangedListener focusChangedListener ) {
        return (focusChangedListener == null) ? false : focusChangeListeners.remove( focusChangedListener );
    }

    @Override
    public final void removeAllFocusChangeListeners() {
        focusChangeListeners.clear();
    }

    @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();
    }

    abstract protected HasEnabled getEnableable();

    // Anytime Methods

    // For Enableable

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

    @Override
    public final void setEnabled( boolean enable ) {
        enabled = enable;
        HasEnabled 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

    protected final 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 final void notifyFocusChangeListeners() {
        for ( FocusChangedListener zListener : focusChangeListeners ) {
            zListener.focusChanged();
        }
    }

    protected final void notifyChangeListeners() {
        for ( ChangeListener<T> zListener : changeListeners ) {
            zListener.changed( this );
        }
    }

    protected final void assertBuildMode( String method ) {
        assertMode( method, false );
    }

    protected final void assertRunMode( String method ) {
        assertMode( method, true );
    }

    private void assertMode( String method, boolean expectedRunMode ) {
        if ( isRunMode() != expectedRunMode ) {
            throw new IllegalStateException( "Unable to access component/method '" + method + "' of InputField Named '" + getName() + //
                                             (expectedRunMode ? "', because not in Run Mode (init NOT called)" :
                                              "', because no longer in Build Mode (init has already been called)") );
        }
    }

    protected final C inheritanceLeaf() {
        return ObjectUtils.cast( this );
    }

    abstract protected Panel getContainer();
}