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

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import org.joda.time.DateTime;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.io.berlinModel.out.mapper.IdMapper;

import eu.etaxonomy.cdm.io.berlinModel.out.mapper.MethodMapper;

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

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

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

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

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

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

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.reference.ReferenceBase;

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

/**

 * @author a.mueller

 * @author e.-m.lee

 * @date 23.02.2010

 *

 */

@Component

@SuppressWarnings("unchecked")

public class PesiTaxonExport extends PesiExportBase {

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

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

	private static int modCount = 1000;

	private static final String dbTableName = "Taxon";

	private static final String pluralString = "Taxa";

	private PreparedStatement parentTaxonFk_TreeIndex_KingdomFkStmt;

	private PreparedStatement synonymsStmt;

	enum NamePosition {

		beginning,

		end,

		between,

		alone,

		nowhere

	}

	public class Data {

		Integer kingdomId = null;

		Integer parentTaxonId = null;

		String treeIndex = null;

		String nomenclaturalCode = null;

		/**

		 * @return the nomenclaturalCode

		 */

		protected String getNomenclaturalCode() {

			return nomenclaturalCode;

		}

		/**

		 * @param nomenclaturalCode the nomenclaturalCode to set

		 */

		protected void setNomenclaturalCode(String nomenclaturalCode) {

			this.nomenclaturalCode = nomenclaturalCode;

		}

		/**

		 * @return the kingdomId

		 */

		protected Integer getKingdomId() {

			return kingdomId;

		}

		/**

		 * @param kingdomId the kingdomId to set

		 */

		protected void setKingdomId(Integer kingdomId) {

			this.kingdomId = kingdomId;

		}

		/**

		 * @return the parentTaxonId

		 */

		protected Integer getParentTaxonId() {

			return parentTaxonId;

		}

		/**

		 * @param parentTaxonid the parentTaxonid to set

		 */

		protected void setParentTaxonId(Integer parentTaxonId) {

			this.parentTaxonId = parentTaxonId;

		}

		/**

		 * @return the treeIndex

		 */

		protected String getTreeIndex() {

			return treeIndex;

		}

		/**

		 * @param treeIndex the treeIndex to set

		 */

