/*
    * 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: VisualResource.java
   * Created: 2009-07-21
   * Author: kpietak
   * $Id$
   */
  
  package pl.edu.agh.cast.resource;
  
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.eclipse.jface.resource.ImageDescriptor;
  import org.eclipse.swt.graphics.Image;
  
  import pl.edu.agh.cast.data.model.Type;
  
  /**
   * Default implementation of {@link IVisualResource}.
   *
   * @author AGH CAST Team
   */
  public class VisualResource implements IVisualResource {
  
  	private static final String ERROR_MSG_01 = "Cannot create image: "; //$NON-NLS-1$
  
  	private String id;
  
  	private String label;
  
  	private String description;
  
  	private List<String> tags;
  
  	private String groupId;
  
  	private Type type;
  
  	private Map<ImageSize, ImageDescriptor> defaultImageDescriptors;
  
  	private Map<ImageSize, Image> defaultImages;
  
  	private Map<String, Map<ImageSize, ImageDescriptor>> variantImageDescriptors;
  
  	private Map<String, Map<ImageSize, Image>> variantImages;
  
  	/**
  	 * Constructor with all required parameters.
  	 *
  	 * @param id
  	 *            resource id
  	 * @param label
  	 *            resource label
  	 * @param description
  	 *            resource description
  	 */
  	public VisualResource(String id, String label, String description) {
  		this(id, label, description, null, null, null);
  	}
  
  	/**
  	 * Constructor.
  	 *
  	 * @param id
  	 *            resource id
  	 * @param label
  	 *            resource label
  	 * @param description
  	 *            resource description
  	 * @param tags
  	 *            resource tags
  	 * @param groupId
  	 *            resource group id
  	 * @param type
  	 *            type of described element or data set
  	 */
  	public VisualResource(String id, String label, String description, List<String> tags, String groupId, Type type) {
  		initialize();
  		setId(id);
  		setLabel(label);
  		setDescription(description);
  		setTags(tags);
  		setGroupId(groupId);
  		setType(type);
  	}
  
 	/**
 	 * Registers image descriptor for default image with specified size. Descriptor and size cannot be equal to
 	 * <code>null</code>. If an image descriptor has been already registered, it is overridden with a new one.
 	 *
 	 * @param size
 	 *            image size
 	 * @param descriptor
 	 *            image descriptor
 	 * @return image descriptor which was registered with the same size before (overridden one), <code>null</code> if
 	 *         there was no such image
 	 * @throws ResourceException
 	 *             when image cannot be created
 	 * @throws IllegalArgumentException
 	 *             when at least one of the given arguments is <code>null</code>
 	 */
 	public ImageDescriptor registerDefaultImageDesriptor(ImageSize size, ImageDescriptor descriptor)
 	        throws ResourceException {
 		assert defaultImageDescriptors != null;
 		if (size == null || descriptor == null) {
 			throw new IllegalArgumentException("Cannot register image descriptor with null argument(s)"); //$NON-NLS-1$
 		}
 		Image img = descriptor.createImage(false);
 		if (img != null) {
 			defaultImages.put(size, img);
 			return defaultImageDescriptors.put(size, descriptor);
 		} else {
 			StringBuilder stringBuilder = new StringBuilder();
 			stringBuilder.append(ERROR_MSG_01);
 			stringBuilder.append(descriptor.toString());
 			throw new ResourceException(stringBuilder.toString());
 		}
 
 	}
 
 	/**
 	 * Registers image descriptor for variant with specified size. All arguments cannot be <code>null</code>. If an
 	 * image descriptor has been already registered, it is overridden with a new one.
 	 *
 	 * @param variant
 	 *            id of image variant
 	 * @param size
 	 *            image size
 	 * @param descriptor
 	 *            image descriptor
 	 * @return image descriptor for specified variant which was registered with the same size before (overridden one),
 	 *         <code>null</code> if there was no such image
 	 * @throws ResourceException
 	 *             when image cannot be created
 	 * @throws IllegalArgumentException
 	 *             when at least one of the given arguments is <code>null</code>
 	 */
 	public ImageDescriptor registerVariantImageDescriptor(String variant, ImageSize size, ImageDescriptor descriptor)
 	        throws ResourceException {
 		assert variantImageDescriptors != null;
 		assert variantImages != null;
 		if (variant == null || variant.isEmpty() || size == null || descriptor == null) {
 			throw new IllegalArgumentException("Cannot register variants of image descriptor " + //$NON-NLS-1$
 			        "with null argument(s)"); //$NON-NLS-1$
 		}
 		if (!variantImageDescriptors.containsKey(variant)) {
 			variantImageDescriptors.put(variant, new HashMap<ImageSize, ImageDescriptor>());
 		}
 		if (!variantImages.containsKey(variant)) {
 			variantImages.put(variant, new HashMap<ImageSize, Image>());
 		}
 
 		Image img = descriptor.createImage(false);
 		if (img != null) {
 			variantImages.get(variant).put(size, img);
 			return variantImageDescriptors.get(variant).put(size, descriptor);
 		} else {
 			StringBuilder stringBuilder = new StringBuilder();
 			stringBuilder.append(ERROR_MSG_01);
 			stringBuilder.append(descriptor);
 			throw new ResourceException(stringBuilder.toString());
 		}
 
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getDescription()
 	 */
 	@Override
 	public String getDescription() {
 		return description;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getGroupId()
 	 */
 	@Override
 	public String getGroupId() {
 		return groupId;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getId()
 	 */
 	@Override
 	public String getId() {
 		return id;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getImage()
 	 */
 	@Override
 	public Image getImage() {
 		if (getAvailableDefaultImageSizes().size() == 1) { // if we have only one image - return it
 			for (ImageSize size : getAvailableDefaultImageSizes()) {
 				return getImage(size); // we can return here as we have only one element in the collection
 			}
 		}
 		return getImage(ImageSize.getDefaultSize());
 
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getImage(pl.edu.agh.cast.resource.ImageSize)
 	 */
 	@Override
 	public Image getImage(ImageSize size) {
 		assert defaultImageDescriptors != null;
 		assert defaultImages != null;
 
 		if (size == null) {
 			throw new IllegalArgumentException(
 			        "Cannot return image with null size. If you want to get image with default " + //$NON-NLS-1$
 			                "size use getImage method with no parameters"); //$NON-NLS-1$
 		}
 		if (defaultImages.containsKey(size)) {
 			return defaultImages.get(size);
 		} else if (defaultImageDescriptors.containsKey(size)) {
 			Image img = defaultImageDescriptors.get(size).createImage();
 			if (img != null) {
 				defaultImages.put(size, img);
 			}
 			return img;
 		}
 
 		return null;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getImage(java.lang.String)
 	 */
 	@Override
 	public Image getImage(String variant) {
 		if (variant == null || variant.isEmpty()) {
 			throw new IllegalArgumentException("Cannot get image with null or empty variant key"); //$NON-NLS-1$
 		}
 		if (getAvailableVariantImageSizes(variant).size() == 1) {// if we have only one image - return it
 			for (ImageSize size : getAvailableVariantImageSizes(variant)) {
 				return getImage(variant, size);
 			}
 		}
 		return getImage(variant, ImageSize.getDefaultSize());
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getImage(java.lang.String, pl.edu.agh.cast.resource.ImageSize)
 	 */
 	@Override
 	public Image getImage(String variant, ImageSize size) {
 		assert variantImageDescriptors != null;
 		assert variantImages != null;
 
 		if (variant == null || variant.isEmpty() || size == null) {
 			throw new IllegalArgumentException("Cannot get image with null variant or size"); //$NON-NLS-1$
 		}
 		if (variantImages.containsKey(variant) && variantImages.get(variant).containsKey(size)) {
 			return variantImages.get(variant).get(size);
 		} else if (variantImageDescriptors.containsKey(variant)
 		        && variantImageDescriptors.get(variant).containsKey(size)) {
 			Image img = variantImageDescriptors.get(variant).get(size).createImage();
 			if (img != null) {
 				if (!variantImages.containsKey(variant)) {
 					variantImages.put(variant, new HashMap<ImageSize, Image>());
 				}
 				variantImages.get(variant).put(size, img);
 			}
 			return img;
 		}
 
 		return null;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getLabel()
 	 */
 	@Override
 	public String getLabel() {
 		return label;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getTags()
 	 */
 	@Override
 	public List<String> getTags() {
 		return tags;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#getType()
 	 */
 	@Override
 	public Type getType() {
 		return type;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.resource.IVisualResource#dispose()
 	 */
 	@Override
 	public void dispose() {
 
 		for (ImageSize size : defaultImages.keySet()) {
 			Image img = defaultImages.get(size);
 			if (img != null && !img.isDisposed()) {
 				img.dispose();
 			}
 		}
 		defaultImages.clear();
 
 		for (Map<ImageSize, Image> map : variantImages.values()) {
 			for (ImageSize size : map.keySet()) {
 				Image img = map.get(size);
 				if (img != null && !img.isDisposed()) {
 					img.dispose();
 				}
 			}
 			map.clear();
 		}
 		variantImages.clear();
 
 	}
 
 	/**
 	 * @param id
 	 *            the id to set
 	 */
 	protected void setId(String id) {
 		if (id == null || id.isEmpty()) {
 			throw new IllegalArgumentException("Resource cannot have null or empty id"); //$NON-NLS-1$
 		}
 		this.id = id;
 	}
 
 	/**
 	 * @param label
 	 *            the label to set
 	 */
 	protected void setLabel(String label) {
 		if (label == null) {
 			throw new IllegalArgumentException("Resource cannot have null label"); //$NON-NLS-1$
 		}
 		this.label = label;
 	}
 
 	/**
 	 * @param description
 	 *            the description to set
 	 */
 	protected void setDescription(String description) {
 		this.description = description;
 	}
 
 	/**
 	 * @param tags
 	 *            the tags to set
 	 */
 	protected void setTags(List<String> tags) {
 		this.tags = tags;
 	}
 
 	/**
 	 * @param groupId
 	 *            the groupId to set
 	 */
 	protected void setGroupId(String groupId) {
 		this.groupId = groupId;
 	}
 
 	/**
 	 * @param type
 	 *            the type to set
 	 */
 	protected void setType(Type type) {
 		this.type = type;
 	}
 
 	// BEGIN CODE - Helper methods
 
 	private void initialize() {
 		defaultImageDescriptors = new HashMap<ImageSize, ImageDescriptor>();
 		defaultImages = new HashMap<ImageSize, Image>();
 		variantImageDescriptors = new HashMap<String, Map<ImageSize, ImageDescriptor>>();
 		variantImages = new HashMap<String, Map<ImageSize, Image>>();
 	}
 
 	private Set<ImageSize> getAvailableDefaultImageSizes() {
 		return defaultImageDescriptors.keySet();
 	}
 
 	@SuppressWarnings("unchecked")
 	private Set<ImageSize> getAvailableVariantImageSizes(String variant) {
 		assert variant != null && !variant.isEmpty();
 		if (variantImageDescriptors.containsKey(variant)) {
 			return variantImageDescriptors.get(variant).keySet();
 		}
 		return (Set<ImageSize>)Collections.EMPTY_SET;
 	}
 
 	// END CODE - Helper methods
 }