package org.litesoft.GWT.forms.client.components.nonpublic;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.core.delayed.*;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

public abstract class AbstractFormElement extends Composite implements IFormComponent
{
    public static final String BASE_STYLE_NAME = "litesoft-FormComponent";
    public static final String FORM_COMPONENT_LABEL_STYLE = "litesoft-FormComponentLabel";
    public static final String FORM_COMPONENT_LABEL_LEFT_STYLE = "litesoft-FormComponentLabelLeft";

    protected String mCurStyleState = "";
    protected boolean mChanged = false;
    protected boolean mFocused = false;
    protected boolean mEnabled = true;
    private Set<Listener> mFormComponentListeners = new HashSet<Listener>();
    protected FormHTMLpanel mInnerHTMLpanel; // Element is either a DIV / FieldSet
    protected String mFieldLabel, mTooltip;

    protected AbstractFormElement( Element pElement )
    {
        VerticalPanel zConstrainingTable = new VerticalPanel();
        initWidget( zConstrainingTable );
        zConstrainingTable.add( mInnerHTMLpanel = new FormHTMLpanel( pElement ) );
        super.setStyleName( BASE_STYLE_NAME );
    }

    protected void initializeHTML( String pHTML )
    {
        mInnerHTMLpanel.setHTML( pHTML );
    }

    // UIObject

    public void setStyleName( String style )
    {
        throw new IllegalStateException( "Can not use setStyleName, use addStyleName & removeStyleName" );
    }

    protected Element getStyleElement()
    {
        return mInnerHTMLpanel.getElement();
    }

    abstract public void simulateUserTextEntry( String pText );

    public String getFieldLabel()
    {
        return mFieldLabel;
    }

    public String getTooltip()
    {
        return mTooltip;
    }

    /**
     * Not supported
     *
     * @throws UnsupportedOperationException
     */
    public void setTitle( String title )
            throws UnsupportedOperationException
    {
        throw new UnsupportedOperationException();
    }

    // IFormComponent

    public boolean hasError()
    {
        return false;
    }

    public void setError( String pError )
            throws UnsupportedOperationException
    {
        if ( UtilsGwt.isNotNullOrEmpty( pError ) )
        {
            throw new UnsupportedOperationException();
        }
    }

    public void setFocused( boolean pFocused )
    {
        mFocused = pFocused;
        stateChanged();
    }

    public void setValueChanged( boolean pChanged )
    {
        mChanged = pChanged;
        stateChanged();
    }

    public boolean isEnabled()
    {
        return mEnabled;
    }

    public void publishAnyPendingChanges()
    {
        // Do nothing as most FormElements do not do defferred processing
        if ( mFocused )
        {
            LOGGER.error.log( "AbstractFormElement.publishAnyPendingChanges: Focused - ", simpleClassname( this ) );
        }
    }

    public IFormComponent addFormComponentListener( Listener pFormComponentListener )
    {
        if ( pFormComponentListener != null )
        {
            pFormComponentListener.add( this );
            mFormComponentListeners.add( pFormComponentListener );
        }
        return this;
    }

    public IFormComponent removeFormComponentListener( Listener pFormComponentListener )
    {
        if ( pFormComponentListener != null )
        {
            pFormComponentListener.remove( this );
            mFormComponentListeners.remove( pFormComponentListener );
        }
        return this;
    }

    // Support...

    protected static String simpleClassname( Object pObject )
    {
        return UtilsGwt.justClassNameOf( pObject );
    }

    protected void fireBlurListeners()
    {
        trace( "fireBlurListeners" );
        for ( Listener zListener : mFormComponentListeners )
        {
            zListener.blurOccurred();
        }
    }

    protected void fireChangeListeners()
    {
        trace( "fireChangeListeners" );
        for ( Listener zListener : mFormComponentListeners )
        {
            zListener.changeOccurred();
        }
    }

    protected void fireFocusListeners()
    {
        trace( "fireFocusListeners" );
        for ( Listener zListener : mFormComponentListeners )
        {
            zListener.focusOccured();
        }
    }

