EDIT

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.model;

import java.util.ArrayList;

import java.util.List;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.description.DescriptionBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.FeatureNode;

import eu.etaxonomy.cdm.model.description.FeatureTree;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

/**

 * This class is a simple container to allow generation of a datastructure that

 * describes a feature tree according to a specific description element, i.e a tree

 * structure that halds only the {@link FeatureNode}s that are relevant for a specific

 * {@link TaxonDescription} as well as the {@link DescriptionElementBase} at the leaf level.

 *

 * This kind of datastructure is needed by interface elements such as viewers and greatly simplify

 * the handling of {@link FeatureTree}s in conjunction with {@link TaxonDescription}s.

 *

 * @author n.hoffmann

 * @created Sep 20, 2010

 * @version 1.0

 */

public class FeatureNodeContainer{

	private FeatureNodeContainer parent;

	private FeatureNode featureNode;

	private List<FeatureNodeContainer> children = new ArrayList<FeatureNodeContainer>();

	private List<DescriptionElementBase> descriptionElements = new ArrayList<DescriptionElementBase>();

	private FeatureNodeContainerTree containerTree;

	/**

	 * @param description

	 */

	protected FeatureNodeContainer(FeatureNodeContainerTree containerTree) {

		this.containerTree = containerTree;

		this.containerTree.addContainer(this);

	}

	/**

	 * Recursively traverse a branch of a feature tree and check if there are

	 *

	 * @param featureNode

	 * @param description

	 * @return

	 */

	protected void findLeaves(FeatureNode featureNode) {

		if(featureNode.isLeaf()){

			buildLeaf(featureNode);

		}else{

			for(FeatureNode childNode : featureNode.getChildNodes()){

				findLeaves(childNode);

			}

		}

	}

	/**

	 *

	 * @param featureNode

	 * @param description

	 * @return

	 */

	private void buildLeaf(FeatureNode featureNode){

		if(featureNode.getFeature() == null){

			throw new IllegalArgumentException("The given feature node does not have a feature.");

		}

		Feature feature = (Feature) HibernateProxyHelper.deproxy(featureNode.getFeature());

		// get feature node container for the given feature

		FeatureNodeContainer container = containerTree.getFeatureNodeContainer(feature);

		// get description elements for the given feature

		List<DescriptionElementBase> elements = containerTree.getDescriptionsElementsForFeature(feature);

		// no description elements, so we should also remove the feature node container

		if(elements.isEmpty()){

			if(container != null){

				container.remove();

			}

		}

		// there are description elements

		else{

			if(container == null){

				container = new FeatureNodeContainer(containerTree);

				container.setFeatureNode(featureNode);

				// build the branch up to root level

				container.buildBranch();

			}

			// add description elements to the feature node container

			container.setDescriptionElements(elements);

		}

	}

	/**

	 *

	 */

	private void remove() {

		if(getParent() != null){

			if(getParent().getChildren().size() == 1){

				getParent().remove();

			}

			getParent().removeChild(this);

		}

	}

	/**

	 * @param featureNodeContainer

	 */

	private void removeChild(FeatureNodeContainer featureNodeContainer) {

		children.remove(featureNodeContainer);

	}

	/**

	 * Recursively

	 *

	 * @param featureNodeMap

	 * @return

	 */

	private void buildBranch(){

		if(getParent() == null){

			FeatureNode parentFeatureNode = getFeatureNode().getParent();

			if(parentFeatureNode.isRoot()){

				containerTree.getRoot().addChild(this);

			}else{

				FeatureNodeContainer parentContainer = containerTree.getFeatureNodeContainer(parentFeatureNode);

				if(parentContainer == null){

					parentContainer = new FeatureNodeContainer(containerTree);

					parentContainer.setFeatureNode(parentFeatureNode);

				}

				parentContainer.addChild(this);

				parentContainer.buildBranch();

			}

		}

	}

	/**

	 * <p>Getter for the field <code>children</code>.</p>

	 *

	 * @return a {@link java.util.List} object.

	 */

	public List<FeatureNodeContainer> getChildren() {

		return children;

	}

	/**

	 * Sets the list of children of this containers children

	 *

	 * @param children a {@link java.util.List} object.

	 *  @throws java.lang.IllegalStateException when <code>this</code> container contains a description element.

	 */

	public void setChildren(List<FeatureNodeContainer> children) {

		if(descriptionElements.isEmpty()){

			this.children = children;

		}else{

			throw new IllegalStateException("Container may not have a description element set when setting children.");

		}

	}

