EDIT

      <mapping class="eu.etaxonomy.cdm.model.description.FeatureNode"/>

      <mapping class="eu.etaxonomy.cdm.model.description.FeatureTree"/>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * 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.cdm.model.description;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.Index;

import javax.persistence.JoinColumn;

import javax.persistence.JoinTable;

import javax.persistence.ManyToMany;

import javax.persistence.ManyToOne;

import javax.persistence.OneToMany;

import javax.persistence.OrderBy;

import javax.persistence.OrderColumn;

import javax.persistence.Table;

import javax.persistence.Transient;

import javax.validation.constraints.NotNull;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlAttribute;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementWrapper;

import javax.xml.bind.annotation.XmlIDREF;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlSchemaType;

import javax.xml.bind.annotation.XmlType;

import org.apache.log4j.Logger;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.annotations.Type;

import org.hibernate.envers.Audited;

import eu.etaxonomy.cdm.hibernate.HHH_9751_Util;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.ITreeNode;

import eu.etaxonomy.cdm.model.common.VersionableEntity;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.IHasTermType;

import eu.etaxonomy.cdm.model.term.TermType;

/**

 * The class for tree nodes within a {@link FeatureTree feature tree} structure.

 * Feature nodes are the elementary components of such a tree since they might

 * be related to other nodes as a parent or as a child. A feature node belongs

 * at most to one feature tree. It cannot have more than one parent node but

 * may have several child nodes. Parent/child relations are bidirectional:

 * a node N1 is the parent of a node N2 if and only if the node N2 is a child of

 * the node N1.

 *

 * @author  m.doering

 * @since 08-Nov-2007 13:06:16

 */

@SuppressWarnings("serial")

@XmlAccessorType(XmlAccessType.FIELD)

@XmlType(name = "FeatureNode", propOrder = {

		"featureTree",

		"termType",

		"feature",

		"parent",

		"treeIndex",

		"sortIndex",

		"children",

		"onlyApplicableIf",

		"inapplicableIf"

})

@XmlRootElement(name = "FeatureNode")

@Entity

@Audited

@Table(name="FeatureNode", indexes = { @Index(name = "featureNodeTreeIndex", columnList = "treeIndex") })

public class FeatureNode <T extends DefinedTermBase> extends VersionableEntity

            implements ITreeNode<FeatureNode<T>>, IHasTermType, Cloneable {

	private static final Logger logger = Logger.getLogger(FeatureNode.class);

    //This is the main key a node belongs to. Although other keys may also reference

	//<code>this</code> node, a node usually belongs to a given key.

	@XmlElement(name = "FeatureTree")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY, targetEntity=FeatureTree.class)

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE}) //TODO this usage is incorrect, needed only for OneToMany, check why it is here, can it be removed??

	 //TODO Val #3379

//    @NotNull

	private FeatureTree<T> featureTree;

    /**

     * The {@link TermType type} of this term node.

     * Must be the same type as for the {@link FeatureTree term collection}

     * this node belongs to and as the term type of the term this node links to.

     */

    @XmlAttribute(name ="TermType")

    @Column(name="termType")

    @NotNull

    @Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",

        parameters = {@org.hibernate.annotations.Parameter(name  = "enumClass", value = "eu.etaxonomy.cdm.model.term.TermType")}

    )

    @Audited

    private TermType termType;

    @XmlElement(name = "Feature")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY, targetEntity=DefinedTermBase.class)

	private T feature;

    @XmlElement(name = "Parent")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY, targetEntity=FeatureNode.class)

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	@JoinColumn(name="parent_id")

	private FeatureNode<T> parent;

    @XmlElement(name = "treeIndex")

    @Column(length=255)

    private String treeIndex;

    @XmlElementWrapper(name = "Children")

    @XmlElement(name = "Child")

    //see https://dev.e-taxonomy.eu/trac/ticket/3722

    @OrderColumn(name="sortIndex")

    @OrderBy("sortIndex")

	@OneToMany(fetch = FetchType.LAZY, mappedBy="parent", targetEntity=FeatureNode.class)

	@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})

	private List<FeatureNode<T>> children = new ArrayList<>();

    //see https://dev.e-taxonomy.eu/trac/ticket/3722

    private Integer sortIndex;

	@XmlElementWrapper(name = "OnlyApplicableIf")

	@XmlElement(name = "OnlyApplicableIf")

	@XmlIDREF

	@XmlSchemaType(name="IDREF")

	@ManyToMany(fetch = FetchType.LAZY)

