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

import org.litesoft.logger.nonpublic.*;

public abstract class AbstractSizableRenderHelper extends AbstractRenderHelper implements SizableRenderHelper
{
    protected AbstractSizableRenderHelper( Object pRectangularRenderableObject, //
                                           RenderAccessor pRenderAccessor, //
                                           RenderSizingApproach pSizingApproach, //
                                           RenderParticipatingAdapter pParticipatingAdapter, //
                                           RenderDimensionAdapter pDimensionAdapter )
    {
        super( pRectangularRenderableObject, pRenderAccessor, pSizingApproach, pParticipatingAdapter, pDimensionAdapter );
    }

    protected DetermineNaturalSizeRHP mDetermineNaturalSize;
    protected DetermineCurrentSizeRHP mDetermineCurrentSize;
    protected MutateSizeRHP mMutateSize;

    private Integer mNaturalSize = null;
    private Integer mMinimumSize = null;

    private boolean mExplicitlySized = false;
    private Integer mSizedTo = null;
    private boolean mSizedToPending = false;

    private Integer mSetSizePending = null;
    private Integer mFloodSetSizePending = null;
    private Integer mAdjustSizeByPending = null;
    private Integer mFloodAdjustSizeByPending = null;

    public boolean isExplicitlySized()
    {
        return mExplicitlySized;
    }

    public void setExplicitlySized( boolean pExplicitlySized )
    {
        mExplicitlySized = pExplicitlySized;
    }

    protected void setSizingChange( int pCurrentSizeToIgnore, Integer pPendingNewSize )
    {
        super.setSizingChange( pCurrentSizeToIgnore, pPendingNewSize );
        mSizedToPending = (null != (mSizedTo = pPendingNewSize));
    }

    protected void LLjustParticipatingInRendering()
    {
        super.LLjustParticipatingInRendering();
        if ( mMutateSize.isProcessingNeeded() )
        {
            queue( mMutateSize );
        }
    }

    /**
     * Restore the RenderableRect to its pre-Layed-out state.
     */
    protected void LLrestoreForLayout()
    {
        if ( mSizedTo != null )
        {
            setSizingChange( mSizedTo, null );
        }
        setExplicitlySized( false );
        getDimensionAdapter().removeSetSize( getRectangularRenderableObject() ); // Remove any previous Set Sizes
        super.LLrestoreForLayout();
    }

    /**
     * Get the "Natural" Size - the size something was when it first was Rendered.
     *
     * @return null means that is not "yet" available.
     */
    public final Integer getNaturalSize()
    {
        return mNaturalSize;
    }

    protected final void setNaturalSize()
    {
        mNaturalSize = getRectSizeNow();
    }

    /**
     * Get the "Natural" 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 unavailableNaturalSizeRHP()
    {
        return queue( mDetermineNaturalSize );
    }

    /**
     * Get the "Current" Size.
     * <p/>
     * Renderable Objects that are not Sizable will return their "Natural" Size.
     *
     * @return null means that is not "yet" available.
     */
    public final Integer getCurrentSize()
    {
        return (getNaturalSize() != null) && isLayedOut() ? getRectSizeNow() : null;
    }

    /**
     * Get the "Current" 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 unavailableCurrentSizeRHP()
    {
        return queue( mDetermineCurrentSize );
    }

    /**
     * Request that all future sizing take the pNewMinimumSize as the Minimum Size.
     *
     * @param pNewMinimumSize - Must be > 0
     *
     * @throws IllegalArgumentException      if pRequestedSize <= 0
     * @throws UnsupportedOperationException if the SizingApproach is "None"
     */
    public final SizableRenderHelper setMinimumSize( int pNewMinimumSize )
            throws IllegalArgumentException, UnsupportedOperationException
    {
        assertSizableAndAtLeastOne( "Set Minimum Size to", pNewMinimumSize );
        mMinimumSize = pNewMinimumSize;
        return this;
    }

    protected final Integer LLgetMinimumSize()
    {
        return mMinimumSize;
    }

    protected final RenderHelperProcess requestSetSize( int pRequestedSize )
    {
        mMutateSize.setSize( pRequestedSize );
        return queue( mMutateSize );
    }

    protected final RenderHelperProcess requestFloodSetSize( int pRequestedSize )
    {
        mMutateSize.floodSetSize( pRequestedSize );
        return queue( mMutateSize );
    }

    protected final RenderHelperProcess requestAdjustSizeBy( int pRequestedSizeChange )
    {
        mMutateSize.adjustSizeBy( pRequestedSizeChange );
        return queue( mMutateSize );
    }

    protected final RenderHelperProcess requestFloodAdjustSizeBy( int pRequestedSizeChange )
    {
        mMutateSize.floodAdjustSizeBy( pRequestedSizeChange );
        return queue( mMutateSize );
    }

    protected final boolean LLsizeChangePending()
    {
        return mSizedToPending || (mSetSizePending != null) || (mFloodSetSizePending != null) || (mAdjustSizeByPending != null) || (mFloodAdjustSizeByPending != null);
    }