    protected void fireEnterPressedListeners( KeyboardKeyModifier pModifiers )
    {
        trace( "fireenterPressedListeners" );
        for ( Listener zListener : mFormComponentListeners )
        {
            zListener.enterPressed( pModifiers );
        }
    }

    protected boolean hasFocus()
    {
        return mFocused;
    }

    protected boolean hasChanged()
    {
        return mChanged;
    }

    protected void stateChanged()
    {
        if ( isEnabled() )
        {
            setEnabledStyles();
        }
        else
        {
            setDisabledStyles();
        }
    }

    protected void setDisabledStyles()
    {
        StringBuilder style = new StringBuilder( "-Disabled" );
        if ( hasError() )
        {
            style.append( "-Error" );
        }
        updateStatefulStyleName( style.toString() );
    }

    protected void setEnabledStyles()
    {
        StringBuilder style = new StringBuilder();
        if ( hasFocus() )
        {
            style.append( "-Focused" );
        }
        if ( hasError() )
        {
            style.append( "-Error" );
        }
        if ( hasChanged() )
        {
            style.append( "-Changed" );
        }
        updateStatefulStyleName( style.toString() );
    }

    private void updateStatefulStyleName( String pNewStyleState )
    {
        if ( !pNewStyleState.equals( mCurStyleState ) )
        {
            if ( !mCurStyleState.equals( "" ) )
            {
                removeStyleName( BASE_STYLE_NAME + mCurStyleState );
            }
            if ( !(mCurStyleState = pNewStyleState).equals( "" ) )
            {
                addStyleName( BASE_STYLE_NAME + mCurStyleState );
            }
        }
    }

    protected static class FormHTMLpanel extends ComplexPanel
    {
        /**
         * Creates an HTML panel with NO specified HTML contents. The element is the wrapping element.
         *
         * @param pElement either the Div or the FieldSet
         */
        public FormHTMLpanel( Element pElement )
        {
            setElement( pElement );
        }

        /**
         * Injects the specified HTML contents into the HTML panel. Any element within
         * this HTML that has a specified id can contain a child widget.
         *
         * @param pHtml the panel's HTML
         */
        public void setHTML( String pHtml )
        {
            DOM.setInnerHTML( getElement(), pHtml );
        }

        /**
         * Adds a child widget to the panel, contained within the HTML element
         * specified by a given id.
         *
         * @param pWidget the widget to be added
         * @param pId     the id of the element within which it will be contained
         */
        public void add( Widget pWidget, String pId )
        {
            Element elem = getElementById( getElement(), pId );
            if ( elem == null )
            {
                throw new NoSuchElementException( pId );
            }

            super.add( pWidget, elem );
        }

        /*
         * Implements getElementById() downward from the given element. We need to do
         * this because {@link #add(Widget, String)} must often be called before the
         * panel is attached to the DOM, so {@link Dom#getElementById} won't yet work.
         */
        private Element getElementById( Element pElement, String pId )
        {
            String elemId = DOM.getElementProperty( pElement, "id" );
            if ( (elemId != null) && elemId.equals( pId ) )
            {
                return pElement;
            }

            Element child = DOM.getFirstChild( pElement );
            while ( child != null )
            {
                Element ret = getElementById( child, pId );
                if ( ret != null )
                {
                    return ret;
                }
                child = DOM.getNextSibling( child );
            }

            return null;
        }
    }

    protected void trace( String pMethod )
    {
        if ( LOGGER.trace.isEnabled() )
        {
            LOGGER.trace.log( pMethod + " - " + simpleClassname( this ) );
        }
    }

    protected void pullFocusTo( final Focusable pFocusable )
    {
        TimedRunnableManager.INSTANCE.runIn( new TimedRunnable()
        {
            public Again runOnce()
            {
                if ( !UtilsGwt.isRecursiveVisible( (Widget) pFocusable ) )
                {
                    return new RunAgainIn( 50 );
                }
                pFocusable.setFocus( true );
                return null;
            }
        }, 10 );
    }
}