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.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Arrays;

import java.util.List;

import java.util.Set;

import org.apache.commons.lang.StringUtils;

import org.hibernate.LazyInitializationException;

import org.joda.time.DateTimeFieldType;

import org.joda.time.Partial;

import org.joda.time.format.DateTimeFormatter;

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.format.description.DefaultCategoricalDescriptionBuilder;

import eu.etaxonomy.cdm.format.description.DefaultQuantitativeDescriptionBuilder;

import eu.etaxonomy.cdm.format.description.DescriptionBuilder;

import eu.etaxonomy.cdm.format.description.QuantitativeDataFormatter;

import eu.etaxonomy.cdm.model.agent.AgentBase;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.media.Media;

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;

import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.permission.Group;

import eu.etaxonomy.cdm.model.permission.User;

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

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;

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

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

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>DescriptionHelper class.</p>

 *

 * @author p.ciardelli

 * @author n.hoffmann

 */

public class DescriptionHelper {

	/**

	 * Returns whatever the element's title cache equivalent is,

	 * depending on its class.

	 *

	 * @param element a {@link eu.etaxonomy.cdm.model.description.DescriptionElementBase} object.

	 * @param language a {@link eu.etaxonomy.cdm.model.common.Language} object.

	 * @return a {@link java.lang.String} object.

	 */

	public static String getCache(DescriptionElementBase element,

			Language language) {

		String mainElementLabel= null;

		DescriptionBase<?> descr = element.getInDescription();

		descr = CdmBase.deproxy(descr, DescriptionBase.class);

		if (descr != null){

			if (descr.isInstanceOf(TaxonDescription.class)){

				Taxon taxon = CdmBase.deproxy(descr, TaxonDescription.class).getTaxon();

				if (taxon != null){

					mainElementLabel = taxon.getTitleCache();

				}

			}else if (descr.isInstanceOf(SpecimenDescription.class)){

				SpecimenOrObservationBase<?> specimen = CdmBase.deproxy(descr, SpecimenDescription.class).getDescribedSpecimenOrObservation();

				if (specimen != null){

					mainElementLabel = specimen.getTitleCache();

				}

			}else if (descr.isInstanceOf(TaxonNameDescription.class)){

				TaxonName name = CdmBase.deproxy(descr, TaxonNameDescription.class).getTaxonName();

				if (name != null){

					mainElementLabel = name.getTitleCache();

				}

			}

		}

		String cache = null;

		if (element instanceof TextData) {

			//cache = ((TextData) element).getText(language);

		    cache = "Text Data";

		}

		if (element instanceof CommonTaxonName) {

			cache = ((CommonTaxonName) element).getName();

		}

		if (element instanceof TaxonInteraction) {

			Taxon taxon2 = ((TaxonInteraction) element).getTaxon2();

			if(taxon2 != null && taxon2.getName() != null){

				cache = taxon2.getName().getTitleCache();

			}else{

				cache = "No taxon chosen";

			}

		}

		if (element instanceof Distribution) {

			Distribution distribution = (Distribution) element;

			NamedArea area = distribution.getArea();

			if(area != null){

				cache =  area.getLabel();

				PresenceAbsenceTerm status = distribution.getStatus();

				if (status == null){

					cache += ", no status";

				}else {

					cache += ", " + status.getLabel();

				}

			}

		}

		String result = cache == null ? "" : cache;

		if (isNotBlank(mainElementLabel)){

			result = CdmUtils.concat(" ", result, "(" + mainElementLabel + ")");

		}

		return result;

	}

	/**

	 * Returns whatever the element's title cache equivalent is,

	 * depending on its class, using the default language.

	 *

	 * @param element a {@link eu.etaxonomy.cdm.model.description.DescriptionElementBase} object.

	 * @return a {@link java.lang.String} object.

	 */

	public static String getCache(DescriptionElementBase element) {

		return getCache(element, CdmStore.getDefaultLanguage());

	}

