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

import java.util.*;

import org.litesoft.GWT.client.widgets.*;
import org.litesoft.core.delayed.*;

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

public abstract class AbstractSizeableDockingPanel extends AbstractSizeablePanel implements IndexedPanel
{
    private abstract static class ExtendedDockPosition
    {
        private NEWSposition mPosition;
        private int mChildIndex;
        private boolean mHorizontal;

        public ExtendedDockPosition( NEWSposition pPosition, int pChildIndex, boolean pHorizontal )
        {
            mPosition = pPosition;
            mChildIndex = pChildIndex;
            mHorizontal = pHorizontal;
        }

        public NEWSposition getPosition()
        {
            return mPosition;
        }

        public int getChildIndex()
        {
            return mChildIndex;
        }

        public boolean isHorizontal()
        {
            return mHorizontal;
        }

        public void checkAcceptability( ISizeableWidget pWidget )
        {
            if ( mHorizontal && !pWidget.getHeightHelper().isStretchable() )
            {
                throw new IllegalArgumentException( "Docked Widget not Vertically Stretchable" );
            }
            if ( !mHorizontal && !pWidget.getWidthHelper().isStretchable() )
            {
                throw new IllegalArgumentException( "Docked Widget not Horizontally Stretchable" );
            }
        }

        public void add( Element pTD, Widget pWidget, WidgetCollection pChildren, Element pContainerElement )
        {
            if ( pChildren.size() == 0 )
            {
                pChildren.add( pWidget );
                appendChild( pContainerElement, appendChild( DOM.createTR(), pTD ) );
            }
            else
            {
                LLadd( pTD, pWidget, pChildren, pContainerElement, pChildren.get( 0 ) );
            }
        }

        abstract protected void LLadd( Element pTD, Widget pWidget, WidgetCollection pChildren,
                                       Element pContainerElement, Widget pContentWidget );
    }

    private static final ExtendedDockPosition NORTH = new ExtendedDockPosition( NEWSposition.NORTH, 0, false )
    {
        protected void LLadd( Element pTD, Widget pWidget, WidgetCollection pChildren,
                              Element pContainerElement, Widget pContentWidget )
        {
            pChildren.insert( pWidget, 0 );
            prependChild( pContainerElement, appendChild( DOM.createTR(), pTD ) );
        }
    };

    private static final ExtendedDockPosition EAST = new ExtendedDockPosition( NEWSposition.EAST, 1, true )
    {
        protected void LLadd( Element pTD, Widget pWidget, WidgetCollection pChildren,
                              Element pContainerElement, Widget pContentWidget )
        {
            pChildren.add( pWidget );
            appendChild( getGrandParentElement( pContentWidget ), pTD );
        }
    };

    private static final ExtendedDockPosition WEST = new ExtendedDockPosition( NEWSposition.WEST, 0, true )
    {
        protected void LLadd( Element pTD, Widget pWidget, WidgetCollection pChildren,
                              Element pContainerElement, Widget pContentWidget )
        {
            pChildren.insert( pWidget, 0 );
            prependChild( getGrandParentElement( pContentWidget ), pTD );
        }
    };

    private static final ExtendedDockPosition SOUTH = new ExtendedDockPosition( NEWSposition.SOUTH, 1, false )
    {
        protected void LLadd( Element pTD, Widget pWidget, WidgetCollection pChildren,
                              Element pContainerElement, Widget pContentWidget )
        {
            pChildren.add( pWidget );
            appendChild( pContainerElement, appendChild( DOM.createTR(), pTD ) );
        }
    };

    private ExtendedDockPosition mCurrentDockPosition = null;
    private WidgetCollection mChildren = new WidgetCollection( this );

    public NEWSposition getDockedPosition()
    {
        return (mCurrentDockPosition == null) ? null : mCurrentDockPosition.getPosition();
    }

