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

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

public abstract class AbstractDelayedTimedRunnableRunner implements DelayedTimedRunnableRunner
{
    protected TimedRunnable mTimedRunnable = null;
    private UnexpectedExceptionHandler mUnexpectedExceptionHandler;

    public AbstractDelayedTimedRunnableRunner( UnexpectedExceptionHandler pUnexpectedExceptionHandler )
    {
        Objects.assertNotNull( "UnexpectedExceptionHandler", mUnexpectedExceptionHandler = pUnexpectedExceptionHandler );
    }

    public DelayedTimedRunnableRunner initialize( TimedRunnable pTimedRunnable, UnexpectedExceptionHandler pUnexpectedExceptionHandler )
    {
        Objects.assertNotNull( "TimedRunnable", mTimedRunnable = pTimedRunnable );
        if ( pUnexpectedExceptionHandler != null )
        {
            mUnexpectedExceptionHandler = pUnexpectedExceptionHandler;
        }
        return this;
    }

    public DelayedTimedRunnableRunner scheduleFor( long pWhenTimeInMilliSecs )
    {
        cancel();
        if ( LLscheduleFor( pWhenTimeInMilliSecs ) )
        {
            LLrun();
        }
        return this;
    }

    private boolean LLscheduleFor( long pWhenTimeInMilliSecs )
    {
        long zNowInMilliSecs = UtilsCommon.now().getTime();
        if ( pWhenTimeInMilliSecs <= zNowInMilliSecs )
        {
            return true;
        }
        LLscheduleFor( pWhenTimeInMilliSecs, zNowInMilliSecs );
        return false;
    }

    public void cancel()
    {
        validateInitialized();
        LLcancel();
    }

    protected void LLrun()
    {
        TimedRunnable runnable = mTimedRunnable;
        while ( runnable != null )
        {
            TimedRunnable.Again zAgain;
            try
            {
                zAgain = runnable.runOnce();
            }
            catch ( RuntimeException e )
            {
                try
                {
                    mUnexpectedExceptionHandler.onUnexpectedException( "DelayedTimedRunnableRunner", e );
                }
                catch ( RuntimeException e1 )
                {
                    e1.printStackTrace(); // Whatever
                }
                return;
            }
            if ( (zAgain == null) || !LLscheduleFor( zAgain.getOnOrAfter() ) )
            {
                runnable = null;
            }
        }
    }

    abstract protected void LLscheduleFor( long pWhenTimeInMilliSecs, long pNowInMilliSecs );

    abstract protected void LLcancel();

    private void validateInitialized()
    {
        if ( mTimedRunnable == null )
        {
            throw new IllegalStateException( "initialize not called!" );
        }
    }
}