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

import java.util.*;

import org.litesoft.core.typeutils.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.uispecification.*;

public abstract class AbstractRenderContainerHelper extends AbstractSizableRenderHelper implements RenderContainerHelper
{
    protected AbstractRenderContainerHelper( Object pRectangularRenderableObject, //
                                             RenderAccessor pRenderAccessor, //
                                             RenderParticipatingAdapter pParticipatingAdapter, //
                                             RenderDimensionAdapter pDimensionAdapter, //
                                             RenderContainmentApproach pContainmentApproach )
    {
        super( pRectangularRenderableObject, pRenderAccessor, pContainmentApproach.getSizingApproach(), pParticipatingAdapter, pDimensionAdapter );

        mContainmentApproach = RenderContainmentApproach.deNull( pContainmentApproach );

        mDetermineNaturalSize = new DetermineNaturalSizeRHP( mRROname, this, //
                                                             mDetermineRectSizeNow, new DetermineContainerNaturalChildSizesRHP( mRROname, this ) );

        mDetermineContainerDecorationSize = new DetermineContainerDecorationSizeRHP( mRROname, this, //
                                                                                     mDetermineRectSizeNow, //
                                                                                     mDetermineNaturalSize );
        mLayoutContainer = new LayoutContainerRHP( mRROname, this, //
                                                   mDetermineRectSizeNow, //
                                                   mDetermineNaturalSize, //
                                                   mDetermineContainerDecorationSize );

        mDetermineCurrentSize = new DetermineCurrentSizeRHP( mRROname, this, //
                                                             mDetermineRectSizeNow, //
                                                             mDetermineNaturalSize, //
                                                             mLayoutContainer );

        DetermineContainerCurrentChildSizesRHP zCurrentChildSizesRHP = new DetermineContainerCurrentChildSizesRHP( mRROname, this );

        if ( Overflow.None.equals( mContainmentApproach.getOverflow() ) )
        {
            mDetermineContainerMinimumSize = new DetermineContainerMinimumSizeRHP( mRROname, this, //
                                                                                   mDetermineCurrentSize );
            mMutateSize = new MutateSizeRHP( mRROname, this, //
                                             mDetermineCurrentSize, //
                                             mDetermineContainerMinimumSize, //
                                             zCurrentChildSizesRHP );
        }
        else
        {
            mDetermineContainerMinimumSize = null;
            mMutateSize = new MutateSizeRHP( mRROname, this, //
                                             mDetermineCurrentSize, //
                                             zCurrentChildSizesRHP );
        }
    }

    private RenderContainmentApproach mContainmentApproach;
    private Integer mDecorationSize = null;

    protected final DetermineContainerDecorationSizeRHP mDetermineContainerDecorationSize;
    protected final LayoutContainerRHP mLayoutContainer;
    protected final DetermineContainerMinimumSizeRHP mDetermineContainerMinimumSize;

    public Integer getDecorationSize()
    {
        if ( getNaturalSize() == null )
        {
            return null;
        }
        if ( mDecorationSize == null )
        {
            Object zRectangularRenderableObject = getRectangularRenderableObject();
            RenderDimensionAdapter zDimensionAdapter = getDimensionAdapter();
            mDecorationSize = zDimensionAdapter.getContainerOverheadSize( zRectangularRenderableObject );
        }
        return mDecorationSize;
    }

    /**
     * Get the "Decoration" Size RHP.
     * <p/>
     * Note: RHPs are Instance Equality Managed, so for the same underlying dependency the same RHP must be returned!
     *
     * @return !null RHP, where its callbacks will be notified when it is complete.
     */
    public final RenderHelperProcess unavailableDecorationSizeRHP()
    {
        return queue( mDetermineContainerDecorationSize );
    }

    /**
     * Get the "Minimum" Size.
     * <p/>
     * Renderable Objects that are not Sizable will return their "Natural" Size.
     *
     * @return null means that is not "yet" available.
     */
    public Integer getMinimumSize()
    {
        Integer zCurrentSize = getCurrentSize(); // Dependency
        Integer zNaturalSize = getNaturalSize(); // Default if No Children &/ No Minimum specified
        Integer zMinimumSize = LLgetMinimumSize();

        if ( zCurrentSize == null )
        {
            return null;
        }
        if ( mDetermineContainerMinimumSize != null )
        {
            RenderHelper[] zChildHelpers = getChildHelpers();
            if ( Objects.isNotNullOrEmpty( zChildHelpers ) )
            {
                Integer zDecorationSize = getDecorationSize();
                if ( zDecorationSize == null )
                {
                    return null;
                }
                Integer zCalculatedMinimumSize = calculateChildrenMinimumSize( zChildHelpers );
                if ( zCalculatedMinimumSize == null )
                {
                    return null;
                }
                zCalculatedMinimumSize += zDecorationSize;
                if ( zMinimumSize == null )
                {
                    zMinimumSize = zCalculatedMinimumSize;
                }
                else
                {
                    zMinimumSize = Math.max( zMinimumSize, zCalculatedMinimumSize );
                }
            }
        }
        return (zMinimumSize != null) ? zMinimumSize : zNaturalSize;
    }

    /**
     * @param pChildHelpers !null / empty
     *
     * @return null means that someone is not ready, otherwise the current Calculated Minimum Size
     */
    abstract protected Integer calculateChildrenMinimumSize( RenderHelper[] pChildHelpers );

