EDIT

/**

* 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.strategy.parser;

import java.util.HashSet;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.joda.time.DateTimeFieldType;

import org.joda.time.Partial;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

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

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

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

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

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

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.name.ZoologicalName;

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.strategy.exceptions.StringNotParsableException;

import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;

/**

 * @author a.mueller

 *

 */

public class NonViralNameParserImpl extends NonViralNameParserImplRegExBase implements INonViralNameParser<NonViralName> {

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

	// good intro: http://java.sun.com/docs/books/tutorial/essential/regex/index.html

	final static boolean MAKE_EMPTY = true;

	final static boolean MAKE_NOT_EMPTY = false;

	private final boolean authorIsAlwaysTeam = false;

	public static NonViralNameParserImpl NewInstance(){

		return new NonViralNameParserImpl();

	}

	@Override

    public NonViralName parseSimpleName(String simpleName){

		return parseSimpleName(simpleName, null, null);

	}

	@Override

    public NonViralName parseSimpleName(String simpleName, NomenclaturalCode code, Rank rank){

		//"parseSimpleName() not yet implemented. Uses parseFullName() instead");

		return parseFullName(simpleName, code, rank);

	}

	public void parseSimpleName(NonViralName nameToBeFilled, String simpleNameString, Rank rank, boolean makeEmpty){

		//"parseSimpleName() not yet implemented. Uses parseFullName() instead");

		parseFullName(nameToBeFilled, simpleNameString, rank, makeEmpty);

	}

