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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

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

public abstract class AbstractSizeablePanel extends AbstractSizeableWidget implements HasWidgets
{
    private AbstractSizeableHelper mHelper = new AbstractSizeableHelper( this );
    // 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

    @Override
    protected AbstractSizeableHelper getHelper()
    {
        return mHelper;
    }

    protected void initializeElements( Element pContainerElement, String pStyleClassName )
    {
        mContainerElement = pContainerElement;
        setElement( getHelper().getOuterElement() );
        initialize();
        if ( null != (pStyleClassName = Strings.noEmpty( pStyleClassName )) )
        {
            setStyleName( getHelper().getStyleElement(), pStyleClassName, true );
        }
    }

    abstract public boolean anyChildren();

    // vvvvvvvvvvv HasWidgets

    /**
     * Removes all child widgets.
     */
    @Override
    public void clear()
    {
        Iterator<Widget> it = iterator();
        while ( it.hasNext() )
        {
            it.next();
            it.remove();
        }
    }

    // ^^^^^^^^^^^ HasWidgets

    /**
     * This method must be called as part of the add method of any panel. It
     * ensures that the Widget's parent is set properly, and that it is removed
     * from any existing parent widget. It also attaches the child widget's
     * DOM element to its new container, ensuring that this process occurs in the
     * right order.
     *
     * @param w         the widget to be adopted
     * @param container the element within which it will be contained
     *
     * @return container element passed in
     */
    protected Element adopt( Widget w, Element container )
    {
        // Remove the widget from its current parent, if any.
        w.removeFromParent();

        // Attach it at the DOM and GWT levels.
        if ( container != null )
        {
            appendChild( container, w.getElement() );
        }
        //noinspection NonJREEmulationClassesInClientCode
        BackDoorToWidget.setParent( w, this );

        return container;
    }

    /**
     * This method must be called whenever a Widget is removed. It ensures that
     * the Widget's parent is cleared.
     *
     * @param w the widget to be disowned
     *
     * @return Parent Element
     */
    protected Element disown( Widget w )
    {
        // Only disown it if it's actually contained in this panel.
        if ( !isOur( w ) )
        {
            throw new IllegalArgumentException( "widget (" + w + ") is not a child of this panel" );
        }

        // Remove it at the DOM and GWT levels.
        Element elem = w.getElement();
        //noinspection NonJREEmulationClassesInClientCode
        BackDoorToWidget.setParent( w, null );
        return removeAsChildAndGetParent( elem );
    }

    protected Element removeAsChildAndGetParent( Element pElem )
    {
        Element zParent = DOM.getParent( pElem );
        DOM.removeChild( zParent, pElem );
        return zParent;
    }

    protected static Element prependChild( Element pParent, Element pChild )
    {
        DOM.insertChild( pParent, pChild, 0 );
        return pParent;
    }

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

    protected static Element getParentElement( Widget pWidget )
    {
        return DOM.getParent( pWidget.getElement() );
    }

    protected static Element getGrandParentElement( Widget pWidget )
    {
        return DOM.getParent( getParentElement( pWidget ) );
    }

    @Override
    protected void onAttach()
    {
        super.onAttach();

        // Ensure that all child widgets are attached.
        for ( Widget child : this )
        {
            //noinspection NonJREEmulationClassesInClientCode
            BackDoorToWidget.onAttach( child );
        }
    }

    @Override
    protected void onDetach()
    {
        super.onDetach();

        // Ensure that all child widgets are detached.
        for ( Widget child : this )
        {
            //noinspection NonJREEmulationClassesInClientCode
            BackDoorToWidget.onDetach( child );
        }
    }

    /**
     * Override this method to specify that an element other than the root element
     * be the container for the panel's child widget. This can be useful when you
     * want to create a simple panel that decorates its contents.
     *
     * @return the element to be used as the panel's container
     */
    protected Element getContainerElement()
    {
        return mContainerElement;
    }

    private Element mContainerElement;

    public void setContainerElement( Element pContainerElement )
    {
        mContainerElement = pContainerElement;
    }

    protected boolean isOur( Widget pWidget )
    {
        return (pWidget != null) && (pWidget.getParent() == this);
    }

    protected ISizeableWidget getSizeableWidget( Widget pWidget )
    {
        return (pWidget instanceof ISizeableWidget) ? (ISizeableWidget) pWidget : ISizeableWidget.NULL;
    }
}