package org.litesoft.core.delayed;

import org.litesoft.core.delayed.nonpublic.*;
import org.litesoft.core.util.*;

public class TimedRunner
{
    private MyTimedRunnable mMyTimedRunnable = null;

    public TimedRunner( DelayedTimedRunnableRunner pRunner,
                        UnexpectedExceptionHandler pUnexpectedExceptionHandler )
    {
        mMyTimedRunnable = new MyTimedRunnable( pRunner, pUnexpectedExceptionHandler ).initialize();
    }

    /**
     * @return null means Not Scheduled, TRUE means canceled, FALSE means Already Running
     *
     * @throws IllegalArgumentException if <code>pTimedRunnable</code> is <code>null</code>
     */
    public Boolean cancel( TimedRunnable pTimedRunnable )
    {
        if ( pTimedRunnable == null )
        {
            throw new IllegalArgumentException();
        }
        return mMyTimedRunnable.cancel( pTimedRunnable );
    }

    /**
     * Schedules <code>pTimedRunnable</code> to run after the specified delay.
     *
     * @param pDelayInMilliSecs if <= 0 then run NOW!, otherwise put on the Queue to run no sooner then indicated
     *
     * @return When to run time in MilliSecs or null if pTimedRunnable was null
     */
    public Long runIn( TimedRunnable pTimedRunnable, long pDelayInMilliSecs )
    {
        return runOnOrAfter( pTimedRunnable, getNow() + pDelayInMilliSecs );
    }

    /**
     * Schedules <code>pTimedRunnable</code> to run at specified time (or later).
     *
     * @param pWhenTimeInMilliSecs if <= Now then run NOW!, otherwise put on the Queue to run no sooner then indicated
     *
     * @return When to run time in MilliSecs or null if pTimedRunnable was null
     */
    public Long runOnOrAfter( TimedRunnable pTimedRunnable, long pWhenTimeInMilliSecs )
    {
        if ( pTimedRunnable != null )
        {
            mMyTimedRunnable.runOnOrAfter( pTimedRunnable, pWhenTimeInMilliSecs );
            return pWhenTimeInMilliSecs;
        }
        return null;
    }

    private static long getNow()
    {
        return UtilsCommon.now().getTime();
    }

    private static class MyTimedRunnable implements TimedRunnable
    {
        private final DelayedTimedRunnableRunner mRunner;
        private final UnexpectedExceptionHandler mUnexpectedExceptionHandler;
        private DoubleLinkedListTimedRunnableNode mHead = null;
        private TimedRunnable mRunning = null;

        public MyTimedRunnable( DelayedTimedRunnableRunner pRunner, UnexpectedExceptionHandler pUnexpectedExceptionHandler )
        {
            UtilsCommon.assertNotNull( "Runner", mRunner = pRunner );
            UtilsCommon.assertNotNull( "UnexpectedExceptionHandler",
                                     mUnexpectedExceptionHandler = pUnexpectedExceptionHandler );
        }

        public MyTimedRunnable initialize()
        {
            mRunner.initialize( this, mUnexpectedExceptionHandler );
            return this;
        }

        public Again runOnce()
        {
            while ( true )
            {
                synchronized ( this )
                {
                    if ( mHead == null )
                    {
                        return null;
                    }
                    long zRunWhen = mHead.getRunWhen();
                    if ( getNow() < zRunWhen )
                    {
                        return new RunAgainOnOrAfter( zRunWhen );
                    }
                    mRunning = mHead.getTimedRunnable();
                    mHead = mHead.remove();
                }
                Again zAgain = null;
                try
                {
                    zAgain = mRunning.runOnce();
                }
                catch ( RuntimeException e )
                {
                    mUnexpectedExceptionHandler.onUnexpectedException( "TimedRunnableManager", e );
                }
                synchronized ( this )
                {
                    if ( zAgain != null )
                    {
                        mHead = DoubleLinkedListTimedRunnableNode.addTo( mHead, zAgain.getOnOrAfter(), mRunning );
                    }
                    mRunning = null;
                }
            }
        }

        public synchronized Boolean cancel( TimedRunnable pTimedRunnable )
        {
            if ( pTimedRunnable == mRunning )
            {
                return Boolean.FALSE;
            }
            DoubleLinkedListTimedRunnableNode found =
                    DoubleLinkedListTimedRunnableNode.locate( mHead, pTimedRunnable );
            if ( found != null )
            {
                if ( found != mHead )
                {
                    found.remove();
                }
                else if ( null == (mHead = mHead.remove()) )
                {
                    mRunner.cancel();
                }
                else
                {
                    LLrescheduleFor( mHead.getRunWhen() );
                }
                return Boolean.TRUE;
            }
            return null;
        }

        public synchronized void runOnOrAfter( TimedRunnable pTimedRunnable, long pWhenTimeInMilliSecs )
        {
            DoubleLinkedListTimedRunnableNode savedHead = mHead;
            mHead = DoubleLinkedListTimedRunnableNode.addTo( mHead, pWhenTimeInMilliSecs, pTimedRunnable );
            if ( savedHead != mHead )
            {
                LLrescheduleFor( pWhenTimeInMilliSecs );
            }
        }

        private void LLrescheduleFor( long pRunWhen ) // sync'd
        {
            mRunner.scheduleFor( pRunWhen );
        }
    }
}