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

import org.litesoft.commonfoundation.typeutils.Objects;

import java.util.*;

public abstract class AbstractRenderHelper implements RenderHelper
{
    private Object mRectangularRenderableObject;
    private RenderAccessor mRenderAccessor;
    private RenderSizingApproach mSizingApproach;
    private RenderParticipatingAdapter mParticipatingAdapter;
    private RenderDimensionAdapter mDimensionAdapter;

    private int mIgnoreInitialNonParticipatingSize;
    private int mIgnoreReportedSize;
    private Integer mLastReportedSize = null;

    private Boolean mParticipatingInRendering = null;

    protected final String mRROname;

    protected final DetermineRectSizeNowRHP mDetermineRectSizeNow;

    private LayoutState mLayoutState = LayoutState.Initial;

    private static TraceLogger sTraceLogger;

    protected AbstractRenderHelper( Object pRectangularRenderableObject, //
                                    RenderAccessor pRenderAccessor, //
                                    RenderSizingApproach pSizingApproach, //
                                    RenderParticipatingAdapter pParticipatingAdapter, //
                                    RenderDimensionAdapter pDimensionAdapter )
    {
        Objects.assertNotNull( "RRO", mRectangularRenderableObject = pRectangularRenderableObject );
        Objects.assertNotNull( "RenderAccessor", mRenderAccessor = pRenderAccessor );
        Objects.assertNotNull( "SizingApproach", mSizingApproach = pSizingApproach );
        Objects.assertNotNull( "ParticipatingAdapter", mParticipatingAdapter = pParticipatingAdapter );
        mIgnoreReportedSize = mIgnoreInitialNonParticipatingSize = (mDimensionAdapter = pDimensionAdapter).getInitialNonParticipatingSize();

        mRROname = Objects.justClassName( pRectangularRenderableObject.getClass().getName() );

        mDetermineRectSizeNow = new DetermineRectSizeNowRHP( mRROname, this );

        if ( sTraceLogger == null )
        {
            sTraceLogger = LOGGER.trace.isEnabled() ? RealTraceLogger.INSTANCE : NullTraceLogger.INSTANCE;
        }
    }

    protected Object getRectangularRenderableObject()
    {
        return mRectangularRenderableObject;
    }

    /**
     * @param pRequestedSize > 0
     */
    abstract protected RenderHelperProcess requestFloodSetSize( int pRequestedSize );

    abstract protected RenderHelperProcess requestFloodAdjustSizeBy( int pRequestedSizeChange );

    /**
     * @param pRequestedSize > 0
     */
    abstract protected RenderHelperProcess requestSetSize( int pRequestedSize );

    abstract protected RenderHelperProcess requestAdjustSizeBy( int pRequestedSizeChange );

    protected final void assertSizableAndAtLeastOne( String pWhat, int pSize )
    {
        if ( pSize < 1 )
        {
            throw new IllegalArgumentException( "Can Not " + pWhat + " '" + pSize + "', < 1 on: " + getRectangularRenderableObject() );
        }
        assertSizable();
    }

    protected final void assertSizable()
    {
        if ( !isSizable() )
        {
            throw exceptionOnSizeChange();
        }
    }

    protected UnsupportedOperationException exceptionOnSizeChange()
    {
        return new UnsupportedOperationException( "SizingApproach '" + mSizingApproach + //
                                                  "' on: " + getRectangularRenderableObject() );
    }

    public final boolean renderingParticipationChanged()
    {
        return chkForRenderingParticipationChanged();
    }

    private boolean chkForRenderingParticipationChanged()
    {
        Boolean zNewParticipating = mParticipatingAdapter.isParticipatingInRendering( getRectangularRenderableObject() );
        if ( zNewParticipating.equals( mParticipatingInRendering ) )
        {
            return false;
        }
        mParticipatingInRendering = zNewParticipating;
        LLrenderingParticipationChanged();
        return true;
    }

    /**
     * Clear Our State
     */
    protected void LLrenderingParticipationChanged()
    {
        if ( mParticipatingInRendering )
        {
            LLjustParticipatingInRendering();
        }
    }

    protected void LLjustParticipatingInRendering()
    {
        mDetermineRectSizeNow.startingToParticipateInRendering();
        layout();
    }

    /**
     * Participating?  (GWT attached & ! "Display=None")
     */
    public final boolean isParticipatingInRendering()
    {
        chkForRenderingParticipationChanged();
        return mParticipatingInRendering;
    }

    public final RenderSizingApproach getSizingApproach()
    {
        return mSizingApproach;
    }

    public boolean isSizable()
    {
        return !RenderSizingApproach.None.equals( mSizingApproach );
    }

    public final RenderDimensionAdapter getDimensionAdapter()
    {
        return mDimensionAdapter;
    }

    public RenderHelper getParentHelper()
    {
        Object zParent = getDimensionAdapter().getParent( getRectangularRenderableObject() );
        return (zParent != null) ? mRenderAccessor.getHelper( zParent ) : null;
    }

