// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.client.command.queue;

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

import java.util.*;

/**
 * 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>();

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

    @Override
    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 ( Object listener : listeners ) {
            result &= ((CommandQueueListener) listener).beforeCommandAdded( this, pCommand );
        }
        return result;
    }

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

        Object[] listeners = mListeners.toArray();
        for ( Object listener : listeners ) {
            ((CommandQueueListener) listener).afterCommandAdded( this, pCommand );
        }
    }

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

        boolean result = true;

        Object[] listeners = mListeners.toArray();
        for ( Object listener : listeners ) {
            result &= ((CommandQueueListener) listener).beforeCommandExecuted( this, pCommand );
        }
        return result;
    }

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

        Object[] listeners = mListeners.toArray();
        for ( Object listener : listeners ) {
            ((CommandQueueListener) listener).afterCommandExecuted( this, pCommand );
        }
    }

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