/*******************************************************************************
 * Copyright (c) 2000, 2015 IBM Corporation and others.
 *
 * 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 Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jface.action;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * A <code>SubContributionManager</code> is used to define a set of contribution
 * items within a parent manager.  Once defined, the visibility of the entire set can
 * be changed as a unit.
 */
public abstract class SubContributionManager implements IContributionManager {
    /**
     * The parent contribution manager.
     */
    private IContributionManager parentMgr;

    /**
     * Maps each item in the manager to a wrapper.  The wrapper is used to
     * control the visibility of each item.
     */
    private Map<IContributionItem, SubContributionItem> mapItemToWrapper = new HashMap<>();

    /**
     * The visibility of the manager,
     */
    private boolean visible = false;

    /**
     * Constructs a new <code>SubContributionManager</code>
     *
     * @param mgr the parent contribution manager.  All contributions made to the
     *      <code>SubContributionManager</code> are forwarded and appear in the
     *      parent manager.
     */
    public SubContributionManager(IContributionManager mgr) {
        super();
        parentMgr = mgr;
    }

    @Override
	public void add(IAction action) {
        add(new ActionContributionItem(action));
    }

    @Override
	public void add(IContributionItem item) {
        SubContributionItem wrap = wrap(item);
        wrap.setVisible(visible);
        parentMgr.add(wrap);
        itemAdded(item, wrap);
    }

    @Override
	public void appendToGroup(String groupName, IAction action) {
        appendToGroup(groupName, new ActionContributionItem(action));
    }

    @Override
	public void appendToGroup(String groupName, IContributionItem item) {
        SubContributionItem wrap = wrap(item);
        wrap.setVisible(visible);
        parentMgr.appendToGroup(groupName, wrap);
        itemAdded(item, wrap);
    }

    /**
     * Disposes this sub contribution manager, removing all its items
     * and cleaning up any other resources allocated by it.
     * This must leave no trace of this sub contribution manager
     * in the parent manager.  Subclasses may extend.
     *
     * @since 3.0
     */
    public void disposeManager() {
        Iterator<SubContributionItem> it = mapItemToWrapper.values().iterator();
        // Dispose items in addition to removing them.
        // See bugs 64024 and 73715 for details.
	    // Do not use getItems() here as subclasses can override that in bad ways.
        while (it.hasNext()) {
            IContributionItem item = it.next();
            item.dispose();
        }
        removeAll();
    }

    @Override
	public IContributionItem find(String id) {
        IContributionItem item = parentMgr.find(id);
        // Return the item passed to us, not the wrapper.
        item = unwrap(item);
        return item;
    }

    @Override
	public IContributionItem[] getItems() {
        IContributionItem[] result = new IContributionItem[mapItemToWrapper
                .size()];
        mapItemToWrapper.keySet().toArray(result);
        return result;
    }

    /**
     * Returns the parent manager.
     *
     * @return the parent manager
     */
    public IContributionManager getParent() {
        return parentMgr;
    }

    @Override
	public IContributionManagerOverrides getOverrides() {
        return parentMgr.getOverrides();
    }

    @Override
	public void insertAfter(String id, IAction action) {
        insertAfter(id, new ActionContributionItem(action));
    }

    @Override
	public void insertAfter(String id, IContributionItem item) {
        SubContributionItem wrap = wrap(item);
        wrap.setVisible(visible);
        parentMgr.insertAfter(id, wrap);
        itemAdded(item, wrap);
    }

    @Override
	public void insertBefore(String id, IAction action) {
        insertBefore(id, new ActionContributionItem(action));
    }

    @Override
	public void insertBefore(String id, IContributionItem item) {
        SubContributionItem wrap = wrap(item);
        wrap.setVisible(visible);
        parentMgr.insertBefore(id, wrap);
        itemAdded(item, wrap);
    }

    @Override
	public boolean isDirty() {
        return parentMgr.isDirty();
    }

    @Override
	public boolean isEmpty() {
        return parentMgr.isEmpty();
    }

    /**
     * Returns whether the contribution list is visible.
     * If the visibility is <code>true</code> then each item within the manager
     * appears within the parent manager.  Otherwise, the items are not visible.
     *
     * @return <code>true</code> if the manager is visible
     */
    public boolean isVisible() {
        return visible;
    }

