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

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.OneToMany;

import javax.persistence.Transient;

import javax.validation.Valid;

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.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.annotations.Type;

import org.hibernate.envers.Audited;

import org.hibernate.search.annotations.ClassBridge;

import org.hibernate.search.annotations.ClassBridges;

import org.hibernate.search.annotations.ContainedIn;

import org.hibernate.search.annotations.Indexed;

import org.hibernate.search.annotations.IndexedEmbedded;

import org.springframework.beans.factory.annotation.Configurable;

import org.springframework.util.ReflectionUtils;

import eu.etaxonomy.cdm.compare.taxon.HomotypicGroupTaxonComparator;

import eu.etaxonomy.cdm.compare.taxon.TaxonComparator;

import eu.etaxonomy.cdm.hibernate.search.GroupByTaxonClassBridge;

import eu.etaxonomy.cdm.hibernate.search.TaxonRelationshipClassBridge;

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.name.HomotypicalGroup;

import eu.etaxonomy.cdm.model.name.ITaxonNameBase;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.reference.ICdmTarget;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.strategy.cache.taxon.ITaxonCacheStrategy;

/**

 * The class for "accepted/correct" {@link TaxonBase taxa} (only these taxa according to

 * the opinion of the {@link eu.etaxonomy.cdm.model.reference.Reference reference} can build a classification).

 * An {@link java.lang.Iterable interface} is supported to iterate through taxonomic children.<BR>

 * Splitting taxa in "accepted/correct" and {@link Synonym "synonyms"} makes it easier to handle

 * particular relationships between ("accepted/correct") taxa on the one hand

 * and between ("synonym") taxa and ("accepted/correct") taxa on the other.

 *

 * @author m.doering

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

 */

@XmlAccessorType(XmlAccessType.FIELD)

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

    "taxonNodes",

    "synonyms",

    "relationsFromThisTaxon",

    "relationsToThisTaxon",

    "descriptions",

    "conceptId",

    "conceptDefinitions",

    "conceptStatus",

    "taxonTypes",

    "currentConceptPeriod"

})

@XmlRootElement(name = "Taxon")

@Entity

@Indexed(index = "eu.etaxonomy.cdm.model.taxon.TaxonBase")

@Audited

@Configurable

@ClassBridges({

    @ClassBridge(impl = GroupByTaxonClassBridge.class),

    @ClassBridge(impl = TaxonRelationshipClassBridge.class)

})