    /**
     * Get the "Minimum" Size RHP.
     * <p/>
     * Note: RHPs are Instance Equality Managed, so for the same underlying dependency the same RHP must be returned!
     *
     * @return !null RHP, where its callbacks will be notified when it is complete.
     */
    public RenderHelperProcess unavailableMinimumSizeRHP()
    {
        return (mDetermineContainerMinimumSize != null) ? //
               queue( mDetermineContainerMinimumSize ) : unavailableCurrentSizeRHP();
    }

    public final RenderContainmentApproach getContainmentApproach()
    {
        return mContainmentApproach;
    }

    protected void LLrenderingParticipationChanged()
    {
        super.LLrenderingParticipationChanged();
        for ( RenderHelper zHelper : mChildHelpers.values() )
        {
            zHelper.renderingParticipationChanged();
        }
    }

    protected RenderProcessResult sizingError( MutateSizeRHP pMutateSizeRHP, int pExpectedSize, int pActualSize )
    {
        if ( mDecorationSize == null ) // Should NOT be possible!!!
        {
            return RenderProcessResult.Terminated;
        }
        if ( ++mDorkedCount < 20 )
        {
            int zNewDecorationSize = getDimensionAdapter().getContainerOverheadSize( getRectangularRenderableObject() );

            int zDecorationDelta = zNewDecorationSize - mDecorationSize;

            if ( zDecorationDelta == 0 )
            {
                logSizingError( LOGGER.error, pExpectedSize, pActualSize, "" );
            }
            else  // Decoration Size Changed!!!
            {
                if ( (pExpectedSize + zDecorationDelta) == pActualSize ) // by just the needed amount
                {
                    logSizingErrorWithDecorationChange( LOGGER.warn, pExpectedSize, pActualSize, zNewDecorationSize );
                    return LLLsetSize( pMutateSizeRHP, pActualSize, pExpectedSize );
                }
                logSizingErrorWithDecorationChange( LOGGER.error, pExpectedSize, pActualSize, zNewDecorationSize );
            }

            defer( pMutateSizeRHP, 50 ); // Will it Settle...?
            return RenderProcessResult.Requeued;
        }
        logSizingError( LOGGER.fatal, pExpectedSize, pActualSize, "" );
        return RenderProcessResult.Terminated;
    }

    protected final void logSizingErrorWithDecorationChange( AbstractLogger pLogger, int pExpectedSize, int pActualSize, int zNewDecorationSize )
    {
        logSizingError( pLogger, pExpectedSize, pActualSize, " Decoration was " + mDecorationSize + " != " + zNewDecorationSize + " now" );
        mDecorationSize = zNewDecorationSize; // Update the Decoration Size
    }

    protected void sizingOK()
    {
        mDorkedCount = 0;
    }

    private int mDorkedCount = 0;

    /**
     * Determine if this Helper is a Layout Ancestor.
     * <p/>
     * When going up the Parentage path, it will obviously return true at the root, but it may also return true at a Clipping Container that has been explicitly sized!
     */
    public boolean isLayoutAncestorHelper()
    {
        return super.isLayoutAncestorHelper() || //
               (isExplicitlySized() && //
                RenderSizingApproach.Settable.equals( getContainmentApproach().getSizingApproach() ));
    }

    /**
     * Restore the RenderableRect to its pre-Layed-out state and return the RenderHelper(s) for its children.
     *
     * @return !null array of the child RenderHelper(s) if any.
     */
    public RenderHelper[] restoreForLayout()
    {
        LLrestoreForLayout();
        return getChildHelpers();
    }

    /**
     * Request "this" RederableRect and its' children be layed out.
     * <p/>
     * Note: RHPs are Instance Equality Managed, so for the same underlying dependency the same RHP must be returned!
     *
     * @return null if no layout process is needed,
     *         otherwise the returned RHP's callbacks will be notified when it is complete.
     */
    public RenderHelperProcess layoutFromHereDown()
    {
        if ( mLayoutContainer.isProcessingNeeded() )
        {
            return RenderProcessManager.INSTANCE.queue( mLayoutContainer );
        }
        setLayedOut();
        return null;
    }

    abstract protected RenderProcessResult LLadjustChildSizesAfterLayout( LayoutContainerRHP pLayoutContainerRHP, RenderHelper[] zChildHelpers );

    public void childRemoved( Object pRectangularRenderableObject )
    {
        mChildHelpers.remove( pRectangularRenderableObject );
        layout();
    }

    private Map<Object, RenderHelper> mChildHelpers = new IdentityHashMap<Object, RenderHelper>();

    protected RenderHelper getChildHelper( Object pRectangularRenderableObject )
    {
        return mChildHelpers.get( pRectangularRenderableObject );
    }

    protected void putChildHelper( Object pRectangularRenderableObject, RenderHelper pHelper )
    {
        mChildHelpers.put( pRectangularRenderableObject, pHelper );
        layout();
    }

    protected static int sum( int[] pInts )
    {
        int rv = 0;
        for ( int zInt : pInts )
        {
            rv += zInt;
        }
        return rv;
    }

    protected static int max( int[] pInts )
    {
        int rv = pInts[0];
        for ( int i = 1; i < pInts.length; i++ )
        {
            rv = Math.max( rv, pInts[i] );
        }
        return rv;
    }
}