/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.0 (the "License").
    * You may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * http://www.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: NodeIconProvider.java
   * Created: 2008-11-11
   * Author: tmilos
   * $Id: NodeIconProvider.java 3054 2009-07-27 10:23:07Z kpietak $
   */
  
  package pl.edu.agh.cast.backward.figure.icons;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IConfigurationElement;
  
  import pl.edu.agh.cast.Activator;
  import pl.edu.agh.cast.CastApplication;
  import pl.edu.agh.cast.util.Images;
  import pl.edu.agh.cast.util.Messages;
  
  /**
   * Provides uniform and centralized way of accessing <code>NodeIcon</code>s.
   *
   * Manages icons provided by all extenders of <code>pl.edu.agh.cast.nodeIcons</code> extension point.
   *
   * @author AGH CAST Team
   */
  public final class NodeIconProvider {
  
  	private static Logger log = Activator.getLogger();
  
  	private static NodeIconProvider instance;
  
  	private HashMap<String, NodeIcon> nodeIcons;
  
  	private HashMap<String, NodeIcon> nodeIconsByID;
  
  	private NodeIcon defaultIcon;
  
  	/**
  	 * Returns single, shared instance of {@link NodeIconProvider}.
  	 *
  	 * @return single, shared instance of {@link NodeIconProvider}
  	 */
  	public static NodeIconProvider getInstance() {
  		if (instance == null) {
  			instance = new NodeIconProvider();
  			instance.init();
  		}
  		return instance;
  	}
  
  	/**
  	 * Hidden constructor.
  	 */
  	private NodeIconProvider() {
  		nodeIcons = new HashMap<String, NodeIcon>();
  		nodeIconsByID = new HashMap<String, NodeIcon>();
  	}
  
  	private void addNodeIcon(NodeIcon nodeIcon) {
  		nodeIcons.put(nodeIcon.getNodeType(), nodeIcon);
  		nodeIconsByID.put(nodeIcon.getIconId(), nodeIcon);
  		nodeIconsByID.put(nodeIcon.getSmallIconId(), nodeIcon);
  
  		Images.getInstance().putDescriptor(nodeIcon.getIconId(), nodeIcon.getIconDescriptor());
  		Images.getInstance().putDescriptor(nodeIcon.getSmallIconId(), nodeIcon.getSmallIconDescriptor());
  	}
  
  	/**
  	 * Initializes the instance. Loads descriptors of all icons provided by factories plugged into
  	 * <code>pl.edu.agh.cast.nodeIcons</code> extension point. Registers all icon images in <code>Images</code>'s
  	 * <code>ImageRegistry</code>.
  	 */
  	private void init() {
  		try {
  			for (IConfigurationElement nodeIconCE : Activator.getNodeIconsConfigurations()) {
  
  				INodeIconFactory factory = null;
  				try {
  					factory = (INodeIconFactory)nodeIconCE.createExecutableExtension(Activator.NODE_ICON_FACTORY);
  				} catch (CoreException e) {
  					log.warn("Failed to instantiate INodeIconFactory provided by extension: " //$NON-NLS-1$
  					        + nodeIconCE.getDeclaringExtension().getUniqueIdentifier(), e);
 					continue;
 				}
 
 				for (NodeIcon nodeIcon : factory.getNodeIcons()) {
 					if (nodeIcon == null) {
 						log.warn("Invalid (null) NodeIcon provided by extension: " //$NON-NLS-1$
 						        + nodeIconCE.getDeclaringExtension().getUniqueIdentifier());
 						continue;
 					}
 
 					addNodeIcon(nodeIcon);
 
 				}
 			}
 
 			defaultIcon = AbstractNodeIconFactory.createNodeIcon(CastApplication.class, null,
 			        Messages.CoreNodeIcon_DisplayName_Default,
 			        "icons/people/entity.png", "icons/people/entity_small.png", //$NON-NLS-1$ //$NON-NLS-2$
 			        Messages.CoreNodeIcon_Group_0);
 
 			addNodeIcon(defaultIcon);
 
 		} catch (Exception e) {
 			// ignore: this may happen when RCP Platform is not running
 			// - ex. during tests
 		}
 	}
 
 	/**
 	 * Returns {@link NodeIcon} for given node type.
 	 *
 	 * @param nodeType
 	 *            type of the node
 	 * @return node icon for requested type
 	 */
 	public NodeIcon getNodeIcon(String nodeType) {
 		NodeIcon nodeIcon = nodeIcons.get(nodeType);
 		if (nodeIcon == null) {
 			nodeIcon = defaultIcon;
 		}
 		return nodeIcon;
 	}
 
 	/**
 	 * Returns Id of the icon image for given node type.
 	 *
 	 * @param nodeType
 	 *            type of the node
 	 * @return Id of the icon image for requested type
 	 */
 	public String getIconId(String nodeType) {
 		NodeIcon nodeIcon = getNodeIcon(nodeType);
 		if (nodeIcon != null) {
 			return nodeIcon.getIconId();
 		} else {
 			return null;
 		}
 	}
 
 	/**
 	 * Returns Id of the small icon image for given node type.
 	 *
 	 * @param nodeType
 	 *            type of the node
 	 * @return Id of the small icon image for requested type
 	 */
 	public String getSmallIconId(String nodeType) {
 		NodeIcon nodeIcon = getNodeIcon(nodeType);
 		if (nodeIcon != null) {
 			return nodeIcon.getSmallIconId();
 		} else {
 			return null;
 		}
 	}
 
 	/**
 	 * Returns localized display name for given icon image.
 	 *
 	 * @param imageId
 	 *            id of the icon image
 	 * @return localized icon description
 	 */
 	public String getFriendlyName(String imageId) {
 		NodeIcon nodeIcon = nodeIconsByID.get(imageId);
 		if (nodeIcon == null) {
 			return null;
 		}
 		if (nodeIcon.getName() != null) {
 			return nodeIcon.getName();
 		} else {
 			return nodeIcon.getNodeType();
 		}
 	}
 
 	public Collection<NodeIcon> getAllNodeIcons() {
 		return Collections.unmodifiableCollection(nodeIcons.values());
 	}
 
 	/**
 	 * Returns a map of <code>NodeIcon</code>s groups, with localized group names as keys.
 	 *
 	 * @return map of <code>NodeIcon</code>s groups
 	 */
 	public Map<String, List<NodeIcon>> getGroupedNodeIcons() {
 		Map<String, List<NodeIcon>> groupMap = new HashMap<String, List<NodeIcon>>();
 		for (NodeIcon nodeIcon : getAllNodeIcons()) {
 			if (nodeIcon == null) {
 				continue;
 			}
 			List<NodeIcon> group = groupMap.get(nodeIcon.getGroup());
 			if (group == null) {
 				group = new LinkedList<NodeIcon>();
 				groupMap.put(nodeIcon.getGroup(), group);
 			}
 			group.add(nodeIcon);
 		}
 		return groupMap;
 	}
 
 	/**
 	 * Returns the default {@link NodeIcon}.
 	 *
 	 * @return the default {@link NodeIcon}
 	 */
 	public NodeIcon getDefaultIcon() {
 		return defaultIcon;
 	}
 
 }