public class Taxon

            extends TaxonBase<ITaxonCacheStrategy<Taxon>>

            implements IRelated<RelationshipBase>, IDescribable<TaxonDescription>, ICdmTarget{

    private static final long serialVersionUID = -584946869762749006L;

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

    private static final TaxonComparator defaultTaxonComparator = new TaxonComparator();

    @XmlElementWrapper(name = "Descriptions")

    @XmlElement(name = "Description")

    @OneToMany(mappedBy="taxon", fetch= FetchType.LAZY)

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

    @NotNull

    @ContainedIn

    private Set<TaxonDescription> descriptions = new HashSet<>();

    // all related synonyms

    @XmlElementWrapper(name = "Synonyms")

    @XmlElement(name = "Synonym")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @OneToMany(mappedBy="acceptedTaxon", fetch=FetchType.LAZY, orphanRemoval=false) //we allow synonyms to stay on their own for dirty data and for intermediate states during e.g. imports

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

    @NotNull

    @Valid

    @ContainedIn

    private Set<Synonym> synonyms = new HashSet<>();

    // all taxa relations with rel.fromTaxon==this

    @XmlElementWrapper(name = "RelationsFromThisTaxon")

    @XmlElement(name = "FromThisTaxonRelationship")

    @OneToMany(mappedBy="relatedFrom", fetch=FetchType.LAZY, orphanRemoval=true)

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

    @NotNull

//    @Valid

    @ContainedIn

    private Set<TaxonRelationship> relationsFromThisTaxon = new HashSet<>();

    // all taxa relations with rel.toTaxon==this

    @XmlElementWrapper(name = "RelationsToThisTaxon")

    @XmlElement(name = "ToThisTaxonRelationship")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @OneToMany(mappedBy="relatedTo", fetch=FetchType.LAZY, orphanRemoval=true)

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

//    @Valid

    @ContainedIn

    private Set<TaxonRelationship> relationsToThisTaxon = new HashSet<>();

    @XmlAttribute(name= "taxonStatusUnknown")

    private boolean taxonStatusUnknown = false;

    /**

     * The status of this taxon is unknown it could also be some kind of synonym.

     * @return the taxonStatusUnknown

     */

    public boolean isTaxonStatusUnknown() {return taxonStatusUnknown;}

     /** @see #isTaxonStatusUnknown()*/

    public void setTaxonStatusUnknown(boolean taxonStatusUnknown) {this.taxonStatusUnknown = taxonStatusUnknown;}

    @XmlElementWrapper(name = "taxonNodes")

    @XmlElement(name = "taxonNode")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @OneToMany(mappedBy="taxon", fetch=FetchType.LAZY)

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

    @IndexedEmbedded

    private Set<TaxonNode> taxonNodes = new HashSet<>();

    private String conceptId;

    @XmlAttribute(name ="TaxonType")

    @NotNull

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

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

    )

    @Audited

    private EnumSet<TaxonType> taxonTypes = EnumSet.noneOf(TaxonType.class);

    @XmlAttribute(name ="ConceptDefinition")

    @NotNull

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

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

    )

    @Audited

    private EnumSet<ConceptDefinition> conceptDefinitions = EnumSet.noneOf(ConceptDefinition.class);

    @XmlAttribute(name ="ConceptStatus")

    @NotNull

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

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

    )

    @Audited

    private EnumSet<ConceptStatus> conceptStatus = EnumSet.noneOf(ConceptStatus.class);

    private TimePeriod currentConceptPeriod = TimePeriod.NewInstance();

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

    /**

     * @see #NewInstance(TaxonName, Reference)

     * @param taxonName

     * @param sec

     * @return

     */

    public static Taxon NewInstance(ITaxonNameBase taxonName, Reference sec){

        return NewInstance(TaxonName.castAndDeproxy(taxonName), sec);

    }

    /**

     * Creates a new (accepted/valid) taxon instance with

     * the {@link eu.etaxonomy.cdm.model.name.TaxonName taxon name} used and the {@link eu.etaxonomy.cdm.model.reference.Reference reference}

     * using it.

     *

     * @param  taxonName	the taxon name used

     * @param  sec				the reference using the taxon name

     * @see    					#Taxon(TaxonName, Reference)

     */

    public static Taxon NewInstance(TaxonName taxonName, Reference sec){

        Taxon result = new Taxon(taxonName, sec);

        return result;

    }

    /**

     * Creates a new Taxon for the given name, secundum reference and secundum detail

     * @param taxonName

     * @param sec

     * @param secMicroReference

     * @see #

     */

    public static Taxon NewInstance(TaxonName taxonName, Reference sec, String secMicroReference){

        Taxon result = new Taxon(taxonName, sec, secMicroReference);

        return result;

    }

    /**

     * Creates a new taxon instance with an unknown status (accepted/synonym) and with

     * the {@link eu.etaxonomy.cdm.model.name.TaxonName taxon name} used and the {@link eu.etaxonomy.cdm.model.reference.Reference reference}

     * using it.

     *

     * @param  taxonName	the taxon name used

     * @param  sec				the reference using the taxon name

     * @see    					#Taxon(TaxonName, Reference)

     */

    public static Taxon NewUnknownStatusInstance(TaxonName taxonName, Reference sec){

        Taxon result = new Taxon(taxonName, sec);

        result.setTaxonStatusUnknown(true);

        return result;

    }