    /**
     * 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 EMPTY_ARRAY;
    }

    /**
     * Restore the RenderableRect to its pre-Layed-out state.
     */
    protected void LLrestoreForLayout()
    {
        mLayoutState = LayoutState.Restored;
    }

    /**
     * Return if this Helper is current in the Laying Out mode.
     */
    public boolean isLayingOut()
    {
        return LayoutState.LayingOut.equals( mLayoutState );
    }

    /**
     * Set the Helper to indicate that we are in the process of Laying Out.
     */
    public void setLayingOut()
    {
        mLayoutState = LayoutState.LayingOut;
    }

    protected void setLayedOut()
    {
        mLayoutState = LayoutState.LayedOut;
    }

    protected boolean isLayedOut()
    {
        return LayoutState.LayedOut.equals( mLayoutState );
    }

    /**
     * Request "this" RederableRect be invalidated from a layout perspective and that it and its related 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 final RenderHelperProcess layout()
    {
        LLsetLayingOut();
        if ( isLayoutAncestorHelper() )
        {
            return layoutFromHereDown();
        }
        return getParentHelper().layout();
    }

    private void LLsetLayingOut()
    {
        if ( !this.isLayingOut() )
        {
            RenderHelper[] zHelpers = prepForLayout( this );
            if ( zHelpers.length != 0 )
            {
                for ( Queue<RenderHelper[]> zLists = new LinkedList<RenderHelper[]>(); zHelpers != null; zHelpers = zLists.poll() )
                {
                    for ( RenderHelper zHelper : zHelpers )
                    {
                        if ( !zHelper.isLayingOut() )
                        {
                            RenderHelper[] zChildHelpers = prepForLayout( zHelper );
                            if ( zChildHelpers.length != 0 )
                            {
                                zLists.offer( zChildHelpers );
                            }
                        }
                    }
                }
            }
        }
    }

    private RenderHelper[] prepForLayout( RenderHelper pHelper )
    {
        RenderHelper[] zChildHelpers = pHelper.restoreForLayout();
        pHelper.setLayingOut();
        return zChildHelpers;
    }

    /**
     * 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 (getParentHelper() == null);
    }

    /**
     * Request that the "flood" Size be set to the pRequestedSize.
     * <p/>
     * It will not set the size below the Minimum.
     * <p/>
     * Note: RHPs are Instance Equality Managed, so for the same underlying dependency the same RHP must be returned!
     *
     * @param pRequestedSize - Must be > 0
     *
     * @return !null RHP, where its callbacks will be notified when it is complete.
     *
     * @throws IllegalArgumentException      if pRequestedSize <= 0
     * @throws UnsupportedOperationException if the SizingApproach is "None"
     */
    public RenderHelperProcess floodSetSize( int pRequestedSize )
            throws IllegalArgumentException, UnsupportedOperationException
    {
        assertSizableAndAtLeastOne( "Flood Set Size to", pRequestedSize );
        String zRequest = sTraceLogger.traceRequestSet( this, "floodSetSize", pRequestedSize );
        RenderHelperProcess zProcess = requestFloodSetSize( pRequestedSize );
        return sTraceLogger.traceCB( this, zRequest, zProcess );
    }

    /**
     * Request that the "flood" Size be adjusted by pRequestedSizeChange.
     * <p/>
     * It will not set the size below the Minimum.
     * <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.
     *
     * @throws UnsupportedOperationException if the SizingApproach is "None"
     */
    public RenderHelperProcess floodAdjustSizeBy( int pRequestedSizeChange )
            throws UnsupportedOperationException
    {
        assertSizable();
        String zRequest = sTraceLogger.traceRequestAdjust( this, "floodAdjustSizeBy", pRequestedSizeChange );
        RenderHelperProcess zProcess = requestFloodAdjustSizeBy( pRequestedSizeChange );
        return sTraceLogger.traceCB( this, zRequest, zProcess );
    }

    /**
     * Request that the "user requested" Size be set to the pRequestedSize.
     * <p/>
     * It will not set the size below the Minimum.
     * <p/>
     * Note: RHPs are Instance Equality Managed, so for the same underlying dependency the same RHP must be returned!
     *
     * @param pRequestedSize - Must be > 0
     *
     * @return !null RHP, where its callbacks will be notified when it is complete.
     *
     * @throws IllegalArgumentException      if pRequestedSize <= 0
     * @throws UnsupportedOperationException if the SizingApproach is "None"
     */
    public RenderHelperProcess setSize( int pRequestedSize )
            throws IllegalArgumentException, UnsupportedOperationException
    {
        assertSizableAndAtLeastOne( "Set Size to", pRequestedSize );
        String zRequest = sTraceLogger.traceRequestSet( this, "setSize", pRequestedSize );
        RenderHelperProcess zProcess = requestSetSize( pRequestedSize );
        return sTraceLogger.traceCB( this, zRequest, zProcess );
    }

