package org.litesoft.render;

import org.litesoft.logger.nonpublic.*;

public abstract class AbstractSimpleSizableRenderHelper extends AbstractSizableRenderHelper
{
    protected AbstractSimpleSizableRenderHelper( Object pRectangularRenderableObject, //
                                                 RenderAccessor pRenderAccessor, //
                                                 RenderParticipatingAdapter pParticipatingAdapter, //
                                                 RenderDimensionAdapter pDimensionAdapter )
    {
        super( pRectangularRenderableObject, pRenderAccessor, RenderSizingApproach.Settable,
               pParticipatingAdapter, pDimensionAdapter );

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

        mDetermineCurrentSize = new DetermineCurrentSizeRHP( mRROname, this, //
                                                             mDetermineRectSizeNow, //
                                                             mDetermineNaturalSize );
        mMutateSize = new MutateSizeRHP( mRROname, this, //
                                         mDetermineCurrentSize );
    }

    /**
     * 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
        Integer zMinimumSize = LLgetMinimumSize();
        if ( zCurrentSize == null )
        {
            return null;
        }
        return (zMinimumSize != null) ? zMinimumSize : zNaturalSize;
    }

    /**
     * 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 unavailableCurrentSizeRHP();
    }

    /**
     * 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 ( null == getNaturalSize() )
        {
            return unavailableNaturalSizeRHP();
        }
        setLayedOut();
        return null;
    }

    protected RenderProcessResult sizingError( MutateSizeRHP pMutateSizeRHP, int pExpectedSize, int pActualSize )
    {
        if ( ++mDorkedCount < 20 )
        {
            logSizingError( LOGGER.error, pExpectedSize, pActualSize, "" );
            defer( pMutateSizeRHP, 50 ); // Will it Settle...?
            return RenderProcessResult.Requeued;
        }
        logSizingError( LOGGER.fatal, pExpectedSize, pActualSize, "" );
        return RenderProcessResult.Terminated;
    }

    protected void sizingOK()
    {
        mDorkedCount = 0;
    }

    private int mDorkedCount = 0;

    /**
     * Set the Size - pCurrentSize != pNewSize
     */
    protected RenderProcessResult LLLsetSize( MutateSizeRHP pMutateSizeRHP, int pCurrentSize, int pNewSize )
    {
        setSizingChange( pCurrentSize, pNewSize );
        getDimensionAdapter().setSize( getRectangularRenderableObject(), pNewSize ); // Set our Size
        // Make us wait until we get the size!
        deferPending( pMutateSizeRHP, unavailableCurrentSizeRHP() );
        return RenderProcessResult.Requeued;
    }

    public String toString()
    {
        return toString( "SimpleSizable" );
    }
}