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

import java.util.*;

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

public abstract class AbstractSizeableOneDimensionalPanel extends AbstractSizeableHasAlignmentPanel implements IndexedPanel
{
    private WidgetCollection mChildren = new WidgetCollection( this );

    @Override
    public boolean anyChildren()
    {
        return (mChildren.size() != 0);
    }

    /**
     * Gets the list of children contained in this panel.
     *
     * @return a collection of child widgets
     */
    protected WidgetCollection getChildren()
    {
        return mChildren;
    }

    // vvvvvvvvvvv HasWidgets

    /**
     * Removes all child widgets.
     */
    @Override
    public void clear()
    {
        // Reverse order for SplitPairs
        while ( anyChildren() )
        {
            remove( getWidgetCount() - 1 );
        }
    }

    /**
     * Gets an iterator for the contained widgets. This iterator is required to
     * implement {@link Iterator#remove()}.
     */
    @Override
    public Iterator<Widget> iterator()
    {
        return mChildren.iterator();
    }

    /**
     * Adds a child widget.
     *
     * @param pWidget the widget to be added
     *
     * @throws UnsupportedOperationException if this method is not supported (most
     *                                       often this means that a specific overload must be called)
     */
    @Override
    public void add( Widget pWidget )
    {
        insert( pWidget, getWidgetCount() );
    }

    /**
     * Removes a child widget.
     *
     * @param pWidget the widget to be removed
     *
     * @return <code>true</code> if the widget was present
     */
    @Override
    public boolean remove( Widget pWidget )
    {
        // Make sure this panel actually contains the child widget.
        if ( !mChildren.contains( pWidget ) )
        {
            return false;
        }

        // Disown it.
        disown( pWidget );
        return true;
    }

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

    /**
     * Inserts a widget before the specified index.
     *
     * @param pWidget      the widget to be inserted
     * @param pBeforeIndex the index before which it will be inserted
     *
     * @throws IndexOutOfBoundsException if <code>beforeIndex</code> is out of
     *                                   range
     */
    public void insert( Widget pWidget, int pBeforeIndex )
    {
        if ( pWidget != null )
        {
            adopt( pWidget, pBeforeIndex );
        }
    }

    protected Widget getFirstWidget()
    {
        return anyChildren() ? getWidget( 0 ) : null;
    }

    protected Widget getLastWidget()
    {
        return anyChildren() ? getWidget( getWidgetCount() - 1 ) : null;
    }

    // vvvvvvvvvvv IndexedPanel

    @Override
    public Widget getWidget( int pIndex )
    {
        return getChildren().get( pIndex );
    }

    @Override
    public int getWidgetCount()
    {
        return getChildren().size();
    }

    @Override
    public int getWidgetIndex( Widget pChild )
    {
        return getChildren().indexOf( pChild );
    }

    @Override
    public boolean remove( int pIndex )
    {
        return remove( getWidget( pIndex ) );
    }

    // ^^^^^^^^^^^ IndexedPanel

    @Override
    protected final Element adopt( Widget w, Element container )
    {
        throw new IllegalStateException( "Inappropriate use of raw adopt( Widget w, Element container )" );
    }

    /**
     * Do everything to insert pWidget at the appropriate place
     *
     * @param pWidget !null
     */
    protected void adopt( Widget pWidget, int pBeforeIndex )
    {
        if ( aboutToAdopt( pWidget, pBeforeIndex ) )
        {
            LLadopt( pWidget, pBeforeIndex );
            justAdopted( pWidget, pBeforeIndex );
        }
    }

    /**
     * Do everything to remove pWidget
     *
     * @param pWidget !null
     */
    @Override
    protected Element disown( Widget pWidget )
    {
        int index = mChildren.indexOf( pWidget );
        if ( index == -1 )
        {
            throw new IllegalStateException( "Attempt to 'disown' widget (" + pWidget + ") not owned by: " + this );
        }
        if ( aboutToDisown( pWidget, index ) )
        {
            LLdisown( pWidget, index );
            justDisowned( pWidget, index );
        }
        return null; // We Don't Care
    }

    protected void LLdisown( Widget pWidget, int pIndex )
    {
        Element td = abstractSizeablePanel_disown( pWidget ); // remove Widget from td
        DOM.removeChild( getContainerElement(), unwrap( td ) );
        mChildren.remove( pIndex );
    }

    protected void LLadopt( Widget pWidget, int pBeforeIndex )
    {
        pWidget.removeFromParent();
        Element td = DOM.createTD();
        abstractSizeablePanel_adopt( pWidget, td ); // put Widget in TD
        DOM.insertChild( getContainerElement(), wrap( td ), pBeforeIndex );
        mChildren.insert( pWidget, pBeforeIndex );
    }

    protected Element abstractSizeablePanel_disown( Widget pWidget )
    {
        return super.disown( pWidget );
    }

    protected void abstractSizeablePanel_adopt( Widget pWidget, Element pContainer )
    {
        super.adopt( pWidget, pContainer );
    }

    /**
     * Override point for special behavior of index based addition, before adding.
     * Could throw an exception!
     *
     * @return true if OK to add
     */
    protected boolean aboutToAdopt( Widget pWidget, int pBeforeIndex )
    {
        return true;
    }

    /**
     * Override point for special behavior of index based addition.
     * Should not throw an exception!
     */
    protected void justAdopted( Widget pWidget, int pWidgetIndex )
    {
    }

    /**
     * Override point for special behavior of index based removal, before removing.
     * Could throw an exception!
     *
     * @return true if OK to add
     */
    protected boolean aboutToDisown( Widget pWidget, int pBeforeIndex )
    {
        return true;
    }

    /**
     * Override point for special behavior of index based removal.
     * Should not throw an exception!
     */
    protected void justDisowned( Widget pWidget, int pWidgetIndex )
    {
    }

    abstract protected Element unwrap( Element pTD );

    abstract protected Element wrap( Element pTD );
}