    private boolean isHorizontal()
    {
        return (mCurrentDockPosition != null) && mCurrentDockPosition.isHorizontal();
    }

    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.
     */
    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()}.
     */
    public Iterator 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)
     */
    public void add( Widget pWidget )
    {
        throw new UnsupportedOperationException(
                "SizeableDockingPanel does NOT support generic add(), please use the specific set...()" );
    }

    /**
     * Removes a child widget.
     *
     * @param pWidget the widget to be removed
     *
     * @return <code>true</code> if the widget was present
     */
    public boolean remove( Widget pWidget )
    {
        if ( pWidget == getContentWidget() )
        {
            removeContentWidget();
            return true;
        }
        if ( pWidget == getDockedWidget() )
        {
            removeDockedWidget();
            return true;
        }
        return true;
    }

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

    // vvvvvvvvvvv IndexedPanel

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

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

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

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

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

    /**
     * @return the content widget, or <code>null</code> if none is present
     */
    public Widget getContentWidget()
    {
        switch ( getWidgetCount() )
        {
            case 2:
                return getWidget( 1 - mCurrentDockPosition.getChildIndex() );
            case 1:
                if ( mCurrentDockPosition == null )
                {
                    return getWidget( 0 );
                }
                // Fall Thru
            case 0:
            default:
                return null;
        }
    }

    /**
     * Sets this panel's content widget. Any existing content widget will be removed.
     */
    public void setContentWidget( ISizeableWidget pWidget )
    {
        // If there is already a widget attached, remove it.
        LLremoveContentWidget();

        if ( pWidget != null )
        {
            if ( !pWidget.getHeightHelper().isStretchable() )
            {
                throw new IllegalArgumentException( "Content Widget not Vertically Stretchable" );
            }
            if ( !pWidget.getWidthHelper().isStretchable() )
            {
                throw new IllegalArgumentException( "Content Widget not Horizontally Stretchable" );
            }
            // Adopt the child.
            Widget zWidget = (Widget) pWidget;
            if ( !aboutToAdopt( zWidget ) )
            {
                return;
            }
            Element td = LLadopt( zWidget );

            switch ( NEWSposition.deNull( getDockedPosition(), NEWSposition.NORTH ) )
            {
                default:
                case NORTH: // Simply Append Row on End
                    mChildren.add( zWidget );
                    appendChild( getContainerElement(), appendChild( DOM.createTR(), td ) );
                    break;
                case WEST: // Append Column after DockWidget
                    mChildren.add( zWidget );
                    appendChild( getGrandParentElement( getDockedWidget() ), td );
                    break;
                case EAST: // Insert Column before DockWidget
                    mChildren.insert( zWidget, 0 );
                    prependChild( getGrandParentElement( getDockedWidget() ), td );
                    break;
                case SOUTH: // Insert Row before DockWidget
                    mChildren.insert( zWidget, 0 );
                    prependChild( getContainerElement(), appendChild( DOM.createTR(), td ) );
                    break;
            }
            justAdopted( zWidget );
        }
        relayout();
    }

    public void removeContentWidget()
    {
        LLremoveContentWidget();
        relayout();
    }

    private void LLremoveContentWidget()
    {
        // If there is a widget attached, remove it.
        Widget zWidget = getContentWidget();
        if ( (zWidget != null) && aboutToDisown( zWidget ) )
        {
            mChildren.remove( zWidget );
            Element td = super.disown( zWidget );// remove Widget from td
            Element tr = removeAsChildAndGetParent( td );// remove td

            if ( !isHorizontal() || (mChildren.size() == 0) )
            {
                removeAsChildAndGetParent( tr );// remove tr
            }
            justDisowned( zWidget );
        }
    }

    /**
     * Sets this panel's content widget. Any existing content widget will be removed.
     */
    public void removeDockedWidget()
    {
        LLremoveDockedWidget();
        relayout();
    }

    private void LLremoveDockedWidget()
    {
        // If there is a widget attached, remove it.
        Widget zWidget = getDockedWidget();
        if ( (zWidget != null) && aboutToDisown( zWidget ) )
        {
            mChildren.remove( zWidget );
            Element td = super.disown( zWidget );// remove Widget from td
            Element tr = removeAsChildAndGetParent( td );// remove td

            if ( !mCurrentDockPosition.isHorizontal() || (mChildren.size() == 0) )
            {
                removeAsChildAndGetParent( tr );// remove tr
            }
            mCurrentDockPosition = null;
            justDisowned( zWidget );
        }
    }

    /**
     * @return the content widget, or <code>null</code> if none is present
     */
    public Widget getDockedWidget()
    {
        switch ( getWidgetCount() )
        {
            case 2:
                return getWidget( mCurrentDockPosition.getChildIndex() );
            case 1:
                if ( mCurrentDockPosition != null )
                {
                    return getWidget( 0 );
                }
                // Fall Thru
            case 0:
            default:
                return null;
        }
    }

    public NEWSposition getDockedWidgetPosition()
    {
        return mCurrentDockPosition != null ? mCurrentDockPosition.getPosition() : null;
    }

    public void setDockedWidget( NEWSposition pPosition, ISizeableWidget pWidget )
    {
        // If there is already a widget attached, remove it.
        LLremoveDockedWidget();

        if ( (pPosition != null) && (pWidget != null) )
        {
            ExtendedDockPosition zExtPosition = convert( pPosition );

            zExtPosition.checkAcceptability( pWidget );

            // Adopt the child.
            Widget zWidget = (Widget) pWidget;
            if ( !aboutToAdopt( zWidget ) )
            {
                return;
            }
            Element td = LLadopt( zWidget );

            zExtPosition.add( td, zWidget, mChildren, getContainerElement() );
            mCurrentDockPosition = zExtPosition;
            justAdopted( zWidget );
        }
        relayout();
    }

    private ExtendedDockPosition convert( NEWSposition pPosition )
    {
        switch ( NEWSposition.deNull( pPosition, NEWSposition.NORTH ) )
        {
            default:
            case NORTH:
                return NORTH;
            case EAST:
                return EAST;
            case WEST:
                return WEST;
            case SOUTH:
                return SOUTH;
        }
    }

    /**
     * @return TD
     */
    private Element LLadopt( Widget pWidget )
    {
        return super.adopt( pWidget, DOM.createTD() ); // put Widget in TD
    }

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

    protected Element disown( Widget w )
    {
        throw new IllegalStateException( "Inappropriate use of raw disown( Widget w )" );
    }

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

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

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

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

    public void setWidth( String width )
    {
        super.setWidth( width ); // for stacktrace Debugging
    }

    public void setHeight( String height )
    {
        super.setHeight( height ); // for stacktrace Debugging
    }

    private MyDistributeToChildren mWidthDistributeToChildren =
            new MyDistributeToChildren( getWidthHelper(), true );

    protected void distributeToChildrenChangedWidth()
    {
        mWidthDistributeToChildren.distributeToChildren();
//        if ( getDockedWidget() instanceof AbstractSizeableWidget)
//        {
// todo: Firefox 'bug': When adding an Overflow Hidden horizontally to a table in an Overflow Hidden will automatically set the size of the new/inner Overflow Hidden to the smaller of whatever space is left or its natural size!
//            AbstractSizeableWidget zSDW = (AbstractSizeableWidget) getDockedWidget();
//            AbstractSizeableHelper zHelper = zSDW.getHelper();
//            int zOuter = dimensionHelper.getDimension( zHelper.getOuterElement() );
//            int zStyle = dimensionHelper.getDimension( zHelper.getStyleElement() );
//            int zInner = dimensionHelper.getDimension( zHelper.getInnerElement() );
//            StatusBar.set( "Outer: " + zOuter + "  Style: " + zStyle + "  Inner: " + zInner );
//            if ( zStyle < zInner )
//            {
//                getDockedWidget().setWidth( "" + (zStyle + zInner) );
//            }
//        }
    }

    private MyDistributeToChildren mHeightDistributeToChildren =
            new MyDistributeToChildren( getHeightHelper(), false );

    protected void distributeToChildrenChangedHeight()
    {
        mHeightDistributeToChildren.distributeToChildren();
    }

    private boolean needToDelaySizeDistribution( ISizeableDimensionHelper pDimensionHelper )
    {
        Widget zDockedWidget = getDockedWidget();
        if ( zDockedWidget != null )
        {
            int zDockedSize = pDimensionHelper.getDimension( zDockedWidget );
            return zDockedSize == 0;
        }
        return false;
    }

    protected void distributeToChildrenChangedDimension( ISizeableDimensionHelper pDimensionHelper,
                                                         boolean pDistributeOverTheTwoIfThere )
    {
        if ( anyChildren() )
        {
            Widget zContentWidget, zDockedWidget = getDockedWidget();
            if ( !pDistributeOverTheTwoIfThere || (zDockedWidget == null) )
            {
                getHelper().applyChangedDimensionToChildren( this, pDimensionHelper );
            }
            else if ( null != (zContentWidget = getContentWidget()) )
            {
                int zOurSize = pDimensionHelper.getDimension( this );
                int zDockedSize = pDimensionHelper.getDimension( zDockedWidget );
                int zContentSize = zOurSize - zDockedSize;
//                StatusBar.set( pDimensionHelper.getWhat() + " OurSize:" + zOurSize + " DockedSize:" +
//                               zDockedSize + " ContentSize:" + zContentSize );
                pDimensionHelper.setDimension( zContentWidget, zContentSize );
            }
        }
    }

    private class MyDistributeToChildren implements DelayedProcess
    {
        private EscalatingProcess mEscalatingProcess = null;
        private ISizeableDimensionHelper mDimensionHelper;
        private boolean mDistributeIfHorizontal;

        public MyDistributeToChildren( ISizeableDimensionHelper pDimensionHelper,
                                       boolean pDistributeIfHorizontal )
        {
            mDimensionHelper = pDimensionHelper;
            mDistributeIfHorizontal = pDistributeIfHorizontal;
        }

        public boolean process()
        {
            if ( !needToDelaySizeDistribution( mDimensionHelper ) )
            {
                distributeToChildrenChangedDimension( mDimensionHelper,
                                                      mDistributeIfHorizontal == isHorizontal() );
                return true;
            }
            return false;
        }

        public void distributeToChildren()
        {
            if ( process() )
            {
                if ( mEscalatingProcess != null )
                {
                    mEscalatingProcess.cancel();
                }
            }
            else
            {
                if ( mEscalatingProcess == null )
                {
                    mEscalatingProcess = new EscalatingProcess( this );
                }
                if ( !mEscalatingProcess.isLive() )
                {
                    mEscalatingProcess.schedule();
                }
            }
        }
    }
}