/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.bpel.common.ui.palette;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;

import org.eclipse.bpel.common.ui.CommonUIPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.gef.dnd.TemplateTransferDragSourceListener;
import org.eclipse.gef.palette.PaletteContainer;
import org.eclipse.gef.palette.PaletteRoot;
import org.eclipse.gef.palette.ToolEntry;
import org.eclipse.gef.ui.actions.ActionRegistry;
import org.eclipse.gef.ui.palette.PaletteViewer;
import org.eclipse.gef.ui.palette.PaletteViewerProvider;
import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.part.IPageSite;


/**
 * Graphical editor to be integrated with a GEFDetailsEditor.
 */
@SuppressWarnings("nls")
public abstract class GraphicalEditorWithPalette extends GraphicalEditorWithFlyoutPalette {

	static final String EXTPT_PALETTE_ADDITIONS = "paletteAdditions";
	static final String ELEMENT_ADDITIONS = "additions";
	static final String ATT_PROVIDER = "provider"; 
	static final String ATT_IMPORTANCE = "importance";
	static final String ATT_CLASS = "class"; 
	static final String ATT_DEFAULT = "default";
	
	static final String ATT_CATEGORY = "category";
	static final String ATT_CATEGORY_ID = "categoryId";
	static final String ATT_CATEGORY_ORDER = "categoryOrder";
	
	static final String ATT_TARGET_EDITOR = "targetEditor";
		
	
	private PaletteRoot paletteRoot;

	
	/**
	 * 
	 */
	public GraphicalEditorWithPalette() {
		super();
	}

	
	/**
	 * @see org.eclipse.gef.ui.parts.GraphicalEditor#dispose()
	 */
	@Override
	public void dispose() {
		super.dispose();
		paletteRoot = null;
	}

	
	@Override
	protected CustomPalettePage createPalettePage() {
		return new CustomPalettePage(getPaletteViewerProvider()) {
			
			@Override
			public void init(IPageSite pageSite) {
				super.init(pageSite);
				
				IAction copy = getActionRegistry().getAction(ActionFactory.COPY.getId());
				pageSite.getActionBars().setGlobalActionHandler(
						ActionFactory.COPY.getId(), copy);
				
			}
		};
	}

	
	/**
	 * Get the action registry.
	 * 
	 * @see org.eclipse.gef.ui.parts.GraphicalEditor#getActionRegistry()
	 */
	
	@Override
	protected ActionRegistry getActionRegistry() {		
		return super.getActionRegistry();
	}


	@Override
	protected PaletteViewerProvider createPaletteViewerProvider() {
		
		return new PaletteViewerProvider(getEditDomain()) {			
			@Override
			protected void configurePaletteViewer(PaletteViewer viewer) {
				super.configurePaletteViewer(viewer);
				// viewer.setCustomizer(new LogicPaletteCustomizer());
				viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
			}
		};
	}
	
	/**
	 * The implementation in new versions of GraphicalEditor assumes that 'this' will be
	 * the top-level editor.  For us, the assumption is most likely wrong--a DetailsEditor
	 * is probably the top-level editor...  
	 */
	