		protected void setTreeIndex(String treeIndex) {

			this.treeIndex = treeIndex;

		}

	}

	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;

	}

	/* (non-Javadoc)

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

	 */

	@SuppressWarnings("deprecation")

	@Override

	protected boolean doInvoke(PesiExportState state) {

		try {

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

			// Prepare TreeIndex-And-KingdomFk-Statement

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

			String parentTaxonFk_TreeIndex_KingdomFkSql = "UPDATE Taxon SET ParentTaxonFk = ?, TreeIndex = ?, " +

					"KingdomFk = ?, RankFk = ?, RankCache = ? WHERE TaxonId = ?"; 

			parentTaxonFk_TreeIndex_KingdomFkStmt = con.prepareStatement(parentTaxonFk_TreeIndex_KingdomFkSql);

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

			synonymsStmt = con.prepareStatement(synonymsSql);

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

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

			// Stores whether this invoke was successful or not.

			boolean success = true;

			// PESI: Clear the database table Taxon.

			doDelete(state);

			// CDM: Get the number of all available taxa.

//			int maxCount = getTaxonService().count(null);

//			logger.error("Total amount of " + maxCount + " " + pluralString + " will be exported.");

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

			PesiExportMapping mapping = getMapping();

			// Initialize the db mapper

			mapping.initialize(state);

			int count = 0;

			int pastCount = 0;

			TransactionStatus txStatus = null;

			List<TaxonNameBase> list = null;

			// 1st Round: Make Taxa

/*			logger.error("PHASE 1...");

			// Start transaction

			txStatus = startTransaction(true);

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

			while ((list = getNameService().list(null, limit, count, null, null)).size() > 0) {

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

				for (TaxonNameBase taxonName : list) {

					doCount(count++, modCount, pluralString);

					success &= mapping.invoke(taxonName);

					// Check whether some rules are violated

//						if (rank == null) {

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

//						} else {

//							if (infraSpecificEpithet == null && rank.intValue() == 190) {

//								logger.error("InfraSpecificEpithet was not determined although it should exist for rank 190: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

//							}

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

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

//							}

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

//								logger.error("InfraSpecificEpithet was determined for rank " + rank + " although it should only exist for ranks higher or equal to 230: "  + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

//							}

//						}

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

//							logger.error("An infraSpecificEpithet was determined, but a specificEpithet was not determined: "  + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

//						}

//						if (genusOrUninomial == null) {

//							logger.error("GenusOrUninomial was not determined: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

//						}

//						

//						rank = null;

//						infraSpecificEpithet = null;

//						genusOrUninomial = null;

//						specificEpithet = null;

				}

				// Commit transaction

				commitTransaction(txStatus);

				logger.error("Committed transaction.");

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

				pastCount = count;

				// Start transaction

				txStatus = startTransaction(true);

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

			}

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

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

			}

			// Commit transaction

			commitTransaction(txStatus);

			logger.error("Committed transaction.");*/

			count = 0;

			pastCount = 0;

			List<TaxonomicTree> taxonomicTreeList = null;

			// 2nd Round: Add ParentTaxonFk to each Taxon

			logger.error("PHASE 2...");

			// Start transaction

			txStatus = startTransaction(true);

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

			Integer taxonomicTreeLimit = 1;

			Integer taxonomicTreeStart = 0;

			StringBuffer treeIndex = new StringBuffer();

			while ((taxonomicTreeList = getTaxonTreeService().listTaxonomicTrees(taxonomicTreeLimit, taxonomicTreeStart, null, null)).size() > 0) {

				logger.error("Fetched " + taxonomicTreeList.size() + " Taxonomic Tree.");

				for (TaxonomicTree taxonomicTree : taxonomicTreeList) {

					logger.error("Number of Root Nodes for this Taxonomic Tree: " + taxonomicTree.getRootNodes().size());

					for (TaxonNode rootNode : taxonomicTree.getRootNodes()) {

						logger.error("Number of Child Nodes for this Root Node: " + rootNode.getChildNodes().size() + ". Traversing branches...");

						for (TaxonNode rootChild : rootNode.getChildNodes()) {

							// Traverse all branches from this rootChild

							treeIndex.append("#");

							traverseTree(rootChild, rootNode, treeIndex, rootChild.getTaxon().getName().getRank(), state);

						}

					}

				}

				// Commit transaction

				commitTransaction(txStatus);

				logger.error("Committed transaction.");

				// Start transaction

				txStatus = startTransaction(true);

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

				// Pick next Taxonomic Tree

				taxonomicTreeStart++;

			}

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

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

			}

			// Commit transaction

			commitTransaction(txStatus);

			logger.error("Committed transaction.");

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

			return success;

		} catch (SQLException e) {

			e.printStackTrace();

			logger.error(e.getMessage());

			return false;

		}

	}

	/**

	 * Traverse the TaxonTree and store determined values for every Taxon.

	 * @param rootChild

	 */

	private void traverseTree(TaxonNode childNode, TaxonNode parentNode, StringBuffer treeIndex, Rank kingdomRank, PesiExportState state) {

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

			if (state.getDbId(childNode.getTaxon().getName()) != null) {

				treeIndex.append(state.getDbId(childNode.getTaxon().getName()));

				treeIndex.append("#");

				saveData(childNode, parentNode, treeIndex, state, state.getDbId(childNode.getTaxon().getName()));

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

					traverseTree(newNode, childNode, treeIndex, kingdomRank, state);

				}

			} else {

				logger.error("TaxonName can not be found in State: " + childNode.getTaxon().getName().getUuid() + " (" + childNode.getTaxon().getName().getTitleCache());

			}

		} else {

			logger.error("Taxon is NULL for TaxonNode: " + childNode.getUuid());

		}

	}

	/**

	 * Store values in database for every recursive round.

	 * @param childNode

	 * @param parentNode

	 * @param treeIndex

	 * @param state

	 * @param currentTaxonFk

	 */

	private void saveData(TaxonNode childNode, TaxonNode parentNode, StringBuffer treeIndex, PesiExportState state, Integer currentTaxonFk) {

		// We are differentiating kingdoms by the nomenclatural code for now.

		// This needs to be handled in a better way as soon as we know how to differentiate between more kingdoms.

		if (childNode.getTaxon() != null && childNode.getTaxon().getName() != null) {

			if (parentNode.getTaxon() != null && parentNode.getTaxon().getName() != null) {

					invokeParentTaxonFkAndTreeIndexAndKindomFk(childNode.getTaxon().getName(), 

							childNode.getTaxon().getName().getNomenclaturalCode(), 

							PesiTransformer.nomenClaturalCode2Kingdom(childNode.getTaxon().getName().getNomenclaturalCode()), 

							state.getDbId(parentNode.getTaxon().getName()), 

							currentTaxonFk, 

							treeIndex);

			}

		}

		// Synonyms of the current Taxon: Don't store treeIndex for Synonyms

		for (Synonym synonym : childNode.getTaxon().getSynonyms()) {

			invokeSynonyms(synonym.getName(), 

					childNode.getTaxon().getName().getNomenclaturalCode(), 

					PesiTransformer.nomenClaturalCode2Kingdom(childNode.getTaxon().getName().getNomenclaturalCode()), 

					currentTaxonFk, 

					state.getDbId(synonym.getName()));

		}

	}

	/**

	 * Store synonym values.

	 * @param taxonName

	 * @param nomenclaturalCode

	 * @param kingdomFk

	 * @param synonymParentTaxonFk

	 * @param currentTaxonFk

	 */

	private boolean invokeSynonyms(TaxonNameBase taxonName,

			NomenclaturalCode nomenclaturalCode, Integer kingdomFk,

			Integer synonymParentTaxonFk, Integer currentSynonymFk) {

		try {

			synonymsStmt.setInt(1, synonymParentTaxonFk);

			synonymsStmt.setInt(2, kingdomFk);

			synonymsStmt.setInt(3, getRankFk(taxonName, nomenclaturalCode));

			synonymsStmt.setString(4, getRankCache(taxonName, nomenclaturalCode));

			synonymsStmt.setInt(5, currentSynonymFk);

			synonymsStmt.executeUpdate();

			return true;

		} catch (SQLException e) {

			logger.error("SQLException during invoke for taxonName - " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + "): " + e.getMessage());

			e.printStackTrace();

			return false;

		}

	}

	/**

	 * 

	 * @param taxonNameBase

	 * @param state

	 * @param stmt

	 * @return

	 */

	protected boolean invokeParentTaxonFkAndTreeIndexAndKindomFk(TaxonNameBase taxonName, NomenclaturalCode nomenclaturalCode, Integer kingdomFk, Integer parentTaxonFk, Integer currentTaxonFk, StringBuffer treeIndex) {

		try {

			parentTaxonFk_TreeIndex_KingdomFkStmt.setInt(1, parentTaxonFk);

			parentTaxonFk_TreeIndex_KingdomFkStmt.setString(2, treeIndex.toString());

			parentTaxonFk_TreeIndex_KingdomFkStmt.setInt(3, kingdomFk);

			parentTaxonFk_TreeIndex_KingdomFkStmt.setInt(4, getRankFk(taxonName, nomenclaturalCode));

			parentTaxonFk_TreeIndex_KingdomFkStmt.setString(5, getRankCache(taxonName, nomenclaturalCode));

			parentTaxonFk_TreeIndex_KingdomFkStmt.setInt(6, currentTaxonFk);

			parentTaxonFk_TreeIndex_KingdomFkStmt.executeUpdate();

			return true;

		} catch (SQLException e) {

			logger.error("SQLException during treeIndex invoke for taxonName - " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + "): " + e.getMessage());

			e.printStackTrace();

			return false;

		}

	}

	/**

	 * Deletes all entries of database tables related to <code>Taxon</code>.

	 * @param state The PesiExportState

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

	 */

	protected boolean doDelete(PesiExportState state) {

		PesiExportConfigurator pesiConfig = (PesiExportConfigurator) state.getConfig();

		String sql;

		Source destination =  pesiConfig.getDestination();

		// Clear Taxon

		sql = "DELETE FROM " + dbTableName;

		destination.setQuery(sql);

		destination.update(sql);

		return true;

	}

	/* (non-Javadoc)

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

	 */

	@Override

	protected boolean isIgnore(PesiExportState state) {

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

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	private static Integer getRankFk(TaxonNameBase taxonName, NomenclaturalCode nomenclaturalCode) {

		Integer result = null;

		if (nomenclaturalCode != null) {

			if (taxonName != null && taxonName.getRank() == null) {

				logger.warn("Rank is null: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

			}

			result = PesiTransformer.rank2RankId(taxonName.getRank(), PesiTransformer.nomenClaturalCode2Kingdom(nomenclaturalCode));

			if (result == null) {

				logger.warn("Rank " + taxonName.getRank().getLabel() + " could not be determined for PESI-Kingdom-Id " + PesiTransformer.nomenClaturalCode2Kingdom(nomenclaturalCode));

			}

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	private static String getRankCache(TaxonNameBase taxonName, NomenclaturalCode nomenclaturalCode) {

		String result = null;

		if (nomenclaturalCode != null) {

			result = PesiTransformer.rank2RankCache(taxonName.getRank(), PesiTransformer.nomenClaturalCode2Kingdom(nomenclaturalCode));

		}

		return result;

	}

	/**

	 * 

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

	 * @return Whether it's genus or uninomial.

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getGenusOrUninomial(TaxonNameBase taxonName) {

		String result = null;

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

			NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

			result = nonViralName.getGenusOrUninomial();

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getInfraGenericEpithet(TaxonNameBase taxonName) {

		String result = null;

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

			NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

			result = nonViralName.getInfraGenericEpithet();

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getSpecificEpithet(TaxonNameBase taxonName) {

		String result = null;

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

			NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

			result = nonViralName.getSpecificEpithet();

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getInfraSpecificEpithet(TaxonNameBase taxonName) {

		String result = null;

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

			NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

			result = nonViralName.getInfraSpecificEpithet();

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getWebSearchName(TaxonNameBase taxonName) {

		String result = null;

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

			NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

			result = nonViralName.getNameCache();

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getWebShowName(TaxonNameBase taxonName) {

		String result = null;

		try {

			if (taxonName != null) {

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

					NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

					String singleWhitespace = "\\s";

					String multipleWhitespaces = "\\s*";

					String whitespaceOrNothing = "\\s?";

					String singleBlank = " ";

					String anyNumberOfCharacters = ".*";

					String backSlashRegEx = "\\";

	//				String periodRegEx = "\\.";

	//				String asterixRegEx = "\\*";

					String questionMarkRegEx = "\\?";

	//				String plusRegEx = "\\+";

	//				String squareBracketRegEx = "\\[";

	//				String curlyBracketRegEx = "\\{";

	//				String pipeRegEx = "\\|";

	//				String accentRegEx = "\\^";

	//				String dollarSignRegEx = "\\$";

					String openingParenthesisRegEx = "\\(";

					String closingParenthesisRegEx = "\\)";

					String openParenthesis = "(";

					String closeParenthesis = ")";

					String italicBeginTag = "<i>";

					String italicEndTag = "</i>";

					String endAnchor = "$";

					String questionMarkReplacement = backSlashRegEx + questionMarkRegEx;

	//				String backSlashReplacement = backSlashRegEx + backSlashRegEx;

	//				String periodReplacement = backSlashRegEx + periodRegEx;

	//				String asterixReplacement = backSlashRegEx + asterixRegEx;

	//				String plusReplacement = backSlashRegEx + plusRegEx;

	//				String squareBracketReplacement = backSlashRegEx + squareBracketRegEx;

	//				String curlyBracketReplacement = backSlashRegEx + curlyBracketRegEx;

	//				String pipeReplacement = backSlashRegEx + pipeRegEx;

	//				String accentReplacement = backSlashRegEx + accentRegEx;

	//				String dollarSignReplacement = backSlashRegEx + dollarSignRegEx;

					if (nonViralName != null) {

						if (nonViralName.getTitleCache() != null) {

							try {

								String fullName = nonViralName.getTitleCache();

								// This deals with question marks that are reserved in regular expressions

								fullName = fullName.replaceAll(questionMarkRegEx, questionMarkReplacement);

								String genusOrUninomial = nonViralName.getGenusOrUninomial();

								String infraGenericEpithet = nonViralName.getInfraGenericEpithet();

								if (infraGenericEpithet != null) {

									infraGenericEpithet = openParenthesis + infraGenericEpithet + closeParenthesis;

								}

								String specificEpithet = nonViralName.getSpecificEpithet();

								String infraSpecificEpithet = nonViralName.getInfraSpecificEpithet();

								boolean rankExists = false;

								StringBuffer replaceFullName = new StringBuffer(fullName);

								List<NamePosition> genusOrUninomialPosition = getPosition(genusOrUninomial, fullName);

								List<NamePosition> infraGenericEpithetPosition = getPosition(infraGenericEpithet, fullName);

								List<NamePosition> specificEpithetPosition = getPosition(specificEpithet, fullName);

								List<NamePosition> authorshipPosition = getPosition(specificEpithet, fullName);

								if (nameExists(genusOrUninomialPosition) || nameExists(infraGenericEpithetPosition) || nameExists(specificEpithetPosition)) {

									replaceFullName.insert(0, italicBeginTag);

									if (nameExists(specificEpithetPosition)) {

										if ((specificEpithet.equals(infraSpecificEpithet) && countPattern(infraSpecificEpithet, fullName) == 2) |

												(! specificEpithet.equals(infraSpecificEpithet) && countPattern(infraSpecificEpithet, fullName) == 1)) {

											// infraSpecificEpithet exists

											// Determine position of infraSpecificEpithet

											int infraSpecificEpithetLocation = replaceFullName.lastIndexOf(infraSpecificEpithet);

											int infraSpecificEpithetBeginLocation = infraSpecificEpithetLocation;

											int infraSpecificEpithetEndLocation = infraSpecificEpithetLocation + infraSpecificEpithet.length();

											// Check whether rank information exists between specificEpithet and infraSpecificEpithet

											String rankExistsRegEx = specificEpithet + singleWhitespace + anyNumberOfCharacters + singleWhitespace + infraSpecificEpithet;

											List<NamePosition> rankPosition = getPosition(rankExistsRegEx, fullName);

											if (rankPosition != null && nameExists(rankPosition)) {

												// Rank information exists

												// Insert italicBeginTag

												replaceFullName.insert(infraSpecificEpithetBeginLocation, italicBeginTag);

												// Check position of infraSpecificEpithet

												List<NamePosition> infraSpecificEpithetPosition = getPosition(infraSpecificEpithet, fullName);

												if (infraSpecificEpithetPosition != null) {

													if (infraSpecificEpithetPosition.contains(NamePosition.end)) {

														// Append italicEndTag

														replaceFullName.append(italicEndTag);

													} else {

														// Insert italicEndTag

														replaceFullName.insert(infraSpecificEpithetEndLocation + italicBeginTag.length(), italicEndTag);

													}

												}

											}

										}

										int specificEpithetLocation = replaceFullName.indexOf(specificEpithet) + specificEpithet.length();

										if (specificEpithetPosition.contains(NamePosition.end)) {

											replaceFullName.append(italicEndTag);

										} else {

											replaceFullName.insert(specificEpithetLocation, italicEndTag);

										}

									} else if (nameExists(infraGenericEpithetPosition)) {

										int infraGenericEpithetLocation = replaceFullName.indexOf(infraGenericEpithet) + 

												openParenthesis.length() + infraGenericEpithet.length() + closeParenthesis.length();

										if (infraGenericEpithetPosition.contains(NamePosition.end)) {

											replaceFullName.append(italicEndTag);

										} else {

											replaceFullName.insert(infraGenericEpithetLocation, italicEndTag);

										}

									} else if (nameExists(genusOrUninomialPosition)) {

										replaceFullName.insert(genusOrUninomial.length() + italicBeginTag.length(), italicEndTag);

									}

								}

								result = replaceFullName.toString();

							} catch (Exception e) {

								// This needs a workaround since very likely there is a character in the fullName that is reserved in regular expressions

								logger.error("WebShowName could not be determined for NonViralName " + nonViralName.getUuid() + " (" + nonViralName.getTitleCache() + "): " + e.getMessage());

//								e.printStackTrace();

								result = nonViralName.getTitleCache();

							}

						} else {

							logger.error("WebShowName could not be determined: TitleCache is NULL for NonViralName " + nonViralName.getUuid() + " (" + nonViralName.getTitleCache() + ")");

						}

					} else {

						logger.error("WebShowName could not be determined: NonViralName is NULL for TaxonName" + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");

					}

				}

			} else {

				logger.warn("WebShowName could not be determined: TaxonName is NULL");

			}

//		logger.error("final result: " + result);

		} catch (Exception e) {

			e.printStackTrace();

		}

		return result;

	}

	/**

	 * 

	 * @param searchString

	 * @param searchedString

	 * @return

	 */

	private static Integer countPattern(String searchString, String searchedString) {

		Integer count = 0;

		if (searchString != null && searchedString != null) {

			Integer index = 0;

			while ((index = searchedString.indexOf(searchString, index)) != -1) {

				count++;

				index++;

			}

		} else {

//			logger.error("Either searchString or searchedString is NULL");

		}

		return count;

	}

	/**

	 * @param namePosition

	 * @return

	 */

	private static boolean nameExists(List<NamePosition> namePosition) {

		boolean result = false;

		if (namePosition != null) {

			if (namePosition.contains(NamePosition.nowhere)) {

				result = false;

			} else {

				result = true;

			}

		}

		return result;

	}

	private static List<NamePosition> getPosition(String name, String targetString) {

		List<NamePosition> result = new ArrayList<NamePosition>();

		boolean touched = false;

		if (name != null && targetString != null) {

			if ("".equals(name.trim())) {

				result.add(NamePosition.nowhere);

			} else {

				String beginningAnchor = "^";

				String endAnchor = "$";

				String anyNumberOfCharacters = ".*";

				String beginningRegEx = beginningAnchor + name;

				String endRegEx = name + endAnchor;

				String middleRegEx = anyNumberOfCharacters + name + anyNumberOfCharacters;

				if (stringExists(beginningRegEx, targetString)) {

					result.add(NamePosition.beginning);

					touched = true;

				}

				if (stringExists(endRegEx, targetString)) {

					result.add(NamePosition.end);

					touched = true;

				}

				if (stringExists(middleRegEx, targetString)) {

					if (result.contains(NamePosition.beginning) && result.contains(NamePosition.end)) {

						result.add(NamePosition.alone);

					} else {

						result.add(NamePosition.between);

					}

					touched = true;

				}

				if (!touched) {

					result.add(NamePosition.nowhere);

				}

			}

		} else {

//			logger.error("Either name or targetString is NULL");

			result = null;

		}

		return result;

	}

	/**

	 * @param beginningRegEx

	 * @param targetString

	 */

	private static boolean stringExists(String regEx, String targetString) {

		Pattern pattern = Pattern.compile(regEx);

		Matcher matcher = pattern.matcher(targetString);

		if (matcher.find()) {

			return true;

		} else {

			return false;

		}

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getAuthorString(TaxonNameBase taxonName) {

		String result = null;

		if (taxonName != null && taxonName != null) {

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

				NonViralName nonViralName = CdmBase.deproxy(taxonName, NonViralName.class);

				result = nonViralName.getAuthorshipCache();

			} else {

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

			}

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getFullName(TaxonNameBase taxonName) {

		if (taxonName != null) {

			return taxonName.getTitleCache();

		} else {

			return null;

		}

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getNomRefString(TaxonNameBase taxonName) {

		String result = null;

		if (taxonName != null) {

			try {

				result = taxonName.getNomenclaturalMicroReference();

			} catch (Exception e) {

				logger.error("While getting NomRefString");

				e.printStackTrace();

			}

		}

		return result;

	}

	/**

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

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

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

	 * @see MethodMapper

	 */

	@SuppressWarnings("unused")

	private static String getDisplayName(TaxonNameBase taxonName) {

		// TODO: extension?

		if (taxonName != null) {