// 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.simpletypes.temporal.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;

public class RenderProcessManager
{
    public static final RenderProcessManager INSTANCE = new RenderProcessManager();

    public interface Listener
    {
        public void processManagerNowHasProcesses();
    }

    private RenderProcessManager()
    {
    }

    private static MillisecTimeSource sTimeSource = MillisecTimeSource.INSTANCE;

    public static void setTimeSource( MillisecTimeSource pSTimeSource )
    {
        if ( pSTimeSource != null )
        {
            sTimeSource = pSTimeSource;
        }
    }

    private Listener mListener = null;

    public synchronized Listener getListener()
    {
        return mListener;
    }

    public synchronized void setListener( Listener pListener )
    {
        mListener = pListener;
    }

    private ProcessQueue mProcessesToRun = new ProcessQueue();
    private DeferredProcessQueue mDeferredProcesses = new DeferredProcessQueue();
    private DependentProcessSet mDependentProcesses = new DependentProcessSet();

    public boolean isEmpty()
    {
        return mProcessesToRun.isEmpty() && mDeferredProcesses.isEmpty() && mDependentProcesses.isEmpty();
    }

    /**
     * @return null means no Deferred Processes, !null means when the next Deferred Processes will be ready to run
     */
    public synchronized Long whenIsNextDeferredProcess()
    {
        return mDeferredProcesses.whenIsNextDeferredProcess();
    }

    public synchronized RenderHelperProcess first()
    {
        RenderHelperProcess rv = mProcessesToRun.first();
        if ( rv == null )
        {
            ProcessList zList = mDeferredProcesses.getReadyList();
            if ( zList != null )
            {
                for ( RenderHelperProcess zProcess : zList )
                {
                    mProcessesToRun.add( zProcess );
                }
                rv = mProcessesToRun.first();
            }
        }
        // System.out.println( toString() + "\n      ->" + rv );
        return rv;
    }

    public RenderHelperProcess queue( RenderHelperProcess pProcess )
    {
        if ( pProcess != null )
        {
            Listener zListener = null;
            synchronized ( this )
            {
                if ( !mProcessesToRun.contains( pProcess ) && //
                     !mDeferredProcesses.contains( pProcess ) && //
                     !mDependentProcesses.contains( pProcess ) )
                {
                    if ( mProcessesToRun.isEmpty() )
                    {
                        zListener = mListener;
                    }
                    mProcessesToRun.add( pProcess );
                }
            }
            if ( zListener != null )
            {
                mListener.processManagerNowHasProcesses();
            }
        }
        return pProcess;
    }

    public synchronized void defer( RenderHelperProcess pProcessToDefer, int pForMillisecs )
    {
        if ( (pProcessToDefer != null) && //
             !mDependentProcesses.contains( pProcessToDefer ) && !mDeferredProcesses.contains( pProcessToDefer ) )
        {
            mProcessesToRun.remove( pProcessToDefer );
            mDeferredProcesses.add( pProcessToDefer, pForMillisecs );
        }
    }

    public synchronized void deferPending( RenderHelperProcess pDependentProcess, RenderHelperProcess pDependsOnProcess )
    {
        if ( pDependentProcess != null )
        {
            mProcessesToRun.remove( pDependentProcess );
            mDeferredProcesses.remove( pDependentProcess );
            mDependentProcesses.add( pDependentProcess );
        }
        queue( pDependsOnProcess );
    }