	public NonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code){

		return getNonViralNameInstance(fullString, code, null);

	}

	public NonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code, Rank rank){

		NonViralName<?> result = null;

		if(code ==null) {

			boolean isBotanicalName = anyBotanicFullNamePattern.matcher(fullString).find();

			boolean isZoologicalName = anyZooFullNamePattern.matcher(fullString).find();;

			boolean isBacteriologicalName = false;

			boolean isCultivatedPlantName = false;

			if ( (isBotanicalName || isCultivatedPlantName) && ! isZoologicalName && !isBacteriologicalName){

				if (isBotanicalName){

					result = BotanicalName.NewInstance(rank);

				}else{

					result = CultivarPlantName.NewInstance(rank);

				}

			}else if ( isZoologicalName /*&& ! isBotanicalName*/ && !isBacteriologicalName && !isCultivatedPlantName){

				result = ZoologicalName.NewInstance(rank);

			}else if ( isZoologicalName && ! isBotanicalName && !isBacteriologicalName && !isCultivatedPlantName){

				result = BacterialName.NewInstance(rank);

			}else {

				result =  NonViralName.NewInstance(rank);

			}

		} else {

			switch (code) {

			case ICNAFP:

				result = BotanicalName.NewInstance(rank);

				break;

			case ICZN:

				result = ZoologicalName.NewInstance(rank);

				break;

			case ICNCP:

				logger.warn("ICNCP parsing not yet implemented");

				result = CultivarPlantName.NewInstance(rank);

				break;

			case ICNB:

				logger.warn("ICNB not yet implemented");

				result = BacterialName.NewInstance(rank);

				break;

			case ICVCN:

				logger.error("Viral name is not a NonViralName !!");

				break;

			default:

				// FIXME Unreachable code

				logger.error("Unknown Nomenclatural Code !!");

			}

		}

		return result;

	}

	@Override

    public NonViralName parseReferencedName(String fullReferenceString) {

		return parseReferencedName(fullReferenceString, null, null);

	}

	@Override

    public NonViralName parseReferencedName(String fullReferenceString, NomenclaturalCode nomCode, Rank rank) {

		if (fullReferenceString == null){

			return null;

		}else{

			NonViralName<?> result = getNonViralNameInstance(fullReferenceString, nomCode, rank);

			parseReferencedName(result, fullReferenceString, rank, MAKE_EMPTY);

			return result;

		}

	}

	private String standardize(NonViralName<?> nameToBeFilled, String fullReferenceString, boolean makeEmpty){

		//Check null and standardize

		if (fullReferenceString == null){

			//return null;

			return null;

		}

		if (makeEmpty){

			makeEmpty(nameToBeFilled);

		}

		fullReferenceString = fullReferenceString.replaceAll(oWs , " ");

		fullReferenceString = fullReferenceString.trim();

		if ("".equals(fullReferenceString)){

			fullReferenceString = null;

		}

		return fullReferenceString;

	}

	/**

	 * Returns the regEx to be used for the full-name depending on the code

	 * @param nameToBeFilled

	 * @return

	 */

	private String getCodeSpecificFullNameRegEx(NonViralName<?> nameToBeFilledOrig){

	    NonViralName<?> nameToBeFilled = HibernateProxyHelper.deproxy(nameToBeFilledOrig, NonViralName.class);

		if (nameToBeFilled instanceof ZoologicalName){

			return anyZooFullName;

		}else if (nameToBeFilled instanceof BotanicalName) {

			return anyBotanicFullName;

		}else if (nameToBeFilled instanceof NonViralName) {

			return anyBotanicFullName;  //TODO ?

		}else{

			logger.warn("nameToBeFilled class not supported ("+nameToBeFilled.getClass()+")");

			return null;

		}

	}

	/**

	 * Returns the regEx to be used for the fsimple-name depending on the code

	 * @param nameToBeFilled

	 * @return

	 */

	private String getCodeSpecificSimpleNameRegEx(NonViralName<?> nameToBeFilled){

		nameToBeFilled = HibernateProxyHelper.deproxy(nameToBeFilled, NonViralName.class);

		if (nameToBeFilled instanceof ZoologicalName){

			return anyZooName;

		}else if (nameToBeFilled instanceof NonViralName){

			return anyZooName;  //TODO ?

		}else if (nameToBeFilled instanceof BotanicalName) {

			return anyBotanicName;

		}else{

			logger.warn("nameToBeFilled class not supported ("+nameToBeFilled.getClass()+")");

			return null;

		}

	}

	private Matcher getMatcher(String regEx, String matchString){

		Pattern pattern = Pattern.compile(regEx);

		Matcher matcher = pattern.matcher(matchString);

		return matcher;

	}

	@Override

    public void parseReferencedName(NonViralName nameToBeFilled, String fullReferenceStringOrig, Rank rank, boolean makeEmpty) {

		//standardize

		String fullReferenceString = standardize(nameToBeFilled, fullReferenceStringOrig, makeEmpty);

		if (fullReferenceString == null){

			return;

		}

		// happens already in standardize(...)

//		makeProblemEmpty(nameToBeFilled);

		//make nomenclatural status and replace it by empty string

	    fullReferenceString = parseNomStatus(fullReferenceString, nameToBeFilled, makeEmpty);

	    nameToBeFilled.setProblemEnds(fullReferenceString.length());

	    //get full name reg

		String localFullNameRegEx = getCodeSpecificFullNameRegEx(nameToBeFilled);

		//get full name reg

		String localSimpleNameRegEx = getCodeSpecificSimpleNameRegEx(nameToBeFilled);

		//separate name and reference part

		String nameAndRefSeparatorRegEx = "(^" + localFullNameRegEx + ")("+ referenceSeperator + ")";

		Matcher nameAndRefSeparatorMatcher = getMatcher (nameAndRefSeparatorRegEx, fullReferenceString);

		Matcher onlyNameMatcher = getMatcher (localFullNameRegEx, fullReferenceString);

		Matcher hybridMatcher = hybridFormulaPattern.matcher(fullReferenceString);

		Matcher onlySimpleNameMatcher = getMatcher (localSimpleNameRegEx, fullReferenceString);

		if (onlyNameMatcher.matches()){

			makeEmpty = false;

			parseFullName(nameToBeFilled, fullReferenceString, rank, makeEmpty);

		} else if (nameAndRefSeparatorMatcher.find()){

			makeNameWithReference(nameToBeFilled, fullReferenceString, nameAndRefSeparatorMatcher, rank, makeEmpty);

		}else if (hybridMatcher.matches() ){

		    //I do not remember why we need makeEmpty = false for onlyNameMatcher,

		    //but for hybridMatcher we need to remove old Hybrid Relationships if necessary, therefore

		    //I removed it from here

            parseFullName(nameToBeFilled, fullReferenceString, rank, makeEmpty);

        }else if (onlySimpleNameMatcher.matches()){

			makeEmpty = false;

			parseFullName(nameToBeFilled, fullReferenceString, rank, makeEmpty);	//simpleName not yet implemented

		}else{

			makeNoFullRefMatch(nameToBeFilled, fullReferenceString, rank);

		}

		//problem handling. Start and end solved in subroutines

		if (! nameToBeFilled.hasProblem()){

			makeProblemEmpty(nameToBeFilled);

		}

	}

	private void makeProblemEmpty(IParsable parsable){

		boolean hasCheckRank = parsable.hasProblem(ParserProblem.CheckRank);

		parsable.setParsingProblem(0);

		if (hasCheckRank){

			parsable.addParsingProblem(ParserProblem.CheckRank);

		}

		parsable.setProblemStarts(-1);

		parsable.setProblemEnds(-1);

	}

	private void makeNoFullRefMatch(NonViralName<?> nameToBeFilled, String fullReferenceString, Rank rank){

	    //try to parse first part as name, but keep in mind full string is not parsable

		int start = 0;

		String localFullName = getCodeSpecificFullNameRegEx(nameToBeFilled);

		Matcher fullNameMatcher = getMatcher (pStart + localFullName, fullReferenceString);

		if (fullNameMatcher.find()){

			String fullNameString = fullNameMatcher.group(0);

			nameToBeFilled.setProtectedNameCache(false);

			parseFullName(nameToBeFilled, fullNameString, rank, false);

			String sure = nameToBeFilled.getNameCache();

			start = sure.length();

		}

//		String localSimpleName = getLocalSimpleName(nameToBeFilled);

//		Matcher simpleNameMatcher = getMatcher (start + localSimpleName, fullReferenceString);

//		if (simpleNameMatcher.find()){

//			String simpleNameString = simpleNameMatcher.group(0);

//			parseFullName(nameToBeFilled, simpleNameString, rank, false);

//			start = simpleNameString.length();

//		}

		//don't parse if name can't be separated

		nameToBeFilled.addParsingProblem(ParserProblem.NameReferenceSeparation);

		nameToBeFilled.setTitleCache(fullReferenceString, true);

		nameToBeFilled.setFullTitleCache(fullReferenceString, true);

		// FIXME Quick fix, otherwise search would not deliver results for unparsable names

		nameToBeFilled.setNameCache(fullReferenceString, true);

		// END

		nameToBeFilled.setProblemStarts(start);

		nameToBeFilled.setProblemEnds(fullReferenceString.length());

		logger.info("no applicable parsing rule could be found for \"" + fullReferenceString + "\"");

	}

	private void makeNameWithReference(NonViralName<?> nameToBeFilled,

			String fullReferenceString,

			Matcher nameAndRefSeparatorMatcher,

			Rank rank,

			boolean makeEmpty){

		String nameAndSeparator = nameAndRefSeparatorMatcher.group(0);

	    String name = nameAndRefSeparatorMatcher.group(1);

	    String referenceString = fullReferenceString.substring(nameAndRefSeparatorMatcher.end());

	    // is reference an in ref?

	    String separator = nameAndSeparator.substring(name.length());

		boolean isInReference = separator.matches(inReferenceSeparator);

	    //parse subparts

		int oldProblemEnds = nameToBeFilled.getProblemEnds();

		parseFullName(nameToBeFilled, name, rank, makeEmpty);

	    nameToBeFilled.setProblemEnds(oldProblemEnds);

		//zoological new combinations should not have a nom. reference to be parsed

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

			ZoologicalName zooName = CdmBase.deproxy(nameToBeFilled, ZoologicalName.class);

			//is name new combination?

			if (zooName.getBasionymAuthorship() != null || zooName.getOriginalPublicationYear() != null){

				ParserProblem parserProblem = ParserProblem.NewCombinationHasPublication;

				zooName.addParsingProblem(parserProblem);

				nameToBeFilled.setProblemStarts((nameToBeFilled.getProblemStarts()> -1) ? nameToBeFilled.getProblemStarts(): name.length());

				nameToBeFilled.setProblemEnds(Math.max(fullReferenceString.length(), nameToBeFilled.getProblemEnds()));

			}

		}

	    parseReference(nameToBeFilled, referenceString, isInReference);

	    INomenclaturalReference ref = nameToBeFilled.getNomenclaturalReference();

	    //problem start

	    int start = nameToBeFilled.getProblemStarts();

	    int nameLength = name.length();

	    int nameAndSeparatorLength = nameAndSeparator.length();

	    int fullRefLength = nameToBeFilled.getFullTitleCache().length();

	    if (nameToBeFilled.isProtectedTitleCache() || nameToBeFilled.getParsingProblems().contains(ParserProblem.CheckRank)){

	    	start = Math.max(0, start);

		}else{

			if (ref != null && ref.getParsingProblem()!=0){

				start = Math.max(nameAndSeparatorLength, start);

		    	//TODO search within ref

			}

		}

	    //end

	    int end = nameToBeFilled.getProblemEnds();

	    if (ref != null && ref.getParsingProblem()!=0){

	    	end = Math.min(nameAndSeparatorLength + ref.getProblemEnds(), end);

	    }else{

	    	if (nameToBeFilled.isProtectedTitleCache() ){

	    		end = Math.min(end, nameAndSeparatorLength);

	    		//TODO search within name

			}

	    }

	    nameToBeFilled.setProblemStarts(start);

	    nameToBeFilled.setProblemEnds(end);

	    //delegate has problem to name

	    if (ref != null && ref.getParsingProblem()!=0){

	    	nameToBeFilled.addParsingProblems(ref.getParsingProblem());

	    }

	    Reference nomRef;

		if ( (nomRef = (Reference)nameToBeFilled.getNomenclaturalReference()) != null ){

			nomRef.setAuthorship(nameToBeFilled.getCombinationAuthorship());

		}

	}

	//TODO make it an Array of status

	/**

	 * Extracts a {@link NomenclaturalStatus} from the reference String and adds it to the @link {@link TaxonNameBase}.

	 * The nomenclatural status part ist deleted from the reference String.

	 * @return  String the new (shortend) reference String

	 */

	public String parseNomStatus(String fullString, NonViralName<?> nameToBeFilled, boolean makeEmpty) {

		Set<NomenclaturalStatusType> existingStatusTypeSet = new HashSet<NomenclaturalStatusType>();

		Set<NomenclaturalStatusType> newStatusTypeSet = new HashSet<NomenclaturalStatusType>();

		for (NomenclaturalStatus existingStatus : nameToBeFilled.getStatus()){

			existingStatusTypeSet.add(existingStatus.getType());

		}

		String statusString;

		Pattern hasStatusPattern = Pattern.compile("(" + pNomStatusPhrase + ")");

		Matcher hasStatusMatcher = hasStatusPattern.matcher(fullString);

		if (hasStatusMatcher.find()) {

			String statusPhrase = hasStatusMatcher.group(0);

			Pattern statusPattern = Pattern.compile(pNomStatus);

			Matcher statusMatcher = statusPattern.matcher(statusPhrase);

			statusMatcher.find();

			statusString = statusMatcher.group(0);

			try {

				NomenclaturalStatusType nomStatusType = NomenclaturalStatusType.getNomenclaturalStatusTypeByAbbreviation(statusString, nameToBeFilled);

				if (! existingStatusTypeSet.contains(nomStatusType)){

					NomenclaturalStatus nomStatus = NomenclaturalStatus.NewInstance(nomStatusType);

					nameToBeFilled.addStatus(nomStatus);

				}

				newStatusTypeSet.add(nomStatusType);

				fullString = fullString.replace(statusPhrase, "");

			} catch (UnknownCdmTypeException e) {

				//Do nothing

			}

		}

		//remove not existing nom status

		if (makeEmpty){

			Set<NomenclaturalStatus> tmpStatus = new HashSet<NomenclaturalStatus>();

			tmpStatus.addAll(nameToBeFilled.getStatus());

			for (NomenclaturalStatus status : tmpStatus){

				if (! newStatusTypeSet.contains(status.getType())){

					nameToBeFilled.removeStatus(status);

				}

			}

		}

		return fullString;

	}

	private void parseReference(NonViralName<?> nameToBeFilled, String strReference, boolean isInReference){

		INomenclaturalReference ref;

		String originalStrReference = strReference;

		//End (just delete end (e.g. '.', may be ambigous for yearPhrase, but no real information gets lost

		Matcher endMatcher = getMatcher(referenceEnd + end, strReference);

		if (endMatcher.find()){

			String endPart = endMatcher.group(0);

			strReference = strReference.substring(0, strReference.length() - endPart.length());

		}

//		String pDetailYear = ".*" + detailSeparator + detail + fWs + yearSeperator + fWs + yearPhrase + fWs + end;

//		Matcher detailYearMatcher = getMatcher(pDetailYear, strReference);

		String strReferenceWithYear = strReference;

		//year

		String yearPart = null;

		String pYearPhrase = yearSeperator + fWs + yearPhrase + fWs + end;

		Matcher yearPhraseMatcher = getMatcher(pYearPhrase, strReference);

		if (yearPhraseMatcher.find()){

			yearPart = yearPhraseMatcher.group(0);

			strReference = strReference.substring(0, strReference.length() - yearPart.length());

			yearPart = yearPart.replaceFirst(pStart + yearSeperator, "").trim();

		}else{

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

				ZoologicalName zooName = CdmBase.deproxy(nameToBeFilled, ZoologicalName.class);

				yearPart = String.valueOf(zooName.getPublicationYear());

				//continue

			}else{

				ref = makeDetailYearUnparsable(nameToBeFilled,strReference);

				ref.setDatePublished(TimePeriodParser.parseString(yearPart));

				return;

			}

		}

		//detail

		String pDetailPhrase = detailSeparator + fWs + detail + fWs + end;

		Matcher detailPhraseMatcher = getMatcher(pDetailPhrase, strReference);

		if (detailPhraseMatcher.find()){

			String detailPart = detailPhraseMatcher.group(0);

			strReference = strReference.substring(0, strReference.length() - detailPart.length());

			detailPart = detailPart.replaceFirst(pStart + detailSeparator, "").trim();

			nameToBeFilled.setNomenclaturalMicroReference(detailPart);

		}else{

			makeDetailYearUnparsable(nameToBeFilled, strReferenceWithYear);

			return;

		}

		//parse title and author

		ref = parseReferenceTitle(strReference, yearPart, isInReference);

		if (ref.hasProblem()){

		    //we need to protect both caches otherwise the titleCache is incorrectly build from atomized parts

			ref.setTitleCache( (isInReference ? "in ":"") +  originalStrReference, true);

			ref.setAbbrevTitleCache( (isInReference ? "in ":"") +  originalStrReference, true);

		}

		nameToBeFilled.setNomenclaturalReference(ref);

		int end = Math.min(strReference.length(), ref.getProblemEnds());

		ref.setProblemEnds(end);

	}

	/**

	 * @param nameToBeFilled

	 * @param strReference

	 * @return

	 */

	private Reference makeDetailYearUnparsable(NonViralName<?> nameToBeFilled, String strReference) {

		Reference ref;

		ref = ReferenceFactory.newGeneric();

		ref.setTitleCache(strReference, true);

        ref.setAbbrevTitleCache(strReference, true);

		ref.setProblemEnds(strReference.length());

		ref.addParsingProblem(ParserProblem.CheckDetailOrYear);

		nameToBeFilled.addParsingProblem(ParserProblem.CheckDetailOrYear);

		nameToBeFilled.setNomenclaturalReference(ref);

		return ref;

	}

	/**

	 * Parses the referenceTitlePart, including the author volume and edition.

	 * @param reference

	 * @param year

	 * @return

	 */

	private INomenclaturalReference parseReferenceTitle(String strReference, String year, boolean isInReference){

		IBook result = null;

		Matcher refSineDetailMatcher = referenceSineDetailPattern.matcher(strReference);

		if (! refSineDetailMatcher.matches()){

			//TODO ?

		}

		Matcher articleMatcher = getMatcher(pArticleReference, strReference);

		Matcher bookMatcher = getMatcher(pBookReference, strReference);

		Matcher softArticleMatcher = getMatcher(pSoftArticleReference, strReference);

		Matcher bookSectionMatcher = getMatcher(pBookSectionReference, strReference);

		if(isInReference == false){

			if (bookMatcher.matches() ){

				result = parseBook(strReference);

			}else{

				logger.warn("Non-InRef must be book but does not match book: "+ strReference);

				result = ReferenceFactory.newBook();

				makeUnparsableRefTitle(result, strReference);

			}

		}else{  //inRef

			if (articleMatcher.matches()){

				//article without separators like ","

				result = parseArticle(strReference);

			}else if (softArticleMatcher.matches()){

				result = parseArticle(strReference);

			}else if (bookSectionMatcher.matches()){

				result = parseBookSection(strReference);

			}else{

				result =  ReferenceFactory.newGeneric();

				makeUnparsableRefTitle(result, "in " + strReference);

			}

		}

		//make year

		if (makeYear(result, year) == false){

			//TODO

			logger.warn("Year could not be parsed");

		}

		result.setProblemStarts(0);

		result.setProblemEnds(strReference.length());

		return result;

	}

	private void makeUnparsableRefTitle(INomenclaturalReference result, String reference){

	    //need to set both to protected otherwise titleCache is created from atomized parts

	    result.setTitleCache(reference, true);

		result.setAbbrevTitleCache(reference, true);

		result.addParsingProblem(ParserProblem.UnparsableReferenceTitle);

	}

	/**

	 * Parses a single date string. If the string is not parsable a StringNotParsableException is thrown

	 * @param singleDateString

	 * @return

	 * @throws StringNotParsableException

	 */

	private static Partial parseSingleDate(String singleDateString)

			throws StringNotParsableException{

		Partial dt = new Partial();

		if (CdmUtils.isNumeric(singleDateString)){

			try {

				Integer year = Integer.valueOf(singleDateString.trim());

				if (year > 1750 && year < 2050){

					dt = dt.with(DateTimeFieldType.year(), year);

				}else{

					dt = null;

				}

			} catch (NumberFormatException e) {

				logger.debug("Not a Integer format in getCalendar()");

				throw new StringNotParsableException(singleDateString + "is not parsable as a single Date");

			}

		}

		return dt;

	}

	/**

	 * Parses the publication date part.

	 * @param nomRef

	 * @param year

	 * @return If the string is not parsable <code>false</code>

	 * is returned. <code>True</code> otherwise

	 */

	private boolean makeYear(INomenclaturalReference nomRef, String year){

		boolean result = true;

		if (year == null){

			return false;

		}

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

			return true;

		}

		TimePeriod datePublished = TimePeriodParser.parseString(year);

		if (nomRef.getType().equals(ReferenceType.BookSection)){

			handleBookSectionYear((IBookSection)nomRef, datePublished);

		}else if (nomRef instanceof Reference){

			((Reference)nomRef).setDatePublished(datePublished);

		}else{

			throw new ClassCastException("nom Ref is not of type Reference but " + (nomRef == null? "(null)" : nomRef.getClass()));

		}

		return result;

	}

	private String makeVolume(IVolumeReference nomRef, String strReference){

		//volume

		String volPart = null;

		String pVolPhrase = volumeSeparator +  volume + end;

		Matcher volPhraseMatcher = getMatcher(pVolPhrase, strReference);

		if (volPhraseMatcher.find()){

			volPart = volPhraseMatcher.group(0);

			strReference = strReference.substring(0, strReference.length() - volPart.length());

			volPart = volPart.replaceFirst(pStart + volumeSeparator, "").trim();

			nomRef.setVolume(volPart);

		}

		return strReference;

	}

	private String makeEdition(IBook book, String strReference){

		//volume

		String editionPart = null;

		Matcher editionPhraseMatcher = getMatcher(pEditionPart, strReference);

		Matcher editionVolumeMatcher = getMatcher(pEditionVolPart, strReference);

		boolean isEditionAndVol = editionVolumeMatcher.find();

		if (editionPhraseMatcher.find()){

			editionPart = editionPhraseMatcher.group(0);

			int pos = strReference.indexOf(editionPart);

			int posEnd = pos + editionPart.length();

			if (isEditionAndVol){

				posEnd++;  //delete also comma

			}

			strReference = strReference.substring(0, pos) + strReference.substring(posEnd);

			editionPart = editionPart.replaceFirst(pStart + editionSeparator, "").trim();

			book.setEdition(editionPart);

		}

		return strReference;

	}

	private IBook parseBook(String reference){

		IBook result = ReferenceFactory.newBook();

		reference = makeEdition(result, reference);

		reference = makeVolume(result, reference);

		result.setAbbrevTitle(reference);

		return result;

	}

	private Reference parseArticle(String reference){

		//if (articlePatter)

		//(type, author, title, volume, editor, series;

		Reference result = ReferenceFactory.newArticle();

		reference = makeVolume(result, reference);

		Reference inJournal = ReferenceFactory.newJournal();

		inJournal.setAbbrevTitle(reference);

		result.setInReference(inJournal);

		return result;

	}

	private Reference parseBookSection(String reference){

		Reference result = ReferenceFactory.newBookSection();

		Pattern authorPattern = Pattern.compile("^" + authorTeam + referenceAuthorSeparator);

		Matcher authorMatcher = authorPattern.matcher(reference);

		boolean find = authorMatcher.find();

		if (find){

			String authorString = authorMatcher.group(0).trim();

			String bookString = reference.substring(authorString.length()).trim();

			authorString = authorString.substring(0, authorString.length() -1);

			TeamOrPersonBase<?> authorTeam = author(authorString);

			IBook inBook = parseBook(bookString);

			inBook.setAuthorship(authorTeam);

			result.setInBook(inBook);

		}else{

			logger.warn("Unexpected non matching book section author part");

			//TODO do we want to record a 'problem' here?

			result.setTitleCache(reference, true);

			result.setAbbrevTitleCache(reference, true);

		}

		return result;

	}

	/**

	 * If the publication date of a book section and it's inBook do differ this is usually

	 * caused by the fact that a book has been published during a period, because originally

	 * it consisted of several parts that only later where put together to one book.

	 * If so, the book section's publication date may be a point in time (year or month of year)

	 * whereas the books publication date may be a period of several years.

	 * Therefore a valid nomenclatural reference string should use the book sections

	 * publication date rather then the book's publication date.<BR>

	 * This method in general adds the publication date to the book section.

	 * An exception exists if the publication date is a period. Then the parser

	 * assumes that the nomenclatural reference string does not follow the above rule but

	 * the books publication date is set.

	 * @param bookSection

	 * @param datePublished

	 */

	private void handleBookSectionYear(IBookSection bookSection, TimePeriod datePublished){

		if (datePublished == null || datePublished.getStart() == null || bookSection == null){

			return;

		}

		if (datePublished.isPeriod() && bookSection.getInBook() != null){

			bookSection.getInBook().setDatePublished(datePublished);

		}else{

			bookSection.setDatePublished(datePublished);

		}

	}

	@Override

    public NonViralName parseFullName(String fullNameString){

		return parseFullName(fullNameString, null, null);

	}

	@Override

    public NonViralName parseFullName(String fullNameString, NomenclaturalCode nomCode, Rank rank) {

		if (fullNameString == null){

			return null;

		}else{

			NonViralName<?> result = getNonViralNameInstance(fullNameString, nomCode, rank);

			parseFullName(result, fullNameString, rank, false);

			return result;

		}

	}

	@Override

	public void parseFullName(NonViralName nameToBeFilledOrig, String fullNameStringOrig, Rank rank, boolean makeEmpty) {

	    NonViralName<?> nameToBeFilled = nameToBeFilledOrig;

	    //TODO prol. etc.

		boolean hasCheckRankProblem = false; //was rank guessed in a previous parsing process?

		if (nameToBeFilled == null){

			throw new IllegalArgumentException("NameToBeFilled must not be null in name parser");

		}else{

			hasCheckRankProblem = nameToBeFilled.hasProblem(ParserProblem.CheckRank);

			nameToBeFilled.removeParsingProblem(ParserProblem.CheckRank);

		}

		String authorString = null;

		if (fullNameStringOrig == null){

			return;

		}

		if (makeEmpty){

			makeEmpty(nameToBeFilled);

		}

		String fullNameString = fullNameStringOrig.replaceAll(oWs , " ").trim();

		fullNameString = removeHybridBlanks(fullNameString);

		String[] epi = pattern.split(fullNameString);

		try {

	    	//cultivars //TODO 2 implement cultivars

//		    if ( cultivarMarkerRE.match(fullName) ){ funktioniert noch nicht, da es z.B. auch Namen gibt, wie 't Hart

//		    	result = parseCultivar(fullName);

//		    }

		    if (genusOrSupraGenusPattern.matcher(fullNameString).matches()){

		    	//supraGeneric

				if (rank != null && ! hasCheckRankProblem  && (rank.isSupraGeneric()|| rank.isGenus())){

					nameToBeFilled.setRank(rank);

					nameToBeFilled.setGenusOrUninomial(epi[0]);

				}

				//genus or guess rank

				else {

					rank = guessUninomialRank(nameToBeFilled, epi[0]);

					nameToBeFilled.setRank(rank);

					nameToBeFilled.setGenusOrUninomial(epi[0]);

					nameToBeFilled.addParsingProblem(ParserProblem.CheckRank);

					nameToBeFilled.setProblemStarts(0);

					nameToBeFilled.setProblemEnds(epi[0].length());

				}

				authorString = fullNameString.substring(epi[0].length());

			}

			 //infra genus

			 else if (infraGenusPattern.matcher(fullNameString).matches()){