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

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

public class DoubleLinkedListTimedRunnableNode
{
    private DoubleLinkedListTimedRunnableNode mPrev = null;
    private DoubleLinkedListTimedRunnableNode mNext = null;
    private long mRunWhen;
    private TimedRunnable mTimedRunnable;

    private DoubleLinkedListTimedRunnableNode( long pRunWhen, TimedRunnable pTimedRunnable )
    {
        mRunWhen = pRunWhen;
        Objects.assertNotNull( "TimedRunnable", mTimedRunnable = pTimedRunnable );
    }

    public long getRunWhen()
    {
        return mRunWhen;
    }

    public TimedRunnable getTimedRunnable()
    {
        return mTimedRunnable;
    }

    /**
     * Remove 'this' from DoubleLinkList
     *
     * @return mNext
     */
    public DoubleLinkedListTimedRunnableNode remove()
    {
        // x - this - y
        DoubleLinkedListTimedRunnableNode rv = this.mNext;
        if ( this.mPrev != null )
        {
            mPrev.mNext = this.mNext;
        }
        if ( this.mNext != null )
        {
            mNext.mPrev = this.mPrev;
        }
        mPrev = mNext = null;
        // x - y
        return rv;
    }

    private boolean isBefore( DoubleLinkedListTimedRunnableNode pTimerNode )
    {
        return (pTimerNode != null) && (this.mRunWhen < pTimerNode.mRunWhen);
    }

    /**
     * Insert 'pNewTimerNode' before 'this' in the LinkList
     *
     * @param pNewTimerNode may NOT have its links set
     *
     * @return pNewTimerNode
     */
    private DoubleLinkedListTimedRunnableNode insertBeforeMe( DoubleLinkedListTimedRunnableNode pNewTimerNode )
    {
        // x - this - y
        if ( chk( pNewTimerNode ) )
        {
            pNewTimerNode.mNext = this;
            pNewTimerNode.mPrev = this.mPrev;
            if ( this.mPrev != null )
            {
                this.mPrev.mNext = pNewTimerNode;
            }
            this.mPrev = pNewTimerNode;
        }
        // x - pNewTimerNode - this - y
        return pNewTimerNode;
    }

    /**
     * Insert 'pNewTimerNode' after 'this' in the LinkList
     *
     * @param pNewTimerNode may NOT have its links set
     */
    private void insertAfterMe( DoubleLinkedListTimedRunnableNode pNewTimerNode )
    {
        // x - this - y
        if ( chk( pNewTimerNode ) )
        {
            pNewTimerNode.mNext = this.mNext;
            if ( this.mNext != null )
            {
                this.mNext.mPrev = pNewTimerNode;
            }
            this.mNext = pNewTimerNode;
            pNewTimerNode.mPrev = this;
        }
        // x - this - pNewTimerNode - y
    }

    private boolean chk( DoubleLinkedListTimedRunnableNode pNewTimerNode )
    {
        if ( pNewTimerNode == null )
        {
            return false;
        }
        if ( (pNewTimerNode.mPrev != null) || (pNewTimerNode.mNext != null) )
        {
            throw new IllegalArgumentException( "NewTimerNode has non-Null links" );
        }
        return true;
    }

    /**
     * @return the New Head
     */
    public static DoubleLinkedListTimedRunnableNode addTo( DoubleLinkedListTimedRunnableNode pCurrent, long pRunWhen, TimedRunnable pTimedRunnable )
    {
        if ( pTimedRunnable != null )
        {
            DoubleLinkedListTimedRunnableNode zNewNode = new DoubleLinkedListTimedRunnableNode( pRunWhen, pTimedRunnable );
            if ( pCurrent == null )
            {
                return zNewNode;
            }
            if ( zNewNode.isBefore( pCurrent ) )
            {
                return pCurrent.insertBeforeMe( zNewNode );
            }
            DoubleLinkedListTimedRunnableNode cur = pCurrent;
            while ( cur.mNext != null )
            {
                cur = cur.mNext;
                if ( zNewNode.isBefore( cur ) )
                {
                    cur.insertBeforeMe( zNewNode );
                    return pCurrent;
                }
            }
            cur.insertAfterMe( zNewNode );
        }
        return pCurrent;
    }

    public static DoubleLinkedListTimedRunnableNode locate( DoubleLinkedListTimedRunnableNode pCurrent, TimedRunnable pTimedRunnable )
    {
        if ( pTimedRunnable != null )
        {
            while ( pCurrent != null )
            {
                if ( pTimedRunnable == pCurrent.mTimedRunnable )
                {
                    return pCurrent;
                }
                pCurrent = pCurrent.mNext;
            }
        }
        return null;
    }
}