EDIT

// $Id$

/**

* Copyright (C) 2009 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.io.pesi.out;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.joda.time.DateTime;

import org.joda.time.format.DateTimeFormat;

import org.joda.time.format.DateTimeFormatter;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.io.common.Source;

import eu.etaxonomy.cdm.io.common.mapping.out.DbExtensionMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbObjectMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.DbStringMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.IdMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.MethodMapper;

import eu.etaxonomy.cdm.io.common.mapping.out.ObjectChangeMapper;

import eu.etaxonomy.cdm.io.pesi.erms.ErmsTransformer;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.taxon.TaxonRelationshipType;

import eu.etaxonomy.cdm.persistence.query.MatchMode;

import eu.etaxonomy.cdm.strategy.cache.TaggedText;

/**

 * The export class for {@link eu.etaxonomy.cdm.model.name.TaxonNameBase TaxonNames}.<p>

 * Inserts into DataWarehouse database table <code>Taxon</code>.

 * It is divided into four phases:<p><ul>

 * <li>Phase 1:	Export of all {@link eu.etaxonomy.cdm.model.name.TaxonNameBase TaxonNames} except some data exported in the following phases.

 * <li>Phase 2:	Export of additional data: ParenTaxonFk and TreeIndex.

 * <li>Phase 3:	Export of additional data: Rank data, KingdomFk, TypeNameFk, expertFk and speciesExpertFk.

 * <li>Phase 4:	Export of Inferred Synonyms.</ul>

 * @author e.-m.lee

 * @date 23.02.2010

 *

 */

@Component

public class PesiTaxonExport extends PesiExportBase {

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

	private static final Class<? extends CdmBase> standardMethodParameter = TaxonBase.class;

	private static int modCount = 1000;

	private static final String dbTableName = "Taxon";

	private static final String pluralString = "Taxa";

	private static final String parentPluralString = "Taxa";

	private PreparedStatement parentTaxonFk_TreeIndex_KingdomFkStmt;

	private PreparedStatement rankTypeExpertsUpdateStmt;

	private PreparedStatement rankUpdateStmt;

	private NomenclaturalCode nomenclaturalCode;

	private Integer kingdomFk;

	private HashMap<Rank, Rank> rank2endRankMap = new HashMap<Rank, Rank>();

	private List<Rank> rankList = new ArrayList<Rank>();

	private static final UUID uuidTreeIndex = UUID.fromString("28f4e205-1d02-4d3a-8288-775ea8413009");

	private AnnotationType treeIndexAnnotationType;

	private static ExtensionType lastActionExtensionType;

	private static ExtensionType lastActionDateExtensionType;

	private static ExtensionType expertNameExtensionType;

	private static ExtensionType speciesExpertNameExtensionType;

	private static ExtensionType cacheCitationExtensionType;

	private static ExtensionType expertUserIdExtensionType;

	private static ExtensionType speciesExpertUserIdExtensionType;

	/**

	 * @return the treeIndexAnnotationType

	 */

	protected AnnotationType getTreeIndexAnnotationType() {

		return treeIndexAnnotationType;

	}

	/**

	 * @param treeIndexAnnotationType the treeIndexAnnotationType to set

	 */

	protected void setTreeIndexAnnotationType(AnnotationType treeIndexAnnotationType) {

		this.treeIndexAnnotationType = treeIndexAnnotationType;

	}

	enum NamePosition {

		beginning,

		end,

		between,

		alone,

		nowhere

	}