//	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})  remove cascade #5755

	@JoinTable(name="FeatureNode_DefinedTermBase_OnlyApplicable")

	private final Set<State> onlyApplicableIf = new HashSet<>();

	@XmlElementWrapper(name = "InapplicableIf")

	@XmlElement(name = "InapplicableIf")

	@XmlIDREF

	@XmlSchemaType(name="IDREF")

	@ManyToMany(fetch = FetchType.LAZY)

//	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})  remove cascade #5755

	@JoinTable(name="FeatureNode_DefinedTermBase_InapplicableIf")

	private final Set<State> inapplicableIf = new HashSet<>();

// ***************************** FACTORY *********************************/

	/**

     * Creates a new empty term node instance.

     *

     * @see #NewInstance(Feature)

     */

    public static <T extends DefinedTermBase<T>> FeatureNode<T> NewInstance(TermType termType){

        return new FeatureNode<>(termType);

    }

	/**

	 * Creates a new empty feature node instance.

	 *

	 * @see #NewInstance(Feature)

	 */

	public static FeatureNode<Feature> NewInstance(){

		return new FeatureNode<>(TermType.Feature);

	}

	/**

	 * Creates a new feature node instance only with the given {@link DefinedTermBase term}

	 * (without parent and children). The termType of the feature node is the termType of

	 * the given term

	 *

	 * @param	term	the term assigned to the new feature node

	 * @see 			#NewInstance()

	 */

	public static <T extends DefinedTermBase<T>> FeatureNode<T> NewInstance(T term){

	    FeatureNode<T> result = new FeatureNode<>(term.getTermType());

	    result.setTerm(term);

	    return result;

	}

// ******************** CONSTRUCTOR ***************************************/

	//TODO needed?

    @Deprecated

    protected FeatureNode(){}

	/**

	 * Class constructor: creates a new empty feature node instance.

	 */

	protected FeatureNode(TermType termType) {

	    this.termType = termType;

	    IHasTermType.checkTermTypeNull(this);

	}

    @Override

    public TermType getTermType() {

        return termType;

    }

//*************************** TREE ************************************/

	public FeatureTree<T> getFeatureTree() {

		return featureTree;

	}

	protected void setFeatureTree(FeatureTree<T> featureTree) {

		checkTermType(featureTree);

	    this.featureTree = featureTree;

	}

//** ********************** FEATURE ******************************/

	/**

     * Returns the {@link Feature feature} <i>this</i> feature node is based on.

     */

    public T getTerm() {

        return CdmBase.deproxy(feature);

    }

    /**

     * @see #getFeature()

     */

    public void setTerm(T term) {

        checkTermType(term);

        this.feature = term;

    }

//** ********************** PARENT ******************************/

	/**

	 * Returns the feature node <i>this</i> feature node is a child of.

	 *

	 * @see	#getChildNodes()

	 */

	@Override

    public FeatureNode<T> getParent() {

		return parent;

	}

	/**

	 * Assigns the given feature node as the parent of <i>this</i> feature node.

	 * Due to bidirectionality this method must also add <i>this</i> feature node

	 * to the list of children of the given parent.

	 *

	 * @param	parent	the feature node to be set as parent

	 * @see				#getParent()

	 */

	protected void setParent(FeatureNode<T> parent) {

		checkTermType(parent);

	    this.parent = parent;

	}

