// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.forms.client.components.factories.others;

import java.util.*;

import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.GWT.forms.client.nonpublic.*;
import org.litesoft.ui.*;
import org.litesoft.ui.def.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.uispecification.*;

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

public abstract class AbstractVerticalOrHorizontalLayoutWidgetFactory extends AbstractLayoutWidgetFactory
{
    abstract protected boolean shouldHaveSplitters( StretchableStruct pStretchableStruct );

    abstract protected boolean isBlockStretchable( DefWidgetStruct pChildDefWidget );

    abstract protected AbstractSizeableOneDimensionalPanel createSplittersTitledBorderedPanel( String pTitle,
                                                                                               UiFont pTitleFont );

    abstract protected AbstractSizeableOneDimensionalPanel createSplittersBorderedPanel();

    abstract protected AbstractSizeableOneDimensionalPanel createSplittersNonBorderedPanel();

    abstract protected AbstractSizeableOneDimensionalPanel createRegularTitledBorderedPanel(
            Overflow pOverflowPolicy, String pTitle, UiFont pTitleFont );

    abstract protected AbstractSizeableOneDimensionalPanel createRegularBorderedPanel(
            Overflow pOverflowPolicy );

    abstract protected AbstractSizeableOneDimensionalPanel createRegularNonBorderedPanel(
            Overflow pOverflowPolicy );

    public Widget createContainerWidget( FormInstanceComponentHandler pComponentHandler, UiDef pUiDef,
                                         FormMetaData pFormMetaData, DefWidgetStruct[] pChildDefWidgets )
    {
        UiLayoutOneDimensionalDef zOneDimensionalDef = (UiLayoutOneDimensionalDef) pUiDef;
        StretchableStruct ss = new StretchableStruct( pChildDefWidgets, zOneDimensionalDef.isCentering() );
        return shouldHaveSplitters( ss ) ? //
               createSplitters( pFormMetaData, zOneDimensionalDef, ss, pChildDefWidgets ) :
               createRegular( pFormMetaData, zOneDimensionalDef, ss, pChildDefWidgets );
    }

    private Widget createSplitters( FormMetaData pFormMetaData, UiLayoutOneDimensionalDef pUiDef,
                                    StretchableStruct pSS, DefWidgetStruct[] pChildDefWidgets )
    {
        Overflow zOverflowPolicy = pUiDef.getOverflowPolicy();
        AbstractSizeableOneDimensionalPanel panel = createSplitterPanel( pFormMetaData, pUiDef );
        AbstractSizeablePanel rv = panel;
        List zWidgetStructBlocks = createBlocks( pSS, pChildDefWidgets, zOverflowPolicy );
        while ( zWidgetStructBlocks.size() > 2 )
        {
            addTo( panel, (WidgetStruct) zWidgetStructBlocks.remove( 0 ) );
            AbstractSizeableOneDimensionalPanel zNBP = createSplittersNonBorderedPanel();
            zNBP.LLstretchableHorizontally();
            zNBP.LLstretchableVertically();
            panel.add( zNBP );
            panel = zNBP;
        }
        addTo( panel, (WidgetStruct) zWidgetStructBlocks.remove( 0 ) );
        addTo( panel, (WidgetStruct) zWidgetStructBlocks.remove( 0 ) );
        return addStretchabilityAndStyle( rv, pUiDef, pSS );
    }

    private List createBlocks( StretchableStruct pSS, DefWidgetStruct[] pChildDefWidgets,
                               Overflow pOverflowPolicy )
    {
        List WidgetStructBlocks = new ArrayList();
        int from = 0;
        for ( int thru = from; (thru < pChildDefWidgets.length) && (pSS.getOrientationStretchables() > 1); )
        {
            if ( isBlockStretchable( pChildDefWidgets[thru] ) )
            {
                WidgetStructBlocks.add(
                        createOptionalBlock( pChildDefWidgets, from, thru, pOverflowPolicy ) );
                from = ++thru;
                pSS.decOrientationStretchables();
            }
            else
            {
                thru++;
            }
        }
        if ( from < pChildDefWidgets.length )
        {
            WidgetStructBlocks.add( createOptionalBlock( pChildDefWidgets, from, pChildDefWidgets.length - 1,
                                                         pOverflowPolicy ) );
        }
        return WidgetStructBlocks;
    }

    private WidgetStruct createOptionalBlock( DefWidgetStruct[] pChildDefWidgets, int pFrom, int pThru,
                                              Overflow pOverflowPolicy //
    )
    {
        if ( pFrom == pThru )
        {
            return pChildDefWidgets[pFrom];
        }
        AbstractSizeableOneDimensionalPanel panel = createRegularNonBorderedPanel( pOverflowPolicy );
        panel.LLstretchableHorizontally();
        panel.LLstretchableVertically();
        while ( pFrom <= pThru )
        {
            addTo( panel, pChildDefWidgets[pFrom++] );
        }
        return new WidgetStruct( panel );
    }

