EDIT

/**

* Copyright (C) 2007 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 org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.common.CdmUtils;

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

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

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

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

import eu.etaxonomy.cdm.io.pesi.out.PesiTransformer;

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

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

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

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

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

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

 */

@Component

public class FaunaEuropaeaTaxonNameImport extends FaunaEuropaeaImportBase  {

	public static final String OS_NAMESPACE_TAXON = "Taxon";

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

	/* Max number of taxa to retrieve (for test purposes) */

	/* (non-Javadoc)

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

		FaunaEuropaeaImportConfigurator fauEuConfig = state.getConfig();

		logger.warn("Checking for Taxa not yet fully implemented");

//		result &= checkTaxonStatus(fauEuConfig);

		return result;

	}

	/* (non-Javadoc)

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

	 */

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

	}

	 * Import taxa from FauEU DB

	 */

		if(logger.isInfoEnabled()) { logger.info("Start making taxa..."); }

		processTaxa(state);

		logger.info("End making taxa...");

		return;

		Map<String, MapWrapper<? extends CdmBase>> stores = state.getStores();

		MapWrapper<TeamOrPersonBase> authorStore = (MapWrapper<TeamOrPersonBase>)stores.get(ICdmIO.TEAM_STORE);

		Map<Integer, TaxonBase<?>> taxonMap = null;

		Map<Integer, FaunaEuropaeaTaxon> fauEuTaxonMap = null;

		/* Store for heterotypic synonyms to be save separately */

		Source source = fauEuConfig.getSource();

		int i = 0;

			" SELECT count(*) ";

			" SELECT Parent.TAX_NAME AS P2Name, Parent.TAX_RNK_ID AS P2RankId, " +

			" GrandParent.TAX_ID AS GP3Id, GrandParent.TAX_NAME AS GP3Name, GrandParent.TAX_RNK_ID AS GP3RankId, " +

			" GreatGrandParent.TAX_ID AS GGP4Id, GreatGrandParent.TAX_NAME AS GGP4Name, GreatGrandParent.TAX_RNK_ID AS GGP4RankId, " +

			" expertUsers.usr_id AS expertUserId, expertUsers.usr_title AS ExpertUsrTitle, expertUsers.usr_firstname AS ExpertUsrFirstname, expertUsers.usr_lastname AS ExpertUsrLastname," +

			" speciesExpertUsers.usr_id AS speciesExpertUserId, speciesExpertUsers.usr_title AS SpeciesUsrTitle, speciesExpertUsers.usr_firstname AS SpeciesUsrFirstname, speciesExpertUsers.usr_lastname AS SpeciesUsrLastname," +

			" Taxon.*, rank.*, author.* ";

			" FROM Taxon LEFT OUTER JOIN " +

			" Taxon AS Parent ON Taxon.TAX_TAX_IDPARENT = Parent.TAX_ID LEFT OUTER JOIN " +

			" Taxon AS GrandParent ON Parent.TAX_TAX_IDPARENT = GrandParent.TAX_ID LEFT OUTER JOIN " +

			" users AS speciesExpertUsers ON Taxon.TAX_USR_IDSP = speciesExpertUsers.usr_id LEFT OUTER JOIN " +

			" rank ON Taxon.TAX_RNK_ID = rank.rnk_id ";

			selectCount + fromClause;

			selectColumns + fromClause;

        try {

			ResultSet rs = source.getResultSet(countQuery);

			rs.next();

			int count = rs.getInt(1);

			rs = source.getResultSet(selectQuery);

	        if (logger.isInfoEnabled()) {

				logger.info("Count Query: " + countQuery);

				logger.info("Select Query: " + selectQuery);

			}

			while (rs.next()) {

				if ((i++ % limit) == 0) {

					txStatus = startTransaction();

					taxonMap = new HashMap<Integer, TaxonBase<?>>(limit);

					fauEuTaxonMap = new HashMap<Integer, FaunaEuropaeaTaxon>(limit);

					synonymSet = new HashSet<Synonym>();

					if(logger.isInfoEnabled()) {

					}

				}

				int originalGenusId = rs.getInt("TAX_TAX_IDGENUS");

				int autId = rs.getInt("TAX_AUT_ID");

				int status = rs.getInt("TAX_VALID");

				// user related

				String expertUsrTitle = rs.getString("ExpertUsrTitle");

				if ((expertUsrTitle != null || expertUsrFirstname != null) && expertUsrLastname != null) {

					expertName += " " + expertUsrLastname;

				}

				String speciesExpertName = speciesUsrTitle == null ? "" : speciesUsrTitle + ".";

				if (speciesUsrTitle != null) {

					speciesExpertName = speciesUsrTitle;

				if ((speciesUsrTitle != null || speciesUsrFirstname != null) && speciesUsrLastname != null) {

					speciesExpertName += " " + speciesUsrLastname;

				}

				// date related

				Timestamp createdTimeStamp = rs.getTimestamp("TAX_CREATEDAT");

				Timestamp modifiedTimeStamp = rs.getTimestamp("TAX_MODIFIEDAT");

				DateTime modified = isCreated ? null : new DateTime(modifiedTimeStamp);

				DateTime lastActionDate = isCreated ?  created : modified;

				String lastActionDateStr = isCreated ? createdTimeStamp.toString() : modifiedTimeStamp.toString();

				// note related

				String taxComment = rs.getString("TAX_TAXCOMMENT");

				String fauComment = rs.getString("TAX_FAUCOMMENT");

				if (year != null && year.intValue() == 0) {

					year = null;

				}

				//int familyId = rs.getInt("TAX_TAX_IDFAMILY");

				Rank rank = null;

				fauEuTaxon.setId(taxonId);

				fauEuTaxon.setRankId(rankId);

				fauEuTaxon.setLocalName(localName);

				fauEuTaxon.setParentId(parentId);

				fauEuTaxon.setParentRankId(parentRankId);

				fauEuTaxon.setParentName(parentName);

				fauEuTaxon.setGrandParentId(grandParentId);

				fauEuTaxon.setGrandParentRankId(grandParentRankId);

				fauEuTaxon.setGrandParentName(grandParentName);

				fauEuTaxon.setGreatGrandParentId(greatGrandParentId);

				fauEuTaxon.setGreatGrandParentRankId(greatGrandParentRankId);

				fauEuTaxon.setGreatGrandParentName(greatGrandParentName);

				fauEuTaxon.setGreatGreatGrandParentId(greatGreatGrandParentId);

				fauEuTaxon.setGreatGreatGrandParentRankId(greatGreatGrandParentRankId);

				fauEuTaxon.setGreatGreatGrandParentName(greatGreatGrandParentName);

				fauEuTaxon.setGreatGreatGreatGrandParentRankId(greatGreatGreatGrandParentRankId);

				fauEuTaxon.setGreatGreatGreatGrandParentName(greatGreatGreatGrandParentName);

				fauEuTaxon.setOriginalGenusId(originalGenusId);

				fauEuTaxon.setYear(year);

				fauEuTaxon.setOriginalGenusName(originalGenusName);

				ZoologicalName zooName = ZoologicalName.NewInstance(rank);

				TeamOrPersonBase<?> author = authorStore.get(autId);

				zooName.setPublicationYear(year);

				// Add Date extensions to this zooName

				Extension.NewInstance(zooName, lastAction, getExtensionType(state, PesiTransformer.lastActionUuid, "LastAction", "LastAction", "LA"));

//				Extension.NewInstance(zooName, lastActionDateStr, getExtensionType(state, PesiTransformer.lastActionDateUuid, "LastActionDate", "LastActionDate", "LAD"));

				zooName.setCreated(created);

				zooName.setUpdated(modified);

				/* Add Note extensions to this zooName

				Extension.NewInstance(zooName, taxComment, getExtensionType(PesiTransformer.taxCommentUuid, "TaxComment", "TaxComment", "TC"));

				Extension.NewInstance(zooName, fauComment, getExtensionType(PesiTransformer.fauCommentUuid, "FauComment", "FauComment", "FC"));

				try {

					// check for occurrence of the auct string in auctName

					String auctRegEx = "\\bauct\\b\\.?"; // The word "auct" with or without "."

					String auctWithNecRegEx = "\\bauct\\b\\.?.*\\bnec\\b\\.?.*";

					String necAuctRegEx = ".*\\bnec\\b\\.?.*\\bauct\\b\\.?";

					boolean auctNecFound = expressionMatches(auctWithNecRegEx, autName);

					boolean necAuctFound = expressionMatches(necAuctRegEx, autName);

					boolean auctWordFound = expressionMatches(auctRegEx, autName);

					if (status == T_STATUS_ACCEPTED ) {

							taxon = Taxon.NewInstance(zooName, sourceReference);

							if (logger.isDebugEnabled()) {

								logger.debug("Taxon created (" + taxonId + ")");

							}

						taxonBase = taxon;

					} else if ((status == T_STATUS_NOT_ACCEPTED) && ! auctWordFound) { // synonym

						synonym = Synonym.NewInstance(zooName, sourceReference);

						logger.info("temporary named name created ("+ taxonId + ") " + zooName.getTitleCache()+ zooName.getStatus().toString());

					}else if (status == T_STATUS_NOT_ACCEPTED && auctWordFound){

							// misapplied name

								zooName.setPublicationYear(null);

								taxon = Taxon.NewInstance(zooName, auctReference);

								taxonBase = taxon;

								//logger.info("Misapplied name created ("+ taxonId + ") " + autName);

									logger.debug("Misapplied name created (" + taxonId + ")");

									}

					}else{

						logger.warn("Unknown taxon status " + status + ". Taxon (" + taxonId + ") ignored.");

						continue;

					}

					taxonBase.setLsid(new LSID( "urn:lsid:faunaeur.org:taxname:"+taxonId));

					taxonBase.setCreated(created);

					taxonBase.setUpdated(modified);

					// Add Note extensions to this taxon

					if (!StringUtils.isBlank(taxComment)){

						Extension.NewInstance(taxonBase, taxComment, getExtensionType(state, PesiTransformer.taxCommentUuid, "TaxComment", "TaxComment", "TC"));

					}

					// Add UserId extensions to this zooName

					//Extension.NewInstance(zooName, expertUserId, getExtensionType(state, PesiTransformer.expertUserIdUuid, "expertUserId", "expertUserId", "EUID"));

					//Extension.NewInstance(zooName, speciesExpertUserId, getExtensionType(state, PesiTransformer.speciesExpertUserIdUuid, "speciesExpertUserId", "speciesExpertUserId", "SEUID"));

					// Add Expert extensions to this zooName

					Extension.NewInstance(taxonBase, expertName, getExtensionType(state, PesiTransformer.expertNameUuid, "ExpertName", "ExpertName", "EN"));

					Extension.NewInstance(taxonBase, speciesExpertName, getExtensionType(state, PesiTransformer.speciesExpertNameUuid, "SpeciesExpertName", "SpeciesExpertName", "SEN"));

					ImportHelper.setOriginalSource(taxonBase, fauEuConfig.getSourceReference(), taxonId, OS_NAMESPACE_TAXON);

					ImportHelper.setOriginalSource(zooName, fauEuConfig.getSourceReference(), taxonId, "TaxonName");

					if (!taxonMap.containsKey(taxonId)) {

						taxonMap.put(taxonId, taxonBase);

						fauEuTaxonMap.put(taxonId, fauEuTaxon);

					} else {

								") " + localName);

					}

				} catch (Exception e) {

					". Taxon base could not be saved.");

					e.printStackTrace();

				}

					commitTaxa(state, txStatus, taxonMap, fauEuTaxonMap,

							synonymSet);

					taxonMap = null;

					synonymSet = null;

					fauEuTaxonMap = null;

					if(logger.isInfoEnabled()) {

					}

				}

		processTaxaSecondPass(state, taxonMap, fauEuTaxonMap, synonymSet);

		if(logger.isDebugEnabled()) { logger.debug("Saving taxa ... " + taxonMap.size()); }

		getTaxonService().save((Collection)taxonMap.values());

		commitTransaction(txStatus);

	}

	/**

	 * Processes taxa from complete taxon store

	 */

		if(logger.isDebugEnabled()) { logger.debug("Processing taxa second pass..."); }

		FaunaEuropaeaImportConfigurator fauEuConfig = state.getConfig();

		for (int id : taxonMap.keySet())

		{

			if (logger.isDebugEnabled()) { logger.debug("Taxon # " + id); }

			TaxonBase<?> taxonBase = taxonMap.get(id);

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

			FaunaEuropaeaTaxon fauEuTaxon = fauEuTaxonMap.get(id);

			if (!fauEuTaxon.isValid() ){

				useOriginalGenus = true;

			}

				buildTaxonName(fauEuTaxon, taxonBase, taxonName, useOriginalGenus, fauEuConfig);

			if (taxonBase instanceof Synonym){

				logger.debug("Name of Synonym: " + nameString);

			}

					&& fauEuTaxon.getRankId() > R_SUBGENUS

					&& (fauEuTaxon.getOriginalGenusId() != 0)) {

				Integer originalGenusId = fauEuTaxon.getOriginalGenusId();

				Integer actualGenusId = getActualGenusId(fauEuTaxon);

				if (logger.isDebugEnabled()) {

					logger.debug("actual genus id = " + actualGenusId + ", original genus id = " + originalGenusId);

				}

				if (actualGenusId.intValue() != originalGenusId.intValue() && taxonBase.isInstanceOf(Taxon.class)) {

					createBasionym(fauEuTaxon, taxonBase, taxonName, fauEuConfig, synonymSet, state);

				} else if (fauEuTaxon.isParenthesis()) {

					ZoologicalName zooName = taxonName.deproxy(taxonName, ZoologicalName.class);

					zooName.setOriginalPublicationYear(zooName.getPublicationYear());

					zooName.setPublicationYear(null);

				}

			}

		}

	}

			TaxonNameBase<?,?>taxonName, FaunaEuropaeaImportConfigurator fauEuConfig,

			Set<Synonym> synonymSet, FaunaEuropaeaImportState state) {

		try {

			ZoologicalName zooName = taxonName.deproxy(taxonName, ZoologicalName.class);

			// create basionym

			ZoologicalName basionym = ZoologicalName.NewInstance(taxonName.getRank());

			basionym.setPublicationYear(zooName.getPublicationYear());

			zooName.addBasionym(basionym, fauEuConfig.getSourceReference(), null, null);

			//TODO:this is a workaround for fauna europaea, this should be fixed in cdm model. this should be not a basionym but an orthographic variant (original spelling)

			if (fauEuTaxon.isParenthesis()){

				zooName.setOriginalPublicationYear(zooName.getPublicationYear());

			} else{

				zooName.setAuthorshipCache(zooName.getAuthorshipCache(), true);

			}

			zooName.setPublicationYear(null);

			zooName.setTitleCache(null); // This should (re)generate the titleCache automatically

			Synonym synonym = Synonym.NewInstance(basionym, fauEuConfig.getSourceReference());

			MarkerType markerType =getMarkerType(state, PesiTransformer.uuidMarkerGuidIsMissing, "Uuid is missing", "Uuid is missing", null);

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

			if (fauEuTaxon.isValid()) { // Taxon

				// homotypic synonym

				Taxon taxon = taxonBase.deproxy(taxonBase, Taxon.class);

				taxon.addHomotypicSynonym(synonym, fauEuConfig.getSourceReference(), null);

				if (logger.isDebugEnabled()) {

					logger.debug("Homotypic synonym created (" + fauEuTaxon.getId() + ")");

				}

			} else { // Synonym

				// heterotypic synonym

				// synonym relationship to the accepted taxon is created later

				synonymSet.add(synonym);

				if (logger.isDebugEnabled()) {

					logger.debug("Heterotypic synonym stored (" + fauEuTaxon.getId() + ")");

				}

			}

			buildTaxonName(fauEuTaxon, synonym, basionym, true, fauEuConfig);

			//originalSources zufügen

			ImportHelper.setOriginalSource(synonym, fauEuConfig.getSourceReference(), fauEuTaxon.getId(), PesiTransformer.STR_NAMESPACE_NOMINAL_TAXON);

			ImportHelper.setOriginalSource(synonym.getName(), fauEuConfig.getSourceReference(), fauEuTaxon.getId(), PesiTransformer.STR_NAMESPACE_NOMINAL_TAXON);

//			String originalGenusIdString = String.valueOf(fauEuTaxon.getId());

//			IdentifiableSource basionymSource = IdentifiableSource.NewInstance(originalGenusIdString, "originalGenusId");

//			basionym.addSource(basionymSource);

//			// add original database reference

//			ImportHelper.setOriginalSource(basionym, fauEuConfig.getSourceReference(), fauEuTaxon.getId(), "TaxonName");

		} catch (Exception e) {

			logger.warn("Exception occurred when creating basionym for " + fauEuTaxon.getId());

			e.printStackTrace();

		}

		return;

	}

	/* Build name title cache */

	private String buildNameTitleCache(String nameString, boolean useOriginalGenus, FaunaEuropaeaTaxon fauEuTaxon) {

		StringBuilder titleCacheStringBuilder = new StringBuilder(nameString);

		Integer year = fauEuTaxon.getYear();

		if (year != null) { // TODO: Ignore authors like xp, xf, etc?

	/* Build taxon title cache */

	private String buildTaxonTitleCache(String nameCache, Reference<?> reference) {

		StringBuilder titleCacheStringBuilder = new StringBuilder(nameCache);

		titleCacheStringBuilder.append(" sec. ");

		titleCacheStringBuilder.append(reference.getTitleCache());

		return titleCacheStringBuilder.toString();

	}

	/* Build name full title cache */

	private String buildNameFullTitleCache(String titleCache, FaunaEuropaeaImportConfigurator fauEuConfig) {

		StringBuilder fullTitleCacheStringBuilder = new StringBuilder(titleCache);

		fullTitleCacheStringBuilder.append(" ");

		fullTitleCacheStringBuilder.append(fauEuConfig.getSourceReferenceTitle());

		return fullTitleCacheStringBuilder.toString();

	}

			StringBuilder genusOrUninomial) {

		StringBuilder stringBuilder = new StringBuilder();

		if(useOriginalGenus) {

			stringBuilder.append(originalGenusName);

			genusOrUninomial.delete(0, genusOrUninomial.length());

		return stringBuilder.toString();

	}

			StringBuilder genusOrUninomial,

			StringBuilder infraGenericEpithet,

			FaunaEuropaeaTaxon fauEuTaxon) {

		StringBuilder stringBuilder = new StringBuilder();

		stringBuilder.append(genusPart(originalGenusName, useOriginalGenus, genusOrUninomial));

		// The infraGenericEpithet is set to empty only if the original genus should be used and

		// InfraGenericEpithets of accepted taxa are not touched at all.

		Integer originalGenusId = fauEuTaxon.getOriginalGenusId();

		Integer actualGenusId = getActualGenusId(fauEuTaxon);

				originalGenusId.intValue() > 0 &&

				actualGenusId.intValue() > 0) {

			infraGenericEpithet.delete(0, infraGenericEpithet.length());

		stringBuilder.append(infraGenericEpithet);

		stringBuilder.append(")");

		stringBuilder.append(" ");

		return stringBuilder.toString();

	}

		ranks.put(fauEuTaxon.getGreatGrandParentRankId(), fauEuTaxon.getGreatGrandParentId());

		ranks.put(fauEuTaxon.getGreatGreatGrandParentRankId(), fauEuTaxon.getGreatGreatGrandParentId());

		ranks.put(fauEuTaxon.getGreatGreatGreatGrandParentRankId(), fauEuTaxon.getGreatGreatGreatGrandParentId());

		actualGenusId = ranks.get(R_GENUS);

		return actualGenusId;

	}

	/** Build species and subspecies names */

			StringBuilder specificEpithet, StringBuilder infraSpecificEpithet,

			FaunaEuropaeaTaxon fauEuTaxon) {

		// species or subspecies name

		String localName = fauEuTaxon.getLocalName();

		int taxonId = fauEuTaxon.getId();

			}

			return nameCacheStringBuilder.toString();

		}

		String parentName = fauEuTaxon.getParentName();

		String grandParentName = fauEuTaxon.getGrandParentName();

		String greatGrandParentName = fauEuTaxon.getGreatGrandParentName();