//** ********************** CHILDREN ******************************/

	/**

	 * @deprecated for internal use only.

	 */

	//see #4278 , #4200

	@Deprecated

    protected void setSortIndex(Integer sortIndex) {

		this.sortIndex = sortIndex;

	}

	/**

	 * Returns the (ordered) list of feature nodes which are children nodes of

	 * <i>this</i> feature node.

	 */

	@Override

    public List<FeatureNode<T>> getChildNodes() {

	    return children;

	}

	/**

	 * Adds the given feature node at the end of the list of children of

	 * <i>this</i> feature node. Due to bidirectionality this method must also

	 * assign <i>this</i> feature node as the parent of the given child.

	 *

	 * @param	child	the feature node to be added

	 * @see				#getChildNodes()

	 * @see				#setChildren(List)

	 * @see				#addChild(FeatureNode, int)

	 * @see				#removeChild(FeatureNode)

	 * @see				#removeChild(int)

	 */

	public void addChild(FeatureNode<T> child){

		addChild(child, children.size());

	}

	/**

	 * Inserts the given feature node in the list of children of <i>this</i> feature node

	 * at the given (index + 1) position. If the given index is out of bounds

	 * an exception will arise.<BR>

	 * Due to bidirectionality this method must also assign <i>this</i> feature node

	 * as the parent of the given child.

	 *

	 * @param	child	the feature node to be added

	 * @param	index	the integer indicating the position at which the child

	 * 					should be added

	 * @see				#getChildNodes()

	 * @see				#setChildren(List)

	 * @see				#addChild(FeatureNode)

	 * @see				#removeChild(FeatureNode)

	 * @see				#removeChild(int)

	 */

	public void addChild(FeatureNode<T> child, int index){

	    checkTermType(child);

	    List<FeatureNode<T>> children = this.getChildNodes();

		if (index < 0 || index > children.size() + 1){

			throw new IndexOutOfBoundsException("Wrong index: " + index);

		}

		if (child.getParent() != null){

			child.getParent().removeChild(child);

		}

		child.setParent(this);

		child.setFeatureTree(this.getFeatureTree());

		children.add(index, child);

		//TODO workaround (see sortIndex doc)

		for(int i = 0; i < children.size(); i++){

			children.get(i).setSortIndex(i);

		}

		child.setSortIndex(index);

	}

    /**

	 * Removes the given feature node from the list of {@link #getChildNodes() children}

	 * of <i>this</i> feature node.

	 *

	 * @param  child	the feature node which should be removed

	 * @see     		#getChildNodes()

	 * @see				#addChild(FeatureNode, int)

	 * @see				#addChild(FeatureNode)

	 * @see				#removeChild(int)

	 */

	public void removeChild(FeatureNode<T> child){

	    int index = children.indexOf(child);

		if (index >= 0){

			removeChild(index);

		}

	}

	/**

	 * Removes the feature node placed at the given (index + 1) position from

	 * the list of {@link #getChildNodes() children} of <i>this</i> feature node.

	 * If the given index is out of bounds no child will be removed.

	 *

	 * @param  index	the integer indicating the position of the feature node to

	 * 					be removed

	 * @see     		#getChildNodes()

	 * @see				#addChild(FeatureNode, int)

	 * @see				#addChild(FeatureNode)

	 * @see				#removeChild(FeatureNode)

	 */

	public void removeChild(int index){

	   FeatureNode<T> child = children.get(index);

	   if (child != null){

			children.remove(index);

			child.setParent(null);

			child.setFeatureTree(null);

			//TODO workaround (see sortIndex doc)

			for(int i = 0; i < children.size(); i++){

				FeatureNode<T> childAt = children.get(i);

				childAt.setSortIndex(i);

			}

			child.setSortIndex(null);

		}

	}

	/**

	 * Returns the feature node placed at the given (childIndex + 1) position

	 * within the list of {@link #getChildNodes() children} of <i>this</i> feature node.

	 * If the given index is out of bounds no child will be returned.

	 *

	 * @param  childIndex	the integer indicating the position of the feature node

	 * @see     			#getChildNodes()

	 * @see					#addChild(FeatureNode, int)

	 * @see					#removeChild(int)

	 */

	public FeatureNode<T> getChildAt(int childIndex) {

	    return children.get(childIndex);

	}

	/**

	 * Returns the number of children nodes of <i>this</i> feature node.

	 *

	 * @see	#getChildNodes()

	 */

	@Transient

	public int getChildCount() {

		return children.size();

	}

	/**

	 * Returns the integer indicating the position of the given feature node

	 * within the list of {@link #getChildNodes() children} of <i>this</i> feature node.

	 * If the list does not contain this node then -1 will be returned.

	 *

	 * @param  node	the feature node the position of which is being searched

	 * @see			#addChild(FeatureNode, int)

	 * @see			#removeChild(int)

	 */

	public int getIndex(FeatureNode<T> node) {

	    if (! children.contains(node)){

			return -1;

		}else{

			return children.indexOf(node);

		}

	}

	/**

	 * Returns the boolean value indicating if <i>this</i> feature node has

	 * children (false) or not (true). A node without children is at the

	 * bottommost level of a tree and is called a leaf.

	 *

	 * @see	#getChildNodes()

	 * @see	#getChildCount()

	 */

	@Transient

	public boolean isLeaf() {

		return children.size() < 1;

	}

	/**

	 * Whether <code>this</code> node is the root node of the associated {@link FeatureTree feature tree}.

	 *

	 * @return <code>true</code> if <code>this</code> is the feature trees root node, <code>false</code> if not

	 */

	@Transient

	public boolean isRoot(){

		if(getFeatureTree() != null){

			return this.equals(getFeatureTree().getRoot());

		}

		return false;

	}

	/**

	 * Returns the set of {@link State states} implying rendering the

	 * concerned {@link Feature feature} applicable.

	 * If at least one state is present in this set, in a given description

	 * the {@link Feature feature} in <i>this</i> feature node is inapplicable

	 * unless any of the listed controlling states is present in the parent

	 * {@link Feature feature} description element {@link CategoricalData

	 * categoricalData}.

	 * This attribute is not equivalent to onlyApplicableIf in SDD as it is

	 * attached directly to the child feature rather than the parent, which

	 * allow having different applicable states for each child feature.

	 *

	 * @see    #addApplicableState(State)

	 * @see    #removeApplicableState(State)

	 */

	public Set<State> getOnlyApplicableIf() {

		return onlyApplicableIf;

	}

	/**

	 * Adds an existing {@link State applicable state} to the set of

	 * {@link #getOnlyApplicableIf() applicable states} described in

	 * <i>this</i> feature node.<BR>

	 *

	 * @param applicableState	the applicable state to be added to <i>this</i> feature node

	 * @see    	   								#getApplicableState()

	 */

	public void addApplicableState(State applicableState) {

		this.onlyApplicableIf.add(applicableState);

	}

	/**

	 * Removes one element from the set of

	 * {@link #getOnlyApplicableIf() applicable states} described in

	 * <i>this</i> feature node.<BR>

	 *

	 * @param  applicableState   the applicable state which should be removed

	 * @see    	   								#getApplicableState()

	 * @see     		  						#addApplicableState(State)

	 */

	public void removeApplicableState(State applicableState) {

		this.onlyApplicableIf.remove(applicableState);

	}

	/**

	 * Returns the set of {@link State states} implying rendering the

	 * concerned {@link Feature feature} inapplicable.

	 * If at least one {@link State inapplicable state} is defined in the set,

	 * in a given description the {@link Feature feature} attribute of

	 * <i>this</i> feature node is inapplicable when any of the listed

	 * controlling states is present.

	 * This attribute is not equivalent to inapplicableIf in SDD as it is

	 * attached directly to the child feature rather than the parent, which

	 * allow having different inapplicability rules for each child feature.

	 *

	 * @see    #addInapplicableState(State)

	 * @see    #removeInapplicableState(State)

	 */

	public Set<State> getInapplicableIf() {

		return inapplicableIf;

	}

	/**

	 * Adds an existing {@link State inapplicable state} to the set of

	 * {@link #getInapplicableIf() inapplicable states} described in

	 * <i>this</i> feature node.<BR>

	 *

	 * @param inapplicableState	the inapplicable state to be added to <i>this</i> feature node

	 * @see    	   								#getInapplicableState()

	 */

	public void addInapplicableState(State inapplicableState) {

		this.inapplicableIf.add(inapplicableState);

	}

	/**

	 * Removes one element from the set of

	 * {@link #getInapplicableIf() inapplicable states} described in

	 * <i>this</i> feature node.<BR>

	 *

	 * @param  inapplicableState   the inapplicable state which should be removed

	 * @see    	   								#getInapplicableState()

	 * @see     		  						#addInapplicableState(State)

	 */

	public void removeInapplicableState(State inapplicableState) {

		this.inapplicableIf.remove(inapplicableState);

	}