	/**

	 * Adds a child container to the list of this containers children

	 *

	 * @param container a {@link eu.etaxonomy.taxeditor.model.FeatureNodeContainer} object.

	 *  @throws java.lang.IllegalStateException when <code>this</code> container contains a description element.

	 */

	public void addChild(FeatureNodeContainer container){

		if(descriptionElements.isEmpty()){

			children.add(container);

			container.setParent(this);

		}else{

			throw new IllegalStateException("Container may not have a description element set when adding children.");

		}

	}

	public void addDescriptionElement(DescriptionElementBase descriptionElement){

		descriptionElements.add(descriptionElement);

	}

	public void removeDescriptionElement(DescriptionElementBase descriptionElement){

		descriptionElements.remove(descriptionElement);

	}

	/**

	 * If {@link #isLeaf()} is true, i.e. this container should have elements, returns the list of description elements.

	 *

	 * @return a {@link java.util.List} object.

	 */

	public List<DescriptionElementBase> getDescriptionElements() {

		return descriptionElements;

	}

	/**

	 * Cumulates description elements for <code>this</code> container as well as child feature nodes recursively,

	 * thus returning a list of description elements for the branch of the feature tree starting with <code>this</code>

	 * node.

	 *

	 * @return a {@link java.util.List} object.

	 */

	public List<DescriptionElementBase> getDescriptionElementsForEntireBranch(){

		return getDescriptionElementsRecursively(new ArrayList<DescriptionElementBase>());

	}

	private List<DescriptionElementBase> getDescriptionElementsRecursively(List<DescriptionElementBase> descriptionElements){

		if(isLeaf()){

			descriptionElements.addAll(getDescriptionElements());

		}else{

			for(FeatureNodeContainer container : getChildren()){

				container.getDescriptionElementsRecursively(descriptionElements);

			}

		}

		return descriptionElements;

	}

	protected List<FeatureNodeContainer> getLeafs(){

		List<FeatureNodeContainer> leafs = new ArrayList<FeatureNodeContainer>();

		if(isLeaf()){

			leafs.add(this);

		}else{

			for(FeatureNodeContainer container : getChildren()){

				leafs.addAll(container.getLeafs());

			}

		}

		return leafs;

	}

	/**

	 * Set the description element

	 *

	 * @throws java.lang.IllegalStateException when <code>this</code> container contains child container.

	 * @param descriptionElements a {@link java.util.List} object.

	 */

	public void setDescriptionElements(List<DescriptionElementBase> descriptionElements) {

		if(children.isEmpty()){

			this.descriptionElements = descriptionElements;

		}else{

			throw new IllegalStateException("Container may not contain child container when adding description elements.");

		}

	}

	/**

	 * If the container is a leaf, it will hold a description element and no child containers

	 *

	 * @return a boolean.

	 */

	public boolean isLeaf(){

		return ! descriptionElements.isEmpty() && children.isEmpty();

	}

	/**

	 * <p>Setter for the field <code>featureNode</code>.</p>

	 *

	 * @param featureNode a {@link eu.etaxonomy.cdm.model.description.FeatureNode} object.

	 */

	public void setFeatureNode(FeatureNode featureNode) {

		this.featureNode = featureNode;

	}

	/**

	 * <p>Getter for the field <code>featureNode</code>.</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.model.description.FeatureNode} object.

	 */

	public FeatureNode getFeatureNode() {

		return featureNode;

	}

	/**

	 * <p>getFeature</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.model.description.Feature} object.

	 */

	public Feature getFeature(){

		if(featureNode != null){

			return featureNode.getFeature();

		}

		return null;

	}

	/**

	 * <p>Getter for the field <code>description</code>.</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.model.description.DescriptionBase} object.

	 */

	public DescriptionBase getDescription(){

		return containerTree.getDescription();

	}

	public FeatureNodeContainerTree getContainerTree(){

		return containerTree;

	}

	/**

	 *

	 */

	public void clear() {

		children.clear();

		descriptionElements.clear();

	}

	/**

	 * @return

	 */

	public boolean isEmpty() {

		return children.isEmpty() && descriptionElements.isEmpty();

	}

	/**

	 * @return the parent

	 */

	public FeatureNodeContainer getParent() {

		return parent;

	}

	/**

	 * @param parent the parent to set

	 */

	public void setParent(FeatureNodeContainer parent) {

		this.parent = parent;

	}

}