	/**

	 * Set whatever the element's title cache equivalent is,

	 * depending on its class.

	 *

	 * @param element a {@link eu.etaxonomy.cdm.model.description.DescriptionElementBase} object.

	 * @param value a {@link java.lang.String} object.

	 * @param language a {@link eu.etaxonomy.cdm.model.common.Language} object.

	 */

	public static void setCache(DescriptionElementBase element,

			String value, Language language) {

		if (element instanceof TextData) {

			((TextData) element).putText(language, value);

			return;

		}else if (element instanceof CommonTaxonName) {

			((CommonTaxonName) element).setName(value);

			return;

		}else if (element instanceof TaxonInteraction) {

		}else if(element instanceof Distribution){

			MessagingUtils.warn(DescriptionHelper.class, "trying to set cache on distribution, don't know what to do at the moment.");

			return;

		}else{

			MessagingUtils.warn(DescriptionHelper.class, "No matching subclass found for DescriptionElementBase object, 'cache' not set.");

		}

	}

	/**

	 * Set whatever the element's title cache equivalent is,

	 * depending on its class, using the default language.

	 *

	 * @param element a {@link eu.etaxonomy.cdm.model.description.DescriptionElementBase} object.

	 * @param value a {@link java.lang.String} object.

	 */

	public static void setCache(DescriptionElementBase element,

			String value) {

		setCache(element, value, CdmStore.getDefaultLanguage());

	}

	public static String getObjectDescription(Object element) {

	    String resultString = null;

		if (element instanceof IdentifiableEntity) {

			try{

			    resultString = ((IdentifiableEntity) element).getTitleCache();

			}catch(LazyInitializationException e){

				String result = "No Session to initialize title cache for IdentifiableEntity";

				MessagingUtils.error(DescriptionHelper.class, result, e);

				resultString = "TODO: " + result;

			}

		}else if (element instanceof OriginalSourceBase) {

			try{

				OriginalSourceBase<?> originalSource = (OriginalSourceBase<?>) element;

//				ISourceable sourcedObject = originalSource.getSourcedObj();

				//due to #5743 the bidirectionality for sourced object had to be removed

				String sourceObjectTitle = "sourced object data not available (#5743)";

//				if(sourcedObject instanceof IIdentifiableEntity){

//					sourceObjectTitle = ((IdentifiableEntity) sourcedObject).getTitleCache();

//				}else if(sourcedObject instanceof DescriptionElementBase){

//					sourceObjectTitle = "Element for description: " + ((DescriptionElementBase) sourcedObject).getInDescription().getTitleCache();

//				}else{

//					throw new IllegalStateException("Unknown ISourceable object for given OriginalSourceBase");

//				}

				resultString = CdmUtils.concat("; ", new String[]{originalSource.getIdNamespace(), originalSource.getIdInSource(), sourceObjectTitle});

			}catch(LazyInitializationException e){

				String result = "Error initializing title cache for ISourceable of an OriginalSourceBase";

				MessagingUtils.error(DescriptionHelper.class, result, e);

				resultString = "TODO: " + result;

			}

		}else if (element instanceof LanguageStringBase) {

		    resultString = ((LanguageStringBase) element).getText();

		}else if (element instanceof DescriptionElementBase) {

		    resultString = getCache((DescriptionElementBase) element);

		}else if (element instanceof RelationshipBase<?, ?, ?>) {

		    resultString = getCache((RelationshipBase<?, ?, ?>) element);

		}else if (element instanceof TypeDesignationBase<?>) {

		    resultString = getCache((TypeDesignationBase<?>) element);

		}else if (element instanceof HomotypicalGroup) {

		    resultString = getCache((HomotypicalGroup) element);

		}else if (element instanceof TaxonNode) {

		    resultString = getCache((TaxonNode) element);

		}else if (element instanceof DeterminationEvent) {

		    resultString = getCache((DeterminationEvent) element);

		}else if (element instanceof GatheringEvent){

			resultString = getCache((GatheringEvent) element);

		}else if (element instanceof Marker) {

			Marker marker = (Marker) element;

			MarkerType type = marker.getMarkerType();

			resultString = (type == null ? "- no marker type -" : marker.getMarkerType().getLabel()) + " (" + marker.getFlag() + ")";

		}else if (element instanceof User) {

			User user = (User) element;

			resultString = user.getUsername();

		}else if (element instanceof Group) {

			Group group = (Group) element;

			resultString = group.getName();

		}else if (element instanceof KeyStatement) {

            KeyStatement keyStatement = (KeyStatement) element;

            resultString = getCache(keyStatement);

        }else{

			// TODO write return texts for HomotypicalGroup, etc.

            resultString = element.toString();

		}

		if (resultString == null){

		    resultString = element.toString();

		}

		return resultString;

	}