//	//** ********************** QUESTIONS ******************************/

//

//	/**

//	 * Returns the {@link Representation question} formulation that

//	 * corresponds to <i>this</i> feature node and the corresponding

//	 * {@link Feature feature} in case it is part of a

//	 * {@link PolytomousKey polytomous key}.

//	 */

//	public Set<Representation> getQuestions() {

//		return this.questions;

//	}

//

//	public void addQuestion(Representation question) {

//		this.questions.add(question);

//	}

//

//	public void removeQuestion(Representation question) {

//		this.questions.remove(question);

//	}

//

//	@Transient

//	public Representation getQuestion(Language lang) {

//		for (Representation question : questions){

//			Language reprLanguage = question.getLanguage();

//			if (reprLanguage != null && reprLanguage.equals(lang)){

//				return question;

//			}

//		}

//		return null;

//	}

	/**

     * Throws {@link IllegalArgumentException} if the given

     * term has not the same term type as this term or if term type is null.

     * @param term

     */

    private void checkTermType(IHasTermType term) {

        IHasTermType.checkTermTypes(term, this);

    }

	/**

	 * Returns all terms that are contained in this node or a child node

	 *

	 * @param featureNode

	 * @param features

	 * @return

	 */

	@Transient

	public Set<T> getDistinctFeaturesRecursive(Set<T> features){

		T term = this.getTerm();

		if(term!=null){

		    features.add(term);

		}

		for(FeatureNode<T> childNode : this.getChildNodes()){

			features.addAll(childNode.getDistinctFeaturesRecursive(features));

		}

		return features;

	}

	public FeatureNode<T> cloneDescendants(){

		FeatureNode<T> clone = (FeatureNode<T>)this.clone();

		FeatureNode<T> childClone;

		for(FeatureNode<T> childNode : this.getChildNodes()){

			childClone = (FeatureNode<T>) childNode.clone();

			for (FeatureNode<T> childChild:childNode.getChildNodes()){

				childClone.addChild(childChild.cloneDescendants());

			}

			clone.addChild(childClone);

		}

		return clone;

	}

