// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.render;

import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;

public abstract class AbstractRenderOneDimensionalContainerHelper extends AbstractRenderContainerHelper
{
    private RenderContainerChildrenPolicy mChildrenPolicy;

    protected AbstractRenderOneDimensionalContainerHelper( Object pRectangularRenderableObject, //
                                                           RenderAccessor pRenderAccessor, //
                                                           RenderParticipatingAdapter pParticipatingAdapter,
                                                           //
                                                           RenderDimensionAdapter pDimensionAdapter, //
                                                           RenderContainmentApproach pContainmentApproach, //
                                                           RenderContainerChildrenPolicy pChildrenPolicy )
    {
        super( pRectangularRenderableObject, pRenderAccessor, pParticipatingAdapter, pDimensionAdapter, pContainmentApproach );
        Objects.assertNotNull( "ChildrenPolicy", mChildrenPolicy = pChildrenPolicy );
    }

    /**
     * @param pChildHelpers !null /
     *
     * @return null means that someone is not ready, otherwise the current Calculated Minimum Size
     */
    protected Integer calculateChildrenMinimumSize( RenderHelper[] pChildHelpers )
    {
        int[] zMinimumSizes = new int[pChildHelpers.length];
        for ( int i = 0; i < pChildHelpers.length; i++ )
        {
            Integer zMinimumSize = pChildHelpers[i].getMinimumSize();
            if ( zMinimumSize == null )
            {
                return null;
            }
            zMinimumSizes[i] = zMinimumSize;
        }
        return RenderContainerChildrenPolicy.Distribute.equals( mChildrenPolicy ) ? //
               sum( zMinimumSizes ) : //
               max( zMinimumSizes );
    }

    protected RenderProcessResult LLadjustChildSizesAfterLayout( LayoutContainerRHP pLayoutContainerRHP, RenderHelper[] pChildHelpers )
    {
        if ( RenderContainerChildrenPolicy.Propogate.equals( mChildrenPolicy ) )
        {
            boolean anySizableKids = false;
            boolean allChildrenSizing = true;
            int[] zCurSizes = new int[pChildHelpers.length];
            for ( int i = 0; i < pChildHelpers.length; i++ )
            {
                RenderHelper zChildHelper = pChildHelpers[i];
                Integer zSize = zChildHelper.getCurrentSize();
                if ( zSize == null )
                {
                    deferPending( pLayoutContainerRHP, zChildHelper.unavailableCurrentSizeRHP() );
                    allChildrenSizing = false;
                }
                else
                {
                    zCurSizes[i] = zSize;
                    anySizableKids |= zChildHelper.isSizable();
                }
            }
            if ( !allChildrenSizing )
            {
                return RenderProcessResult.Requeued;
            }
            if ( anySizableKids )
            {
                boolean anyFloodings = false;
                int zMaxSize = max( zCurSizes );
                for ( RenderHelper zChildHelper : pChildHelpers )
                {
                    if ( zChildHelper.isSizable() )
                    {
                        Integer zChildSize = zChildHelper.getCurrentSize();
                        if ( zChildSize == null )
                        {
                            deferPending( pLayoutContainerRHP, zChildHelper.unavailableCurrentSizeRHP() );
                            return RenderProcessResult.Requeued;
                        }
                        if ( zMaxSize > zChildSize )
                        {
                            RenderHelperProcess zChildHelperProcess = zChildHelper.floodSetSize( zMaxSize );
                            if ( zChildHelperProcess != null )
                            {
                                deferPending( pLayoutContainerRHP, zChildHelperProcess );
                                anyFloodings = true;
                            }
                        }
                    }
                }
                if ( anyFloodings )
                {
                    return RenderProcessResult.Requeued;
                }
            }
        }
        return RenderProcessResult.Completed;
    }

    public final RenderHelper[] getChildHelpers()
    {
        Object[] zChildObjects = getChildObjects();
        if ( UtilsCommon.isNullOrEmpty( zChildObjects ) )
        {
            return RenderHelper.EMPTY_ARRAY;
        }
        RenderHelper[] zHelpers = new RenderHelper[zChildObjects.length];
        for ( int i = 0; i < zChildObjects.length; i++ )
        {
            Object zChildObject = zChildObjects[i];
            RenderHelper zHelper = getChildHelper( zChildObject );
            if ( zHelper == null )
            {
                putChildHelper( zChildObject, zHelper = getRenderHelperForChildObject( zChildObject ) );
            }
            zHelpers[i] = zHelper;
        }
        return zHelpers;
    }

    abstract protected Object[] getChildObjects();

    abstract protected RenderHelper getRenderHelperForChildObject( Object pRectangularRenderableObject );

    /**
     * Set the Size - pCurrentSize != pNewSize
     */
    protected RenderProcessResult LLLsetSize( MutateSizeRHP pMutateSizeRHP, int pCurrentSize, int pNewSize )
    {
        setSizingChange( pCurrentSize, pNewSize );
        switch ( getSizingApproach() )
        {
            case Adjustable:
                return wrapping_adjustSizeTo( pMutateSizeRHP, pNewSize );

            default: // Should Never Happen...
            case Settable:
                return clipping_setSizeTo( pMutateSizeRHP, pNewSize );
        }
    }