// ************* CONSTRUCTORS *************/

    //for hibernate use only, *packet* private required by bytebuddy

    //TODO should be private, but still produces Spring init errors

    @Deprecated

    Taxon(){}

    private Taxon(TaxonName taxonName, Reference sec){

        super(taxonName, sec, null);

    }

    private Taxon(TaxonName taxonName, Reference sec, String secMicroReference){

        super(taxonName, sec, secMicroReference);

    }

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

    public String getConceptId() {

        return conceptId;

    }

    public void setConceptId(String conceptId) {

        this.conceptId = conceptId;

    }

    public TimePeriod getCurrentConceptPeriod() {

        return currentConceptPeriod;

    }

    public void setCurrentConceptPeriod(TimePeriod currentConceptPeriod) {

        this.currentConceptPeriod = currentConceptPeriod;

    }

// ************************ Concept Defintion ************************/

    public boolean isHomotypicGroups() {

        return ConceptDefinition.includesType(conceptDefinitions, ConceptDefinition.HOMOTYPIC_GROUP);

    }

    public void setHomotypicGroups(boolean isHomotypicGroups) {

        setConceptDefinition(ConceptDefinition.HOMOTYPIC_GROUP, isHomotypicGroups);

    }

    //calling it descriptionConcept not Descriptions to avoid name clash with setter for TaxonDescriptions

    public boolean isDescriptionConcept() {

        return ConceptDefinition.includesType(conceptDefinitions, ConceptDefinition.DESCRIPTION);

    }

    public void setDescriptionConcept(boolean isDescriptions) {

        setConceptDefinition(ConceptDefinition.DESCRIPTION, isDescriptions);

    }

    protected EnumSet<ConceptDefinition> getConceptDefinition() {

        return conceptDefinitions;

    }

    /**

     * for know it is private and the boolean getters and setters should be used instead.

     * If you make it public make sure to guarantee that any change to the enum set results

     * in a new enum set (see also {@link #newEnumSet(EnumSet, ConceptDefinition, ConceptDefinition)}

     * and that the client is aware of the enum set being immutable.

     */

    private void setConceptDefinitions(EnumSet<ConceptDefinition> conceptDefinitions){

        this.conceptDefinitions = conceptDefinitions;

    }

    /**

     * Sets the value for taxon concept definitions

     * @param conceptDefinition the concept definition

     * @param value the value if this taxon has this concept definition (<code>true</code>) or not (<code>false</code>)

     */

    protected void setConceptDefinition(ConceptDefinition conceptDefinition, boolean value) {

        if (value && !this.conceptDefinitions.contains(conceptDefinition)){

            setConceptDefinitions(newEnumSet(this.conceptDefinitions, conceptDefinition, null));

        }else if (!value && this.conceptDefinitions.contains(conceptDefinition)){

            setConceptDefinitions(newEnumSet(this.conceptDefinitions, null, conceptDefinition));

        }else{

            return;

        }

    }

// ************************ TaxonType ********************************/

    public boolean isConcept() {

        return TaxonType.includesType(taxonTypes, TaxonType.CONCEPT);

    }

    public void setConcept(boolean isConcept) {

        setTaxonType(TaxonType.CONCEPT, isConcept);

    }

    public boolean isNameUsage() {

        return TaxonType.includesType(taxonTypes, TaxonType.NAME_USAGE);

    }

    public void setNameUsage(boolean isNameUsage) {

        setTaxonType(TaxonType.NAME_USAGE, isNameUsage);

    }

    protected EnumSet<TaxonType> getTaxonTypes() {

        return taxonTypes;

    }

    /**

     * for know it is private and the boolean getters and setters should be used instead.

     * If you make it public make sure to guarantee that any change to the enum set results

     * in a new enum set (see also {@link #newEnumSet(EnumSet, TaxonType, TaxonType)}

     * and that the client is aware of the enum set being immutable.

     */

    private void setTaxonTypes(EnumSet<TaxonType> taxonTypes){

        this.taxonTypes = taxonTypes;

    }

    /**

     * Sets the value for taxon types

     * @param type the taxon type

     * @param value the value if this taxon has this type (<code>true</code>) or not (<code>false</code>)

     */

    protected void setTaxonType(TaxonType type, boolean value) {

        if (value && !this.taxonTypes.contains(type)){

            setTaxonTypes(newEnumSet(this.taxonTypes, type, null));

        }else if (!value && this.taxonTypes.contains(type)){

            setTaxonTypes(newEnumSet(this.taxonTypes, null, type));

        }else{

            return;

        }

    }

