EDIT

// $Id$

/**

* Copyright (C) 2007 EDIT

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

*/

package eu.etaxonomy.cdm.model.taxon;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.ManyToOne;

import javax.persistence.OneToMany;

import javax.xml.bind.annotation.XmlAccessorType;

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.Table;

import org.hibernate.search.annotations.Indexed;

import org.hibernate.search.annotations.IndexedEmbedded;

/**

 * @author a.mueller

 * @created 31.03.2009

 */

@XmlAccessorType(XmlAccessType.FIELD)

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

    "taxon",

    "referenceForParentChildRelation",

    "microReferenceForParentChildRelation",

    "countChildren",

    "synonymToBeUsed"

})

@XmlRootElement(name = "TaxonNode")

@Entity

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

    @XmlElement(name = "taxon")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

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

    @XmlElement(name = "parent")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

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

    private TaxonNode parent;

    @XmlElement(name = "classification")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

    @XmlElementWrapper(name = "childNodes")

    @XmlElement(name = "childNode")

    @XmlSchemaType(name = "IDREF")

	@XmlElement(name = "reference")

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

    @XmlElement(name = "microReference")

    private String microReferenceForParentChildRelation;

    @XmlElement(name = "countChildren")

    private int countChildren;

//	//or

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

    /**

     * to create nodes either use {@link Classification#addChildTaxon(Taxon, Reference, String, Synonym)}

     * or {@link TaxonNode#addChildTaxon(Taxon, Reference, String, Synonym)}

     * @param taxon

     * @param classification

     * @deprecated setting of classification is handled in the addTaxonNode() method,

     * use TaxonNode(taxon) instead

     */

        this(taxon);

        setClassification(classification);

    }

    /**

     * to create nodes either use {@link Classification#addChildTaxon(Taxon, Reference, String, Synonym)}

     * or {@link TaxonNode#addChildTaxon(Taxon, Reference, String, Synonym)}

     *

     * @param taxon

     */

    protected TaxonNode(Taxon taxon){

        setTaxon(taxon);

    }

    public Integer getSortIndex() {

		return sortIndex;

	}

    /**

     * SortIndex shall be handled only internally, therefore not public.

     * Alternatively we could use deproxy on every call of this method (see commented code)

     * @return

     * @deprecated for internal use only

     */

