/*******************************************************************************
 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Nokia Corporation - initial implementation
 *******************************************************************************/
package org.eclipse.swt.internal.qt;

import org.eclipse.ercp.swt.mobile.Command;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Decorations;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Internal_PackageSupport;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Widget;

/**
 * Manages the Command presentation cycle. This is a singleton object that gets
 * notified about the events that can have an effect on the way the Commands are
 * represented. It maintains an ordered list of Commands on the current focus
 * context with the help of {@link CommandCollection}. It also notifies the
 * currently active {@link CommandPresentationStrategy} so that the presentation
 * is updated if necessary.
 * 
 * @see Command
 * @see CommandCollection
 * @see CommandPresentationStrategy
 */
public class CommandArranger {

/**
 * A helper for keeping an ordered list of {@link Command}s in the current focus
 * context. The Commands are ordered according to their proximity to the
 * currently focused control. The ordered list starts with Commands from the
 * currently focused Control if any and ends with the active Shell and includes
 * all the Commands in between. If a Control has more than one Command they are
 * ordered among themselves according to creation order.
 */
public class CommandCollection {

private Command[] fCommands;

CommandCollection() {
    super();
}

/**
 * Adds the command to the collection. Warning: This does not make duplicate
 * control.
 * 
 * @param command
 */
void addCommand(Command command) {
    if (command == null)
        return;
    if (fCommands == null) {
        fCommands = new Command[1];
        fCommands[0] = command;
        return;
    }
    int size = fCommands.length + 1;
    Command[] newList = new Command[size];
    // find the insertion point so that the order is correct
    int insertPoint = 0;
    Shell activeShell = display.getActiveShell();
    Control ctrl = display.getFocusControl();
    while (ctrl != null && ctrl != activeShell) {
        if (ctrl == command.control) {
            // Adding a command to focused control increment by one.
            // adding Command.internal_getCommands(ctrl).length will
            // just duplicate the count for Commands already in array.
            insertPoint++;
            break;
        }
        insertPoint += Command.internal_getCommands(ctrl).length;
        ctrl = ctrl.getParent();
    }
    System.arraycopy(fCommands, 0, newList, 0, insertPoint);
    System.arraycopy(fCommands, insertPoint, newList, insertPoint + 1, fCommands.length
        - insertPoint);
    newList[insertPoint] = command;
    fCommands = newList;
}

/**
 * Adds the list of Commands to the collection.
 * 
 * @param commands
 */
void addCommand(Command[] commands) {
    if (commands == null || commands.length == 0)
        return;
    if (fCommands == null) {
        fCommands = new Command[commands.length];
        System.arraycopy(commands, 0, fCommands, 0, commands.length);
        return;
    }
    int size = commands.length + fCommands.length;
    Command[] newList = new Command[size];
    System.arraycopy(fCommands, 0, newList, 0, fCommands.length);
    System.arraycopy(commands, 0, newList, fCommands.length, commands.length);
    fCommands = newList;
}

/**
 * Removes the command from the list.
 * 
 * @param command
 */
void removeCommand(Command command) {
    if (command == null)
        return;
    if (fCommands == null || fCommands.length == 0)
        return;
    int removeIndex = -1;
    for (int i = 0; i < fCommands.length; i++) {
        if (fCommands[i] == command) {
            removeIndex = i;
        }
    }
    if (removeIndex == -1)
        return;
    Command[] newList = new Command[fCommands.length - 1];
    System.arraycopy(fCommands, 0, newList, 0, removeIndex);
    System.arraycopy(fCommands, removeIndex + 1, newList, removeIndex, (fCommands.length
        - removeIndex - 1));
    fCommands = newList;
}

/**
 * Returns the number of the Commands
 * 
 * @return boolean
 */
int getSize() {
    int size = 0;
    if (fCommands != null)
        size = fCommands.length;
    return size;
}

/**
 * Retrieves the Commands of the types indicated by the commandTypes array. The
 * order of the commandTypes array has no significance. Passing a null parameter
 * or an empty array retrieves all the available Commands.
 * 
 * @param commandTypes
 * @return Command list
 */
Command[] getCommands(int[] commandTypes) {
    if (commandTypes == null || commandTypes.length == 0) {
        return fCommands;
    }
    int size = getSize();
    Command[] filteredCommands = new Command[size];
    int index = 0;
    for (int i = 0; i < fCommands.length; i++) {
        for (int j = 0; j < commandTypes.length; j++) {
            if (fCommands[i].type == commandTypes[j]) {
                filteredCommands[index] = fCommands[i];
                index++;
                break;
            }
        }
    }
    if (size > (index)) {// Some commands filtered resize the Array
        Command[] shrunk = new Command[index];
        System.arraycopy(filteredCommands, 0, shrunk, 0, index);
        return shrunk;
    }
    return filteredCommands;
}

}// CommandCollection

private CommandCollection currentCommands;
private Command defaultCommand;
private Display display;
Control focusedControl;
Shell lastKnownActiveShell;
private Command[] positiveKeyCommands;
private Command negativeKeyCommand;


public CommandArranger(Display display) {
    super();
    this.display = display;
    currentCommands = new CommandCollection();
}

/**
 * Called when the application changes the QMenuBar. This method does not handle
 * the cases when the QMenuBar may change when the active top-level Shell
 * changes. Since this does not cause a menu bar change on all platforms.
 * 
 * @see org.eclipse.swt.widgets.Decorations#setMenuBar(Menu)
 * 
 **/
public void menuBarChanged(Decorations decorations) {
    if (currentCommands == null || currentCommands.getSize() < 1)
        return;
    // if the changed menu bar is not on the active shell ignore and leave
    // it to focus change.
    if (decorations.getShell() != decorations.getDisplay().getActiveShell())
        return;
    // Call internal_getOwnMenuBar because the menu bar can be set to null
    // in Decorations and
    // we may need to create the internal one.
    int menuBarHandle = decorations.internal_getOwnMenuBar();

    handleMenuBarChanged(menuBarHandle, currentCommands);
}

/**
 * Called when a new Shell becomes active.
 * 
 * @see Control#qt_swt_event_focusWasGained() //TODO
 */
public void shellActivityChanged() {
    if (display == null) {
        return;
    }

    Shell activeShell = display.getActiveShell();
    
    if (activeShell == lastKnownActiveShell) {
        return;
    }
    lastKnownActiveShell = activeShell;
    
    cleanPositiveCommands();
    cleanNegativeCommand();
    
    currentCommands = new CommandCollection();

    if (activeShell != null && Command.internal_getCommands(activeShell).length > 0) {
        currentCommands.addCommand(Command.internal_getCommands(activeShell));
    }

    // Determine where the commands go
    if (currentCommands.getSize() > 0) {
        Command[] add = currentCommands.getCommands(null);
        updateCommandPositions(add);
        placePositiveCommands();
        placeNegativeCommand();
    }
}

/**
 * Called when a new Command is created
 * 
 * @param command
 */
public void commandAdded(Command command) {
    if (isInFocusContext(command.control)) {
        currentCommands.addCommand(command);
        handleCommandListChange(command, null, currentCommands);
    }
}

/**
 * Called when a Command is disposed
 * 
 * @param command
 */
public void commandRemoved(Command command) {
    if (command == defaultCommand)
        defaultCommand = null;
    if (isInFocusContext(command.control)) {
        currentCommands.removeCommand(command);
        handleCommandListChange(null, command, currentCommands);
    }
}

/**
 * Called when the Display is getting disposed.
 */
public void dispose() {
    currentCommands = null;
    display = null;
    positiveKeyCommands = null;
    negativeKeyCommand = null;
    defaultCommand = null;
    lastKnownActiveShell = null;
}

/**
 * Called when a Command is set default
 * 
 * @param command
 * @see Command#setDefaultCommand();
 */
public void setDefaultCommand(Command command) {
    defaultCommand = command;
    if (isInFocusContext(command.control)) {
        handleDefaultCommandChange(command);
    }
}

/**
 * Returns the default command or null if there is none.
 * 
 * @return
 * @see Command#isDefaultCommand()
 */
public Command getDefaultCommand() {
    return defaultCommand;
}


private boolean isInFocusContext(Control control) {
    Display display = control.getDisplay();
    Shell activeShell = display.getActiveShell();
    return control == activeShell;
}

private void handleCommandListChange(Command added, Command removed, CommandCollection commands) {
    cleanNegativeCommand();
    cleanPositiveCommands();
    updateCommandPositions(commands.getCommands(null));
    placeNegativeCommand();
    placePositiveCommands();
}

private void handleDefaultCommandChange(Command defaultCommand) {
    this.defaultCommand = defaultCommand;
    cleanPositiveCommands();
    placePositiveCommands();
}

private void updateCommandPositions(Command[] commands) {
    positiveKeyCommands = new Command[commands.length];
    int positiveKeyIndex = 0;
    for (int i = 0; i < commands.length; i++) {
        Command cmd = commands[i];
        if (cmd.isDefaultCommand()) {
            defaultCommand = cmd;
            continue;
        }
        if (CommandUtils.isNegativeType(cmd.type)) {
            if (negativeKeyCommand == null || negativeKeyCommand.isDisposed()) {
                negativeKeyCommand = cmd;
            } else if (negativeKeyCommand.getPriority() <= cmd.getPriority()) {
                positiveKeyCommands[positiveKeyIndex] = negativeKeyCommand;
                positiveKeyIndex++;
                negativeKeyCommand = cmd;
            } else {
                positiveKeyCommands[positiveKeyIndex] = cmd;
                positiveKeyIndex++;
            }
            continue;
        }
        positiveKeyCommands[positiveKeyIndex] = cmd;
        positiveKeyIndex++;
    }
    if ((positiveKeyIndex) < positiveKeyCommands.length) {// needs to shrink
        Command[] rightSized = new Command[positiveKeyIndex];
        System.arraycopy(positiveKeyCommands, 0, rightSized, 0, rightSized.length);
        positiveKeyCommands = rightSized;
    }
}

private void cleanPositiveCommands() {
    boolean useBar = false;
    if ((positiveKeyCommands != null && positiveKeyCommands.length > 1)
        || (defaultCommand != null && positiveKeyCommands != null)) {
        useBar = true;
    }
    if (defaultCommand != null && !defaultCommand.isDisposed()
        && !defaultCommand.control.isDisposed()) {
        if (useBar) {
            OS.QWidget_removeAction(defaultCommand.control.getShell().internal_getOwnMenuBar(),
                topHandle(defaultCommand));
        } else {
            OS.QWidget_removeAction(topHandle(defaultCommand.control), topHandle(defaultCommand));
        }
    }
    if (positiveKeyCommands != null) {
        for (int i = 0; i < positiveKeyCommands.length; i++) {
            Command cmd = positiveKeyCommands[i];
            if (cmd == null || cmd.isDisposed() || cmd.control.isDisposed()) {
                continue;
            }
            int handle = 0;
            if (useBar) {
                handle = cmd.control.getShell().internal_getOwnMenuBar();
            } else {
                handle = topHandle(positiveKeyCommands[0].control);
            }
            OS.QWidget_removeAction(handle, topHandle(cmd));

        }
    }
}

private void cleanNegativeCommand() {
    if (negativeKeyCommand != null && !negativeKeyCommand.isDisposed()
        && !negativeKeyCommand.control.isDisposed()) {
        OS.QWidget_removeAction(topHandle(negativeKeyCommand.control),
            topHandle(negativeKeyCommand));
    }
}

private void placeNegativeCommand() {
    if (negativeKeyCommand != null) {
        OS.QWidget_addAction(Internal_PackageSupport.topHandle(negativeKeyCommand.control),
            topHandle(negativeKeyCommand));
    }
}

private void placePositiveCommands() {
    if (defaultCommand != null) {
        int defaultCmdHandle = topHandle(defaultCommand);
        if (positiveKeyCommands != null) {
            OS.QMenuBar_addAction(defaultCommand.control.getShell().internal_getOwnMenuBar(),
                defaultCmdHandle);
        } else {
            OS.QWidget_addAction(Internal_PackageSupport.topHandle(defaultCommand.control),
                defaultCmdHandle);
        }
    }
    if (positiveKeyCommands != null) {
        if (positiveKeyCommands.length == 1 && defaultCommand == null) {
            OS.QWidget_addAction(Internal_PackageSupport.topHandle(positiveKeyCommands[0].control),
                topHandle(positiveKeyCommands[0]));
        } else {
            CommandUtils.sort(positiveKeyCommands);
            for (int i = 0; i < positiveKeyCommands.length; i++) {
                OS.QMenuBar_addAction(positiveKeyCommands[i].control.getShell()
                    .internal_getOwnMenuBar(), topHandle(positiveKeyCommands[i]));
            }
        }
    }
}

private void handleMenuBarChanged(int newMenuBar, CommandCollection commands) {
    placePositiveCommands();
}

private static final int topHandle(Widget w) {
    return Internal_PackageSupport.topHandle(w);
}

}