/**
 * Copyright (c) 2002-2007 IBM Corporation and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * IBM - Initial API and implementation
 */
// REUSED CLASS
package org.eclipse.emf.edit.ui.action.emfforms;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.UnexecutableCommand;
import org.eclipse.emf.edit.command.CommandActionDelegate;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

/**
 * This class is used as a basis for implementing an {@link org.eclipse.jface.action.IAction} on the menubar, the
 * toolbar, or a pop-up menu by delegating all required
 * behaviour to a {@link Command}, only when it is guaranteed that the
 * selection will not change during the life of the action. In other words,
 * the action itself would be created based on the selection, and destroyed
 * when the selection changed. All possible aspects of the action are
 * delegated to the command, namely the enablement state and, if it
 * implements {@link CommandActionDelegate}, the text, the toolbar icon, and
 * the tool tip text; however, this need only be done once, at the time the
 * action is created.
 *
 * <p>
 * Subclasses must provide an implementation for {@link #createActionCommand} that creates the command to perform this
 * action. They may also override {@link #getDefaultImageDescriptor} to provide a default icon and {@link #disable} to
 * set the action's state when a command cannot be created.
 */
public abstract class StaticSelectionCommandAction extends Action {

	/**
	 * This records the editing domain of the current editor or viewer. For global
	 * popups, we try to determine the editing domain from the selected
	 * objects themselves.
	 */
	protected EditingDomain editingDomain;

	/**
	 * This records the command.
	 */
	protected Command command;

	/**
	 * This constructs an instance for a command to be executed via the given editing domain.
	 *
	 * @since 2.4.0
	 */
	public StaticSelectionCommandAction(EditingDomain editingDomain) {
		this.editingDomain = editingDomain;
	}

	/**
	 * This constructs an instance without a specified workbenchPart.
	 */
	public StaticSelectionCommandAction() {
		super();
	}

	/**
	 * This should be implemented to create a command that performs the action.
	 */
	protected abstract Command createActionCommand(EditingDomain editingDomain, Collection<?> collection);

	/**
	 * This extracts the objects from selection, invokes createActionCommand
	 * to create the command, and then configures the action based on the
	 * result.
	 */
	public void configureAction(ISelection selection) {
		// only handle structured selections
		if (!(selection instanceof IStructuredSelection)) {
			disable();
		} else {
			// convert the selection to a collection of the selected objects
			final IStructuredSelection sselection = (IStructuredSelection) selection;
			final List<?> list = sselection.toList();
			final Collection<Object> collection = new ArrayList<Object>(list);

			// if the editing domain wasn't given by the workbench part, try to get
			// it from the selection
			if (editingDomain == null) {
				for (final Object o : collection) {
					editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(o);
					if (editingDomain != null) {
						break;
					}
				}
			}

			// if we found an editing domain, create command
			if (editingDomain != null) {
				command = createActionCommand(editingDomain, collection);
				setEnabled(command.canExecute());
			}

			// give up if we couldn't create the command; otherwise, use a
			// CommandActionDelegate to set the action's text, tool-tip, icon,
			// etc. or just use the default icon
			if (command == null || command == UnexecutableCommand.INSTANCE) {
				disable();
			} else if (!(command instanceof CommandActionDelegate)) {
				if (getDefaultImageDescriptor() != null) {
					setImageDescriptor(getDefaultImageDescriptor());
				}
			} else {
				final CommandActionDelegate commandActionDelegate = (CommandActionDelegate) command;

				final ImageDescriptor imageDescriptor = objectToImageDescriptor(commandActionDelegate.getImage());
				if (imageDescriptor != null) {
					setImageDescriptor(imageDescriptor);
				} else if (getDefaultImageDescriptor() != null) {
					setImageDescriptor(getDefaultImageDescriptor());
				}

				if (commandActionDelegate.getText() != null) {
					setText(commandActionDelegate.getText());
				}

				if (commandActionDelegate.getDescription() != null) {
					setDescription(commandActionDelegate.getDescription());
				}

				if (commandActionDelegate.getToolTipText() != null) {
					setToolTipText(commandActionDelegate.getToolTipText());
				}
			}
		}
	}

	/**
	 * This can be overridden to provide the image descriptor used when the
	 * command does not provide one. This implementation simply returns null.
	 */
	protected ImageDescriptor getDefaultImageDescriptor() {
		return null;
	}

	/**
	 * This gets invoked when the selection is inappropriate or the command
	 * cannot be created. It puts the action in the correct state for such
	 * error conditions. This implementation disables the action and sets its
	 * icon to the default.
	 */
	protected void disable() {
		setEnabled(false);
		if (getDefaultImageDescriptor() != null) {
			setImageDescriptor(getDefaultImageDescriptor());
		}
	}

	/**
	 * This executes the command.
	 */
	@Override
	public void run() {
		// this guard is for extra security, but should not be necessary
		if (editingDomain != null && command != null) {
			// use up the command
			editingDomain.getCommandStack().execute(command);
		}
	}

	/**
	 * If necessary, this converts any image representation into an image
	 * descriptor.
	 */
	protected ImageDescriptor objectToImageDescriptor(Object object) {
		return ExtendedImageRegistry.getInstance().getImageDescriptor(object);
	}
}