	private static String getCache(GatheringEvent gatheringEvent){

		String ALTITUDE_PREFIX = "alt. ";

		final String METER = "m";

		String result = "";

		//collector

		AgentBase<?> collector = CdmBase.deproxy(gatheringEvent.getCollector());

		String collectorStr = collector == null? null : collector.getTitleCache();

		result = CdmUtils.concat(", ", result, collectorStr);

		//gathering period

		TimePeriod gatheringPeriod = gatheringEvent.getTimeperiod();

		result = CdmUtils.concat(", ", result, (gatheringPeriod == null? null : gatheringPeriod.toString()));

		//country

		String strCountry = null;

		NamedArea country = gatheringEvent.getCountry();

		Representation repCountry = country == null ? null : country.getRepresentation(Language.DEFAULT());

		strCountry = repCountry == null ? null: repCountry.getLabel();

		result = CdmUtils.concat(", ", result, strCountry);

		//locality

		LanguageString locality = gatheringEvent.getLocality();

		if (locality != null) {

			result = CdmUtils.concat(", ", result, locality.getText());

		}

		//elevation

		String elevationStr;

		if (isNotBlank(gatheringEvent.getAbsoluteElevationText())){

			elevationStr = gatheringEvent.getAbsoluteElevationText();

		}else{

			String text = gatheringEvent.getAbsoluteElevationText();

			Integer min = gatheringEvent.getAbsoluteElevation();

			Integer max = gatheringEvent.getAbsoluteElevationMax();

			elevationStr = DerivedUnitFacade.distanceString(min, max, text, METER);

		}

		if (isNotBlank(elevationStr)){

			result = CdmUtils.concat(", " , result, ALTITUDE_PREFIX);

			result += elevationStr;

		}

		//exact locality

		if (gatheringEvent.getExactLocation() != null){

			String exactLocation = gatheringEvent.getExactLocation().toSexagesimalString(false, false);

			result = CdmUtils.concat(", ", result, exactLocation);

		}

		return result;

	}

	private static String getCache(DeterminationEvent detEvent) {

		//taxon

		String taxonStr = null;

		TaxonName taxonName = detEvent.getTaxonName();

		TaxonBase<?> taxon = detEvent.getTaxon();

		if (taxonName != null){

			taxonStr = taxonName.getTitleCache();

		}

		if (isBlank(taxonStr) && taxon != null){

			taxonStr = taxon.getTitleCache();

		}

		if (isBlank(taxonStr)){

			taxonStr = "no or unlabled taxon";

		}

		//unit

		SpecimenOrObservationBase<?> unit = detEvent.getIdentifiedUnit();

		String unitStr;

		if (unit != null){

			unitStr = unit.getTitleCache();

			if (isBlank(unitStr)){

				unitStr = "Unlabled unit";

			}

		}else{

			unitStr = "no unit";

		}

		String result = CdmUtils.concat(" determined as ", unitStr, taxonStr);

		return result;

	}