    public synchronized void release( RenderHelperProcess pDependentProcess )
    {
        if ( pDependentProcess != null )
        {
            mDeferredProcesses.remove( pDependentProcess );
            mDependentProcesses.remove( pDependentProcess );
            queue( pDependentProcess );
        }
    }

    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append( "RenderProcessManager" );
        LineIndentUtil.newLine( sb, 1 ).append( "ToRun:" ).append( mProcessesToRun );
        LineIndentUtil.newLine( sb, 1 ).append( "Deferred:" ).append( mDeferredProcesses );
        LineIndentUtil.newLine( sb, 1 ).append( "Dependent:" ).append( mDependentProcesses );
        return sb.toString();
    }

    public void clear()
    {
        mProcessesToRun.clear();
        mDeferredProcesses.clear();
        mDependentProcesses.clear();
    }

    private static class ProcessList extends LinkedList<RenderHelperProcess>
    {
    }

    private static class DependentProcessSet extends HashSet<RenderHelperProcess>
    {
        public boolean add( RenderHelperProcess pProcess )
        {
            pProcess.activate();
            return super.add( pProcess );
        }

        public String toString()
        {
            if ( isEmpty() )
            {
                return "";
            }
            String[] zStrings = Strings.toArray( this );
            Arrays.sort( zStrings );
            return " " + Arrays.asList( zStrings ).toString();
        }
    }

    private static class ProcessQueue
    {
        private ProcessList mQueue = new ProcessList();
        private HashSet<RenderHelperProcess> mQueued = new HashSet<RenderHelperProcess>();

        public void clear()
        {
            mQueue.clear();
            mQueued.clear();
        }

        public boolean isEmpty()
        {
            return mQueue.isEmpty();
        }

        public boolean contains( RenderHelperProcess pProcess )
        {
            return mQueued.contains( pProcess );
        }

        public void add( RenderHelperProcess pProcess )
        {
            pProcess.activate();
            if ( !contains( pProcess ) )
            {
                mQueued.add( pProcess );
                mQueue.add( pProcess );
            }
        }

        public void remove( RenderHelperProcess pProcess )
        {
            if ( mQueued.remove( pProcess ) )
            {
                mQueue.remove( pProcess );
            }
        }

        public RenderHelperProcess first()
        {
            if ( mQueued.isEmpty() )
            {
                return null;
            }
            RenderHelperProcess zProcess = mQueue.removeFirst();
            mQueued.remove( zProcess );
            return zProcess;
        }

        public String toString()
        {
            return mQueue.isEmpty() ? "" : " " + mQueue.toString();
        }
    }

    private static class DeferredProcessQueue
    {
        private PriorityQueue<Long> mWhens = new PriorityQueue<Long>();
        private HashMap<Long, ProcessList> mProcessListByWhen = new HashMap<Long, ProcessList>();
        private HashMap<RenderHelperProcess, Long> mWhenByProcess = new HashMap<RenderHelperProcess, Long>();

        public void clear()
        {
            mWhens.clear();
            mProcessListByWhen.clear();
            mWhenByProcess.clear();
        }

        public boolean isEmpty()
        {
            return mWhens.isEmpty();
        }

        public Long whenIsNextDeferredProcess()
        {
            return mWhens.peek();
        }

        public void add( RenderHelperProcess pProcess, int pForMillisecs )
        {
            pProcess.activate();
            if ( pForMillisecs < 1 )
            {
                pForMillisecs = 1;
            }
            Long zWhen = sTimeSource.now() + pForMillisecs;

            mWhenByProcess.put( pProcess, zWhen );
            ProcessList zProcessList = mProcessListByWhen.get( zWhen );
            if ( zProcessList == null )
            {
                mProcessListByWhen.put( zWhen, zProcessList = new ProcessList() );
                mWhens.add( zWhen );
            }
            zProcessList.add( pProcess );
        }

        public ProcessList getReadyList()
        {
            Long zNextWhen = whenIsNextDeferredProcess();
            if ( zNextWhen != null )
            {
                long zNow = sTimeSource.now();
                if ( zNow >= zNextWhen )
                {
                    mWhens.remove();
                    ProcessList zProcessList = mProcessListByWhen.remove( zNextWhen );
                    for ( RenderHelperProcess zProcess : zProcessList )
                    {
                        mWhenByProcess.remove( zProcess );
                    }
                    return zProcessList;
                }
            }
            return null;
        }

        public void remove( RenderHelperProcess pProcess )
        {
            Long zLong = mWhenByProcess.remove( pProcess );
            if ( zLong != null )
            {
                ProcessList zProcessList = mProcessListByWhen.get( zLong );
                if ( zProcessList != null )
                {
                    zProcessList.remove( pProcess );
                    if ( zProcessList.isEmpty() )
                    {
                        mProcessListByWhen.remove( zLong );
                        mWhens.remove( zLong );
                    }
                }
            }
        }

        public boolean contains( RenderHelperProcess pProcess )
        {
            return mWhenByProcess.containsKey( pProcess );
        }

        public String toString()
        {
            if ( mWhens.isEmpty() )
            {
                return "";
            }
            StringBuilder sb = new StringBuilder();
            long zNow = sTimeSource.now();
            for ( Long zWhen : mWhens )
            {
                if ( sb.length() != 0 )
                {
                    LineIndentUtil.newLine( sb, 2 );
                }
                else
                {
                    sb.append( ' ' );
                }
                sb.append( zWhen - zNow ).append( '-' ).append( mProcessListByWhen.get( zWhen ) );
            }
            return sb.toString();
        }
    }
}