	public PesiTaxonExport() {

		super();

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.DbExportBase#getStandardMethodParameter()

	 */

	@Override

	public Class<? extends CdmBase> getStandardMethodParameter() {

		return standardMethodParameter;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)

	 */

	@Override

	protected boolean doCheck(PesiExportState state) {

		boolean result = true;

		return result;

	}

	/**

	 * Returns the CDM to PESI specific export mappings.

	 * @return The {@link PesiExportMapping PesiExportMapping}.

	 */

	private PesiExportMapping getMapping() {

		PesiExportMapping mapping = new PesiExportMapping(dbTableName);

		ExtensionType extensionType = null;

		mapping.addMapper(IdMapper.NewInstance("TaxonId"));

		mapping.addMapper(DbObjectMapper.NewInstance("sec", "sourceFk")); //OLD:mapping.addMapper(MethodMapper.NewInstance("SourceFK", this.getClass(), "getSourceFk", standardMethodParameter, PesiExportState.class));

		mapping.addMapper(MethodMapper.NewInstance("TaxonStatusFk", this.getClass(), "getTaxonStatusFk", standardMethodParameter, PesiExportState.class));

		mapping.addMapper(MethodMapper.NewInstance("TaxonStatusCache", this.getClass(), "getTaxonStatusCache", standardMethodParameter, PesiExportState.class));

		// QualityStatus (Fk, Cache)

		extensionType = (ExtensionType)getTermService().find(ErmsTransformer.uuidQualityStatus);

		if (extensionType != null) {

			mapping.addMapper(DbExtensionMapper.NewInstance(extensionType, "QualityStatusCache"));

		} else {

			mapping.addMapper(MethodMapper.NewInstance("QualityStatusCache", this));

		}

		mapping.addMapper(MethodMapper.NewInstance("QualityStatusFk", this)); // PesiTransformer.QualityStatusCache2QualityStatusFk?

		mapping.addMapper(MethodMapper.NewInstance("GUID", this));

		//TODO implement again

//		mapping.addMapper(MethodMapper.NewInstance("IdInSource", this));

		mapping.addMapper(MethodMapper.NewInstance("DerivedFromGuid", this));

		mapping.addMapper(MethodMapper.NewInstance("CacheCitation", this));

//		mapping.addMapper(MethodMapper.NewInstance("OriginalDB", this));

		mapping.addMapper(MethodMapper.NewInstance("OriginalDB", this.getClass(), "getOriginalDB", IdentifiableEntity.class) );

		mapping.addMapper(MethodMapper.NewInstance("LastAction", this.getClass(), "getLastAction",  IdentifiableEntity.class));

		mapping.addMapper(MethodMapper.NewInstance("LastActionDate", this.getClass(), "getLastActionDate",  IdentifiableEntity.class));

		mapping.addMapper(MethodMapper.NewInstance("ExpertName", this));

		mapping.addMapper(MethodMapper.NewInstance("SpeciesExpertName", this));

		mapping.addMapper(MethodMapper.NewInstance("AuthorString", this));  //For Taxon because Misallied Names are handled differently

		mapping.addMapper(ObjectChangeMapper.NewInstance(TaxonBase.class, TaxonNameBase.class, "Name"));

		addNameMappers(mapping);

		return mapping;

	}

	/**

	 * Returns the CDM to PESI specific export mappings.

	 * @return The {@link PesiExportMapping PesiExportMapping}.

	 */

	private PesiExportMapping getNameMapping() {

		PesiExportMapping mapping = new PesiExportMapping(dbTableName);

		mapping.addMapper(IdMapper.NewInstance("TaxonId"));

		//		mapping.addMapper(MethodMapper.NewInstance("TaxonStatusFk", this.getClass(), "getTaxonStatusFk", standardMethodParameter, PesiExportState.class));

		mapping.addMapper(MethodMapper.NewInstance("LastAction", this.getClass(), "getLastAction", IdentifiableEntity.class));

		mapping.addMapper(MethodMapper.NewInstance("LastActionDate",  this.getClass(), "getLastAction", IdentifiableEntity.class));

		mapping.addMapper(MethodMapper.NewInstance("OriginalDB", this.getClass(), "getOriginalDB", IdentifiableEntity.class) );

		addNameMappers(mapping);

		//TODO add author mapper, taxonStatusFk, TaxonStatusCache, TypeNameFk

//		mapping.addMapper(MethodMapper.NewInstance("IdInSource", this));

//	immer 2 f?r E+M ?	mapping.addMapper(MethodMapper.NewInstance("QualityStatusFk", this)); // PesiTransformer.QualityStatusCache2QualityStatusFk?

//		mapping.addMapper(MethodMapper.NewInstance("TaxonStatusCache", this.getClass(), "getTaxonStatusCache", standardMethodParameter, PesiExportState.class));

		return mapping;

	}

	private void addNameMappers(PesiExportMapping mapping) {

		ExtensionType extensionType;

		mapping.addMapper(DbStringMapper.NewInstance("GenusOrUninomial", "GenusOrUninomial"));

		mapping.addMapper(DbStringMapper.NewInstance("InfraGenericEpithet", "InfraGenericEpithet"));

		mapping.addMapper(DbStringMapper.NewInstance("SpecificEpithet", "SpecificEpithet"));

		mapping.addMapper(DbStringMapper.NewInstance("InfraSpecificEpithet", "InfraSpecificEpithet"));

		mapping.addMapper(DbStringMapper.NewInstance("NameCache", "WebSearchName"));

		mapping.addMapper(DbStringMapper.NewInstance("TitleCache", "FullName"));

		//TODO FIXME incorrect mapping -> should be ref +  microref but is only microref

		mapping.addMapper(DbStringMapper.NewInstance("NomenclaturalMicroReference", "NomRefString"));

		mapping.addMapper(MethodMapper.NewInstance("WebShowName", this, TaxonNameBase.class));

		// DisplayName

		extensionType = (ExtensionType)getTermService().find(ErmsTransformer.uuidDisplayName);		

		if (extensionType != null) {

			mapping.addMapper(DbExtensionMapper.NewInstance(extensionType, "DisplayName"));

		} else {

			mapping.addMapper(MethodMapper.NewInstance("DisplayName", this, TaxonNameBase.class));

		}

		mapping.addMapper(MethodMapper.NewInstance("NameStatusFk", this, TaxonNameBase.class));

		mapping.addMapper(MethodMapper.NewInstance("NameStatusCache", this, TaxonNameBase.class));

		mapping.addMapper(MethodMapper.NewInstance("TypeFullnameCache", this, TaxonNameBase.class));

		//TODO TypeNameFk

		// FossilStatus (Fk, Cache)

		extensionType = (ExtensionType)getTermService().find(ErmsTransformer.uuidFossilStatus);

		if (extensionType != null) {

			mapping.addMapper(DbExtensionMapper.NewInstance(extensionType, "FossilStatusCache"));

		} else {

			mapping.addMapper(MethodMapper.NewInstance("FossilStatusCache", this, TaxonNameBase.class));

		}

		mapping.addMapper(MethodMapper.NewInstance("FossilStatusFk", this, TaxonNameBase.class)); // PesiTransformer.FossilStatusCache2FossilStatusFk?

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doInvoke(eu.etaxonomy.cdm.io.common.IoStateBase)

	 */

	@Override

	protected void doInvoke(PesiExportState state) {

		try {

			logger.info("*** Started Making " + pluralString + " ...");

			initPreparedStatements(state);

			// Stores whether this invoke was successful or not.

			boolean success = true;

			// PESI: Clear the database table Taxon.

			doDelete(state);

			// Get specific mappings: (CDM) Taxon -> (PESI) Taxon

			PesiExportMapping mapping = getMapping();

			// Initialize the db mapper

			mapping.initialize(state);

			// Find extensionTypes

			lastActionExtensionType = (ExtensionType)getTermService().find(PesiTransformer.lastActionUuid);

			lastActionDateExtensionType = (ExtensionType)getTermService().find(PesiTransformer.lastActionDateUuid);

			expertNameExtensionType = (ExtensionType)getTermService().find(PesiTransformer.expertNameUuid);

			speciesExpertNameExtensionType = (ExtensionType)getTermService().find(PesiTransformer.speciesExpertNameUuid);

			cacheCitationExtensionType = (ExtensionType)getTermService().find(PesiTransformer.cacheCitationUuid);

			expertUserIdExtensionType = (ExtensionType)getTermService().find(PesiTransformer.expertUserIdUuid);

			speciesExpertUserIdExtensionType = (ExtensionType)getTermService().find(PesiTransformer.speciesExpertUserIdUuid);

			//"PHASE 5: Handle names without taxa ...

			success &= doNames(state);

			//Export Taxa..

			success &= doPhase01(state, mapping);

			// 2nd Round: Add ParentTaxonFk, TreeIndex to each Taxon

			success &= doPhase02(state);

			//PHASE 3: Add Rank data, KingdomFk, TypeNameFk, expertFk and speciesExpertFk...

			success &= doPhase03(state);

			//"PHASE 4: Creating Inferred Synonyms...

			success &= doPhase04(state, mapping);

			logger.info("*** Finished Making " + pluralString + " ..." + getSuccessString(success));

			if (!success){

				state.setUnsuccessfull();

			}

			return;

		} catch (SQLException e) {

			e.printStackTrace();

			logger.error(e.getMessage());

			state.setUnsuccessfull();

			return;

		}

	}

	private void initPreparedStatements(PesiExportState state) throws SQLException {

		initTreeIndexStatement(state);

		initRankExpertsUpdateStmt(state);

		initRankUpdateStatement(state);

	}

	// Prepare TreeIndex-And-KingdomFk-Statement

	private void initTreeIndexStatement(PesiExportState state) throws SQLException {

		Connection connection = state.getConfig().getDestination().getConnection();

		String parentTaxonFk_TreeIndex_KingdomFkSql = "UPDATE Taxon SET ParentTaxonFk = ?, TreeIndex = ? WHERE TaxonId = ?"; 

		parentTaxonFk_TreeIndex_KingdomFkStmt = connection.prepareStatement(parentTaxonFk_TreeIndex_KingdomFkSql);

	}

	private void initRankUpdateStatement(PesiExportState state) throws SQLException {

		Connection connection = state.getConfig().getDestination().getConnection();

		String rankSql = "UPDATE Taxon SET RankFk = ?, RankCache = ?, KingdomFk = ? WHERE TaxonId = ?";

		rankUpdateStmt = connection.prepareStatement(rankSql);

	}

	private void initRankExpertsUpdateStmt(PesiExportState state) throws SQLException {

//		String sql_old = "UPDATE Taxon SET RankFk = ?, RankCache = ?, TypeNameFk = ?, KingdomFk = ?, " +

//				"ExpertFk = ?, SpeciesExpertFk = ? WHERE TaxonId = ?";

		//TODO handle experts GUIDs

		Connection connection = state.getConfig().getDestination().getConnection();

		String sql = "UPDATE Taxon SET RankFk = ?, RankCache = ?, TypeNameFk = ?, KingdomFk = ? " +

				" WHERE TaxonId = ?";

		rankTypeExpertsUpdateStmt = connection.prepareStatement(sql);

	}

	private boolean doPhase01(PesiExportState state, PesiExportMapping mapping) throws SQLException {

		int count = 0;

		int pastCount = 0;

		List<TaxonBase> list;

		boolean success = true;

		// Get the limit for objects to save within a single transaction.

		int limit = state.getConfig().getLimitSave();

		logger.info("PHASE 1: Export Taxa...");

		// Start transaction

		TransactionStatus txStatus = startTransaction(true);

		logger.info("Started new transaction. Fetching some " + pluralString + " (max: " + limit + ") ...");

		int partitionCount = 0;

		while ((list = getNextTaxonPartition(null, limit, partitionCount++)).size() > 0   ) {

			logger.info("Fetched " + list.size() + " " + pluralString + ". Exporting...");

			for (TaxonBase<?> taxon : list) {

				doCount(count++, modCount, pluralString);

				success &= mapping.invoke(taxon);

				TaxonNameBase<?,?> taxonName = taxon.getName();

				validatePhaseOne(taxon, taxonName);

			}

			// Commit transaction

			commitTransaction(txStatus);

			logger.debug("Committed transaction.");

			logger.info("Exported " + (count - pastCount) + " " + pluralString + ". Total: " + count);

			pastCount = count;

			// Start transaction

			txStatus = startTransaction(true);

			logger.info("Started new transaction. Fetching some " + pluralString + " (max: " + limit + ") ...");

		}

		if (list.size() == 0) {

			logger.info("No " + pluralString + " left to fetch.");

		}

		// Commit transaction

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

		return success;

	}

	private void validatePhaseOne(TaxonBase<?> taxon, TaxonNameBase<?, ?> taxonName) {

		// Check whether some rules are violated

		nomenclaturalCode = taxonName.getNomenclaturalCode();

		if (! taxonName.isInstanceOf(NonViralName.class)){

			logger.warn("Viral names can't be validated");

		}

		NonViralName<?> nvn = CdmBase.deproxy(taxonName, NonViralName.class);

		String genusOrUninomial = nvn.getGenusOrUninomial();

		String specificEpithet = nvn.getSpecificEpithet();

		String infraSpecificEpithet = nvn.getInfraSpecificEpithet();

		String infraGenericEpithet = nvn.getInfraGenericEpithet();

		Integer rank = getRankFk(taxonName, nomenclaturalCode);

		if (rank == null) {

			logger.error("Rank was not determined: " + taxon.getUuid() + " (" + taxon.getTitleCache() + ")");

		} else {

			// Check whether infraGenericEpithet is set correctly

			// 1. Childs of an accepted taxon of rank subgenus that are accepted taxa of rank species have to have an infraGenericEpithet

			// 2. Grandchilds of an accepted taxon of rank subgenus that are accepted taxa of rank subspecies have to have an infraGenericEpithet

			int ancestorLevel = 0;

			if (taxonName.getRank().equals(Rank.SUBSPECIES())) {

				// The accepted taxon two rank levels above should be of rank subgenus

				ancestorLevel  = 2;

			}

			if (taxonName.getRank().equals(Rank.SPECIES())) {

				// The accepted taxon one rank level above should be of rank subgenus

				ancestorLevel = 1;

			}

			if (ancestorLevel > 0) {

				if (ancestorOfSpecificRank(taxon, ancestorLevel, Rank.SUBGENUS())) {

					// The child (species or subspecies) of this parent (subgenus) has to have an infraGenericEpithet

					if (infraGenericEpithet == null) {

						logger.warn("InfraGenericEpithet does not exist even though it should for: " + taxon.getUuid() + " (" + taxon.getTitleCache() + ")");

						// maybe the taxon could be named here

					}

				}

			}

			if (infraGenericEpithet == null && rank.intValue() == 190) {

				logger.warn("InfraGenericEpithet was not determined although it should exist for rank 190: " + taxon.getUuid() + " (" + taxon.getTitleCache() + ")");

			}

			if (specificEpithet != null && rank.intValue() < 216) {

				logger.warn("SpecificEpithet was determined for rank " + rank + " although it should only exist for ranks higher or equal to 220: TaxonName " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

			}

			if (infraSpecificEpithet != null && rank.intValue() < 225) {

				String message = "InfraSpecificEpithet '" +infraSpecificEpithet + "' was determined for rank " + rank + " although it should only exist for ranks higher or equal to 230: "  + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")"; 

				if (StringUtils.isNotBlank(infraSpecificEpithet)){

					logger.warn(message);

				}else{

					logger.warn(message);

				}

			}

		}

		if (infraSpecificEpithet != null && specificEpithet == null) {

			logger.warn("An infraSpecificEpithet was determined, but a specificEpithet was not determined: "  + taxon.getUuid() + " (" + taxon.getTitleCache() + ")");

		}

		if (genusOrUninomial == null) {

			logger.warn("GenusOrUninomial was not determined: " + taxon.getUuid() + " (" + taxon.getTitleCache() + ")");

		}

	}

	// 2nd Round: Add ParentTaxonFk, TreeIndex to each Taxon

	private boolean doPhase02(PesiExportState state) {

		boolean success = true;

		List<Classification> classificationList = null;

		logger.info("PHASE 2: Add ParenTaxonFk and TreeIndex...");

		// Specify starting ranks for tree traversing

		rankList.add(Rank.KINGDOM());

		rankList.add(Rank.GENUS());

		// Specify where to stop traversing (value) when starting at a specific Rank (key)

		rank2endRankMap.put(Rank.GENUS(), null); // Since NULL does not match an existing Rank, traverse all the way down to the leaves

		rank2endRankMap.put(Rank.KINGDOM(), Rank.GENUS()); // excludes rank genus

		StringBuffer treeIndex = new StringBuffer();

		// Retrieve list of classifications

		TransactionStatus txStatus = startTransaction(true);

		logger.info("Started transaction. Fetching all classifications...");

		classificationList = getClassificationService().listClassifications(null, 0, null, null);

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

		logger.info("Fetched " + classificationList.size() + " classification(s).");

		setTreeIndexAnnotationType(getAnnotationType(uuidTreeIndex, "TreeIndex", "", "TI"));

		for (Classification classification : classificationList) {

			for (Rank rank : rankList) {

				txStatus = startTransaction(true);

				logger.info("Started transaction to fetch all rootNodes specific to Rank " + rank.getLabel() + " ...");

				List<TaxonNode> rankSpecificRootNodes = getClassificationService().loadRankSpecificRootNodes(classification, rank, null);

				logger.info("Fetched " + rankSpecificRootNodes.size() + " RootNodes for Rank " + rank.getLabel());

				commitTransaction(txStatus);

				logger.debug("Committed transaction.");

				for (TaxonNode rootNode : rankSpecificRootNodes) {

					txStatus = startTransaction(false);

					Rank endRank = rank2endRankMap.get(rank);

					if (endRank != null) {

						logger.debug("Started transaction to traverse childNodes of rootNode (" + rootNode.getUuid() + ") till Rank " + endRank.getLabel() + " ...");

					} else {

						logger.debug("Started transaction to traverse childNodes of rootNode (" + rootNode.getUuid() + ") till leaves are reached ...");

					}

					TaxonNode newNode = getTaxonNodeService().load(rootNode.getUuid());

					if (isPesiTaxon(newNode.getTaxon())){

						TaxonNode parentNode = newNode.getParent();

						if (rank.equals(Rank.KINGDOM())) {

							treeIndex = new StringBuffer();

							treeIndex.append("#");

						} else {

							// Get treeIndex from parentNode

							if (parentNode != null) {

								boolean annotationFound = false;

								Set<Annotation> annotations = parentNode.getAnnotations();

								for (Annotation annotation : annotations) {

									AnnotationType annotationType = annotation.getAnnotationType();

									if (annotationType != null && annotationType.equals(getTreeIndexAnnotationType())) {

										treeIndex = new StringBuffer(CdmUtils.Nz(annotation.getText()));

										annotationFound = true;

	//									logger.error("treeIndex: " + treeIndex);

										break;

									}

								}

								if (!annotationFound) {

									// This should not happen because it means that the treeIndex was not set correctly as an annotation to parentNode

									logger.error("TreeIndex could not be read from annotation of TaxonNode: " + parentNode.getUuid() + ", Taxon: " + parentNode.getTaxon().getUuid());

									treeIndex = new StringBuffer();

									treeIndex.append("#");

								}

							} else {

								// TreeIndex could not be determined, but it's unclear how to proceed to generate a correct treeIndex if the parentNode is NULL

								logger.error("ParentNode for RootNode is NULL. TreeIndex could not be determined: " + newNode.getUuid());

								treeIndex = new StringBuffer(); // This just prevents growing of the treeIndex in a wrong manner

								treeIndex.append("#");

							}

						}

						nomenclaturalCode = newNode.getTaxon().getName().getNomenclaturalCode();

						kingdomFk = PesiTransformer.nomenClaturalCode2Kingdom(nomenclaturalCode);

						traverseTree(newNode, parentNode, treeIndex, endRank, state);

					}else{

						logger.debug("Taxon is not a PESI taxon: " + newNode.getTaxon().getUuid());

					}

					commitTransaction(txStatus);

					logger.debug("Committed transaction.");

				}

			}

		}

		return success;

	}	

	//PHASE 3: Add Rank data, KingdomFk, TypeNameFk, expertFk and speciesExpertFk...

	private boolean doPhase03(PesiExportState state) {

		int count = 0;

		int pastCount = 0;

		boolean success = true;

		// Get the limit for objects to save within a single transaction.

		int limit = state.getConfig().getLimitSave();

		List<TaxonBase> list;

		logger.info("PHASE 3: Add Rank data, KingdomFk, TypeNameFk, expertFk and speciesExpertFk...");

		// Be sure to add rank information, KingdomFk, TypeNameFk, expertFk and speciesExpertFk to every taxonName

		// Start transaction

		TransactionStatus txStatus = startTransaction(true);

		logger.info("Started new transaction. Fetching some " + pluralString + " (max: " + limit + ") ...");

		int partitionCount = 0;

		while ((list = getNextTaxonPartition(null, limit, partitionCount++)).size() > 0) {

			logger.info("Fetched " + list.size() + " " + pluralString + ". Exporting...");

			for (TaxonBase<?> taxon : list) {

				TaxonNameBase<?,?> taxonName = taxon.getName();

				// Determine expertFk

				Integer expertFk = makeExpertFk(state, taxonName);

				// Determine speciesExpertFk

				Integer speciesExpertFk = makeSpeciesExpertFk(state, taxonName);

				doCount(count++, modCount, pluralString);

				Integer typeNameFk = getTypeNameFk(taxonName, state);

				//TODO why are expertFks needed? (Andreas M.)

//				if (expertFk != null || speciesExpertFk != null) {

					invokeRankDataAndTypeNameFkAndKingdomFk(taxonName, nomenclaturalCode, state.getDbId(taxon), 

							typeNameFk, kingdomFk, expertFk, speciesExpertFk);

//				}

			}

			// Commit transaction

			commitTransaction(txStatus);

			logger.debug("Committed transaction.");

			logger.info("Exported " + (count - pastCount) + " " + pluralString + ". Total: " + count);

			pastCount = count;

			// Start transaction

			txStatus = startTransaction(true);

			logger.info("Started new transaction. Fetching some " + pluralString + " (max: " + limit + ") ...");

		}

		if (list.size() == 0) {

			logger.info("No " + pluralString + " left to fetch.");

		}

		// Commit transaction

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

		return success;

	}

	private Integer makeSpeciesExpertFk(PesiExportState state, TaxonNameBase<?, ?> taxonName) {

		List<Reference> referenceList;

		Integer speciesExpertFk = null;

		String speciesExpertUserId = getSpeciesExpertUserId(taxonName);

		if (speciesExpertUserId != null) {

			// The speciesExpertUserId was stored in the field 'title' of the corresponding Reference during FaEu import

			referenceList = getReferenceService().listByReferenceTitle(null, speciesExpertUserId, MatchMode.EXACT, null, null, null, null, null);

			if (referenceList.size() == 1) {

				speciesExpertFk  = getSpeciesExpertFk(referenceList.iterator().next(), state);

			} else if (referenceList.size() > 1) {

				logger.error("Found more than one match using listByTitle() searching for a Reference with this speciesExpertUserId as title: " + speciesExpertUserId);

			} else if (referenceList.size() == 0) {

				logger.error("Found no match using listByReferenceTitle() searching for a Reference with this speciesExpertUserId as title: " + speciesExpertUserId);

			}

		} else {

			logger.debug("SpeciesExpertName is NULL for this TaxonName: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

		}

		return speciesExpertFk;

	}

	private Integer makeExpertFk(PesiExportState state,

			TaxonNameBase<?, ?> taxonName) {

		List<Reference> referenceList;

		Integer expertFk = null;

		String expertUserId = getExpertUserId(taxonName);

		if (expertUserId != null) {

			// The expertUserId was stored in the field 'title' of the corresponding Reference during FaEu import

			referenceList = getReferenceService().listByReferenceTitle(null, expertUserId, MatchMode.EXACT, null, null, null, null, null);

			if (referenceList.size() == 1) {

				expertFk  = getExpertFk(referenceList.iterator().next(), state);

			} else if (referenceList.size() > 1) {

				logger.error("Found more than one match using listByReferenceTitle() searching for a Reference with this expertUserId as title: " + expertUserId);

			} else if (referenceList.size() == 0) {

				logger.error("Found no match using listByReferenceTitle() searching for a Reference with this expertUserId as title: " + expertUserId);

			}

		} else {

			logger.debug("ExpertName is NULL for this TaxonName: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

		}

		return expertFk;

	}

	//	"PHASE 4: Creating Inferred Synonyms..."

	private boolean doPhase04(PesiExportState state, PesiExportMapping mapping) throws SQLException {

		int count;

		int pastCount;

		boolean success = true;

		// Get the limit for objects to save within a single transaction.

		int limit = state.getConfig().getLimitSave();

		// Create inferred synonyms for accepted taxa

		logger.info("PHASE 4: Creating Inferred Synonyms...");

		// Determine the count of elements in datawarehouse database table Taxon

		Integer currentTaxonId = determineTaxonCount(state);

		currentTaxonId++;

		count = 0;

		pastCount = 0;

		int pageSize = limit;

		int pageNumber = 1;

		String inferredSynonymPluralString = "Inferred Synonyms";

		// Start transaction

		Classification classification = null;

		Taxon acceptedTaxon = null;

		TransactionStatus txStatus = startTransaction(true);

		logger.info("Started new transaction. Fetching some " + parentPluralString + " first (max: " + limit + ") ...");

		List<TaxonBase> taxonList = null;

		List<Synonym> inferredSynonyms = null;

		while ((taxonList  = getTaxonService().listTaxaByName(Taxon.class, "*", "*", "*", "*", null, pageSize, pageNumber)).size() > 0) {

			HashMap<Integer, TaxonNameBase<?,?>> inferredSynonymsDataToBeSaved = new HashMap<Integer, TaxonNameBase<?,?>>();

			logger.info("Fetched " + taxonList.size() + " " + parentPluralString + ". Exporting...");

			for (TaxonBase<?> taxonBase : taxonList) {

				if (taxonBase.isInstanceOf(Taxon.class)) { // this should always be the case since we should have fetched accepted taxon only, but you never know...

					acceptedTaxon = CdmBase.deproxy(taxonBase, Taxon.class);

					TaxonNameBase<?,?> taxonName = acceptedTaxon.getName();

					if (taxonName.isInstanceOf(ZoologicalName.class)) {

						nomenclaturalCode  = taxonName.getNomenclaturalCode();

						kingdomFk = PesiTransformer.nomenClaturalCode2Kingdom(nomenclaturalCode);

						Set<TaxonNode> taxonNodes = acceptedTaxon.getTaxonNodes();

						TaxonNode singleNode = null;

						if (taxonNodes.size() > 0) {

							// Determine the classification of the current TaxonNode

							singleNode = taxonNodes.iterator().next();

							if (singleNode != null) {

								classification = singleNode.getClassification();

							} else {

								logger.error("A TaxonNode belonging to this accepted Taxon is NULL: " + acceptedTaxon.getUuid() + " (" + acceptedTaxon.getTitleCache() +")");

							}

						} else {

							// Classification could not be determined directly from this TaxonNode

							// The stored classification from another TaxonNode is used. It's a simple, but not a failsafe fallback solution.

							if (classification == null) {

								logger.error("Classification could not be determined directly from this TaxonNode: " + singleNode.getUuid() + "). " +

										"This classification stored from another TaxonNode is used: " + classification.getTitleCache());

							}

						}

						if (classification != null) {

							inferredSynonyms  = getTaxonService().createAllInferredSynonyms(classification, acceptedTaxon);

//								inferredSynonyms = getTaxonService().createInferredSynonyms(classification, acceptedTaxon, SynonymRelationshipType.INFERRED_GENUS_OF());

							if (inferredSynonyms != null) {

								for (Synonym synonym : inferredSynonyms) {

									TaxonNameBase<?,?> synonymName = synonym.getName();

									if (synonymName != null) {

										// Both Synonym and its TaxonName have no valid Id yet

										synonym.setId(currentTaxonId++);

										synonymName.setId(currentTaxonId++);

										doCount(count++, modCount, inferredSynonymPluralString);

										success &= mapping.invoke(synonymName);

										// Add Rank Data and KingdomFk to hashmap for later saving

										inferredSynonymsDataToBeSaved.put(synonymName.getId(), synonymName);

									} else {

										logger.error("TaxonName of this Synonym is NULL: " + synonym.getUuid() + " (" + synonym.getTitleCache() + ")");

									}

								}

							}

						} else {

							logger.error("Classification is NULL. Inferred Synonyms could not be created for this Taxon: " + acceptedTaxon.getUuid() + " (" + acceptedTaxon.getTitleCache() + ")");

						}

					} else {

//							logger.error("TaxonName is not a ZoologicalName: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

					}

				} else {

					logger.error("This TaxonBase is not a Taxon even though it should be: " + taxonBase.getUuid() + " (" + taxonBase.getTitleCache() + ")");

				}

			}

			// Commit transaction

			commitTransaction(txStatus);

			logger.debug("Committed transaction.");

			logger.info("Exported " + (count - pastCount) + " " + inferredSynonymPluralString + ". Total: " + count);

			pastCount = count;

			// Save Rank Data and KingdomFk for inferred synonyms

			for (Integer taxonFk : inferredSynonymsDataToBeSaved.keySet()) {

				invokeRankDataAndKingdomFk(inferredSynonymsDataToBeSaved.get(taxonFk), nomenclaturalCode, taxonFk, kingdomFk);

			}

			// Start transaction

			txStatus = startTransaction(true);

			logger.info("Started new transaction. Fetching some " + parentPluralString + " first (max: " + limit + ") ...");

			// Increment pageNumber

			pageNumber++;

		}

		if (taxonList.size() == 0) {

			logger.info("No " + parentPluralString + " left to fetch.");

		}

		// Commit transaction

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

		return success;

	}

	/**

	 * Handles names that do not appear in taxa

	 * @param state

	 * @param mapping

	 * @return

	 */

	private boolean doNames(PesiExportState state)  throws SQLException {

		boolean success;