// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.delayed.nonpublic;

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

public class ThreadBasedDelayedTimedRunnableRunner extends AbstractDelayedTimedRunnableRunner
{
    private final MyRunnable mMyRunnable;

    public ThreadBasedDelayedTimedRunnableRunner( MillisecTimeSource pMillisecTimeSource )
    {
        super( pMillisecTimeSource, LoggingUnexpectedExceptionHandler.INSTANCE );
        mMyRunnable = new MyRunnable();
    }

    public ThreadBasedDelayedTimedRunnableRunner()
    {
        this( null );
    }

    @Override
    protected void LLscheduleFor( long pWhenTimeInMilliSecs, long pNowInMilliSecs )
    {
        if ( pWhenTimeInMilliSecs <= 0 )
        {
            throw new IllegalArgumentException( "WhenTimeInMilliSecs is not greater than 0 with (" + //
                                                mTimedRunnable.getClass() + "): " + pWhenTimeInMilliSecs );
        }
        mMyRunnable.scheduleFor( pWhenTimeInMilliSecs );
    }

    @Override
    protected void LLcancel()
    {
        mMyRunnable.cancel();
    }

    public boolean isScheduled()
    {
        return mMyRunnable.isScheduled();
    }

    private class MyRunnable implements Runnable
    {
        private Thread mMyThread = null;
        private Long mTillTime = null;

        public synchronized boolean isScheduled()
        {
            return (mTillTime != null);
        }

        public synchronized void scheduleFor( long pWhenTimeInMilliSecs )
        {
            mTillTime = pWhenTimeInMilliSecs;
            if ( mMyThread != null )
            {
                notifyAll();
            }
            else
            {
                mMyThread = new Thread( this );
                mMyThread.setDaemon( true );
                mMyThread.start();
            }
        }

        @Override
        public void run()
        {
            while ( waitTillTime() )
            {
                LLrun();
            }
        }

        private synchronized boolean waitTillTime()
        {
            while ( mMyThread != null )
            {
                try
                {
                    while ( mTillTime == null )
                    {
                        wait();
                    }
                    long zNow = mMillisecTimeSource.now();
                    if ( mTillTime <= zNow )
                    {
                        mTillTime = null;
                        return true;
                    }
                    long milliSecsToWait = mTillTime - zNow;
                    wait( milliSecsToWait );
                }
                catch ( InterruptedException e )
                {
                    // Whatever...
                }
            }
            return false;
        }

        public synchronized void cancel()
        {
            mTillTime = null;
            if ( mMyThread != null )
            {
                notifyAll();
            }
        }
    }
}