// ************************ Concept Status ********************************/

    public boolean isPersistent() {

        return ConceptStatus.includesType(conceptStatus, ConceptStatus.PERSISTENT);

    }

    public void setPersistent(boolean isPersistent) {

        setConceptStatus(ConceptStatus.PERSISTENT, isPersistent);

    }

    public boolean isSupportsProvenance() {

        return ConceptStatus.includesType(conceptStatus, ConceptStatus.SUPPORTS_PROVENANCE);

    }

    public void setSupportsProvenance(boolean isSupportsProvenance) {

        setConceptStatus(ConceptStatus.SUPPORTS_PROVENANCE, isSupportsProvenance);

    }

    public boolean isCurrentConcept() {

        return ConceptStatus.includesType(conceptStatus, ConceptStatus.CURRENT);

    }

    public void setCurrentConcept(boolean isCurrentConcept) {

        setConceptStatus(ConceptStatus.CURRENT, isCurrentConcept);

    }

    protected EnumSet<ConceptStatus> getConceptStatus() {

        return conceptStatus;

    }

    /**

     * for know it is private and the boolean getters and setters should be used instead.

     * If you make it public make sure to guarantee that any change to the enum set results

     * in a new enum set (see also {@link #newEnumSet(EnumSet, CdmClass, CdmClass)}

     * and that the client is aware of the enum set being immutable.

     */

    private void setConceptStatus(EnumSet<ConceptStatus> conceptStatus){

        this.conceptStatus = conceptStatus;

    }

    /**

     * Sets the value for concept status

     * @param conceptStatus the concept status

     * @param value the value if this concept has this status (<code>true</code>) or not (<code>false</code>)

     */

    protected void setConceptStatus(ConceptStatus conceptStatus, boolean value) {

        if (value && !this.conceptStatus.contains(conceptStatus)){

            setConceptStatus(newEnumSet(this.conceptStatus, conceptStatus, null));

        }else if (!value && this.conceptStatus.contains(conceptStatus)){

            setConceptStatus(newEnumSet(this.conceptStatus, null, conceptStatus));

        }else{

            return;

        }

    }