//*********************** CLONE ********************************************************/

	/**

	 * Clones <i>this</i> FeatureNode. This is a shortcut that enables to create

	 * a new instance that differs only slightly from <i>this</i> FeatureNode by

	 * modifying only some of the attributes.

	 * The parent, the feature and the featureTree are the are the same as for the original feature node

	 * the children are removed

	 *

	 * @see eu.etaxonomy.cdm.model.common.VersionableEntity#clone()

	 * @see java.lang.Object#clone()

	 */

	@Override

	public Object clone() {

		FeatureNode<T> result;

		try {

			result = (FeatureNode<T>)super.clone();

			result.children = new ArrayList<>();

			return result;

		}catch (CloneNotSupportedException e) {

			logger.warn("Object does not implement cloneable");

			e.printStackTrace();

			return null;

		}

	}

// ********************** TREE NODE METHODS ******************************/

	@Override

	public String treeIndex() {

		return this.treeIndex;

	}    @Override

    public String treeIndexLike() {

        return treeIndex + "%";

    }

    @Override

    public String treeIndexWc() {

        return treeIndex + "*";

    }

	@Override

	@Deprecated

	public void setTreeIndex(String newTreeIndex) {

		this.treeIndex = newTreeIndex;

	}

	@Override

	@Deprecated

	public int treeId() {

		if (this.featureTree == null){

			return -1;

		}else{

			return this.featureTree.getId();

		}

	}

	private void updateSortIndex(){

	 // TODO workaround (see sortIndex doc)

        for (int i = 0; i < children.size(); i++) {

            children.get(i).setSortIndex(i);

        }

	}

	public void removeNullValueFromChildren(){

	    HHH_9751_Util.removeAllNull(children);

	    updateSortIndex();

	}

}

