/*******************************************************************************

 * 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.internal.CommandPresentationStrategyWrapper;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Decorations;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Shell;

/**

 * 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 {

    Control focusedControl;

    /**

     * 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;

            Display display = Display.getCurrent();

            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

         */

        public 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

         */

        public 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 CommandPresentationStrategy strategy;

    private Command defaultCommand;

    public CommandArranger(){

        super();

        currentCommands = new CommandCollection();

        strategy = CommandPresentationStrategyWrapper.createStrategy();

    }

    /**

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

        strategy.handleMenuBarChanged( menuBarHandle, currentCommands );

    }

    /**

     * Called when a new Control gains focus.

     *

     * @see Control#qt_swt_event_focusWasGained()

     */

    public void focusedControlChanged(){

        Display display = Display.getCurrent();

        Control focusControl = display.getFocusControl();

        if (focusControl == focusedControl) {

            return;

        }

        focusedControl = focusControl;

        Shell activeShell = display.getActiveShell();

        CommandCollection oldCollection = currentCommands;

        currentCommands = new CommandCollection();

        Control ctrl = focusControl;

        while ( ctrl!= null && ctrl != activeShell ){

            if ( Command.internal_getCommands(ctrl).length > 0 ){

                currentCommands.addCommand( Command.internal_getCommands(ctrl) );

            }

            ctrl = ctrl.getParent();

        }

        if (activeShell != null && Command.internal_getCommands(activeShell).length > 0 ){

            currentCommands.addCommand( Command.internal_getCommands(activeShell) );

        }

        if (strategy != null) {

            strategy.handleFocusChange(focusControl, oldCollection, currentCommands);

        }

    }

    /**

     * Called when a new Command is created

     * @param command

     */

    public void commandAdded( Command command ){

        if( isInFocusContext(command.control)){

            currentCommands.addCommand(command);

            strategy.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 );

            strategy.handleCommandListChange(null, command, currentCommands);

        }

    }

    /**

     * Called when the Display is getting disposed.

     */

    public void dispose(){

        strategy.dispose();

        strategy = null;

        currentCommands = null;

    }

    /**

     * Called when a Command is set default

     *

     * @param command

     * @see Command#setDefaultCommand();

     */

    public void setDefaultCommand(Command command ){

        defaultCommand = command;

        if(isInFocusContext(command.control)){

            strategy.handleDefaultCommandChange(command);

        }

    }

    /**

     * Returns the default command or null if there is none.

     *

     * @return

     * @see Command#isDefaultCommand()

     */

    public Command getDefaultCommand(){

        return defaultCommand;

    }

    /**

     * Sets a new {@link CommandPresentationStrategy}. It also disposes to old one.

     *

     * @param commandPresentationStrategy

     */

    public void setPresentationStrategy( CommandPresentationStrategy commandPresentationStrategy ){

        CommandPresentationStrategy oldStrategy = strategy;

        strategy = commandPresentationStrategy;

        if (oldStrategy != null ){

            oldStrategy.dispose();

        }

    }

    private boolean isInFocusContext(Control control){

        Display display = control.getDisplay();

        Shell activeShell = display.getActiveShell();

        Control focused = display.getFocusControl();

        if( focused == null )return false;

        if(control.getShell() != activeShell) return false;

        if( control == focused ) return true;

        return isFocusAncestor(focused, control);

    }

    private boolean isFocusAncestor(Control node, Control parent){

        Control nodeParent = node.getParent();

        if( nodeParent == parent )return true;

        if (nodeParent == null || nodeParent == node.getShell() )return false;

        return isFocusAncestor(nodeParent, parent);

    }

}