package org.litesoft.GWT.client.command.queue;

import java.util.*;

import com.google.gwt.user.client.*;

/**
 * The subclass is responsible for starting the queue once a command has been
 * added and determining how each run cycle is scheduled.
 */
public abstract class CommandQueueBase implements SourcesCommandQueueEvents
{
    private final ArrayList<CommandQueueListener> mListeners = new ArrayList<CommandQueueListener>();
    private final ArrayList<Command> mQueue = new ArrayList<Command>();

    public void addListener( CommandQueueListener pListener )
    {
        mListeners.add( pListener );
    }

    public void removeListener( CommandQueueListener pListener )
    {
        mListeners.remove( pListener );
    }

    public boolean hasNext()
    {
        return mQueue.size() > 0;
    }

    /**
     * Get the command at the specified index. <code>0</code> is the next
     * command to be executed.
     *
     * @param pIndex
     *
     * @return the command
     *
     * @throws IndexOutOfBoundsException if <code>index < 0 || index > {@link #getSize()}</code>
     */
    public Command get( int pIndex )
    {
        return mQueue.get( pIndex );
    }

    public Command remove( int pIndex )
    {
        return mQueue.remove( pIndex );
    }

    public void clear()
    {
        mQueue.clear();
    }

    public int getSize()
    {
        return mQueue.size();
    }

    public abstract void add( Command pCommand );

    protected boolean addImpl( Command pCommand )
    {
//		Debug.println("CommandQueue.addImpl(" + command + ')');
        if ( !fireBeforeCommandAdded( pCommand ) )
        {
            return false;
        }

        mQueue.add( pCommand );
        fireAfterCommandAdded( pCommand );
        return true;
    }

    protected abstract void scheduleRunIteration();

    protected void run()
    {
//		Debug.println("CommandQueue.run()");
        executeCommand( mQueue.remove( 0 ) );
        if ( hasNext() )
        {
            scheduleRunIteration();
        }
    }

    /**
     * Notifies listeners and executes the specified command.
     * <ul>
     * <li>pre: the command has been removed from the queue</li>
     * <li>post: the queue may have be modified</li>
     * </ul>
     *
     * @param pCommand
     */
    protected void executeCommand( Command pCommand )
    {
//		Debug.println("CommandQueue.executeCommand(" + command + ")");
        if ( !fireBeforeCommandExecuted( pCommand ) )
        {
            return;
        }

        executeCommandImpl( pCommand );
        fireAfterCommandExecuted( pCommand );
    }

    protected void executeCommandImpl( Command pCommand )
    {
        pCommand.execute();
    }

    protected boolean fireBeforeCommandAdded( Command pCommand )
    {
        if ( mListeners.size() == 0 )
        {
            return true;
        }

        boolean result = true;

        Object[] listeners = mListeners.toArray();
        for ( int i = 0; i < listeners.length; i++ )
        {
            result &= ((CommandQueueListener) listeners[i]).beforeCommandAdded( this, pCommand );
        }
        return result;
    }

    protected void fireAfterCommandAdded( Command pCommand )
    {
        if ( mListeners.size() == 0 )
        {
            return;
        }

        Object[] listeners = mListeners.toArray();
        for ( int i = 0; i < listeners.length; i++ )
        {
            ((CommandQueueListener) listeners[i]).afterCommandAdded( this, pCommand );
        }
    }

    protected boolean fireBeforeCommandExecuted( Command pCommand )
    {
        if ( mListeners.size() == 0 )
        {
            return true;
        }

        boolean result = true;

        Object[] listeners = mListeners.toArray();
        for ( int i = 0; i < listeners.length; i++ )
        {
            result &= ((CommandQueueListener) listeners[i]).beforeCommandExecuted( this, pCommand );
        }
        return result;
    }

    protected void fireAfterCommandExecuted( Command pCommand )
    {
        if ( mListeners.size() == 0 )
        {
            return;
        }

        Object[] listeners = mListeners.toArray();
        for ( int i = 0; i < listeners.length; i++ )
        {
            ((CommandQueueListener) listeners[i]).afterCommandExecuted( this, pCommand );
        }
    }

    public String toString()
    {
        return "CommandQueueBase" + mQueue.toString();
    }
}