    /**
     * Request that the "user requested" Size be adjusted by pRequestedSizeChange.
     * <p/>
     * It will not set the size below the Minimum.
     * <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.
     *
     * @throws UnsupportedOperationException if the SizingApproach is "None"
     */
    public RenderHelperProcess adjustSizeBy( int pRequestedSizeChange )
            throws UnsupportedOperationException
    {
        assertSizable();
        String zRequest = sTraceLogger.traceRequestAdjust( this, "adjustSizeBy", pRequestedSizeChange );
        RenderHelperProcess zProcess = requestAdjustSizeBy( pRequestedSizeChange );
        return sTraceLogger.traceCB( this, zRequest, zProcess );
    }

    protected final Integer getRectSizeNow()
    {
        if ( isParticipatingInRendering() )
        {
            if ( mLastReportedSize != null )
            {
                return mLastReportedSize;
            }
            int zSize = mDimensionAdapter.getSize( getRectangularRenderableObject() );
            if ( (zSize != mIgnoreInitialNonParticipatingSize) && (zSize != mIgnoreReportedSize) )
            {
                return (mLastReportedSize = zSize);
            }
        }
        return null;
    }

    protected void setSizingChange( int pCurrentSizeToIgnore, Integer pPendingNewSize )
    {
        mIgnoreReportedSize = pCurrentSizeToIgnore;
        mLastReportedSize = null;
    }

    protected static RenderHelperProcess queue( RenderHelperProcess pProcess )
    {
        return RenderProcessManager.INSTANCE.queue( pProcess );
    }

    protected static void defer( RenderHelperProcess pProcessToDefer, int pForMillisecs )
    {
        RenderProcessManager.INSTANCE.defer( pProcessToDefer, pForMillisecs );
    }

    protected static void deferPending( AbstractRHPwithDependencies pDependentProcess, RenderHelperProcess pDependsOnProcess )
    {
        if ( pDependentProcess != null )
        {
            pDependentProcess.deferPending( pDependsOnProcess );
        }
    }

    protected String toString( String pHelperName )
    {
        return pHelperName + getDimensionAdapter().getWhat() + "-" + Objects.justClassName( getRectangularRenderableObject().getClass() );
    }

    private interface TraceLogger
    {
        public String traceRequestSet( RenderHelper pRenderHelper, String pMethod, int pParam );

        public String traceRequestAdjust( RenderHelper pRenderHelper, String pMethod, int pParam );

        public RenderHelperProcess traceCB( RenderHelper pRenderHelper, String pRequest, RenderHelperProcess pHelperProcess );
    }

    private static class NullTraceLogger implements TraceLogger
    {
        public static final TraceLogger INSTANCE = new NullTraceLogger();

        public String traceRequestSet( RenderHelper pRenderHelper, String pMethod, int pParam )
        {
            return null;
        }

        public String traceRequestAdjust( RenderHelper pRenderHelper, String pMethod, int pParam )
        {
            return null;
        }

        public RenderHelperProcess traceCB( RenderHelper pRenderHelper, String pRequest, RenderHelperProcess pHelperProcess )
        {
            return pHelperProcess;
        }
    }

    private static class RealTraceLogger implements TraceLogger
    {
        public static final TraceLogger INSTANCE = new RealTraceLogger();

        private static int sTraceInstance = 0;

        public String traceRequestSet( RenderHelper pRenderHelper, String pMethod, int pParam )
        {
            return LLtraceRequest( pRenderHelper, pMethod, Integer.toString( pParam ) );
        }

        public String traceRequestAdjust( RenderHelper pRenderHelper, String pMethod, int pParam )
        {
            Integer zCurrentSize = pRenderHelper.getCurrentSize();
            Integer zExpectedSize = (zCurrentSize != null) ? (zCurrentSize + pParam) : null;
            return LLtraceRequest( pRenderHelper, pMethod, "" + pParam + " + " + zCurrentSize + " = " + zExpectedSize );
        }

        private String LLtraceRequest( RenderHelper pRenderHelper, String pMethod, String pParam )
        {
            String zRequest = "" + (++sTraceInstance) + "|" + pRenderHelper + ": " + //
                              pMethod + "( " + pParam + " )";
            LOGGER.trace.log( zRequest, "..." );
            return zRequest;
        }

        public RenderHelperProcess traceCB( RenderHelper pRenderHelper, String pRequest, RenderHelperProcess pHelperProcess )
        {
            if ( pHelperProcess == null )
            {
                LOGGER.trace.log( pRequest, "!" );
            }
            else
            {
                pHelperProcess.addCallback( new TraceCallBack( pRenderHelper, pRequest ) );
            }
            return pHelperProcess;
        }
    }

    private static class TraceCallBack implements RenderHelperCallback
    {
        private RenderHelper mRenderHelper;
        private String mRequest;

        public TraceCallBack( RenderHelper pRenderHelper, String pRequest )
        {
            mRenderHelper = pRenderHelper;
            mRequest = pRequest;
        }

        public void processCompleted( RenderHelperProcess pCompletedProcess, RenderProcessResult pCompletedProcessResult )
        {
            LOGGER.trace.log( mRequest, //
                              " -> ", mRenderHelper.getCurrentSize(), //
                              " (min:", mRenderHelper.getMinimumSize(), //
                              " | ", //
                              mRenderHelper.getNaturalSize(), ":nat) ", //
                              pCompletedProcessResult );
        }
    }
}