    /**
     * Notifies that an item has been added.
     * <p>
     * Subclasses are not expected to override this method.
     * </p>
     *
     * @param item the item contributed by the client
     * @param wrap the item contributed to the parent manager as a proxy for the item
     *      contributed by the client
     */
    protected void itemAdded(IContributionItem item, SubContributionItem wrap) {
    	item.setParent(this);
        mapItemToWrapper.put(item, wrap);
    }

    /**
     * Notifies that an item has been removed.
     * <p>
     * Subclasses are not expected to override this method.
     * </p>
     *
     * @param item the item contributed by the client
     */
    protected void itemRemoved(IContributionItem item) {
        mapItemToWrapper.remove(item);
        item.setParent(null);
    }

    /**
     * @return fetch all enumeration of wrappers for the item
     * @deprecated Use getItems(String value) instead.
     */
    @Deprecated
	public Enumeration<SubContributionItem> items() {
        final Iterator<SubContributionItem> i = mapItemToWrapper.values().iterator();
        return new Enumeration<SubContributionItem>() {
            @Override
			public boolean hasMoreElements() {
                return i.hasNext();
            }

            @Override
			public SubContributionItem nextElement() {
                return i.next();
            }
        };
    }

    @Override
	public void markDirty() {
        parentMgr.markDirty();
    }

    @Override
	public void prependToGroup(String groupName, IAction action) {
        prependToGroup(groupName, new ActionContributionItem(action));
    }

    @Override
	public void prependToGroup(String groupName, IContributionItem item) {
        SubContributionItem wrap = wrap(item);
        wrap.setVisible(visible);
        parentMgr.prependToGroup(groupName, wrap);
        itemAdded(item, wrap);
    }

    @Override
	public IContributionItem remove(String id) {
        IContributionItem result = parentMgr.remove(id);
        // result is the wrapped item
        if (result != null) {
        	IContributionItem item = unwrap(result);
			itemRemoved(item);
		}
        return result;
    }

    @Override
	public IContributionItem remove(IContributionItem item) {
        SubContributionItem wrap = mapItemToWrapper
                .get(item);
        if (wrap == null) {
			return null;
		}
        IContributionItem result = parentMgr.remove(wrap);
        if (result == null) {
			return null;
		}
        itemRemoved(item);
        return item;
    }

    @Override
	public void removeAll() {
    	Object[] array = mapItemToWrapper.keySet().toArray();
    	for (Object element : array) {
			IContributionItem item = (IContributionItem) element;
			remove(item);
		}
        mapItemToWrapper.clear();
    }

    /**
     * Sets the visibility of the manager.  If the visibility is <code>true</code>
     * then each item within the manager appears within the parent manager.
     * Otherwise, the items are not visible.
     *
     * @param visible the new visibility
     */
    public void setVisible(boolean visible) {
        this.visible = visible;
        if (mapItemToWrapper.size() > 0) {
            Iterator<SubContributionItem> it = mapItemToWrapper.values().iterator();
            while (it.hasNext()) {
                IContributionItem item = it.next();
                item.setVisible(visible);
            }
            parentMgr.markDirty();
        }
    }

    /**
     * Wraps a contribution item in a sub contribution item, and returns the new wrapper.
     * @param item the contribution item to be wrapped
     * @return the wrapped item
     */
    protected SubContributionItem wrap(IContributionItem item) {
        return new SubContributionItem(item);
    }

    /**
     * Unwraps a nested contribution item. If the contribution item is an
     * instance of <code>SubContributionItem</code>, then its inner item is
     * returned. Otherwise, the item itself is returned.
     *
     * @param item
     *            The item to unwrap; may be <code>null</code>.
     * @return The inner item of <code>item</code>, if <code>item</code> is
     *         a <code>SubContributionItem</code>;<code>item</code>
     *         otherwise.
     */
    protected IContributionItem unwrap(IContributionItem item) {
        if (item instanceof SubContributionItem) {
            return ((SubContributionItem) item).getInnerItem();
        }

        return item;
    }
}