// ****************************************************************/

    /**

     * Returns the set of {@link eu.etaxonomy.cdm.model.description.TaxonDescription taxon descriptions}

     * concerning <i>this</i> taxon.

     *

     * @see #removeDescription(TaxonDescription)

     * @see #addDescription(TaxonDescription)

     * @see eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon()

     */

    @Override

    public Set<TaxonDescription> getDescriptions() {

        if(descriptions == null) {

            descriptions = new HashSet<>();

        }

        return descriptions;

    }

    public Set<TaxonDescription> getDescriptions(DescriptionType type) {

        Set<TaxonDescription> result = new HashSet<>();

        for (TaxonDescription description : getDescriptions()){

            if (description.getTypes().contains(type)){

                result.add(description);

            }

        }

        return result;

    }

    /**

     * Adds a new {@link eu.etaxonomy.cdm.model.description.TaxonDescription taxon description} to the set

     * of taxon descriptions assigned to <i>this</i> (accepted/correct) taxon.

     * Due to bidirectionality the content of the {@link eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon() taxon attribute} of the

     * taxon description itself will be replaced with <i>this</i> taxon. The taxon

     * description will also be removed from the set of taxon descriptions

     * assigned to its previous taxon.

     *

     * @param  description	the taxon description to be added for <i>this</i> taxon

     * @see     		  	#getDescriptions()

     * @see     		  	#removeDescription(TaxonDescription)

     * @see 			  	eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon()

     */

    @Override

    public void addDescription(TaxonDescription description) {

        if (description.getTaxon() != null){

            description.getTaxon().removeDescription(description);

        }

        Field field = ReflectionUtils.findField(TaxonDescription.class, "taxon", Taxon.class);

        ReflectionUtils.makeAccessible(field);

        ReflectionUtils.setField(field, description, this);

        descriptions.add(description);

    }

    /**

     * Removes one element from the set of {@link eu.etaxonomy.cdm.model.description.TaxonDescription taxon descriptions} assigned

     * to <i>this</i> (accepted/correct) taxon. Due to bidirectionality the content of

     * the {@link eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon() taxon attribute} of the taxon description

     * itself will be set to "null".

     *

     * @param  description  the taxon description which should be removed

     * @see     		  	#getDescriptions()

     * @see     		  	#addDescription(TaxonDescription)

     * @see 			  	eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon()

     */

    @Override

    public void removeDescription(TaxonDescription description) {

        //description.setTaxon(null) for not visible method

        Field field = ReflectionUtils.findField(TaxonDescription.class, "taxon", Taxon.class);

        ReflectionUtils.makeAccessible(field);

        ReflectionUtils.setField(field, description, null);

        descriptions.remove(description);

    }

    public void removeDescription(TaxonDescription description, boolean removeElements){

    	if (removeElements){

    		Set<DescriptionElementBase> elements = new HashSet<DescriptionElementBase>(description.getElements());

            for (DescriptionElementBase el:elements){

            	description.getElements().remove(el);

            }

            removeDescription(description);

    	} else{

    		removeDescription(description);

    	}

    }

    /**

     * Returns the image gallery for a taxon. If there are multiple taxon descriptions

     * marked as image galleries an arbitrary one is chosen.

     * If no image gallery exists, a new one is created if <code>createNewIfNotExists</code>

     * is <code>true</code>.

     * @param createNewIfNotExists

     * @return

     */

    public TaxonDescription getImageGallery(boolean createNewIfNotExists) {

        TaxonDescription result = null;

        Set<TaxonDescription> descriptions= getDescriptions();

        for (TaxonDescription description : descriptions){

            if (description.isImageGallery()){

                result = description;

                break;

            }

        }

        if (result == null && createNewIfNotExists){

            result = TaxonDescription.NewInstance(this);

            result.setImageGallery(true);

        }

        return result;

    }

    public Set<TaxonNode> getTaxonNodes() {

        return taxonNodes;

    }

    //	protected void setTaxonNodes(Set<TaxonNode> taxonNodes) {

//		this.taxonNodes = taxonNodes;

