/*
    * 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: ModifyPresentationElementCommand2.java
   * Created: Aug 18, 2009
   * Author: Kamil
   * $Id$
   */
  
  package pl.edu.agh.cast.command;
  
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.log4j.Logger;
  import org.eclipse.gef.commands.Command;
  
  import pl.edu.agh.cast.Activator;
  import pl.edu.agh.cast.common.collections.MultiMap;
  import pl.edu.agh.cast.data.model.IElement;
  import pl.edu.agh.cast.data.model.presentation.IPresentationElement;
  import pl.edu.agh.cast.data.model.presentation.PresentationPropertyDescriptor;
  import pl.edu.agh.cast.data.model.presentation.IPresentationElement.PropertyCategory;
  import pl.edu.agh.cast.data.model.property.CustomProperty;
  import pl.edu.agh.cast.data.model.property.MetaProperty;
  import pl.edu.agh.cast.data.model.property.Property;
  import pl.edu.agh.cast.data.model.property.PropertyType;
  import pl.edu.agh.cast.ui.dialogs.property.PropertyTreeEntry;
  
  /**
   * Modifies properties for presentation element including modification of visual and original elements associated with
   * the presentation element.
   *
   * @author AGH CAST Team
   */
  public class ModifyPresentationElementCommand extends Command {
  
  	private static Logger log = Activator.getLogger();
  
  	private IPresentationElement<? extends IElement> model;
  
  	private MultiMap<PropertyCategory, PropertyTreeEntry> entriesMap;
  
  	/**
  	 * Map which contains mapping between modified property and it's old value.
  	 */
  	private Map<Property<? extends MetaProperty>, Object> modifiedProperties;
  
  	private Map<PresentationPropertyDescriptor, Boolean> modifiedAsLabel;
  
  	private Set<PresentationPropertyDescriptor> addedMetaProperties;
  
  	/**
  	 * Constructor.
  	 *
  	 * @param model
  	 *            presentation element for which properties are going to be changed
  	 * @param entriesMap
  	 *            map of property tree entries with new data
  	 */
  	public ModifyPresentationElementCommand(IPresentationElement<? extends IElement> model,
  	        MultiMap<PropertyCategory, PropertyTreeEntry> entriesMap) {
  
  		if (model == null || entriesMap == null) {
  			throw new IllegalArgumentException();
  		}
  		this.model = model;
  		this.entriesMap = entriesMap;
  
  		modifiedProperties = new HashMap<Property<? extends MetaProperty>, Object>();
  		modifiedAsLabel = new HashMap<PresentationPropertyDescriptor, Boolean>();
  		addedMetaProperties = new HashSet<PresentationPropertyDescriptor>();
  	}
  
  	/**
  	 *
  	 * {@inheritDoc}
  	 *
  	 * @see org.eclipse.gef.commands.Command#execute()
  	 */
  	public void execute() {
  		modifiedProperties.clear();
  		modifiedAsLabel.clear();
  		addedMetaProperties.clear();
  		for (PropertyCategory category : PropertyCategory.values()) {
  			IElement element = getElementByCategory(model, category);
  			if (element != null) {
  				processModification(category, element, entriesMap.get(category));
 			}
 		}
 	}
 
 	/**
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see org.eclipse.gef.commands.Command#undo()
 	 */
 	public void undo() {
 
 		for (Property<? extends MetaProperty> property : modifiedProperties.keySet()) {
 			changePropertyValue(property, modifiedProperties.get(property));
 		}
 		modifiedProperties.clear();
 
 		for (PresentationPropertyDescriptor desc : modifiedAsLabel.keySet()) {
 			changePropertyAsLabelAttribute(desc, modifiedAsLabel.get(desc));
 		}
 		modifiedAsLabel.clear();
 
 		for (PresentationPropertyDescriptor desc : addedMetaProperties) {
 			IElement element = getElementByCategory(model, desc.getPropertyCategory());
 			if (element != null) {
 				removeMetaProperty(element, desc.getPropertyName());
 			}
 		}
 	}
 
 	private void processModification(PropertyCategory category, IElement element, Collection<PropertyTreeEntry> entries) {
 
 		// used to check if any property has been removed
 		Set<String> cachedPropertiesNames = new HashSet<String>();
 		if (entries != null) {
 			for (PropertyTreeEntry entry : entries) {
 				if (entry.getProperty() == null) {
 					continue;
 				}
 				Property<? extends MetaProperty> newProperty = entry.getProperty();
 				String propertyName = newProperty.getMetaProperty().getName();
 				cachedPropertiesNames.add(propertyName);
 
 				// check if exists
 				MetaProperty metaProperty = element.getMetaPropertyManager().getMetaProperty(propertyName);
 				if (metaProperty == null) {
 					// add new meta property and set value
 					addMetaProperty(element, propertyName);
 					addedMetaProperties.add(new PresentationPropertyDescriptor(category, propertyName));
 				}
 
 				// check if there is any modification
 				Property<? extends MetaProperty> oldProperty = element.getProperty(propertyName);
 				if (!oldProperty.equals(newProperty)) {
 					// and update property
 					Object oldValue = changePropertyValue(oldProperty, newProperty.getValue());
 					modifiedProperties.put(oldProperty, oldValue);
 				}
 				if (model.getVisualElement().getPropertiesMarkedAsLabel().contains(newProperty) != entry
 				        .isMarkAsLabel()) {
 					// set as label flag
 					PresentationPropertyDescriptor desc = new PresentationPropertyDescriptor(category, oldProperty
 					        .getMetaProperty().getName());
 					changePropertyAsLabelAttribute(desc, entry.isMarkAsLabel());
 					modifiedAsLabel.put(desc, !entry.isMarkAsLabel());
 				}
 
 			}
 		}
 
 		// remove properties
 		// check only custom properties
 		for (CustomProperty property : element.getCustomProperties()) {
 			if (!cachedPropertiesNames.contains(property.getMetaProperty().getName())) {
 				// remove property and meta property
 				removeMetaProperty(element, property.getMetaProperty().getName());
 			}
 		}
 	}
 
 	private Object changePropertyValue(Property<? extends MetaProperty> property, Object value) {
 		Object oldValue = property.getValue();
 		property.setValue(value);
 		return oldValue;
 	}
 
 	private void changePropertyAsLabelAttribute(PresentationPropertyDescriptor desc, boolean flag) {
 		model.getVisualElement().markPropertyAsLabel(desc, flag);
 	}
 
 	private void removeMetaProperty(IElement element, String name) {
 		// this operation cannot be undone
 		element.getMetaPropertyManager().removeMetaProperty(name);
 		log.debug(String.format("Property %s removed from element of type %s.", name, element.getType())); //$NON-NLS-1$
 	}
 
 	private void addMetaProperty(IElement element, String name) {
 		element.getMetaPropertyManager().registerMetaProperty(name, PropertyType.TEXT, true, true);
 		log.debug(String.format("Property %s added to element of type %s.", name, element.getType())); //$NON-NLS-1$
 	}
 
 	private IElement getElementByCategory(IPresentationElement<? extends IElement> presElement,
 	        PropertyCategory category) {
 		IElement element = null;
 		switch (category) {
 			case PRESENTATION:
 				element = presElement;
 				break;
 			case VISUAL:
 				element = presElement.getVisualElement();
 				break;
 			case ORIGINAL:
 				Collection<? extends IElement> originalElements = presElement.getOriginalElements();
 				if (originalElements != null && originalElements.size() == 1) {
 					element = originalElements.iterator().next();
 				}
 				break;
 			default:
 				break;
 		}
 		return element;
 	}
 
 }