    protected final RenderProcessResult LLrequestSetSize( MutateSizeRHP pMutateSizeRHP, int pRequestedSize )
    {
        mSetSizePending = pRequestedSize;
        return LLprocessPendingSizeChange( pMutateSizeRHP );
    }

    protected final RenderProcessResult LLrequestFloodSetSize( MutateSizeRHP pMutateSizeRHP, int pRequestedSize )
    {
        mFloodSetSizePending = pRequestedSize;
        return LLprocessPendingSizeChange( pMutateSizeRHP );
    }

    protected final RenderProcessResult LLrequestAdjustSizeBy( MutateSizeRHP pMutateSizeRHP, int pRequestedSizeChange )
    {
        mAdjustSizeByPending = pRequestedSizeChange;
        return LLprocessPendingSizeChange( pMutateSizeRHP );
    }

    protected final RenderProcessResult LLrequestFloodAdjustSizeBy( MutateSizeRHP pMutateSizeRHP, int pRequestedSizeChange )
    {
        mFloodAdjustSizeByPending = pRequestedSizeChange;
        return LLprocessPendingSizeChange( pMutateSizeRHP );
    }

    protected final RenderProcessResult LLprocessPendingSizeChange( MutateSizeRHP pMutateSizeRHP )
    {
        Integer zCurrentSize = getCurrentSize();
        if ( zCurrentSize == null )
        {
            deferPending( pMutateSizeRHP, unavailableCurrentSizeRHP() );
            return RenderProcessResult.Requeued;
        }
        Integer zMinimumSize = getMinimumSize();
        if ( zMinimumSize == null )
        {
            deferPending( pMutateSizeRHP, unavailableMinimumSizeRHP() );
            return RenderProcessResult.Requeued;
        }
        if ( mSizedTo != null )
        {
            if ( !mSizedTo.equals( zCurrentSize ) )
            {
                return sizingError( pMutateSizeRHP, mSizedTo, zCurrentSize );
            }
            mSizedToPending = false;
        }
        sizingOK();
        RenderProcessResult rv = RenderProcessResult.Completed;
        if ( (mSetSizePending != null) && RenderProcessResult.Completed.equals( rv ) )
        {
            int zNewSize = mSetSizePending;
            mSetSizePending = null;
            rv = LLsetSize( pMutateSizeRHP, zCurrentSize, zMinimumSize, zNewSize, true );
        }
        if ( (mFloodSetSizePending != null) && RenderProcessResult.Completed.equals( rv ) )
        {
            int zNewSize = mFloodSetSizePending;
            mFloodSetSizePending = null;
            rv = LLsetSize( pMutateSizeRHP, zCurrentSize, zMinimumSize, zNewSize, false );
        }
        if ( (mAdjustSizeByPending != null) && RenderProcessResult.Completed.equals( rv ) )
        {
            int zNewSize = zCurrentSize + mAdjustSizeByPending;
            mAdjustSizeByPending = null;
            rv = LLsetSize( pMutateSizeRHP, zCurrentSize, zMinimumSize, zNewSize, true );
        }
        if ( (mFloodAdjustSizeByPending != null) && RenderProcessResult.Completed.equals( rv ) )
        {
            int zNewSize = zCurrentSize + mFloodAdjustSizeByPending;
            mFloodAdjustSizeByPending = null;
            rv = LLsetSize( pMutateSizeRHP, zCurrentSize, zMinimumSize, zNewSize, false );
        }
        return rv;
    }

    abstract protected RenderProcessResult sizingError( MutateSizeRHP pMutateSizeRHP, //
                                                        int pExpectedSize, int pActualSize );

    abstract protected void sizingOK();

    protected final void logSizingError( AbstractLogger pLogger, int pExpectedSize, int pActualSize, String pPlus )
    {
        pLogger.log( "SizingError: ", this, " SizedTo ", pExpectedSize, ", but Current Size = ", pActualSize, pPlus );
    }

    private RenderProcessResult LLsetSize( MutateSizeRHP pMutateSizeRHP, int pCurrentSize, int pMinimumSize, int pNewSize, boolean pExplicitlySized )
    {
        // Note: we will not be here unless ((mSizedTo == null) || (mSizedTo == pCurrentSize))
        if ( pNewSize < pMinimumSize )
        {
            pNewSize = pMinimumSize;
        }
        if ( (mSizedTo != null) && (pNewSize == mSizedTo) )
        {
            setExplicitlySized( pExplicitlySized ); // Possibly change state
            return RenderProcessResult.Completed;
        }
        if ( pNewSize == pCurrentSize ) // Nothing to do OR we did IT!
        {
            return RenderProcessResult.Completed;
        }
        setExplicitlySized( pExplicitlySized );
        return LLLsetSize( pMutateSizeRHP, pCurrentSize, pNewSize );
    }

    /**
     * Set the Size - pCurrentSize != pNewSize
     */
    abstract protected RenderProcessResult LLLsetSize( MutateSizeRHP pMutateSizeRHP, int pCurrentSize, int pNewSize );
}