/*
    * 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: PropertyTreeEntry.java
   * Created: 2009-08-04
   * Author: kpietak
   * $Id$
   */
  
  package pl.edu.agh.cast.ui.dialogs.property;
  
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.Map;
  import java.util.SortedMap;
  import java.util.TreeMap;
  
  import pl.edu.agh.cast.data.model.property.MetaProperty;
  import pl.edu.agh.cast.data.model.property.Property;
  
  /**
   * Class which describes single entry in properties tree. It contains one of the two following fields:
   * <ul>
   * <li><code>label</code> when describe category entry such as 'visual data', etc.; such entries are not editable,
   * <li><code>property</code> when describe element's property with value; such entries types depends on property type
   * </ul>
   * One and the only one field from above list is not null.
   *
   * @author AGH CAST Team
   */
  public final class PropertyTreeEntry {
  
  	private String id;
  
  	private PropertyEditType type;
  
  	private String label;
  
  	private boolean isMarkAsLabel;
  
  	private Property<? extends MetaProperty> property;
  
  	private PropertyTreeEntry parent;
  
  	private SortedMap<String, PropertyTreeEntry> children;
  
  	/**
  	 * Enumeration of properties entries edition types.
  	 *
  	 * @author AGH CAST Team
  	 */
  	public enum PropertyEditType {
  		CUSTOM_EDITABLE, CUSTOM_NOT_EDITABLE, EDITABLE, NOT_EDITABLE, CATEGORY
  	}
  
  	/**
  	 * Alphabetic string comparator.
  	 *
  	 * @author AGH CAST Team
  	 */
  	class AlphabeticComparator implements Comparator<String> {
  		public int compare(String o1, String o2) {
  			return o1.toLowerCase().compareTo(o2.toLowerCase());
  		}
  
  	}
  
  	// BEGIN Constructors
  
  	/**
  	 * Constructor for entry with label. The type is set to {@link PropertyEditType#CATEGORY}.
  	 *
  	 * @param id
  	 *            entry id
  	 * @param label
  	 *            entry label
  	 */
  	public PropertyTreeEntry(String id, String label) {
  		this(id, PropertyEditType.CATEGORY);
  		if (label == null) {
  			throw new IllegalArgumentException();
  		}
  		this.label = label;
  		this.property = null;
  	}
  
  	/**
  	 * Constructor for entry with property. The type is based on property type.
  	 *
  	 * @param id
  	 *            entry id
 	 * @param property
 	 *            property in this entry
 	 * @param type
 	 *            entry type based on property type
 	 */
 	public PropertyTreeEntry(String id, Property<? extends MetaProperty> property, PropertyEditType type) {
 		this(id, type);
 		if (property == null) {
 			throw new IllegalArgumentException();
 		}
 		this.label = null;
 		this.property = property;
 	}
 
 	/**
 	 * Constructor for entry with label which sets also parent entry.
 	 *
 	 * @param id
 	 *            entry id
 	 * @param label
 	 *            entry label
 	 * @param parent
 	 *            parent entry
 	 * @see PropertyTreeEntry#PropertyTreeEntry(String, String)
 	 */
 	public PropertyTreeEntry(String id, String label, PropertyTreeEntry parent) {
 		this(id, label);
 		setParent(parent);
 	}
 
 	/**
 	 * Constructor for entry with property which sets also parent entry.
 	 *
 	 * @param id
 	 *            entry id
 	 * @param property
 	 *            property in this entry
 	 * @param type
 	 *            entry type based on property type
 	 * @param parent
 	 *            parent entry
 	 * @see PropertyTreeEntry#PropertyTreeEntry(String, Property, PropertyEditType)
 	 */
 	public PropertyTreeEntry(String id, Property<? extends MetaProperty> property, PropertyEditType type,
 	        PropertyTreeEntry parent) {
 		this(id, property, type);
 		setParent(parent);
 	}
 
 	private PropertyTreeEntry(String id, PropertyEditType type) {
 		if (id == null || type == null) {
 			throw new IllegalArgumentException();
 		}
 		this.id = id;
 		this.type = type;
 		children = new TreeMap<String, PropertyTreeEntry>(new AlphabeticComparator());
 		isMarkAsLabel = false;
 	}
 
 	// END Constructors
 
 	// BEGIN Getters & setters
 
 	public String getId() {
 		return id;
 	}
 
 	public PropertyEditType getType() {
 		return type;
 	}
 
 	public String getLabel() {
 		return label;
 	}
 
 	public boolean isMarkAsLabel() {
 		return isMarkAsLabel;
 	}
 
 	public void setIsMarkAsLabel(boolean isMarkAsLabel) {
 		this.isMarkAsLabel = isMarkAsLabel;
 	}
 
 	public Property<? extends MetaProperty> getProperty() {
 		return property;
 	}
 
 	public void setParent(PropertyTreeEntry parent) {
 		this.parent = parent;
 	}
 
 	public PropertyTreeEntry getParent() {
 		return parent;
 	}
 
 	public Collection<PropertyTreeEntry> getChildren() {
 		return children.values();
 	}
 
 	// END Getters & setters
 
 	// BEGIN Children management methods
 
 	/**
 	 * Add child {@link PropertyTreeEntry}. Sets parent in child entry as this.
 	 *
 	 * @param entry
 	 *            child entry to add
 	 */
 	public void addChild(PropertyTreeEntry entry) {
 		if (entry == null) {
 			throw new IllegalArgumentException();
 		}
 		children.put(entry.getId(), entry);
 		entry.setParent(this);
 	}
 
 	/**
 	 * Adds children {@link PropertyTreeEntry} entries. Sets parent in all children as this.
 	 *
 	 * @param childrenToAdd
 	 *            children entries to add
 	 */
 	public void addAllChildren(Map<String, PropertyTreeEntry> childrenToAdd) {
 		if (childrenToAdd == null) {
 			throw new IllegalArgumentException();
 		}
 		this.children.putAll(childrenToAdd);
 		for (PropertyTreeEntry entry : childrenToAdd.values()) {
 			entry.setParent(this);
 		}
 	}
 
 	/**
 	 * Removes given child.
 	 *
 	 * @param entry
 	 *            entry to remove
 	 * @return removed entry
 	 */
 	public PropertyTreeEntry removeChild(PropertyTreeEntry entry) {
 		if (entry == null) {
 			throw new IllegalArgumentException();
 		}
 		return children.remove(entry.getId());
 	}
 
 	/**
 	 * Checks if entry has children.
 	 *
 	 * @return true if entry has at least one child, false otherwise
 	 */
 	public boolean hasChildren() {
 		return !children.isEmpty();
 	}
 
 	/**
 	 * Gets child by given id.
 	 *
 	 * @param childId
 	 *            entry id
 	 * @return child entry
 	 */
 	public PropertyTreeEntry getChild(String childId) {
 		return children.get(childId);
 	}
 
 	/**
 	 * Gets maps of children.
 	 *
 	 * @return maps of children entries
 	 */
 	public Map<String, PropertyTreeEntry> getChildrenMap() {
 		return children;
 	}
 
 	// END Children management methods
 
 }