//    	 CdmBase.deproxy(this, TaxonNode.class).sortIndex = i;  //alternative solution for private, DON'T remove

    	 sortIndex = i;

        return taxon;

    }

    protected void setTaxon(Taxon taxon) {

        this.taxon = taxon;

        if (taxon != null){

            taxon.addTaxonNode(this);

        }

    }

    public List<TaxonNode> getChildNodes() {

        return childNodes;

    }

	protected void setChildNodes(List<TaxonNode> childNodes) {

		this.childNodes = childNodes;	

	}

    public Classification getClassification() {

        return classification;

    }

    /**

     * THIS METHOD SHOULD NOT BE CALLED!

     * invisible part of the bidirectional relationship, for public use TaxonomicView.addRoot() or TaxonNode.addChild()

     * @param classification

     * @deprecated for internal use only

     */

    protected void setClassification(Classification classification) {

        this.classification = classification;

    }

        return microReferenceForParentChildRelation;

    }

    public void setMicroReference(String microReference) {

        this.microReferenceForParentChildRelation = microReference;

    }

    @Override

    public Reference getReference() {

        return referenceForParentChildRelation;

    }

    public void setReference(Reference reference) {

        this.referenceForParentChildRelation = reference;

    }

    //countChildren

    public int getCountChildren() {

        return countChildren;

    }

    /**

     * @deprecated for internal use only

     * @param countChildren

     */

    protected void setCountChildren(int countChildren) {

        this.countChildren = countChildren;

    }

    //parent

    @Override

    public TaxonNode getParent(){

        return parent;

    }

    /**

     * Sets the parent of this taxon node.<BR>

     *

     * In most cases you would want to call setParentTreeNode(ITreeNode) which

     * handles updating of the bidirectional relationship

     *

     * @see setParentTreeNode(ITreeNode)

     * @param parent

     *

     */

    protected void setParent(TaxonNode parent) {

        this.parent = parent;

    }

    //synonymToBeused

    public Synonym getSynonymToBeUsed() {

        return synonymToBeUsed;

    }

    public void setSynonymToBeUsed(Synonym synonymToBeUsed) {

        this.synonymToBeUsed = synonymToBeUsed;

    }

    //treeindex

    @Override

    public String treeIndex() {

        return treeIndex;

    }

    @Override

    @Deprecated //for CDM lib internal use only, may be removed in future versions

    public void setTreeIndex(String treeIndex) {

        this.treeIndex = treeIndex;

    }

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

   @Override

    @Override

    public TaxonNode addChildTaxon(Taxon taxon, int index, Reference citation, String microCitation) {

    /**

     * Moves a taxon node to a new parent. Descendents of the node are moved as well

     *

     * @param childNode the taxon node to be moved to the new parent

     * @return the child node in the state of having a new parent

     */

    public TaxonNode addChildNode(TaxonNode childNode, Reference reference, String microReference){

        addChildNode(childNode, childNodes.size(), reference, microReference);

        return childNode;

    }

    /**

     * Inserts the given taxon node in the list of children of <i>this</i> taxon 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> taxon node

     * as the parent of the given child.

     *

     * @param	child	the taxon node to be added

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

     * 					should be added

     * @see				#getChildNodes()

     * @see				#addChildNode(TaxonNode, Reference, String, Synonym)

     * @see				#deleteChildNode(TaxonNode)

     * @see				#deleteChildNode(int)

     */

    public TaxonNode addChildNode(TaxonNode child, int index, Reference reference, String microReference){

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

        }

           // check if this node is a descendant of the childNode

        }

        child.setMicroReference(microReference);

    /**

     * 

     * @throws IllegalArgumentException if newClassifciation is null

    @Transient

        if (newClassification == null){

        	throw new IllegalArgumentException("New Classification must not be 'null' when setting new classification.");

        }

    	if(! newClassification.equals(this.getClassification())){

            this.setClassification(newClassification);

        }

    }

    @Override

        boolean result = removeChildNode(node);

        for(TaxonNode childNode : childNodes){

            node.deleteChildNode(childNode);

        }

    }

     * Deletes the child node and also removes children of childnode 

     * recursively if delete children is <code>true</code>

     * @param node

     * @param deleteChildren

     * @return

     */

        boolean result = removeChildNode(node);

        node.setTaxon(null);

        taxon.removeTaxonNode(node);

            for(TaxonNode childNode : childNodes){

                node.deleteChildNode(childNode, deleteChildren);

            }

        	ArrayList<TaxonNode> childNodes = new ArrayList<TaxonNode>(node.getChildNodes());

            for(TaxonNode childNode : childNodes){

             this.addChildNode(childNode, null, null);

            }

    }

    /**

     * Removes the child node from this node. Sets the parent and the classification of the child

     * node to null

     *

     * @param childNode

     * @return

     */

    protected boolean removeChildNode(TaxonNode childNode){

        if(childNode == null){

            throw new IllegalArgumentException("TaxonNode may not be null");

        }

            removeChild(index);

        } else {

            result = false;

        }

    }

    /**

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

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

     * Sets the parent and the classification of the child

     *

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

     * 					be removed

     * @see     		#getChildNodes()

     * @see				#addChildNode(TaxonNode, Reference, String)

     * @see				#addChildNode(TaxonNode, int, Reference, String)

     * @see				#deleteChildNode(TaxonNode)

     */

    public void removeChild(int index){

        TaxonNode child = childNodes.get(index);

        child = HibernateProxyHelper.deproxy(child, TaxonNode.class); //strange that this is required, but otherwise child.getParent() returns null for some lazy-loaded items.

        if (child != null){

            TaxonNode parent = HibernateProxyHelper.deproxy(child.getParent(), TaxonNode.class);

            TaxonNode thisNode = HibernateProxyHelper.deproxy(this, TaxonNode.class);

            if(parent != null && parent != thisNode){

                throw new IllegalArgumentException("Child TaxonNode (id:" + child.getId() +") must be a child of this (id:" + thisNode.getId() + " node. Sortindex is: " + index + ", parent-id:" + parent.getId());

            }else if (parent == null){

                throw new IllegalStateException("Parent of child is null in TaxonNode.removeChild(int). This should not happen.");

            }

            childNodes.remove(index);

            //update sortindex

            //TODO workaround (see sortIndex doc)

            child.setParent(null);

    }

    /**

     * Remove this taxonNode From its taxonomic parent

     *

     * @return true on success

     */

    public boolean delete(){

        if(isTopmostNode()){

            return classification.deleteChildNode(this);

        }else{

            return getParent().deleteChildNode(this);

        }

    }

     * Remove this taxonNode From its taxonomic parent

     *

     * @return true on success

     */

    public boolean delete(boolean deleteChildren){

        if(isTopmostNode()){

            return classification.deleteChildNode(this, deleteChildren);

        }else{

            return getParent().deleteChildNode(this, deleteChildren);

        }

    }

    @Deprecated //for CDM lib internal use only, may be removed in future versions

    public int treeId() {

        }else{

        	return this.classification.getId();

        }

    /**

     * Sets the parent of this taxon node to the given parent. Cleans up references to

     * old parents and sets the classification to the new parents classification

     *

     * @param parent

     */

    @Transient

            //FIXME document / check for correctness

            if (formerParent.equals(parent)){

                if (currentIndex != -1 && currentIndex < index){

                    index--;

                }

        	}

        setParent(parent);

        // set the classification to the parents classification

        // add this node to the parent child nodes

        if (parentChildren.contains(this)){

            if (parentChildren.indexOf(this) < index){

                index = index -1;

            }

            parentChildren.remove(this);

            parentChildren.add(index, this);

        //sortIndex

        if (! this.getSortIndex().equals(index)){

        	logger.warn("index and sortindex are not equal");

        }

	/**

	 * As long as the sort index is not correctly handled through hibernate this is a workaround method

	 * to update the sort index manually

	 * @param parentChildren

	 * @param index

	 */

	private void updateSortIndex(List<TaxonNode> children, int index) {

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

        	TaxonNode child = children.get(i);

        	if (child != null){

//        		child = CdmBase.deproxy(child, TaxonNode.class);  //deproxy not needed as long as setSortIndex is protected or public #4200

        		child.setSortIndex(i);

        	}else{

        		String message = "A node in a taxon tree must never be null but is (ParentId: %d; sort index: %d; index: %d; i: %d)";

        		throw new IllegalStateException(String.format(message, getId(), sortIndex, index, i));

        	}

        }

	}

    /**

     * Returns a set containing this node and all nodes that are descendants of this node

     *

     * @return

     */

    protected Set<TaxonNode> getDescendants(){

        nodeSet.add(this);

        for(TaxonNode childNode : getChildNodes()){

            nodeSet.addAll(childNode.getDescendants());

        }

        return nodeSet;

    }

    /**

     * Returns a set containing a clone of this node and of all nodes that are descendants of this node

     *

     * @return

     */

    protected TaxonNode cloneDescendants(){

        TaxonNode clone = (TaxonNode)this.clone();

        TaxonNode childClone;

        for(TaxonNode childNode : getChildNodes()){

            childClone = (TaxonNode) childNode.clone();

            for (TaxonNode childChild:childNode.getChildNodes()){

        }

        return clone;

    }

    /**

     * Returns a

     *

     * @return

     */

    protected Set<TaxonNode> getAncestors(){

        Set<TaxonNode> nodeSet = new HashSet<TaxonNode>();

            nodeSet.addAll(parent.getAncestors());

        return nodeSet;

    }

     * Whether this TaxonNode is a direct child of the classification TreeNode

     * @return

     */

    @Transient

    public boolean isTopmostNode(){

    	boolean classificationCheck = false;

    	if(getParent() != null) {

    		if(getParent().getTaxon() == null) {

    			parentCheck = true;

    		}

    	}

    	// FIXME This should work but doesn't, due to missing sort indexes, can be removed after fixing #4200, #4098

    		classificationCheck = classification.getRootNode().getChildNodes().contains(this);

    	}else{

    		classificationCheck = false;

    	}

    	// The following is just for logging purposes for the missing sort indexes problem

    	// ticket #4098

    	if(parentCheck != classificationCheck) {        	

    		logger.warn("isTopmost node check " + parentCheck + " not same as classificationCheck : " + classificationCheck + " for taxon node ");        	

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

    			logger.warn("-- with parent uuid " + this.getParent().getUuid().toString());

    			logger.warn("-- with parent id " + this.getParent().getId());

    			for(TaxonNode node : this.getParent().getChildNodes()) {

    				if(node == null) {

    					logger.warn("-- child node is null");

    				} else if (node.getTaxon() == null) {

    					logger.warn("-- child node taxon is null");

    				} 

    			}

    			logger.warn("-- parent child count" + this.getParent().getChildNodes().size());        		

    		}       	

    	}

    	return parentCheck;

    /**

     * Whether this TaxonNode is a descendant of the given TaxonNode

     *

     * Caution: use this method with care on big branches. -> performance and memory hungry

     *

     * Protip: Try solving your problem with the isAscendant method which traverses the tree in the

     * other direction (up). It will always result in a rather small set of consecutive parents beeing

     * generated.

     *

     * TODO implement more efficiently without generating the set of descendants first

     *

     * @param possibleParent

     * @return true if this is a descendant

     */

    @Transient

    public boolean isDescendant(TaxonNode possibleParent){

    		return false;

    	}

    	return possibleParent == null ? false : this.treeIndex().startsWith(possibleParent.treeIndex() );