//		int grandParentId = fauEuTaxon.getGrandParentId();

//		int greatGrandParentId = grandParent.getParentId();

		if (fauEuTaxon.isValid()) { // Taxon

			if (rank == R_SPECIES) {

				if(parentRankId == R_SUBGENUS) {

					//differ between isParanthesis= true and false

							infraGenericEpithet.append(parentName),

							fauEuTaxon);

						nameCacheStringBuilder.append(genusSubGenusPart);

				} else if(parentRankId == R_GENUS) {

							genusOrUninomial.append(parentName));

					nameCacheStringBuilder.append(genusPart);

				}

				if(grandParentRankId == R_SUBGENUS) {

							infraGenericEpithet.append(grandParentName),

							fauEuTaxon);

					nameCacheStringBuilder.append(genusSubGenusPart);

				} else if (grandParentRankId == R_GENUS) {

							genusOrUninomial.append(grandParentName));

					nameCacheStringBuilder.append(genusPart);

				infraSpecificEpithet.append(localName);

			}

		} else { // Synonym or misapplied name

			if (rank == R_SPECIES) {

				if(grandParentRankId == R_SUBGENUS) {

							infraGenericEpithet.append(grandParentName),

							fauEuTaxon);

					nameCacheStringBuilder.append(genusSubGenusPart);

				} else if (grandParentRankId == R_GENUS) {

							genusOrUninomial.append(grandParentName));

					nameCacheStringBuilder.append(genusPart);

				specificEpithet.append(localName);

			} else if (rank == R_SUBSPECIES) {

				String greatGreatGrandParentName = fauEuTaxon.getGreatGreatGrandParentName();

				if(greatGrandParentRankId == R_SUBGENUS) {

							infraGenericEpithet.append(greatGrandParentName),

							fauEuTaxon);

					nameCacheStringBuilder.append(genusSubGenusPart);

				} else if (greatGrandParentRankId == R_GENUS) {

							genusOrUninomial.append(greatGreatGrandParentName));

					nameCacheStringBuilder.append(genusPart);

				}

				nameCacheStringBuilder.append(grandParentName);

				nameCacheStringBuilder.append(" ");

				specificEpithet.append(grandParentName);

				nameCacheStringBuilder.append(localName);

				infraSpecificEpithet.append(localName);

			}

		}

		return nameCacheStringBuilder.toString();

	}

	/** Build taxon's name parts and caches */

	private String buildTaxonName(FaunaEuropaeaTaxon fauEuTaxon, TaxonBase<?> taxonBase, TaxonNameBase<?,?>taxonName,

			boolean useOriginalGenus, FaunaEuropaeaImportConfigurator fauEuConfig) {

		String completeString = "";

		StringBuilder acceptedGenus = new StringBuilder("");

		StringBuilder genusOrUninomial = new StringBuilder();

		StringBuilder specificEpithet = new StringBuilder();

		StringBuilder infraSpecificEpithet = new StringBuilder();

		localString = fauEuTaxon.getLocalName();

		int rank = fauEuTaxon.getRankId();

		// determine genus: this also works for cases of synonyms since the accepted taxon is its parent

		String acceptedGenusString = null;

		String tempAcceptedGenusString = determineAcceptedGenus(fauEuTaxon);

			acceptedGenus = new StringBuilder(acceptedGenusString);

		}

		}

		if (rank < R_SPECIES) {

			if (rank == R_SUBGENUS) {

				// subgenus part

				infraGenericEpithet.append(localString);

				// genus part

				genusOrUninomial.append(acceptedGenus);

				completeString = acceptedGenus + " ("+ localString + ")";

			} else {

				// genus or above

				genusOrUninomial.append(localString);

			}

		} else {

			// species or below

			taxonBase = taxonBase.deproxy(taxonBase, TaxonBase.class);

						genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet,

						fauEuTaxon);

			completeString = (String) CdmUtils.removeDuplicateWhitespace(completeString.trim());

		}

		return setCompleteTaxonName(completeString, useOriginalGenus,

				specificEpithet.toString(), infraSpecificEpithet.toString(),

				fauEuTaxon, taxonBase, fauEuConfig);

	}

	/**

	 * Determines the original genus name by searching the taxon with rank Genus.

	 * @param fauEuTaxon

		ranks.put(fauEuTaxon.getGreatGrandParentRankId(), fauEuTaxon.getGreatGrandParentName());

		ranks.put(fauEuTaxon.getGreatGreatGrandParentRankId(), fauEuTaxon.getGreatGreatGrandParentName());

		ranks.put(fauEuTaxon.getGreatGreatGreatGrandParentRankId(), fauEuTaxon.getGreatGreatGreatGrandParentName());

		originalGenus = ranks.get(R_GENUS);

		return originalGenus;

	/** Sets name parts and caches */

	private String setCompleteTaxonName(String concatString, boolean useOriginalGenus,

			FaunaEuropaeaTaxon fauEuTaxon, TaxonBase<?> taxonBase, FaunaEuropaeaImportConfigurator fauEuConfig) {

		boolean success = true;

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

		ZoologicalName zooName = (ZoologicalName)taxonName;

		if (!genusOrUninomial.equals("")) {

			zooName.setGenusOrUninomial(emptyToNull(genusOrUninomial));

			}

		}

		//if ((!infraGenericEpithet.equals("") && fauEuTaxon.isParenthesis()) || (!infraGenericEpithet.equals("") && fauEuTaxon.)) {

		if (fauEuTaxon.getParentRankId() == R_SUBGENUS || fauEuTaxon.getRankId() == R_SUBGENUS ||

				fauEuTaxon.getGrandParentRankId() == R_SUBGENUS || fauEuTaxon.getGreatGrandParentRankId() == R_SUBGENUS) {

			zooName.setInfraGenericEpithet(emptyToNull(infraGenericEpithet));

			}

		}

		if ((fauEuTaxon.getRankId() == R_SPECIES || fauEuTaxon.getRankId() == R_SUBSPECIES)) {

			zooName.setSpecificEpithet(emptyToNull(specificEpithet));

			}

		}

		if (fauEuTaxon.getRankId() == R_SUBSPECIES) {

			zooName.setInfraSpecificEpithet(emptyToNull(infraSpecificEpithet));

			}

		}

		//TODO: use generate NameCache

		//titleCache = buildNameFullTitleCache(concatString, fauEuConfig);

//		zooName.generateFullTitle();

		//zooName.setFullTitleCache(titleCache); // TODO: Add reference, NC status

//				fauEuTaxon.getId(), "TaxonName");

//		taxonBase.setSec(fauEuConfig.getSourceReference());

//		taxonBase.generateTitle();

		//titleCache = buildTaxonTitleCache(concatString, fauEuConfig.getSourceReference());

		//taxonBase.setTitleCache(titleCache);

		}

		return result;

	}

			return text;

		}

	}

}