package org.litesoft.GWT.client.widgets;

import com.google.gwt.user.client.ui.*;
import org.litesoft.GWT.client.*;
import org.litesoft.core.*;
import org.litesoft.core.delayed.*;
import org.litesoft.core.util.*;

public class SizeableVerticalFlowPanel extends SizeableHorizontalPanel
{
    private boolean mSizesDetermined = false;
    private int mMaxWidgetWidth;
    private int mMaxWidgetHeight;
    private WidgetPlus[] mWidgets;

    public SizeableVerticalFlowPanel( Widget... pChildren )
    {
        VerticalPanel zSizeDeterminer = new VerticalPanel();

        LLadd( new SizeableSpacer().stretchableVertically() );
        LLadd( new MyHtmlPanel( StaticSimpleIdSource.getNext(), zSizeDeterminer ) );

        if ( pChildren == null )
        {
            pChildren = new Widget[]{null};
        }
        mWidgets = new WidgetPlus[pChildren.length];
        for ( int i = 0; i < pChildren.length; i++ )
        {
            zSizeDeterminer.add( (mWidgets[i] = new WidgetPlus( pChildren[i] )).getWidget() );
        }
    }

    public SizeableVerticalFlowPanel style( String pStyleName )
    {
        addStyleName( pStyleName );
        return this;
    }

    //****** Implementation Code Block to support delegation to AbsoluteSizeHelper

    public SizeableVerticalFlowPanel stretchable()
    {
        LLstretchable();
        return this;
    }

    private void LLadd( Widget pWidget )
    {
        LLinsert( pWidget, getWidgetCount() );
    }

    private void LLinsert( Widget pWidget, int pBeforeIndex )
    {
        if ( pWidget != null )
        {
            adopt( pWidget, pBeforeIndex );
        }
    }

    @Override
    public void add( Widget pWidget )
    {
        throw new UnsupportedOperationException( "Children may NOT be added except via the Constructor" );
    }

    @Override
    public void insert( Widget pWidget, int pBeforeIndex )
    {
        throw new UnsupportedOperationException( "Children may NOT be added except via the Constructor" );
    }

    /**
     * @return False if need to try later, True if success / Can't proceed now
     */
    private boolean LLreflow()
    {
        if ( !isAttached() )
        {
            return true;
        }
        if ( !mSizesDetermined )
        {
            mMaxWidgetWidth = mMaxWidgetHeight = 0;
            for ( WidgetPlus zPlus : mWidgets )
            {
                Widget zWidget = zPlus.getWidget();
                if ( !zPlus.hasHeight() )
                {
                    int zHeight = zWidget.getOffsetHeight();
                    if ( zHeight < 1 )
                    {
                        return false;
                    }
                    zPlus.setHeight( zHeight );
                }
                int zWidth = zWidget.getOffsetWidth();
                if ( zWidth < 1 )
                {
                    return false;
                }
                mMaxWidgetWidth = Math.max( mMaxWidgetWidth, zWidth );
                mMaxWidgetHeight = Math.max( mMaxWidgetHeight, zPlus.getHeight() );
            }
            mSizesDetermined = true;
        }
        int zWorkingHeight = getLastSetHeight();
        if ( zWorkingHeight <= mMaxWidgetHeight ) // Note '=' to force adding 1 Pixel
        {
            return true; // No point in processing!
        }
        clear();
        LLadd( new SizeableSpacer().stretchableVertically() );
        MyColumn zColumn = new MyColumn( zWorkingHeight, mMaxWidgetWidth );
        for ( WidgetPlus zPlus : mWidgets )
        {
            if ( !zColumn.added( zPlus ) )
            {
                LLadd( zColumn );
                zColumn = new MyColumn( zWorkingHeight, mMaxWidgetWidth );
                zColumn.added( zPlus );
            }
        }
        LLadd( zColumn );
        return true;
    }

    private static class MyColumn extends VerticalPanel
    {
        private int mHeightRemaining;

        public MyColumn( int pHeightRemaining, int pDesiredWidth )
        {
            mHeightRemaining = pHeightRemaining - 1;
            add( new Spacer().height( 1 ).width( pDesiredWidth ) );
        }

        public boolean added( WidgetPlus pPlus )
        {
            int zHeight = pPlus.getHeight();
            if ( mHeightRemaining >= zHeight )
            {
                mHeightRemaining -= zHeight;
                add( pPlus.getWidget() );
                return true;
            }
            return false;
        }
    }

    private long LLreflowLater()
    {
        Long zOnOrAfter = mReflowOnOrAfter;
        mReflowOnOrAfter = UtilsCommon.now().getTime() + 50;
        if ( zOnOrAfter == null )
        {
            TimedRunnableManager.INSTANCE.runIn( mLaterReflow, 50 );
        }
        return mReflowOnOrAfter;
    }

    private Long mReflowOnOrAfter = null;
    private TimedRunnable mLaterReflow = new TimedRunnable()
    {
        public Again runOnce()
        {
            if ( mReflowOnOrAfter != null )
            {
                long zNow = UtilsCommon.now().getTime();
                if ( zNow < mReflowOnOrAfter )
                {
                    return new RunAgainOnOrAfter( mReflowOnOrAfter );
                }
                try
                {
                    if ( !LLreflow() )
                    {
                        return new RunAgainOnOrAfter( LLreflowLater() );
                    }
                }
                catch ( Exception e )
                {
                    e.printStackTrace();
                }
                mReflowOnOrAfter = null;
            }
            return null;
        }
    };

    // private implementation

    private String mLastWidth;

    public void setWidth( String width )
    {
        super.setWidth( width );
        if ( !UtilsCommon.areNonArraysEqual( mLastWidth, width ) )
        {
            mLastWidth = width;
            LLreflowLater();
        }
    }

    private int getLastSetHeight()
    {
        if ( mLastHeight != null )
        {
            try
            {
                return parse( mLastHeight );
            }
            catch ( NumberFormatException e )
            {
                // Fall Thru
            }
        }
        return 0;
    }

    private String mLastHeight;

    public void setHeight( String height )
    {
        super.setHeight( height );
        if ( !UtilsCommon.areNonArraysEqual( mLastHeight, height ) )
        {
            mLastHeight = height;
            LLreflowLater();
        }
    }

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

    private static class WidgetPlus
    {
        private Widget mWidget;
        private Integer mHeight = null;

        public WidgetPlus( Widget pWidget )
        {
            mWidget = (pWidget != null) ? pWidget : new Spacer();
        }

        public Widget getWidget()
        {
            return mWidget;
        }

        public boolean hasHeight()
        {
            return (mHeight != null);
        }

        public int getHeight()
        {
            return mHeight;
        }

        public void setHeight( int pHeight )
        {
            mHeight = pHeight;
        }
    }

    private static class MyHtmlPanel extends HTMLPanel
    {
        private static final String DIV_ID_PREFIX = "SVFP_";

        private static final String TRANSPARENT_SPACER = "<img width='1' height='1' src='" + TransparentImage.URL + "'>";

        public MyHtmlPanel( int zUniqueID, VerticalPanel pSizeDeterminer )
        {
            super( "<div id='" + DIV_ID_PREFIX + zUniqueID + "' style='height:1px; width:1px; overflow:hidden;'>" + TRANSPARENT_SPACER + "<br></div>" );

            add( pSizeDeterminer, DIV_ID_PREFIX + zUniqueID );
        }
    }
}