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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.GWT.forms.client.components.*;

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

public abstract class AbstractTextElement extends AbstractFocusWidgetErrorableFormElement implements ISizeableWidget,
                                                                                                     IFormComponentWithRawTextAccess
{
    protected TextBoxBase mTextBoxBase;
    protected ISizeableDimensionHelper mWidthHelper;
    protected ISizeableDimensionHelper mHeightHelper;
//    private HandlerRegistration mChangeHandlerDisposer;

    protected AbstractTextElement( IFocusWidget pTextBoxBase, String pTooltip, String pWidgetStyle )
    {
        this( pTextBoxBase, (TextBoxBase) pTextBoxBase, pTooltip, pWidgetStyle );
    }

    protected AbstractTextElement( IFocusWidget pInputWidget, TextBoxBase pTextBoxBase, String pTooltip, String pWidgetStyle )
    {
        super( pInputWidget, pTooltip, pWidgetStyle, false );
//        mChangeHandlerDisposer =
        (mTextBoxBase = pTextBoxBase).addChangeHandler( new ChangeHandler()
        {
            public void onChange( ChangeEvent event )
            {
                fireChangeListeners();
            }
        } );
    }

    // Example of unregistering
//    public void dispose()
//    {
//        if ( mChangeHandlerDisposer != null )
//        {
//            mChangeHandlerDisposer.removeHandler();
//            mChangeHandlerDisposer = null;
//        }
//    }

    // ISizeableWidget

    public ISizeableDimensionHelper getWidthHelper()
    {
        return mWidthHelper;
    }

    public ISizeableDimensionHelper getHeightHelper()
    {
        return mHeightHelper;
    }

    public void relayout()
    {
    }

    /**
     * Sets the object's width. This width does not include decorations such as
     * border, margin, and padding.
     *
     * @param width the object's new width, in CSS units (e.g. "10px", "1em")
     */
    public void setWidth( String width )
    {
        setDimensionFromWidget( getWidthHelper(), width );
    }

    /**
     * Sets the object's height. This height does not include decorations such as
     * border, margin, and padding.
     *
     * @param height the object's new height, in CSS units (e.g. "10px", "1em")
     */
    public void setHeight( String height )
    {
        setDimensionFromWidget( getHeightHelper(), height );
    }

    // IFormComponent

    public Object getCurrentValue()
    {
        return getCurrentText();
    }

    public void setCurrentValue( Object pNewValue )
    {
        setCurrentText( (pNewValue == null) ? "" : pNewValue.toString() );
    }

    // Support...

    public void simulateUserTextEntry( String pText )
    {
        String zCurrentText = getCurrentText();
        setCurrentText( pText );
        if ( !zCurrentText.equals( getCurrentText() ) )
        {
            fireChangeListeners();
        }
        pullFocusTo( getTextBoxBase() );
    }

    public String getCurrentText()
    {
        return UtilsGwt.deNull( getTextBoxBase().getText() );
    }

    public void setCurrentText( String pNewText )
    {
        getTextBoxBase().setText( UtilsGwt.deNull( pNewText ) );
    }

    public TextBoxBase getTextBoxBase()
    {
        return mTextBoxBase;
    }

    private void setDimensionFromWidget( ISizeableDimensionHelper pDimensionHelper, String pSize_1D )
    {
        int zSize_1D;
        try
        {
            zSize_1D = AbstractSizeableWidget.parse( pSize_1D );
        }
        catch ( NumberFormatException e )
        {
            throw new IllegalArgumentException( "Attempt to set" + pDimensionHelper.getWhat() + "( \"" + pSize_1D + "\" ) on " + getClass().getName() );
        }
        pDimensionHelper.deligateSetDimensionFromWidget( zSize_1D );
    }

    protected static abstract class AbstractHeightHelper extends AbstractDimensionHelper
    {
        protected AbstractHeightHelper( boolean pStretchable )
        {
            super( pStretchable, HeightDimensionHelper.INSTANCE );
        }
    }

    protected static class NullHeightHelper extends AbstractHeightHelper
    {
        public static final NullHeightHelper INSTANCE = new NullHeightHelper();

        private NullHeightHelper()
        {
            super( false );
        }
    }

    private static abstract class AbstractWidthHelper extends AbstractDimensionHelper
    {
        protected AbstractWidthHelper( boolean pStretchable )
        {
            super( pStretchable, WidthDimensionHelper.INSTANCE );
        }
    }

    protected static class NullWidthHelper extends AbstractWidthHelper
    {
        public static final NullWidthHelper INSTANCE = new NullWidthHelper();

        private NullWidthHelper()
        {
            super( false );
        }
    }

    protected static class StretchableWidthHelper extends AbstractWidthHelper
    {
        private AbstractTextElement mOurWidget;

        public StretchableWidthHelper( AbstractTextElement pOurWidget )
        {
            super( true );
            mOurWidget = pOurWidget;
        }

        public void setDimension( int pDimension )
        {
            setDimension( mOurWidget, pDimension );
        }

        public int getDimension()
        {
            return getDimension( mOurWidget );
        }

        public int getDimensionMaxShrinkability()
        {
            return getDimension( mOurWidget.getInjectedInputWidget() ) - 5;
        }

        public int getDecorationSize()
        {
            return getDimension() - getDimension( mOurWidget.getInjectedInputWidget() );
        }

        public void deligateSetDimensionFromWidget( int pDimension )
        {
            int zIndicatorSize = 0;//getDimension( mOurWidget.mIndicatorTd ); // Appears to have been a refactor that eliminated the need for this!
            int zInputDecorationSize = getInputDecorationSize();
            int zOuterSandwichDecorationSize = getOuterSandwichDecorationSize();
            pDimension -= zIndicatorSize + zInputDecorationSize + zOuterSandwichDecorationSize;
            if ( pDimension > 5 )
            {
                setDimension( mOurWidget.getInjectedInputWidget(), pDimension );
            }
        }

        private Integer mInputDecorationSize = null;

        private int getInputDecorationSize()
        {
            if ( mInputDecorationSize == null )
            {
                if ( !mOurWidget.isAttached() )
                {
                    return 9999;
                }
                mInputDecorationSize = (getDimension( getGrandParent( mOurWidget.getInjectedInputWidget() ) ) - //
                                        getDimension( mOurWidget.getInjectedInputWidget() ));
            }
            return mInputDecorationSize;
        }

        private Integer mOuterSandwichDecorationSize = null;

        private int getOuterSandwichDecorationSize()
        {
            if ( mOuterSandwichDecorationSize == null )
            {
                if ( !mOurWidget.isAttached() )
                {
                    return 9999;
                }
                Element zDivOrFS = mOurWidget.mInnerHTMLpanel.getElement();
                int children = DOM.getChildCount( zDivOrFS );
                Element zInnerBread = DOM.getChild( zDivOrFS, children - 1 );
                mOuterSandwichDecorationSize = (getDimension( mOurWidget ) - getDimension( zInnerBread ));
            }
            return mOuterSandwichDecorationSize;
        }

        private Element getGrandParent( Widget pWidget )
        {
            return getGrandParent( pWidget.getElement() );
        }

        private Element getGrandParent( Element pElement )
        {
            return getParent( getParent( pElement ) );
        }

        private Element getParent( Element pElement )
        {
            return DOM.getParent( pElement );
        }
    }
}