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

import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.logger.*;

import java.util.*;

public abstract class RenderHelperProcess
{
    public static final RenderHelperProcess[] EMPTY_ARRAY = new RenderHelperProcess[0];

    protected static final Logger LOGGER = LoggerFactory.getLogger( RenderHelperProcess.class );

    private int mSequenceID = getNextSequence();
    protected final String mName;
    protected final RenderHelper mRenderHelper;

    protected RenderHelperProcess( String pName, RenderHelper pRenderHelper )
    {
        mName = pName;
        mRenderHelper = pRenderHelper;
    }

    protected RenderHelperProcess( String pName )
    {
        this( pName, null );
    }

    public final void addCallback( RenderHelperCallback pCallback )
    {
        if ( pCallback != null )
        {
            synchronized ( mCallbacks )
            {
                mCallbacks.add( pCallback );
                // System.out.println( this + " addCallback to " + pCallback );
            }
        }
    }

    private final Set<RenderHelperCallback> mCallbacks = new HashSet<RenderHelperCallback>();

    private RenderProcessResult notifyCallbacks_processComplete( RenderProcessResult pRenderProcessResult )
    {
        mActive = false;
        RenderHelperCallback[] zCallbacks = null;
        synchronized ( mCallbacks )
        {
            if ( !mCallbacks.isEmpty() )
            {
                // System.out.println( this + " notifyCallbacks: " + mCallbacks );
                zCallbacks = mCallbacks.toArray( new RenderHelperCallback[mCallbacks.size()] );
                mCallbacks.clear();
            }
        }
        if ( zCallbacks != null )
        {
            for ( RenderHelperCallback zCallback : zCallbacks )
            {
                // System.out.println( this + " calling back: " + zCallback );
                zCallback.processCompleted( this, pRenderProcessResult );
            }
        }
        return pRenderProcessResult;
    }

    private volatile boolean mActive = false;

    public boolean isActive()
    {
        return mActive;
    }

    public void activate()
    {
        mActive = true;
    }

    public final RenderProcessResult process()
    {
        // System.out.println( "process: " + this );
        RenderProcessResult zProcessResult;
        if ( !mRenderHelper.isParticipatingInRendering() )
        {
            zProcessResult = RenderProcessResult.Terminated;
        }
        else if ( !LLisProcessingNeeded() )
        {
            zProcessResult = RenderProcessResult.Completed;
        }
        else
        {
            zProcessResult = LLprocess();
        }
        // System.out.println( "     --> " + this + " --> " + zProcessResult + "\n" );
        switch ( zProcessResult )
        {
            case Requeued:
                return zProcessResult;
            case Completed:
                break;
            case Terminated:
                break;
        }
        return notifyCallbacks_processComplete( zProcessResult );
    }

    /**
     * Low Level Processing for this process.
     * <p/>
     * Note: For some Ui Infrastructures it may need to be synchronized.
     */
    abstract protected RenderProcessResult LLprocess();

    protected boolean isProcessingNeeded()
    {
        if ( mRenderHelper.isParticipatingInRendering() )
        {
            if ( LLisProcessingNeeded() )
            {
                return true;
            }
        }
        return false;
    }

    abstract protected boolean LLisProcessingNeeded();

    protected final synchronized MySubProcessCallback getMySubProcessCallback()
    {
        return (mMySubProcessCallback != null) ? //
               mMySubProcessCallback : //
               (mMySubProcessCallback = new MySubProcessCallback());
    }

    private MySubProcessCallback mMySubProcessCallback = null;

    private class MySubProcessCallback implements RenderHelperCallback
    {
        public void processCompleted( RenderHelperProcess pCompletedProcess, RenderProcessResult pCompletedProcessResult )
        {
            process();
        }
    }

    public String toString()
    {
        String zType = getTypeName();
        if ( mRenderHelper == null )
        {
            if ( (mName == null) )
            {
                return zType;
            }
            return zType + "-" + mName + "-?";
        }
        return zType + "-" + mRenderHelper;
    }

    protected String getTypeName()
    {
        return Objects.justClassName( getClass() ) + "-" + mSequenceID;
    }

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

    private static int sSequenceSource = 0;

    private static synchronized int getNextSequence()
    {
        return ++sSequenceSource;
    }
}