/**

* 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.cdm.model.description;

import java.rmi.UnexpectedException;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.OneToMany;

import javax.persistence.OneToOne;

import javax.persistence.Transient;

import javax.validation.constraints.NotNull;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlAttribute;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementWrapper;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

import org.apache.log4j.Logger;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.annotations.Type;

import org.hibernate.envers.Audited;

import eu.etaxonomy.cdm.model.common.IdentifiableEntity;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.IHasTermType;

import eu.etaxonomy.cdm.model.term.Representation;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;

/**

 * The class to arrange {@link Feature features} (characters) in a tree structure.

 * Feature trees are essential as interactive multiple-access keys for

 * determination process and for systematical output arrangement of

 * {@link DescriptionElementBase description elements} according to different goals

 * but may also be used to define flat feature subsets for filtering purposes.<BR>

 * A feature tree is build on {@link FeatureNode feature nodes}.

 * <P>

 * This class corresponds partially to ConceptTreeDefType according to the SDD

 * schema.

 * <P>

 * Note: The tree structure of features used for purposes described above has

 * nothing in common with the possible hierarchical structure of features

 * depending on their grade of precision.

 *

 * @see		MediaKey

 *

 * @author  m.doering

 * @since 08-Nov-2007 13:06:16

 */

@XmlAccessorType(XmlAccessType.FIELD)

@XmlType(name = "FeatureTree", propOrder = {

    "root",

    "termType",

    "allowDuplicates",

    "representations"

})

@XmlRootElement(name = "FeatureTree")

@Entity

//@Indexed disabled to reduce clutter in indexes, since this type is not used by any search

//@Indexed(index = "eu.etaxonomy.cdm.model.description.FeatureTree")

@Audited

public class FeatureTree <T extends DefinedTermBase>

            extends IdentifiableEntity<IIdentifiableEntityCacheStrategy>

            implements IHasTermType, Cloneable{

	private static final long serialVersionUID = -6713834139003172735L;

	private static final Logger logger = Logger.getLogger(FeatureTree.class);

	@XmlElement(name = "Root")

	@OneToOne(fetch = FetchType.LAZY, targetEntity=FeatureNode.class)

	@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})

	private FeatureNode<T> root;

    /**

     * The {@link TermType type} of this term collection. All nodes in the graph must refer to a term of the same type.

     */

    @XmlAttribute(name ="TermType")

    @Column(name="termType")

    @NotNull

    @Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",

        parameters = {@org.hibernate.annotations.Parameter(name  = "enumClass", value = "eu.etaxonomy.cdm.model.term.TermType")}

    )

    @Audited

    private TermType termType;

    // TODO needed? FeatureTree was a TermBase until v3.3 but was removed from

	//it as TermBase got the termType which does not apply to FeatureTree.

	//We need to check how far representations and uri is still required

	//or can be deleted. Current implementations seem all to use the title cache

	//instead of representation. This may not be correct.

	@XmlElementWrapper(name = "Representations")

    @XmlElement(name = "Representation")

    @OneToMany(fetch=FetchType.EAGER, orphanRemoval=true)

    @Cascade( { CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})

    // @IndexedEmbedded no need for embedding since we are using the DefinedTermBaseClassBridge

    private Set<Representation> representations = new HashSet<>();

    //make them private for now as we may delete representations in future

	//otherwise if we decide to use representations we can make the getters public

	private Set<Representation> getRepresentations() {return representations;}

    private void setRepresentations(Set<Representation> representations) {this.representations = representations;}

    //#7372 indicates if this tree/graph allows duplicated terms/features

    private boolean allowDuplicates = false;

//******************** FACTORY METHODS ******************************************/

    /**

     * Creates a new term collection instance for the given term type

     * with an empty {@link #getRoot() root node}.

     * @param termType the {@link TermType term type}, must not be null

     */

    public static <T extends DefinedTermBase<T>> FeatureTree<T> NewInstance(@NotNull TermType termType){

        return new FeatureTree<>(termType);

    }

    /**

	 * Creates a new feature tree instance with an empty {@link #getRoot() root node}.

	 *

	 * @see #NewInstance(UUID)

	 * @see #NewInstance(List)

	 */

	public static FeatureTree<Feature> NewInstance(){

		return new FeatureTree<>(TermType.Feature);

	}

	/**

	 * Creates a new feature tree instance with an empty {@link #getRoot() root node}

	 * and assigns to the new feature tree the given

	 * UUID (universally unique identifier).

	 *

	 * @param	uuid	the universally unique identifier

	 * @see 			#NewInstance()

	 * @see 			#NewInstance(List)

	 */

	public static <T extends DefinedTermBase<T>> FeatureTree<T> NewInstance(UUID uuid){

		FeatureTree<T> result =  new FeatureTree<>(TermType.Feature);

		result.setUuid(uuid);

		return result;

	}

	/**

	 * Creates a new feature tree instance with a {@link #getRoot() root node}

	 * the children of which are the feature nodes build on the base of the

	 * given list of {@link Feature features}. This corresponds to a flat feature tree.

	 * For each feature within the list a new {@link FeatureNode feature node} without

	 * children nodes will be created.

	 *

	 * @param	featureList	the feature list

	 * @see 				#NewInstance()

	 * @see 				#NewInstance(UUID)

	 */

	public static FeatureTree<Feature> NewInstance(List<Feature> featureList){

		FeatureTree<Feature> result =  new FeatureTree<>(TermType.Feature);

		FeatureNode<Feature> root = result.getRoot();

		for (Feature feature : featureList){

			FeatureNode<Feature> child = FeatureNode.NewInstance(feature);

			root.addChild(child);

		}

		return result;

	}