    private Widget createRegular( FormMetaData pFormMetaData, UiLayoutOneDimensionalDef pUiDef,
                                  StretchableStruct pSS, DefWidgetStruct[] pChildDefWidgets )
    {
        AbstractSizeableOneDimensionalPanel panel =
                createRegularPanel( pFormMetaData, pUiDef, pChildDefWidgets );
        for ( int i = 0; i < pChildDefWidgets.length; i++ )
        {
            addTo( panel, pChildDefWidgets[i] );
        }
        return addStretchabilityAndStyle( panel, pUiDef, pSS );
    }

    private AbstractSizeableOneDimensionalPanel createSplitterPanel( FormMetaData pFormMetaData,
                                                                     UiLayoutOneDimensionalDef pUiDef )
    {
        String zExtTitle = pUiDef.getExtTitle();
        if ( zExtTitle != null )
        {
            LabelMetaData md = pFormMetaData.getLabel( pUiDef );
            String zTitle = md.getExternalText();
            return createSplittersTitledBorderedPanel( zTitle, pUiDef.getTitleFont() );
        }
        if ( pUiDef.isBordered() )
        {
            return createSplittersBorderedPanel();
        }
        return createSplittersNonBorderedPanel();
    }

    protected AbstractSizeableOneDimensionalPanel createRegularPanel( FormMetaData pFormMetaData,
                                                                      UiLayoutOneDimensionalDef pUiDef,
                                                                      DefWidgetStruct[] pChildDefWidgets )
    {
        Overflow zOverflowPolicy = pUiDef.getOverflowPolicy();
        String zExtTitle = pUiDef.getExtTitle();
        if ( zExtTitle != null )
        {
            LabelMetaData md = pFormMetaData.getLabel( pUiDef );
            String zTitle = md.getExternalText();
            return createRegularTitledBorderedPanel( zOverflowPolicy, zTitle, pUiDef.getTitleFont() );
        }
        if ( pUiDef.isBordered() )
        {
            return createRegularBorderedPanel( zOverflowPolicy );
        }
        return createRegularNonBorderedPanel( zOverflowPolicy );
    }

    private void addTo( AbstractSizeableOneDimensionalPanel pPanel, WidgetStruct pChildDefWidget )
    {
        Widget widget = pChildDefWidget.getWidget();
        pPanel.add( widget );
        if ( pChildDefWidget.hasHorizontalAlignment() )
        {
            pPanel.setCellHorizontalAlignment( widget, pChildDefWidget.getHorizontalAlignment() );
        }
        else if ( pChildDefWidget.isFloodsX() && !(widget instanceof SizeManaged) )
        {
            widget.setWidth( "100%" );
        }
        if ( pChildDefWidget.hasVerticalAlignment() )
        {
            pPanel.setCellVerticalAlignment( widget, pChildDefWidget.getVerticalAlignment() );
        }
        else if ( pChildDefWidget.isFloodsY() && !(widget instanceof SizeManaged) )
        {
            widget.setHeight( "100%" );
        }
    }

    private Widget addStretchabilityAndStyle( AbstractSizeablePanel pPanel, UiLayoutDef pUiDef,
                                              StretchableStruct pSS )
    {
        return addStretchabilityAndStyle( pPanel, pUiDef, //
                                          pSS.getHorizontals() > 0, //
                                          pSS.getVerticals() > 0 );
    }

    protected static class StretchableStruct
    {
        private int mHorizontals = 0;
        private int mHorizontalSpacers = 0;
        private int mVerticals = 0;
        private int mVerticalSpacers = 0;

        public StretchableStruct( DefWidgetStruct[] pDefWidgets, boolean pCenterAll )
        {
            for ( int i = 0; i < pDefWidgets.length; i++ )
            {
                DefWidgetStruct zDefWidget = pDefWidgets[i];

                if ( pCenterAll )
                {
                    zDefWidget.center();
                }
                if ( zDefWidget.isStretchableHorizontally() )
                {
                    mHorizontals++;
                    if ( zDefWidget.isSpacer() )
                    {
                        mHorizontalSpacers++;
                    }
                }
                if ( zDefWidget.isStretchableVertically() )
                {
                    mVerticals++;
                    if ( zDefWidget.isSpacer() )
                    {
                        mVerticalSpacers++;
                    }
                }
            }
        }

        public int getHorizontals()
        {
            return mHorizontals;
        }

        public int getHorizontalSpacers()
        {
            return mHorizontalSpacers;
        }

        public int getVerticals()
        {
            return mVerticals;
        }

        public int getVerticalSpacers()
        {
            return mVerticalSpacers;
        }

        public void setOrientationStretchables( int pOrientationStretchables )
        {
            mOrientationStretchables = pOrientationStretchables;
        }

        private int mOrientationStretchables = 0;

        public int getOrientationStretchables()
        {
            return mOrientationStretchables;
        }

        public void decOrientationStretchables()
        {
            mOrientationStretchables--;
        }
    }
}