    /**
     * Set the Size - pNewSize != The Current Size
     */
    private RenderProcessResult wrapping_adjustSizeTo( MutateSizeRHP pMutateSizeRHP, int pNewSize )
    {
        AbstractRHPwithDependencies zRenderHelperProcess = (AbstractRHPwithDependencies) unavailableCurrentSizeRHP();
        deferPending( pMutateSizeRHP, zRenderHelperProcess );
        processChildren( zRenderHelperProcess, pNewSize );
        // Set our Size so that we might "stretch"
        getDimensionAdapter().setSize( getRectangularRenderableObject(), pNewSize );
        return RenderProcessResult.Requeued;
    }

    /**
     * Set the Size - pNewSize != The Current Size
     */
    private RenderProcessResult clipping_setSizeTo( MutateSizeRHP pMutateSizeRHP, int pNewSize )
    {
        getDimensionAdapter().setSize( getRectangularRenderableObject(), pNewSize ); // Set our Size
        // Make us wait until we get the size!
        deferPending( pMutateSizeRHP, unavailableCurrentSizeRHP() );
        processChildren( null, pNewSize );
        return RenderProcessResult.Requeued;
    }

    /**
     * Set the child Size(s) - pNewSize != The Current Size
     */
    private void processChildren( AbstractRHPwithDependencies pRHPtoDefer, int pNewSize )
    {
        RenderHelper[] zChildHelpers = getChildHelpers();
        if ( zChildHelpers.length != 0 )
        {
            Integer zDecorationSize = getDecorationSize();
            if ( zDecorationSize == null )
            {
                LOGGER.error.log( "No Decoration Size on ", this, //
                                  " w/ Sizes: " + getCurrentSize() + " Current", //
                                  ", " + getMinimumSize() + " Minimum", //
                                  ", " + getNaturalSize() + " Natural", //
                                  ", " + getRectSizeNow() + " Now" );
                return;
            }
            int zInnerSize = pNewSize - zDecorationSize;
            if ( LOGGER.trace.isEnabled() )
            {
                LOGGER.trace.log( "Size Children to " + zInnerSize, //
                                  " from ( " + pNewSize + " - " + zDecorationSize + " ) ", " on ", this, //
                                  " w/ Sizes: " + getCurrentSize() + " Current", //
                                  ", " + getMinimumSize() + " Minimum", //
                                  ", " + getNaturalSize() + " Natural", //
                                  ", " + getRectSizeNow() + " Now" );
            }
            switch ( mChildrenPolicy )
            {
                default: // should never happen!
                case Propogate:
                    propogateToChildren( pRHPtoDefer, zChildHelpers, zInnerSize );
                    break;
                case Distribute:
                    distributeToChildren( pRHPtoDefer, zChildHelpers, zInnerSize );
                    break;
            }
        }
    }

    /**
     * This should work because we should have previously Flooded!
     *
     * @param pNewSize !0
     */
    private void propogateToChildren( AbstractRHPwithDependencies pRHPtoDefer, RenderHelper[] pChildHelpers, int pNewSize )
    {
        for ( RenderHelper zHelper : pChildHelpers )
        {
            if ( zHelper.isSizable() )
            {
                adjustChildTo( pRHPtoDefer, zHelper, pNewSize );
            }
        }
    }

    private void adjustChildTo( AbstractRHPwithDependencies pRHPtoDefer, RenderHelper pHelper, int pNewSize )
    {
        RenderHelperProcess zProcess = pHelper.floodSetSize( pNewSize );
        if ( (pRHPtoDefer != null) && (zProcess != null) )
        {
            deferPending( pRHPtoDefer, zProcess );
        }
    }

    /**
     * @param pNewSize !0
     */
    private void distributeToChildren( AbstractRHPwithDependencies pRHPtoDefer, RenderHelper[] pChildHelpers, int pNewSize )
    {
        int zSumChildSizes = 0;
        DistributeToChildren zDC = new DistributeToChildren();
        for ( int i = 0; i < pChildHelpers.length; i++ )
        {
            RenderHelper zHelper = pChildHelpers[i];
            Integer zCurrentSize = zHelper.getCurrentSize();
            Integer zMinimumSize = zHelper.getMinimumSize();
            if ( (zCurrentSize == null) || (zMinimumSize == null) )
            {
                LOGGER.error.log( "Child ", zHelper, " of ", this, " w/ Sizes: ", //
                                  zCurrentSize, " Current, ", zMinimumSize, " Minimum" );
            }
            zSumChildSizes += zCurrentSize;
            if ( zHelper.isSizable() )
            {
                int zMaxShrinkAllowed = zCurrentSize - zMinimumSize;
                zDC.add( new ChildAdjustStruct( i, zMaxShrinkAllowed ) );
            }
        }
        if ( zDC.hasChildren() )
        {
            int zAdjustSizeBy = pNewSize - zSumChildSizes;
            mIndexOfLastAdjusted = zDC.distribute( zAdjustSizeBy, mIndexOfLastAdjusted );
            for ( ChildAdjustStruct zChild : zDC.getChildren() )
            {
                int zAdjustBy = zChild.getAdjustBy();
                if ( zAdjustBy != 0 )
                {
                    adjustChildBy( pRHPtoDefer, pChildHelpers[zChild.getIndex()], zAdjustBy );
                }
            }
        }
    }

    private void adjustChildBy( AbstractRHPwithDependencies pRHPtoDefer, RenderHelper pHelper, int pAdjustBy )
    {
        RenderHelperProcess zProcess = pHelper.floodAdjustSizeBy( pAdjustBy );
        if ( (pRHPtoDefer != null) && (zProcess != null) )
        {
            deferPending( pRHPtoDefer, zProcess );
        }
    }

    private int mIndexOfLastAdjusted = -1;

    public String toString()
    {
        return toString( "1dContainer" );
    }
}