// ******************** CONSTRUCTOR *************************************/

    //for JAXB only, TODO needed?

    @Deprecated

    protected FeatureTree(){}

	/**

	 * Class constructor: creates a new feature tree instance with an empty

	 * {@link #getRoot() root node}.

	 */

	protected FeatureTree(TermType termType) {

        this.termType = termType;

        checkTermType(this);

		root = FeatureNode.NewInstance(termType);

		root.setFeatureTree(this);

	}

// ****************** GETTER / SETTER **********************************/

	@Override

    public TermType getTermType() {

        return termType;

    }

    /**

	 * Returns the topmost {@link FeatureNode feature node} (root node) of <i>this</i>

	 * feature tree. The root node does not have any parent. Since feature nodes

	 * recursively point to their child nodes the complete feature tree is

	 * defined by its root node.

	 */

	public FeatureNode<T> getRoot() {

		return root;

	}

    /**

     * @deprecated this method is only for internal use when deleting a {@link FeatureTree}

     * from a database. It should never be called for other reasons.

     */

    @Deprecated

    public void removeRootNode() {

        this.root = null;

    }

	/**

	 * Returns the (ordered) list of {@link FeatureNode feature nodes} which are immediate

	 * children of the root node of <i>this</i> feature tree.

	 */

	@Transient

	public List<FeatureNode<T>> getRootChildren(){

		List<FeatureNode<T>> result = new ArrayList<>();

		result.addAll(root.getChildNodes());

		return result;

	}

    public boolean isAllowDuplicates() {

        return allowDuplicates;

    }

    public void setAllowDuplicates(boolean allowDuplicates) {

        this.allowDuplicates = allowDuplicates;

    }

    /**

     * Throws {@link IllegalArgumentException} if the given

     * term has not the same term type as this term or if term type is null.

     * @param term

     */

    private void checkTermType(IHasTermType term) {

        IHasTermType.checkTermTypes(term, this);

    }

//******************** METHODS ***********************************************/

	/**

	 * Computes a set of distinct terms that are present in this feature tree

	 *

	 * @return

	 */

	@Transient

	public Set<T> getDistinctFeatures(){

	    if(termType.equals(TermType.Feature) || termType.isKindOf(TermType.Feature)){

	        Set<T> features = new HashSet<>();

	        return root.getDistinctFeaturesRecursive(features);

	    }

	    String message = "FeatureTree is not of type FEATURE.";

	    logger.warn(message, new UnexpectedException(message));

	    return new HashSet<>();

	}

//*********************** CLONE ********************************************************/

	/**

	 * Clones <i>this</i> FeatureTree. This is a shortcut that enables to create

	 * a new instance that differs only slightly from <i>this</i> FeatureTree by

	 * modifying only some of the attributes.

	 * FeatureNodes always belong only to one tree, so all FeatureNodes are cloned to build

	 * the new FeatureTree

	 *

	 *

	 * @see eu.etaxonomy.cdm.model.term.TermBase#clone()

	 * @see java.lang.Object#clone()

	 */

	@Override

	public Object clone() {

		FeatureTree<T> result;

		try {

			result = (FeatureTree<T>)super.clone();

		}catch (CloneNotSupportedException e) {

			logger.warn("Object does not implement cloneable");

			e.printStackTrace();

			return null;

		}

		FeatureNode<T> rootClone = this.getRoot().cloneDescendants();

		result.root = rootClone;

		return result;

	}

}