EDIT

// $Id$

/**

* Copyright (C) 2009 EDIT

* 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.

*/

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

	private PreparedStatement rankUpdateStmt;

	private NomenclaturalCode nomenclaturalCode;

	private Integer kingdomFk;

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

	private AnnotationType treeIndexAnnotationType;

	private static ExtensionType lastActionExtensionType;

	public static NonViralNameDefaultCacheStrategy<?> nonViralNameStrategy = NonViralNameDefaultCacheStrategy.NewInstance();

	public static NonViralNameDefaultCacheStrategy<?> bacterialNameStrategy = BacterialNameDefaultCacheStrategy.NewInstance();

	private static int currentTaxonId;

	/**

	 * @return the treeIndexAnnotationType

	 */

		boolean result = true;

		return result;

	}

	/* (non-Javadoc)

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

	 */

			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();

			PesiExportMapping synonymRelMapping = getSynRelMapping();

			// Initialize the db mapper

			mapping.initialize(state);

			synonymRelMapping.initialize(state);

			additionalSourceMapping.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);

			//Export Taxa..

			success &= doPhase01(state, mapping, additionalSourceMapping);

			//"PHASE 1b: Handle names without taxa ...

			success &= doNames(state, additionalSourceMapping);

			// 2nd Round: Add ParentTaxonFk to each taxon

			success &= doPhase02(state);

			//PHASE 3: Add Rank data, KingdomFk, TypeNameFk ...

			success &= doPhase03(state);

			// 4nd Round: Add TreeIndex to each taxon

			success &= doPhase04(state);

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

			success &= doPhase05(state, mapping, synonymRelMapping);

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

			if (!success){

		}

	}

	private void initPreparedStatements(PesiExportState state) throws SQLException {

		initTreeIndexStatement(state);

		initRankExpertsUpdateStmt(state);

		initRankUpdateStatement(state);

		initParentFkStatement(state);

	}

	// Prepare TreeIndex-And-KingdomFk-Statement

	private void initTreeIndexStatement(PesiExportState state) throws SQLException {

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

		parentTaxonFk_TreeIndex_KingdomFkStmt = connection.prepareStatement(parentTaxonFk_TreeIndex_KingdomFkSql);

	}

	// Prepare TreeIndex-And-KingdomFk-Statement

	private void initParentFkStatement(PesiExportState state) throws SQLException {

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

		parentTaxonFkStmt = connection.prepareStatement(parentTaxonFkSql);

	}

	private void initRankUpdateStatement(PesiExportState state) throws SQLException {

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

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

//				"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);

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

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

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

		// Start transaction

		TransactionStatus txStatus = startTransaction(true);

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

		int partitionCount = 0;

		logger.info("Taking snapshot at the beginning of phase 1 of taxonExport");

		while ((list = getNextTaxonPartition(null, limit, partitionCount++, null)) != null   ) {

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

			for (TaxonBase<?> taxon : list) {

				doCount(count++, modCount, pluralString);

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

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

				if (! nvn.isProtectedTitleCache()){

				}

				if (! nvn.isProtectedNameCache()){

				}

				if (! nvn.isProtectedFullTitleCache()){

				}

				if (! nvn.isProtectedAuthorshipCache()){

				}

				//core mapping

				success &= mapping.invoke(taxon);

				//additional source

				if (nvn.getNomenclaturalReference() != null || StringUtils.isNotBlank(nvn.getNomenclaturalMicroReference() )){

					additionalSourceMapping.invoke(taxon);

				}

				validatePhaseOne(taxon, nvn);

				taxon = null;

				nvn = null;

				taxonName = null;

			}

			// Commit transaction

			commitTransaction(txStatus);

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

			pastCount = count;

			/*logger.warn("Taking snapshot at the end of the loop of phase 1 of taxonExport");

			*/

			// Start transaction

			txStatus = startTransaction(true);

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

		}

		if (list == null ) {

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

		}

		// Commit transaction

		commitTransaction(txStatus);

		txStatus = null;

		String infraSpecificEpithet = taxonName.getInfraSpecificEpithet();

		String infraGenericEpithet = taxonName.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

					}

				}

			}

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

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

			}

				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) {

				if (StringUtils.isNotBlank(infraSpecificEpithet)){

					logger.warn(message);

				}else{

		}

	}

	/**

	 * 2nd Round: Add ParentTaxonFk to each taxon and add Biota if not exists

	 * @param state

			logger.info ("Ignore PHASE 2: Make ParentFk and Biota...");

			return success;

		}

		List<Taxon> list;

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

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

		insertBiota(state);

		logger.info("PHASE 2: Make ParentFk and Biota ... limit is " + limit);

		// Start transaction

		TransactionStatus txStatus = startTransaction(true);

//		ProfilerController.memorySnapshot();

		while ((list = getNextTaxonPartition(Taxon.class, limit, partitionCount++, null)) != null   ) {

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

			for (Taxon taxon : list) {

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

					doCount(count++, modCount, pluralString);

					TaxonNode parentNode = node.getParent();

					if (parentNode != null && parentNode.getTaxon() != null){  //new root node handling requires has root taxon with taxon == null

						int parentId = state.getDbId(parentNode.getTaxon());

						success &= invokeParentTaxonFk(parentId, childId);

					}

				}

			}

			// Commit transaction

			commitTransaction(txStatus);

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

			// Start transaction

			txStatus = startTransaction(true);

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

		}

		if (list == null ) {

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

		list = null;

		// Commit transaction

		commitTransaction(txStatus);

		return success;

	}

	/**

		} catch (SQLException e) {

			logger.warn ("Biota could not be requested or inserted");

		}

	}

	// 4th round: Add TreeIndex to each taxon

	private boolean doPhase04(PesiExportState state) {

		boolean success = true;

		logger.info("PHASE 4: Make TreeIndex ... ");

		String sql = " UPDATE Taxon SET ParentTaxonFk = (Select TaxonId from Taxon where RankFk = 0) " +

				" WHERE (RankFk = 10) and TaxonStatusFk = 1 ";

		state.getConfig().getDestination().update(sql);

		state.getConfig().getDestination().update("EXEC dbo.recalculateallstoredpaths");

		return success;

	}

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

	private boolean doPhase02_OLD(PesiExportState state) {

		boolean success = true;

			logger.info ("Ignore PHASE 2: ParentTaxonFk and TreeIndex");

			return success;

		}

		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 for parentFk and treeIndex. Fetching all classifications...");

		List<TaxonNode> rankSpecificRootNodes;

		for (Classification classification : classificationList) {

			for (Rank rank : rankList) {

				txStatus = startTransaction(true);

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

					}else{

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

					}

					newNode = null;

					try {

						commitTransaction(txStatus);

						logger.debug("Committed transaction.");

				}

				rankSpecificRootNodes = null;

			}

		}

		logger.warn("Taking snapshot at the end of phase 2 of taxonExport");

		return success;

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

	private boolean doPhase03(PesiExportState state) {

		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 for rank, kingdom, typeName, expertFk and speciesExpertFK. Fetching some " + pluralString + " (max: " + limit + ") ...");

				doCount(count++, modCount, pluralString);

				Integer typeNameFk = getTypeNameFk(taxonName, state);

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

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

							typeNameFk, kingdomFk, state);

//				}

					taxon = null;

					taxonName = null;

			}

		if (list == null) {

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

		}

		list = null;

		// Commit transaction

		commitTransaction(txStatus);

		logger.debug("Committed transaction.");

		logger.debug("Try to take snapshot at the end of phase 3 of taxonExport, number of partitions: " + partitionCount);

		return success;

	}

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

		int count;

		int pastCount;

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

			return success;

		}

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

		// Create inferred synonyms for accepted taxa

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

		count = 0;

		pastCount = 0;

		int pageNumber = 1;

		String inferredSynonymPluralString = "Inferred Synonyms";

		// Start transaction

		TransactionStatus txStatus = startTransaction(true);

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

		List<TaxonBase> taxonList = null;

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

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

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

			inferredSynonymsDataToBeSaved.putAll(createInferredSynonymsForTaxonList(state, mapping,

					synRelMapping, taxonList));

			doCount(count += taxonList.size(), modCount, inferredSynonymPluralString);

			// Commit transaction

			commitTransaction(txStatus);

			logger.debug("Committed transaction.");

			logger.info("Exported " + (taxonList.size()) + " " + 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, state);

			// Start transaction

			txStatus = startTransaction(true);

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

			// Increment pageNumber

			pageNumber++;

		}

			logger.debug("Committed transaction.");

			logger.info("Exported " + taxonList.size()+ " " + 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, state);

			// 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.");

		}

		taxonList = null;

//		logger.warn("Taking snapshot at the end of phase 4 of taxonExport");

//		ProfilerController.memorySnapshot();

		// Commit transaction

		commitTransaction(txStatus);

		System.gc();

		logger.debug("Taking snapshot at the end of phase 4 after gc() of taxonExport");

		logger.debug("Committed transaction.");

		return success;

	}

	 */

	private HashMap<Integer, TaxonNameBase<?, ?>> createInferredSynonymsForTaxonList(PesiExportState state,

			PesiExportMapping mapping, PesiExportMapping synRelMapping,	 List<TaxonBase> taxonList) {

		Taxon acceptedTaxon;

		Classification classification = null;

		List<Synonym> inferredSynonyms = null;

		boolean localSuccess = true;

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

		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();

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

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

							//logger.error("Classification could not be determined directly from this Taxon: " + acceptedTaxon.getUuid() + " is misapplication? "+acceptedTaxon.isMisapplication()+ "). The classification of the last taxon is used");

						}

					}

					if (classification != null) {

						try{

							TaxonNameBase name = acceptedTaxon.getName();

									synonym.addMarker(Marker.NewInstance(markerType, true));

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

									synonym.setId(currentTaxonId++);

									localSuccess &= mapping.invoke(synonym);

									//get SynonymRelationship and export

									if (synonym.getSynonymRelations().isEmpty() ){

										IdentifiableSource source = synonym.getSources().iterator().next();

										if (source.getIdNamespace().contains("Potential combination")){

											synRel = acceptedTaxon.addSynonym(synonym, SynonymRelationshipType.POTENTIAL_COMBINATION_OF());

											synRel = acceptedTaxon.addSynonym(synonym, SynonymRelationshipType.INFERRED_SYNONYM_OF());

											logger.error(synonym.getTitleCache() + " has no synonym relationship to " + acceptedTaxon.getTitleCache() + " type is set to inferred synonym");

										}

										localSuccess &= synRelMapping.invoke(synRel);

										if (!localSuccess) {

											logger.error("Synonym relationship export failed " + synonym.getTitleCache() + " accepted taxon: " + acceptedTaxon.getUuid() + " (" + acceptedTaxon.getTitleCache()+")");

											synRel = null;

										}

									}

									inferredSynonymsDataToBeSaved.put(synonym.getId(), synonym.getName());

								}

							}

		taxonList = null;

		return inferredSynonymsDataToBeSaved;

	}

	/**

	 * Handles names that do not appear in taxa

	 * @return

	 */

	private boolean doNames(PesiExportState state, PesiExportMapping additionalSourceMapping)  throws SQLException {

		boolean success = true;

		if (! state.getConfig().isDoPureNames()){

			logger.info ("Ignore PHASE 1b: PureNames");

			return success;

		}

		try {

			PesiExportMapping mapping = getPureNameMapping(state);

			mapping.initialize(state);

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

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

			logger.info("PHASE 1b: Export Pure Names ...");

			// Start transaction

			TransactionStatus txStatus = startTransaction(true);

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

			int partitionCount = 0;

			while ((list = getNextPureNamePartition(null, limit, partitionCount++)) != null   ) {

	 */

	private Integer determineTaxonCount(PesiExportState state) {

		Integer result = null;

		String sql;

		Source destination =  pesiConfig.getDestination();

		sql = "SELECT max(taxonId) FROM Taxon";

		resultSet = null;

		return result;

	}

	/**

	 * Checks whether a parent at specific level has a specific Rank.

	 * @param taxonName A {@link TaxonNameBase TaxonName}.

					Rank childRank = childName.getRank();

					if (childRank != null) {

						if (! childRank.equals(fetchLevel)) {

							localTreeIndex.append(taxonId + "#");

							saveData(childNode, parentNode, localTreeIndex, state, taxonId);

							// Store treeIndex as annotation for further use

							Annotation annotation = Annotation.NewInstance(localTreeIndex.toString(), getTreeIndexAnnotationType(), Language.DEFAULT());

							childNode.addAnnotation(annotation);

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

								if (newNode.getTaxon() != null && isPesiTaxon(newNode.getTaxon())){

									traverseTree(newNode, childNode, localTreeIndex, fetchLevel, state);

								}

							}

						} else {

	//						logger.debug("Target Rank " + fetchLevel.getLabel() + " reached");

							return;

					logger.error("Taxon can not be found in state: " + childTaxon.getUuid() + " (" + childTaxon.getTitleCache() + ")");

				}

			}else{

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

				}

			}

			TaxonBase<?> parentTaxon = null;

			if (parentNode != null) {

				parentTaxon = parentNode.getTaxon();

			}

			invokeParentTaxonFkAndTreeIndex(state.getDbId(parentTaxon), currentTaxonFk,	treeIndex);

		}

	}

	/**

			} else {

				parentTaxonFk_TreeIndex_KingdomFkStmt.setObject(3, null);

			}

			parentTaxonFk_TreeIndex_KingdomFkStmt.executeUpdate();

			return true;

		} catch (SQLException e) {

			return false;

		}

	}

	protected boolean invokeParentTaxonFk(Integer parentId, Integer childId) {

		try {

			parentTaxonFkStmt.setInt(1, parentId);

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	 * @param nomenclaturalCode The {@link NomenclaturalCode NomenclaturalCode}.

	 * @param taxonFk The TaxonFk to store the values for.

	 * @param kindomFk The KingdomFk.

	 * @return Whether save was successful or not.

	 */

			} else {

				rankUpdateStmt.setObject(1, null);

			}

			String rankCache = getRankCache(taxonName, nomenclaturalCode, state);

			if (rankCache != null) {

				rankUpdateStmt.setString(2, rankCache);

			} else {

				rankUpdateStmt.setObject(2, null);

			}

			if (kingdomFk != null) {

				rankUpdateStmt.setInt(3, kingdomFk);

			} else {

				rankUpdateStmt.setObject(3, null);

			}

			if (taxonFk != null) {

				rankUpdateStmt.setInt(4, taxonFk);

			} else {

				rankUpdateStmt.setObject(4, null);

			}

			rankUpdateStmt.executeUpdate();

			return true;

		} catch (SQLException e) {

	 * @param nomenclaturalCode The {@link NomenclaturalCode NomenclaturalCode}.

	 * @param taxonFk The TaxonFk to store the values for.

	 * @param typeNameFk The TypeNameFk.

	 * @param kindomFk The KingdomFk.

	 * @param expertFk The ExpertFk.

	 * @param speciesExpertFk The SpeciesExpertFk.

	 * @return Whether save was successful or not.

	 */

			Integer taxonFk, Integer typeNameFk, Integer kingdomFkk, PesiExportState state) {

		try {

			int index = 1;

			} else {

				rankTypeExpertsUpdateStmt.setObject(index++, null);

			}

			String rankCache = getRankCache(taxonName, nomenclaturalCode, state);

			if (rankCache != null) {

				rankTypeExpertsUpdateStmt.setString(index++, rankCache);

			} else {

				rankTypeExpertsUpdateStmt.setObject(index++, null);

			}

			if (typeNameFk != null) {

				rankTypeExpertsUpdateStmt.setInt(index++, typeNameFk);

			} else {

				rankTypeExpertsUpdateStmt.setObject(index++, null);

			}

			} else {

				rankTypeExpertsUpdateStmt.setObject(index++, null);

			}

//			if (expertFk != null) {

//				rankTypeExpertsUpdateStmt.setInt(5, expertFk);

//			} else {

//			} else {

//				rankTypeExpertsUpdateStmt.setObject(6, null);

//			}

			if (taxonFk != null) {

				rankTypeExpertsUpdateStmt.setInt(index++, taxonFk);

			} else {

	 * @return Whether the delete operation was successful or not.

	 */

	protected boolean doDelete(PesiExportState state) {

		String sql;

		Source destination =  pesiConfig.getDestination();

		return ! state.getConfig().isDoTaxa();

	}

	/**

	 * Creates the kingdom fk.

	 * @param taxonName

	private static Integer getKingdomFk(TaxonNameBase taxonName){

		return PesiTransformer.nomenClaturalCode2Kingdom(taxonName.getNomenclaturalCode());

	}

	/**

	 * Creates the parent fk.

	 * @param taxonName

	private static Integer getRankFk(TaxonNameBase<?,?> taxonName) {

		return getRankFk(taxonName, taxonName.getNomenclaturalCode());

	}

	/**

	 * Returns the <code>RankFk</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

		return getRankCache(taxonName, taxonName.getNomenclaturalCode(), state);

	}

	/**

	 * Returns the <code>RankCache</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	 * @param nomenclaturalCode The {@link NomenclaturalCode NomenclaturalCode}.

	 * @return The <code>RankCache</code> attribute.

	 * @see MethodMapper

	 */

			logger.warn("No nomenclatural code defined for name " + taxonName.getUuid());

			return null;

		}

	}

	/**

	 * Returns the <code>DisplayName</code> attribute.

	 * @param taxon The {@link TaxonBase Taxon}.

		}

		return result;

	}

	/**

	 * Returns the <code>AuthorString</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

				isNonViralName = true;

			}

			result = authorshipCache;

			// For a misapplied names there are special rules

			if (isMisappliedName(taxon)){

				if (taxon.getSec() != null){

//					result = authorshipCache;

				}

			}

			if (taxonName == null){

				logger.warn("TaxonName does not exist for taxon: " + taxon.getUuid() + " (" + taxon.getTitleCache() + ")");

			}else if (! isNonViralName){

				logger.warn("TaxonName is not of instance NonViralName: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

			}

			if (StringUtils.isBlank(result)) {

				return null;

			} else {

			e.printStackTrace();

			return null;

		}

	}

	/**

	 * Returns the <code>DisplayName</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

			HTMLTagRules tagRules = new HTMLTagRules().

					addRule(TagEnum.name, "i").

					addRule(TagEnum.nomStatus, "@status@");

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

			String result = cacheStrategy.getFullTitleCache(nvn, tagRules);

			cacheStrategy = null;

			return result.replaceAll(",?\\<@status@\\>.*\\</@status@\\>", "");

		}

	}

	@SuppressWarnings("unused")

	private static String getGUID(TaxonNameBase<?,?> taxonName) {

		UUID uuid = taxonName.getUuid();

		String result = "NameUUID:" + uuid.toString();

		return result;

	}

	/**

	 * Returns the <code>WebShowName</code> attribute for a taxon.

		}

		return result;

	}

	/**

	 * Returns the <code>WebShowName</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

			return null;

		}else{

			INonViralNameCacheStrategy<NonViralName<?>> cacheStrategy = getCacheStrategy(taxonName);

			HTMLTagRules tagRules = new HTMLTagRules().addRule(TagEnum.name, "i");

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

			String result = cacheStrategy.getTitleCache(nvn, tagRules);

		}

	}

	/**

	 * Returns the <code>WebSearchName</code> attribute.

	 * @param taxonName The {@link NonViralName NonViralName}.

		nvn = null;

		return result;

	}

	/**

	 * Returns the SourceNameCache for the AdditionalSource table

	 * @param taxonName

			if (nomRef != null){

				return nomRef.getAbbrevTitleCache();

			}

		}

		return null;

	}

	/**

	 * Returns the <code>FullName</code> attribute.

	 * @param taxon The {@link TaxonBase taxon}.

		if (isMisappliedName(taxon)){

			result = result + " " + getAuthorString(taxon);

		}

		return result;

	}

*/

	/**

	 * Returns the nomenclatural reference which is the reference

	 * including the detail (microreference).

		}

		return ref.getNomenclaturalCitation(taxonName.getNomenclaturalMicroReference());

	}

	/**

	 * Returns the <code>NameStatusFk</code> attribute.

		}

		return result;

	}

	/**

	 * Returns the <code>NameStatusCache</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	 * @return The <code>NameStatusCache</code> attribute.

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

		}

		return result;

	}

	private static NomenclaturalStatus getNameStatus(TaxonNameBase<?,?> taxonName) {

		try {

			if (taxonName != null && (taxonName.isInstanceOf(NonViralName.class))) {

					logger.error("This TaxonName has more than one Nomenclatural Status: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

				}

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

	 */

	private static Integer getTaxonStatusFk(TaxonBase<?> taxon, PesiExportState state) {

		Integer result = null;

		try {

			if (isMisappliedName(taxon)) {

				Synonym synonym = Synonym.NewInstance(null, null);

				// This works as long as only the instance is important to differentiate between TaxonStatus.

				result = PesiTransformer.taxonBase2statusFk(synonym); // Auct References are treated as Synonyms in Datawarehouse now.

			} else {

				result = PesiTransformer.taxonBase2statusFk(taxon);

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return result;

	}

	/**

	 * Returns the <code>TaxonStatusCache</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	 * @param state The {@link PesiExportState PesiExportState}.

	 * @return The <code>TaxonStatusCache</code> attribute.

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getTaxonStatusCache(TaxonBase<?> taxon, PesiExportState state) throws UndefinedTransformerMethodException {

		return state.getTransformer().getTaxonStatusCacheByKey(getTaxonStatusFk(taxon, state));

	}

	/**

	 * Returns the <code>TypeNameFk</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

		}

		return result;

	}

	/**

	 * Returns the <code>TypeFullnameCache</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	@SuppressWarnings("unused")

	private static String getTypeFullnameCache(TaxonNameBase<?,?> taxonName) {

		String result = null;

		try {

		if (taxonName != null) {

			Set<NameTypeDesignation> nameTypeDesignations = taxonName.getNameTypeDesignations();

				logger.warn("This TaxonName has " + nameTypeDesignations.size() + " NameTypeDesignations: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

			}

		}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return result;

	}

	/**

	 * Returns the <code>QualityStatusFk</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

		return PesiTransformer.getQualityStatusKeyBySource(sources, taxonName);

	}

	/**

	 * Returns the <code>QualityStatusCache</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	 * @return The <code>QualityStatusCache</code> attribute.

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

		return state.getTransformer().getQualityStatusCacheByKey(getQualityStatusFk(taxonName));

	}

	/**

	 * Returns the <code>TypeDesignationStatusFk</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	@SuppressWarnings("unused")

	private static Integer getTypeDesignationStatusFk(TaxonNameBase<?,?> taxonName) {

		Integer result = null;

		try {

		if (taxonName != null) {

			Set<NameTypeDesignation> typeDesignations = taxonName.getNameTypeDesignations();

				logger.error("Found a TaxonName with more than one NameTypeDesignation: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

			}

		}

		} catch (Exception e) {

			e.printStackTrace();

		}

	@SuppressWarnings("unused")

	private static String getTypeDesignationStatusCache(TaxonNameBase<?,?> taxonName) {

		String result = null;

		try {

		if (taxonName != null) {

			Set<NameTypeDesignation> typeDesignations = taxonName.getNameTypeDesignations();

				logger.error("Found a TaxonName with more than one NameTypeDesignation: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

			}

		}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return result;

	}

	/**

	 * Returns the <code>FossilStatusFk</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	@SuppressWarnings("unused")

	private static Integer getFossilStatusFk(IdentifiableEntity<?> identEntity, PesiExportState state) {

		Integer result = null;

		Set<String> fossilStatuus = identEntity.getExtensions(ErmsTransformer.uuidFossilStatus);

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

			return null;

			logger.warn("More than 1 fossil status given for " +  identEntity.getTitleCache() + " " + identEntity.getUuid());

		}

		String fossilStatus = fossilStatuus.iterator().next();

		int statusFk = state.getTransformer().FossilStatusCache2FossilStatusFk(fossilStatus);

		return statusFk;

	}

	/**

	 * Returns the <code>FossilStatusCache</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

		}

		return result;

	}

	/**

	 * Returns the <code>IdInSource</code> attribute.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	@SuppressWarnings("unused")

	private static String getIdInSource(IdentifiableEntity taxonName) {

		String result = null;

		try {

			Set<IdentifiableSource> sources = getPesiSources(taxonName);

			if (sources.size() > 1){

				}else{

					if (logger.isDebugEnabled()){logger.debug("Not a PESI source");};

				}

				String sourceIdNameSpace = source.getIdNamespace();

				if (sourceIdNameSpace != null) {

					if (sourceIdNameSpace.equals(PesiTransformer.STR_NAMESPACE_NOMINAL_TAXON)) {

						result =  idInSource != null ? ("Inferred genus from TAX_ID: " + source.getIdInSource()):null;

					} else if (sourceIdNameSpace.equals(TaxonServiceImpl.POTENTIAL_COMBINATION_NAMESPACE)) {

						result =  idInSource != null ? ("Potential combination from TAX_ID: " + source.getIdInSource()):null;

				}

				if (result == null) {

					logger.warn("IdInSource is NULL for this taxonName: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() +", sourceIdNameSpace: " + source.getIdNamespace()+")");

		}

		return result;

	}

	/**

	 * Returns the idInSource for a given TaxonName only.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

	 */

	private static String getIdInSourceOnly(IdentifiableEntity identEntity) {

		String result = null;

		// Get the sources first

		Set<IdentifiableSource> sources = getPesiSources(identEntity);

			}

		}

		return result;

	}

	/**

	 * Returns the Sources for a given TaxonName only.

	 * @param taxonName The {@link TaxonNameBase TaxonName}.

			TaxonNameBase taxonName = CdmBase.deproxy(identEntity, TaxonNameBase.class);

			Set<IdentifiableSource> testSources = identEntity.getSources();

			sources = filterPesiSources(identEntity.getSources());

			if (sources.size() == 0 && testSources.size()>0){

				IdentifiableSource source = testSources.iterator().next();

				logger.warn("There are sources, but they are no pesi sources!!!" + source.getIdInSource() + " - " + source.getIdNamespace() + " - " + source.getCitation().getTitleCache());

			if (sources.size() > 1) {

				logger.warn("This TaxonName has more than one Source: " + identEntity.getUuid() + " (" + identEntity.getTitleCache() + ")");

			}

			// name has no PESI source, take sources from TaxonBase

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

				Set<TaxonBase> taxa = taxonName.getTaxonBases();

		//for TaxonBases

		}else if (identEntity.isInstanceOf(TaxonBase.class)){

		}

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

			logger.warn("This TaxonName has no PESI Sources: " + identEntity.getUuid() + " (" + identEntity.getTitleCache() +")");

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