//	}

    protected void addTaxonNode(TaxonNode taxonNode){

        taxonNodes.add(taxonNode);

    }

    public boolean removeTaxonNode(TaxonNode taxonNode){

        if (!taxonNodes.contains(taxonNode)){

            return false;

        }

        TaxonNode parent = taxonNode.getParent();

        if (parent != null){

            parent.removeChildNode(taxonNode);

        }

        taxonNode.setTaxon(null);

        return taxonNodes.remove(taxonNode);

    }

    public boolean removeTaxonNode(TaxonNode taxonNode, boolean deleteChildren){

        TaxonNode parent = taxonNode.getParent();

        boolean success = true;

        if ((!taxonNode.getChildNodes().isEmpty() && deleteChildren) || (taxonNode.getChildNodes().isEmpty()) ){

            taxonNode.delete();

        } else if (!taxonNode.isTopmostNode()){

            List<TaxonNode> nodes = new ArrayList<TaxonNode> (taxonNode.getChildNodes());

            for (TaxonNode childNode: nodes){

                taxonNode.getChildNodes().remove(childNode);

                parent.addChildNode(childNode, null, null);

            }

            taxonNode.delete();

        } else if (taxonNode.isTopmostNode()){

            success = false;

        }

        return success;

    }

    public boolean removeTaxonNodes(boolean deleteChildren){

        Iterator<TaxonNode> nodesIterator = taxonNodes.iterator();

        TaxonNode node;

        TaxonNode parent;

        boolean success = false;

        List<TaxonNode> removeNodes = new ArrayList<>();

        while (nodesIterator.hasNext()){

            node = nodesIterator.next();

            if (!deleteChildren){

                List<TaxonNode> children = node.getChildNodes();

                Iterator<TaxonNode> childrenIterator = children.iterator();

                parent = node.getParent();

                while (childrenIterator.hasNext()){

                    TaxonNode childNode = childrenIterator.next();

                    if (parent != null){

                        parent.addChildNode(childNode, null, null);

                    }else{

                        childNode.setParent(null);

                    }

                }

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

                    node.removeChild(i);

                }

            }

            removeNodes.add(node);

         }

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

            TaxonNode removeNode = removeNodes.get(i);

            success = removeNode.delete(deleteChildren);

            removeNode.setTaxon(null);

            removeTaxonNode(removeNode);

        }

        return success;

    }

    public TaxonNode getTaxonNode(Classification classification) {

        if (classification == null){

            return null;

        }

        for (TaxonNode node : this.getTaxonNodes()){

            if (classification.equals(node.getClassification())){

                return node;

            }

        }

        return null;

    }

    /**

     * Returns the set of all {@link Synonym synonyms}

     * for which <i>this</i> ("accepted/valid") taxon is the accepted taxon.

     *

     * @see    #addSynonym(Synonym, SynonymType)

     * @see    #removeSynonym(Synonym)

     */

    public Set<Synonym> getSynonyms() {

        if(synonyms == null) {

            this.synonyms = new HashSet<>();

        }

        return synonyms;

    }

    /**

     * Returns the set of all {@link TaxonRelationship taxon relationships}

     * between two taxa in which <i>this</i> taxon is involved as a source.

     *

     * @see    #getRelationsToThisTaxon()

     * @see    #getTaxonRelations()

     */

    public Set<TaxonRelationship> getRelationsFromThisTaxon() {

        if(relationsFromThisTaxon == null) {

            this.relationsFromThisTaxon = new HashSet<>();

        }

        return relationsFromThisTaxon;

    }

    /**

     * Returns the set of all {@link TaxonRelationship taxon relationships}

     * between two taxa in which <i>this</i> taxon is involved as a target.

     *

     * @see    #getRelationsFromThisTaxon()

     * @see    #getTaxonRelations()

     */

    public Set<TaxonRelationship> getRelationsToThisTaxon() {

        if(relationsToThisTaxon == null) {

            this.relationsToThisTaxon = new HashSet<>();

        }

        return relationsToThisTaxon;

    }

    /**

     * Returns the set of all {@link TaxonRelationship taxon relationships}

     * between two taxa in which <i>this</i> taxon is involved either as a source or

     * as a target.

     *

     * @see    #getRelationsFromThisTaxon()

     * @see    #getRelationsToThisTaxon()

     */

    @Transient

    public Set<TaxonRelationship> getTaxonRelations() {

        Set<TaxonRelationship> rels = new HashSet<>();

        rels.addAll(getRelationsToThisTaxon());

        rels.addAll(getRelationsFromThisTaxon());

        return rels;

    }

    /**

     * @see    #getRelationsToThisTaxon()

     */

    protected void setRelationsToThisTaxon(Set<TaxonRelationship> relationsToThisTaxon) {

        this.relationsToThisTaxon = relationsToThisTaxon;

    }

    /**

     * @see    #getRelationsFromThisTaxon()

     */

    protected void setRelationsFromThisTaxon(Set<TaxonRelationship> relationsFromThisTaxon) {

        this.relationsFromThisTaxon = relationsFromThisTaxon;

    }

    /**

     * If a relationships between <i>this</i> and the given taxon exists they will be returned.

     * <i>This</i> taxon is involved either as a source or as a target in the relationships.

     * The method will return <code>null</code> if no relations exist between the two taxa.

     *

     * @param possiblyRelatedTaxon

     * 			a taxon to check for a relationship

     * @return

     * 			a set of <code>TaxonRelationship</code>s or <code>null</null> if none exists.

     */

    public Set<TaxonRelationship> getTaxonRelations(Taxon possiblyRelatedTaxon){

        Set<TaxonRelationship> relations = new HashSet<>();

        for(TaxonRelationship relationship : getTaxonRelations()){

            if(relationship.getFromTaxon().equals(possiblyRelatedTaxon)) {

                relations.add(relationship);

            }

            if(relationship.getToTaxon().equals(possiblyRelatedTaxon)) {

                relations.add(relationship);

            }

        }

        return relations.size() > 0 ? relations : null;

    }

    /**

     * Removes one {@link TaxonRelationship taxon relationship} from one of both sets of

     * {@link #getTaxonRelations() taxon relationships} in which <i>this</i> taxon is involved

     * either as a {@link #getRelationsFromThisTaxon() source} or as a {@link #getRelationsToThisTaxon() target}.

     * The taxon relationship will also be removed from one of both sets

     * belonging to the second taxon involved. Furthermore the inherited RelatedFrom and

     * RelatedTo attributes of the given taxon relationship will be nullified.<P>

     *

     * @param  rel  the taxon relationship which should be removed from one

     * 				of both sets

     * @see    		#getTaxonRelations()

     * @see    		eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()

     * @see    		eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedTo()

     *

     */

    public void removeTaxonRelation(TaxonRelationship rel) {

        this.relationsToThisTaxon.remove(rel);

        this.relationsFromThisTaxon.remove(rel);

        Taxon fromTaxon = rel.getFromTaxon();

        Taxon toTaxon = rel.getToTaxon();

        //delete Relationship from other related Taxon

        if (fromTaxon != this){

            rel.setToTaxon(null);  //remove this Taxon from relationship

            if (fromTaxon != null){

                if (fromTaxon.getTaxonRelations().contains(rel)){

                    fromTaxon.removeTaxonRelation(rel);

                }

            }

        }

        if (toTaxon != this ){

            rel.setFromTaxon(null); //remove this Taxon from relationship

           if (toTaxon != null){

               if (toTaxon.getTaxonRelations().contains(rel)) {

                   toTaxon.removeTaxonRelation(rel);

               }

           }

        }

    }

    /**

     * Adds an existing {@link TaxonRelationship taxon relationship} either to the set of

     * {@link #getRelationsToThisTaxon() taxon relationships to <i>this</i> taxon} or to the set of

     * {@link #getRelationsFromThisTaxon() taxon relationships from <i>this</i> taxon}. If neither the

     * source nor the target of the taxon relationship match with <i>this</i> taxon

     * no addition will be carried out. The taxon relationship will also be

     * added to the second taxon involved in the given relationship.<P>

     *

     * @param rel  the taxon relationship to be added to one of <i>this</i> taxon's taxon relationships sets

     * @see    	   #addTaxonRelation(Taxon, TaxonRelationshipType, Reference, String)

     * @see    	   #getTaxonRelations()

     * @see    	   #getRelationsFromThisTaxon()

     * @see    	   #getRelationsToThisTaxon()

     */

    public void addTaxonRelation(TaxonRelationship rel) {

        if (rel!=null && rel.getType()!=null && !getTaxonRelations().contains(rel) ){

            Taxon toTaxon=rel.getToTaxon();

            Taxon fromTaxon=rel.getFromTaxon();

            if ( this.equals(toTaxon) || this.equals(fromTaxon) ){

                if (this.equals(fromTaxon)){

                    relationsFromThisTaxon.add(rel);

                    // also add relation to other taxon object

                    if (toTaxon!=null){

                        toTaxon.addTaxonRelation(rel);

                    }

                }else if (this.equals(toTaxon)){

                    relationsToThisTaxon.add(rel);

                    // also add relation to other taxon object

                    if (fromTaxon!=null){

                        fromTaxon.addTaxonRelation(rel);

                    }

                }

            }else if (toTaxon == null || fromTaxon == null){

                if (toTaxon == null){

                    toTaxon = this;

                    relationsToThisTaxon.add(rel);

                    if (fromTaxon!= null){

                        fromTaxon.addTaxonRelation(rel);

                    }

                }else if (fromTaxon == null && toTaxon != null){

                    fromTaxon = this;

                    relationsFromThisTaxon.add(rel);

                    toTaxon.addTaxonRelation(rel);

                }

            }

        }

    }

    @Override

    @Deprecated //for inner use by RelationshipBase only

    public void addRelationship(RelationshipBase rel){

        if (rel instanceof TaxonRelationship){

            addTaxonRelation((TaxonRelationship)rel);

        }else{

            throw new ClassCastException("Wrong Relationsship type for Taxon.addRelationship");

        }

    }

    /**

     * Creates a new {@link TaxonRelationship taxon relationship} instance where <i>this</i> taxon

     * plays the source role and adds it to the set of

     * {@link #getRelationsFromThisTaxon() "taxon relationships from"} belonging to <i>this</i> taxon.

     * The taxon relationship will also be added to the set of taxon

     * relationships to the second taxon involved in the created relationship.<P>

     *

     * @param toTaxon		the taxon which plays the target role in the new taxon relationship

     * @param type			the taxon relationship type for the new taxon relationship

     * @param citation		the reference source for the new taxon relationship

     * @param microcitation	the string with the details describing the exact localisation within the reference

     * @return

     * @see    	   			#addTaxonRelation(TaxonRelationship)

     * @see    	   			#getTaxonRelations()

     * @see    	   			#getRelationsFromThisTaxon()

     * @see    	   			#getRelationsToThisTaxon()

     */

    public TaxonRelationship addTaxonRelation(Taxon toTaxon, TaxonRelationshipType type, Reference citation, String microcitation) {

        return new TaxonRelationship(this, toTaxon, type, citation, microcitation);

    }

    /**

     * Creates a new {@link TaxonRelationship taxon relationship} (with {@link TaxonRelationshipType taxon relationship type}

     * "misapplied name for") instance where <i>this</i> taxon plays the target role

     * and adds it to the set of {@link #getRelationsToThisTaxon() taxon relationships to <i>this</i> taxon}.

     * The taxon relationship will also be added to the set of taxon

     * relationships to the other (misapplied name) taxon involved in the created relationship.

     *

     * @param misappliedNameTaxon	the taxon which plays the source role in the new taxon relationship

     * @param citation				the reference source for the new taxon relationship

     * @param microcitation			the string with the details describing the exact localisation within the reference

     * @return

     * @see    	   					#getMisappliedNames()

     * @see                         #addProParteMisappliedName(Taxon, Reference, String)

     * @see    	   					#addTaxonRelation(Taxon, TaxonRelationshipType, Reference, String)

     * @see    	   					#addTaxonRelation(TaxonRelationship)

     * @see    	   					#getTaxonRelations()

     * @see    	   					#getRelationsFromThisTaxon()

     * @see    	   					#getRelationsToThisTaxon()

     */

    public TaxonRelationship addMisappliedName(Taxon misappliedNameTaxon, Reference citation, String microcitation) {

        return misappliedNameTaxon.addTaxonRelation(this, TaxonRelationshipType.MISAPPLIED_NAME_FOR(), citation, microcitation);

    }