	private static String getCache(TaxonNode taxonNode) {

		String result = "";

		Classification classification = taxonNode.getClassification();

		if (classification != null){

			String classificationStr = classification.getName() == null ? "" : classification.getName().getText();

			result = CdmUtils.concat("" , result, classificationStr);

			if (isBlank(result)){

				result = classification.toString();

			}

		}

		String parentStr;

		TaxonNode parentNode = taxonNode.getParent();

		if (parentNode == null){

			parentStr = "no parent";

		}else{

			Taxon parentTaxon = parentNode.getTaxon();

			if (parentTaxon == null){

				parentStr = "no parent taxon";

			}else{

				TaxonName parentName = parentTaxon.getName();

				if (parentName == null){

					parentStr = "child of " + parentTaxon.getTitleCache();

				}else{

					parentStr = "child of " + parentName.getTitleCache();

				}

			}

		}

		result = CdmUtils.concat(": ", result, parentStr);

		return result;

	}

	private static String getCache(TypeDesignationBase<?> designation) {

		designation = CdmBase.deproxy(designation);

		//from

		String fromString = null;

		Set<TaxonName> from = designation.getTypifiedNames();

		if(from != null){

		    for (TaxonName name : from){

		        fromString = CdmUtils.concat(",", fromString, name.getTitleCache());

		    }

		}

		//to

		IdentifiableEntity<?> to = null;

		String toStr = "";

		if (designation.isInstanceOf(SpecimenTypeDesignation.class)){

			to = ((SpecimenTypeDesignation)designation).getTypeSpecimen();

		}else if (designation.isInstanceOf(NameTypeDesignation.class)){

			to = ((NameTypeDesignation)designation).getTypeName();

		}else if (designation.isInstanceOf(TextualTypeDesignation.class)){

		    toStr = ((TextualTypeDesignation)designation).getPreferredText(CdmStore.getDefaultLanguage());

		}else{

			throw new RuntimeException("Type Designation class not supported: " +  designation.getClass().getName());

		}

		toStr = to == null? toStr : to.getTitleCache();

		//status

		String typeLabel = null;

		TypeDesignationStatusBase<?> status = designation.getTypeStatus();

		if (status != null){

			Representation typeRepr = status.getPreferredRepresentation(CdmStore.getDefaultLanguage());

			if (typeRepr != null){

				typeLabel = typeRepr.getAbbreviatedLabel();

			}

			if (isBlank(typeLabel) && typeRepr != null){

				typeLabel = typeRepr.getLabel();

			}

			if (isBlank(typeLabel) ){

				typeLabel = status.getSymbol();

			}

			if (isBlank(typeLabel)){

				typeLabel = status.getTitleCache();

			}

		}

		if (isBlank(typeLabel)){

			typeLabel = "->";

		}

		//concat

		String result = CdmUtils.concat(" ", new String[]{fromString, typeLabel, toStr});

		return result;

	}

	private static String getCache(RelationshipBase<?, ?, ?> rel) {

		rel = CdmBase.deproxy(rel);

		RelationshipTermBase<?> type = rel.getType();

		IdentifiableEntity<?> from;

		IdentifiableEntity<?> to;

		if (rel.isInstanceOf(NameRelationship.class)){

			from = ((NameRelationship)rel).getFromName();

			to = ((NameRelationship)rel).getToName();

		}else if (rel.isInstanceOf(HybridRelationship.class)){

			from = ((HybridRelationship)rel).getParentName();

			to = ((HybridRelationship)rel).getHybridName();

		}else if (rel.isInstanceOf(TaxonRelationship.class)){

			from = ((TaxonRelationship)rel).getFromTaxon();

			to = ((TaxonRelationship)rel).getToTaxon();

		}else{

			try {

				Method fromMethod = rel.getClass().getMethod("getRelatedFrom");

				Method toMethod = rel.getClass().getMethod("getRelatedFrom");

				fromMethod.setAccessible(true);

				toMethod.setAccessible(true);

				from = (IdentifiableEntity<?>)fromMethod.invoke(rel);

				to = (IdentifiableEntity<?>)toMethod.invoke(rel);

			} catch (NoSuchMethodException | SecurityException | IllegalAccessException

				| IllegalArgumentException | InvocationTargetException e) {

				throw new RuntimeException(e);

			}

		}

		String typeLabel = null;

		if (type != null){

			Representation typeRepr = type.getPreferredRepresentation(CdmStore.getDefaultLanguage());

			if (typeRepr != null){

				typeLabel = typeRepr.getAbbreviatedLabel();

			}

			if (isBlank(typeLabel) && typeRepr != null){

				typeLabel = typeRepr.getLabel();

			}

			if (isBlank(typeLabel) ){

				typeLabel = type.getSymbol();

			}

			if (isBlank(typeLabel)){

				typeLabel = type.getTitleCache();

			}

		}

		if (isBlank(typeLabel)){

			typeLabel = "->";

		}

		String result = CdmUtils.concat(" ", new String[]{from == null ? null : from.getTitleCache(),

				typeLabel, to == null? null : to.getTitleCache()});

		return result;

	}

