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

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

public class TimedRunner {
    private final MillisecTimeSource mMillisecTimeSource;
    private final MyTimedRunnable mMyTimedRunnable;

    public TimedRunner( DelayedTimedRunnableRunner pRunner, UnexpectedExceptionHandler pUnexpectedExceptionHandler ) {
        mMillisecTimeSource = pRunner.getMillisecTimeSource();
        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, mMillisecTimeSource.now() + 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 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 ) {
            Confirm.isNotNull( "Runner", mRunner = pRunner );
            Confirm.isNotNull( "UnexpectedExceptionHandler", mUnexpectedExceptionHandler = pUnexpectedExceptionHandler );
        }

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

        @Override
        public Again runOnce() {
            while ( true ) {
                synchronized ( this ) {
                    if ( mHead == null ) {
                        return null;
                    }
                    long zRunWhen = mHead.getRunWhen();
                    if ( mRunner.getMillisecTimeSource().now() < 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( mRunner.getMillisecTimeSource() ), 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 );
        }
    }
}