	@Override
	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
		// Bugzilla 330526
		getSite().getShell().getDisplay().asyncExec(new Runnable() {
			public void run() {
				updateActions(getSelectionActions());
			}
		});
	}
	
	@Override
	protected PaletteRoot getPaletteRoot() {
		if (paletteRoot == null) {
			paletteRoot = new PaletteRoot();			
			createPalette ();
		}

		return paletteRoot;
	}

	
	HashMap<String,IOrderedPaletteEntry> paletteContainers () {
		
		// Create extension items
		HashMap<String,IOrderedPaletteEntry> map = new HashMap<String,IOrderedPaletteEntry>();		
		
		for(Object next : paletteRoot.getChildren()) {
			if (next instanceof IOrderedPaletteEntry) {
				IOrderedPaletteEntry entry = (IOrderedPaletteEntry)next;
				map.put(entry.getCategoryId(), entry);
			}
		}
		return map;
	}
	
	
	protected String getPaletteAdditionsContributorId() {
		return getEditorSite().getId();
	}
	
	
	protected void createPalette ( ) {
		
		// Get the id of this editor
		String id = getPaletteAdditionsContributorId();
				
		ArrayList<IConfigurationElement> listOfAdditions = new ArrayList<IConfigurationElement>();
		
		for( IConfigurationElement additions : getConfigurationElements(EXTPT_PALETTE_ADDITIONS) ) {	
			
			if (additions.getName().equals(ELEMENT_ADDITIONS) == false || 
					id.equals ( additions.getAttribute(ATT_TARGET_EDITOR)) == false ) {
				continue;
			}										
			listOfAdditions.add( additions );
		}
		
		
		// Sort the additions in order.
		Collections.sort(listOfAdditions, new Comparator<IConfigurationElement> () {			
			int getInt ( String n ) {
				try {
					return Integer.parseInt(n);
				} catch (Throwable t) {
					return 10;
				}
			}			
			public int compare(IConfigurationElement o1, IConfigurationElement o2) {
				return getInt ( o1.getAttribute(ATT_IMPORTANCE) ) - 
				       getInt ( o2.getAttribute(ATT_IMPORTANCE) );
			}			
		});
		
		
		HashMap<String,IOrderedPaletteEntry> containerMap = null;
		
		// Process the palette additions.
		for(IConfigurationElement additions : listOfAdditions ) {
				
			String provider = additions.getAttribute(ATT_PROVIDER);
			if (provider != null) {
				try {
					IPaletteProvider entry = (IPaletteProvider) additions.createExecutableExtension(ATT_PROVIDER);
					entry.contributeItems( paletteRoot );
					// Recompute the categories, added by this bulk-addition
					containerMap = null;
				} catch ( CoreException ce ) {
					CommonUIPlugin.getDefault().getLog().log(ce.getStatus());
				}
			}

			if (containerMap == null) {
				containerMap = paletteContainers();
			}
						
			// Now process individual additions.
			
			for (IConfigurationElement addition: additions.getChildren() ) {
								
				String def = addition.getAttribute(ATT_DEFAULT);
				String categoryName = addition.getAttribute(ATT_CATEGORY);
				String categoryId   = addition.getAttribute(ATT_CATEGORY_ID);
				
				int    categoryOrder = 100;
				
				try {
					categoryOrder = Math.abs( Integer.parseInt( addition.getAttribute(ATT_CATEGORY_ORDER) ) );
				} catch (Throwable t) {
					categoryOrder = 100;
				}
				
				if (categoryId == null) {
					categoryId = "bpel.user";
				}
				

				PaletteContainer container = null;				
				PaletteCategory category = null;
				
				IOrderedPaletteEntry orderedContainer = containerMap.get(categoryId);
				
				if (orderedContainer == null) {
					
					container = category = new PaletteCategory(categoryName); //$NON-NLS-1$					
					
					category.setOrder ( categoryOrder );
					category.setCategoryId ( categoryId );
					
					containerMap.put(categoryId, category);
					
					paletteRoot.add(container);		
					
				} else if (orderedContainer instanceof PaletteCategory) {
					container = category = (PaletteCategory) orderedContainer;
				} else if (orderedContainer instanceof PaletteContainer) {
					container = (PaletteContainer) orderedContainer;
				} 
								
				
				try {
					
					ToolEntry entry = (ToolEntry)addition.createExecutableExtension(ATT_CLASS);
					
					// The container may be null. This is most likely due to some error in configruation.
					if (container != null) {
						container.add(entry);
					}
					
					if (def != null && def.equals("true") && category != null) { //$NON-NLS-1$
						category.setDefaultTool(entry);
					}
					
				} catch (CoreException e) {
					CommonUIPlugin.getDefault().getLog().log(e.getStatus());
				}
			}
		}
		
		
		// Now sort the palette categories within the list
		
		Collections.sort(paletteRoot.getChildren(), new Comparator () {
			public int compare(Object o1, Object o2) {
				try {				
					IOrderedPaletteEntry e1 = (IOrderedPaletteEntry) o1;
					IOrderedPaletteEntry e2 = (IOrderedPaletteEntry) o2;
					return e1.getOrder() - e2.getOrder();
				} catch (Throwable t) {
					return 0;
				}				
			} 					
		});		
		
	}
	
	
	private IConfigurationElement[] getConfigurationElements(String extensionPointId) {
		
		IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(CommonUIPlugin.PLUGIN_ID, extensionPointId);
		if (extensionPoint == null) {
			return new IConfigurationElement[0];
		}
		return extensionPoint.getConfigurationElements();
	}
}