//	public void removeMisappliedName(Taxon misappliedNameTaxon){

//		Set<TaxonRelationship> taxRels = this.getTaxonRelations();

//		for (TaxonRelationship taxRel : taxRels ){

//			if (taxRel.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())

//				&& taxRel.getFromTaxon().equals(misappliedNameTaxon)){

//				this.removeTaxonRelation(taxRel);

//			}

//		}

//	}

    /**

     * Creates a new {@link TaxonRelationship taxon relationship} (with {@link TaxonRelationshipType taxon relationship type}

     * "pro parte misapplied name for") instance where <i>this</i> taxon plays the target role

     * and adds it to the set of {@link #getRelationsToThisTaxon() taxon relationships to <i>this</i> taxon}.

     * The taxon relationship will also be added to the set of taxon

     * relationships to the other (pro parte misapplied name) taxon involved in the created relationship.

     *

     * @param proParteMisappliedNameTaxon   the taxon which plays the source role in the new taxon relationship

     * @param citation              the reference source for the new taxon relationship

     * @param microcitation         the string with the details describing the exact localisation within the reference

     * @return

     * @see                         #addMisappliedName(Taxon, Reference, String)

     * @see                         #getMisappliedNames()

     * @see                         #addTaxonRelation(Taxon, TaxonRelationshipType, Reference, String)

     * @see                         #addTaxonRelation(TaxonRelationship)

     * @see                         #getTaxonRelations()

     * @see                         #getRelationsFromThisTaxon()

     * @see                         #getRelationsToThisTaxon()

     */