	private static String getCache(HomotypicalGroup hg) {

		String result = "";

		for (TaxonName tnb : hg.getTypifiedNames()){

			result = CdmUtils.concat(", ", result, tnb.getTitleCache());

		}

		if (isBlank(result)){

			result = "No typified names";

		}

		return result;

	}

	private static String getCache(KeyStatement ks) {

        String result = "";

        result = "KeyStatement";

        return result;

    }

	public static String getObjectClassname(Object element) {

		return element.getClass().getSimpleName();

	}

	public static String getFeatureNodeContainerText(FeatureNodeContainer element) {

		String result = null;

		if(element.getFeatureNode() != null && element.getFeatureNode().getTerm() != null){

			result = element.getFeatureNode().getTerm().getLabel(CdmStore.getDefaultLanguage());

		} else{

			return "No label set";

		}

		if (result == null){

			result = element.getFeatureNode().getTerm().getLabel();

		}

		return result;

	}

	public static String getQuantitativeDataText(QuantitativeData element) {

	    QuantitativeDataFormatter formatter = new QuantitativeDataFormatter(null, null);

	    String label = formatter.doFormat(element);

		return label;

	}

	public static String getCategoricalDataText(CategoricalData element) {

		TextData textData = categoricalDescriptionBuilder.build(element, getLanguageList());

		return textData.getText(CdmStore.getDefaultLanguage());

	}

	private static List<Language> getLanguageList(){

		return Arrays.asList(new Language[]{CdmStore.getDefaultLanguage()});

	}

	private static DescriptionBuilder<QuantitativeData> quantitativeDescriptionBuilder = new DefaultQuantitativeDescriptionBuilder();

	private static DescriptionBuilder<CategoricalData> categoricalDescriptionBuilder = new DefaultCategoricalDescriptionBuilder();

    public static final String NO_LABEL_STRING = "[no label]";

	public static String getDistributionText(Distribution element) {

		String text = "EMPTY";

		Distribution distribution = element;

		NamedArea area = distribution.getArea();

		if(area != null){

			text = NamedArea.labelWithLevel(area, CdmStore.getDefaultLanguage());

			PresenceAbsenceTerm status = distribution.getStatus();

			if (status != null) {

				text += ", " + status.getLabel();

			}else{

				text += ", NO STATUS";

			}

		}

		return text;

	}

	public static  String getImageText(Media media) {

		 LanguageString title = media.getTitle(CdmStore.getDefaultLanguage());

		if (title != null) {

			return title.getText();

		}

		return "No title.";

	}

	public static  String getElementText(TextData element) {

		String text = null;

		if(element.getFeature().equals(Feature.CITATION())){

			text = "";

			for(DescriptionElementSource source : element.getSources()){

				if(source.getCitation() != null){

					text += source.getCitation().getTitleCache();

				}

				if(source.getNameUsedInSource() != null){

					text += " [ " + source.getNameUsedInSource().getTitleCache() + " ]";

				}

			}

			if(isBlank(text)){

				text = "No sources provided";

			}

		}else{

			List<Language> languages = Arrays.asList(new Language[]{CdmStore.getDefaultLanguage()});

			LanguageString languageString = element.getPreferredLanguageString(languages);

			text = languageString != null ? languageString.getText() : null;

		}

		return isBlank(text) ? "No text provided" : text;

	}

