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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.core.delayed.*;
import org.litesoft.logger.*;
import org.litesoft.ui.*;

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

public abstract class AbstractSizeableWidget extends AbstractBrowserEventListenableWidget implements ISizeableWidget {
    public static final Logger LOGGER = LoggerFactory.getLogger( AbstractSizeableWidget.class );

    // AbstractSizeableHelper:
    //
    // Outer Element: A Table to Constrain the Style Elements size (Must be the get/set Element)
    // Style Element: Normally the Div that is sandwiched between the inner and outer tables
    // Inner Element: Inner most Element

    abstract protected AbstractSizeableHelper getHelper();

    /**
     * Override point called after the widget is effectively set-up
     */
    protected void initialize() {
    }

    @Override
    protected Element getStyleElement() {
        return getHelper().getStyleElement();
    }

    public void setSizingWorking() {
    }

    public boolean isSizingWorking() {
        return true;
    }

    /**
     * @return true if could do it (default is yes!)
     */
    public boolean setPrefferredWidth() {
        return true;
    }

    /**
     * @return true if could do it (default is yes!)
     */
    public boolean adjustWidthBy( int pDelta ) {
        return true;
    }

    @Override
    public ISizeableDimensionHelper getWidthHelper() {
        return getHelper().getWidthHelper();
    }

    /**
     * @return true if could do it (default is yes!)
     */
    public boolean setPrefferredHeight() {
        return true;
    }

    /**
     * @return true if could do it (default is yes!)
     */
    public boolean adjustHeightBy( int pDelta ) {
        return true;
    }

    @Override
    public ISizeableDimensionHelper getHeightHelper() {
        return getHelper().getHeightHelper();
    }

    @Override
    public void relayout() {
        Widget parent = getParent();
        if ( parent instanceof SizeManaged ) {
            ((SizeManaged) parent).relayout();
        } else {
            relayoutFromHereDown();
        }
    }

    public boolean relayoutFromHereDown() {
        if ( !isAttached() ) {
            return true;
        }
        // More Sizing code
        Element zInnerElement = getHelper().getInnerElement();
        int zCurInnerWidth = getWidthHelper().getDimension( zInnerElement );
        int zCurInnerHeight = getHeightHelper().getDimension( zInnerElement );
        int zCurOuterWidth = getOffsetWidth();
        int zCurOuterHeight = getOffsetHeight();
        if ( (zCurInnerWidth != 0) && (zCurInnerHeight != 0) && //
             (zCurOuterWidth != 0) && (zCurOuterHeight != 0) ) {
            if ( mRelayoutDelayedProcess != null ) {
                mRelayoutDelayedProcess.cancel();
                mRelayoutDelayedProcess = null;
            }
            setWidth( "" + zCurOuterWidth );
            setHeight( "" + zCurOuterHeight );
            distributeToChildrenChangedWidth();
            distributeToChildrenChangedHeight();
            return true;
        }
        if ( mRelayoutDelayedProcess == null ) {
            mRelayoutDelayedProcess = new EscalatingProcess( new DelayedProcess() {
                @Override
                public boolean process() {
                    return relayoutFromHereDown();
                }
            } );
            mRelayoutDelayedProcess.schedule();
        }
        return false;
    }

    private EscalatingProcess mRelayoutDelayedProcess = null;

    protected void distributeToChildrenChangedWidth() {
        // For Overriding in Sizeables w/ children
    }

    protected void distributeToChildrenChangedHeight() {
        // For Overriding in Sizeables w/ children
    }

    protected void LLstretchable() {
        LLstretchableHorizontally();
        LLstretchableVertically();
    }

    public void LLstretchableVertically() {
        getHeightHelper().setStretchable( true );
    }

    public void LLstretchableHorizontally() {
        getWidthHelper().setStretchable( true );
    }

    /**
     * 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 );
    }

    /**
     * Sets the object's style name, removing all other styles.
     * <p/>
     * <p/>
     * The style name is the name referred to in CSS style rules (in HTML, this is
     * referred to as the element's "class"). By convention, style rules are of
     * the form <code>[project]-[widget]</code> (e.g. the {@link Button}
     * widget's style name is <code>.gwt-Button</code>).
     * </p>
     * <p/>
     * <p/>
     * For example, if a widget's style name is <code>myProject-MyWidget</code>,
     * then the style rule that applies to it will be
     * <code>.myProject-MyWidget</code>. Note the "dot" prefix -- this is
     * necessary because calling this method sets the underlying element's
     * <code>className</code> property.
     * </p>
     * <p/>
     * <p/>
     * An object may have any number of style names, which may be manipulated
     * using {@link #addStyleName(String)} and {@link #removeStyleName(String)}.
     * The attributes of all styles associated with the object will be applied to
     * it.
     * </p>
     *
     * @param style the style name to be added
     *
     * @see #addStyleName(String)
     * @see #removeStyleName(String)
     */
    @Override
    public final void setStyleName( String style ) {
        throw new UnsupportedOperationException( "Must use addStyleName" );
    }

//    /**
//     * Adds a set of events to be sunk by this object. Note that only
//     * {@link Widget widgets} may actually receive events, but can receive events
//     * from all objects contained within them.
//     *
//     * @param eventBitsToAdd a bitfield representing the set of events to be added
//     *                       to this element's event set
//     *
//     * @see com.google.gwt.user.client.Event
//     */
//    public void sinkEvents( int eventBitsToAdd )
//    {
//        Element element = getStyleElement();
//        DOM.sinkEvents( element, eventBitsToAdd | DOM.getEventsSunk( element ) );
//    }
//
//    /**
//     * Removes a set of events from this object's event list.
//     *
//     * @param eventBitsToRemove a bitfield representing the set of events to be
//     *                          removed from this element's event set
//     *
//     * @see #sinkEvents
//     * @see com.google.gwt.user.client.Event
//     */
//    public void unsinkEvents( int eventBitsToRemove )
//    {
//        Element element = getStyleElement();
//        DOM.sinkEvents( element, DOM.getEventsSunk( element ) & (~eventBitsToRemove) );
//    }

    @Override
    public String toString() {
        String name = ClassName.simple( this );
        return name + ":" + super.toString();
    }

    public void resized() {
        // for overriding, called by the helper after the widget is resized at the element level
    }

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

    protected void setDimensionFromWidget( ISizeableDimensionHelper pDimensionHelper, int pSize_1D ) {
        pDimensionHelper.deligateSetDimensionFromWidget( pSize_1D );
    }

    public static int parse( String pSize_1D )
            throws NumberFormatException {
        String cleaned = ConstrainTo.notNull( pSize_1D ).trim();
        String toParse = "0" + cleaned;
        if ( toParse.endsWith( "px" ) ) {
            toParse = toParse.substring( 0, toParse.length() - 2 );
        }
        return Integer.parseInt( toParse );
    }

    protected Element addParent( Element pParent, Element pChild ) {
        DOM.appendChild( pParent, pChild );
        return pParent;
    }
}