// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.forms.client.components.nonpublic;

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

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() {
            @Override
            public void onChange( ChangeEvent event ) {
                fireChangeListeners();
            }
        } );
    }

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

    // ISizeableWidget

    @Override
    public ISizeableDimensionHelper getWidthHelper() {
        return mWidthHelper;
    }

    @Override
    public ISizeableDimensionHelper getHeightHelper() {
        return mHeightHelper;
    }

    @Override
    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")
     */
    @Override
    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")
     */
    @Override
    public void setHeight( String height ) {
        setDimensionFromWidget( getHeightHelper(), height );
    }

    // IFormComponent

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

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

    // Support...

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

    @Override
    public String getCurrentText() {
        return ConstrainTo.notNull( getTextBoxBase().getText() );
    }

    public void setCurrentText( String pNewText ) {
        getTextBoxBase().setText( ConstrainTo.notNull( 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;
        }

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

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

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

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

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