	public static  String getTaxonInteractionText(TaxonInteraction element) {

		String text = "";

		Taxon taxon2 = element.getTaxon2();

		if(taxon2 != null && taxon2.getName() != null){

			text = taxon2.getName().getTitleCache();

		}else{

			text = "No taxon chosen";

		}

		return text;

	}

	public static  String getCommonNameText(CommonTaxonName commonName) {

		String name = commonName.getName();

		if (name == null || name.length() == 0) {

			name = "No name provided";

		}

		Language language = commonName.getLanguage();

		if (language == null) {

			name += " (No language provided)";

		} else {

			name += " (" + language.getLabel(CdmStore.getDefaultLanguage()) + ")";

		}

		return name;

	}

	public static  String getDescriptionText(DescriptionBase element) {

		String text = element.getTitleCache();

		if (text == null || text.length() == 0) {

			text = "No label provided";

		}

		return text;

	}

	public static  String getIndividualsAssociationText(IndividualsAssociation element) {

		SpecimenOrObservationBase<?> derivedUnit = element.getAssociatedSpecimenOrObservation();

		if(derivedUnit != null){

			return derivedUnit.getTitleCache();

		}

		return "No unit chosen";

	}

	public static String getLabel(Object element){

		if (element instanceof FeatureNodeContainer){

			return getFeatureNodeContainerText((FeatureNodeContainer) element);

		}

		else if (element instanceof DescriptionBase) {

			return getDescriptionText((DescriptionBase<?>) element);

		}

		else if(element instanceof CategoricalData){

			String categoricalDataText = getCategoricalDataText((CategoricalData) element);

			if(categoricalDataText==null || categoricalDataText.isEmpty()){

			    categoricalDataText = NO_LABEL_STRING;

			}

            return categoricalDataText;

		}

		else if (element instanceof CommonTaxonName) {

			return getCommonNameText((CommonTaxonName) element);

		}

		else if (element instanceof Distribution) {

			return getDistributionText((Distribution) element);

		}

		else if (element instanceof IndividualsAssociation) {

			return getIndividualsAssociationText((IndividualsAssociation) element);

		}

		else if (element instanceof QuantitativeData) {

			String quantitativeDataText = getQuantitativeDataText((QuantitativeData) element);

			if(quantitativeDataText==null || quantitativeDataText.isEmpty()){

                quantitativeDataText = NO_LABEL_STRING;

			}

            return quantitativeDataText;

		}

		else if (element instanceof TaxonInteraction) {

			return getTaxonInteractionText((TaxonInteraction) element);

		}

		else if (element instanceof TextData) {

			return getElementText((TextData) element);

		}

		else if (element instanceof TemporalData) {

            return getTemporalDataText((TemporalData) element);

        }

		else{

			return element.toString();

		}

	}

    private static String getTemporalDataText(TemporalData element) {

        ExtendedTimePeriod period = element.getPeriod();

        Partial end = period.getEnd()==null?null:period.getEnd().without(DateTimeFieldType.year());

        Partial extremeEnd = period.getExtremeEnd()== null? null: period.getExtremeEnd().without(DateTimeFieldType.year());

        Partial start = period.getStart()==null? null: period.getStart().without(DateTimeFieldType.year());

        Partial extremeStart = period.getExtremeStart()==null? null : period.getExtremeStart().without(DateTimeFieldType.year());

        String result = "";

        DateTimeFormatter formatter = ExtendedTimePeriodPartialFormatter.NewInstance();

        if (extremeStart != null){

            result = "(" + extremeStart.toString(formatter) +"-)";

        }

        if (start != null){

            result += start.toString(formatter);

        }

        if (end != null){

            result += "-" + end.toString(formatter);

        }

        if (extremeEnd != null){

            result += "(-" + extremeEnd.toString(formatter)+")";

        }

        return result;

//        return element.getPeriod().toString();

    }

    private static boolean isNotBlank(String str){

		return StringUtils.isNotBlank(str);

	}

	private static boolean isBlank(String str){

		return StringUtils.isBlank(str);

	}

}