EDIT

/**

 *

 */

package eu.etaxonomy.taxeditor.parser;

import java.util.ArrayList;

import java.util.List;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

import eu.etaxonomy.cdm.strategy.match.MatchException;

import eu.etaxonomy.cdm.strategy.match.MatchStrategyConfigurator.MatchStrategy;

import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>ParseHandler class.</p>

 *

 * @author n.hoffmann

 * @version $Id: $

 */

public class ParseHandler{

	private TaxonNameBase taxonNameBase;

	private class MatchMatrix {

		List<TaxonNameBase> duplicateNames = new ArrayList<TaxonNameBase>();

		List<INomenclaturalReference> duplicateReferences = new ArrayList<INomenclaturalReference>();

		List<INomenclaturalReference> duplicateInReferences = new ArrayList<INomenclaturalReference>();

		List<TeamOrPersonBase> duplicateCombinationAuthorships = new ArrayList<TeamOrPersonBase>();

		List<TeamOrPersonBase> duplicateExCombinationAuthorships = new ArrayList<TeamOrPersonBase>();

		List<TeamOrPersonBase> duplicateBasionymAuthorships = new ArrayList<TeamOrPersonBase>();

		List<TeamOrPersonBase> duplicateExBasionymAuthorships = new ArrayList<TeamOrPersonBase>();

	}

	private static NonViralNameParserImpl nonViralNameParser = NonViralNameParserImpl.NewInstance();

	/**

	 * The name that should get parsed

	 */

	private INonViralName name;

	private boolean doResolveInReferences;

	/**

	 * Creates a new instance

	 *

	 * @param textWidget

	 * @param name

	 */

	private ParseHandler(TaxonNameBase name){

		if(name == null){

			this.name = nonViralNameParser.getNonViralNameInstance("", PreferencesUtil.getPreferredNomenclaturalCode());

		}else{

			this.name = (NonViralName) HibernateProxyHelper.deproxy(name);

		}

	}

	/**

	 * Factory method to create a new instance of the this class

	 *

	 * @param textWidget	The text widget where the NonViralName may be entered into

	 * @param name			An initial NonViralName or null when creating a new name

	 * @return				An instance of this class

	 */

	public static ParseHandler NewInstance(TaxonNameBase name){

		return new ParseHandler(name);

	}

	/**

	 * Parses a given string and returns a <code>TaxonNameBase</code> instance with the

	 * results of the parsing.

	 *

	 * This method should be used to quickly create a new name from a string.

	 * Wherever the string will be parsed again in subsequent editing, an instance

	 * of <code>ParseHandler</code> should be attached to the text widget.

	 *

	 * @param unparsedNameString a {@link java.lang.String} object.

	 * @return a {@link eu.etaxonomy.cdm.model.name.TaxonNameBase} object.

	 */

	public static NonViralName parseReferencedName(String unparsedNameString, Rank rank){

	    NonViralName name = nonViralNameParser.parseReferencedName(unparsedNameString,

				PreferencesUtil.getPreferredNomenclaturalCode(), rank);

//		if (name.hasProblem()) {

//			name.setFullTitleCache(unparsedNameString);

//		}

		return name;

	}

	public static TaxonNameBase<?,?> parseName(String unparsedNameString, Rank rank){

		INonViralName name = nonViralNameParser.parseFullName(unparsedNameString,

				PreferencesUtil.getPreferredNomenclaturalCode(), rank);

		return (TaxonNameBase<?,?>)name;

	}

	/**

	 * Creates an empty <code>TaxonNameBase</code> instance with the nomenclatural code

	 * currently set in preferences.

	 *

	 * @return a {@link eu.etaxonomy.cdm.model.name.TaxonNameBase} object.

	 */

	public static TaxonNameBase<?,?> createEmptyName(){

		return (TaxonNameBase<?,?>)nonViralNameParser.getNonViralNameInstance("", PreferencesUtil.getPreferredNomenclaturalCode());

	}

	/**

	 * Parses the string that was entered into the text widget and returns a

	 * NonViralName object that resulted from the parsing process.

	 *

	 * @return	The parsed NonViralName object

	 */

	public INonViralName parse(String unparsedNameString){

//		String unparsedNameString = "";

//		try {

//			Method getText;

//			getText = textWidget.getClass().getDeclaredMethod("getText", null);

//			unparsedNameString = (String) getText.invoke(textWidget, null);

//		} catch (Exception e) {

//			// we should never get here

//			StoreUtil.error(this.getClass(), "Error trying to invoke getText method", e);

//		}

		nonViralNameParser.parseReferencedName(name, unparsedNameString,

				name.getRank(), true);

//		if (name.hasProblem()) {

//			name.setFullTitleCache(unparsedNameString);

//		}

		return name;

	}

	/**

	 * Parses the string that was entered into the text widget and returns a

	 * NonViralName object that resulted from the parsing process.

	 *

	 * The atomized fields (scientific name, author and reference) will be matched

	 * against the database to find possible duplicates. If duplicates were found

	 * the respective parts of the NonViralName will be replaced with the found

	 * objects.

	 *

	 * @return	The parsed NonViralName object

	 */

	public INonViralName parseAndResolveDuplicates(String unparsedNameString){

		INonViralName parsedName = parse(unparsedNameString);

		MatchMatrix matchMatrix = findMatches(parsedName);

		resolveDuplicates(parsedName, matchMatrix);

		return parsedName;

	}

	/**

	 * @param name The name to resolve duplicates for.

	 */

	private void resolveDuplicates(INonViralName name, MatchMatrix matchMatrix) {

		resolveDuplicateNames(name, matchMatrix);

		resolveAllDuplicateAuthors(name, matchMatrix);

		resolveDuplicateReferences(name, matchMatrix);

		if(matchMatrix.duplicateInReferences != null) {

            resolveDuplicateInReferences(name, matchMatrix);

        }

	}

	/**

	 * @param name The name to resolve duplicates for.

	 */

	private void resolveDuplicateNames(INonViralName name, MatchMatrix matchMatrix) {

		if (matchMatrix.duplicateNames.size() == 1){

			name = matchMatrix.duplicateNames.iterator().next();

		}else if(matchMatrix.duplicateNames.size() > 1){

			// FIXME TODO resolve multiple duplications. Use first match for a start

			name = matchMatrix.duplicateNames.iterator().next();

		}

	}

	/**

	 * @param name The name to resolve duplicates for.

	 */

	private void resolveDuplicateReferences(INonViralName name, MatchMatrix matchMatrix) {

		if(matchMatrix.duplicateReferences.size() == 1){

			// exactly one match. We assume that the user wants this reference

			INomenclaturalReference duplicate = matchMatrix.duplicateReferences.iterator().next();

			name.setNomenclaturalReference(duplicate);

		}else if(matchMatrix.duplicateReferences.size() > 1){

			// FIXME TODO resolve multiple duplications. Use first match for a start

			INomenclaturalReference duplicate = matchMatrix.duplicateReferences.iterator().next();

			name.setNomenclaturalReference(duplicate);

		}

	}

	/**

	 * @param name The name to resolve duplicates for.

	 */

	private void resolveDuplicateInReferences(INonViralName name, MatchMatrix matchMatrix) {

		Reference reference = (Reference) HibernateProxyHelper.deproxy(name.getNomenclaturalReference());

		if(matchMatrix.duplicateInReferences.size() > 0){

			Reference inReference = (Reference) matchMatrix.duplicateInReferences.iterator().next();

			reference.setInReference(inReference);

			MessagingUtils.warn(this.getClass(), reference.generateTitle());

			// FIXME TODO resolve multiple duplications. We use first match for a start

			MessagingUtils.warn(this.getClass(), reference.getTitleCache());

		}

	}

	/**

	 * @param name The name to resolve duplicates for.

	 */

	private void resolveAllDuplicateAuthors(INonViralName name, MatchMatrix matchMatrix) {

		if(matchMatrix.duplicateCombinationAuthorships.size() > 0){

			name.setCombinationAuthorship(matchMatrix.duplicateCombinationAuthorships.iterator().next());

			Reference reference = (Reference) name.getNomenclaturalReference();

			if(reference != null){

				reference.setAuthorship(matchMatrix.duplicateCombinationAuthorships.iterator().next());

			}

			// FIXME TODO resolve multiple duplications. We use first match for a start.

		}

		if(matchMatrix.duplicateExCombinationAuthorships.size() > 0){

			name.setExCombinationAuthorship(matchMatrix.duplicateExCombinationAuthorships.iterator().next());

			// FIXME TODO resolve multiple duplications. We use first match for a start.

		}

		if(matchMatrix.duplicateBasionymAuthorships.size() > 0){

			name.setBasionymAuthorship(matchMatrix.duplicateBasionymAuthorships.iterator().next());

			// FIXME TODO resolve multiple duplications. We use first match for a start.

		}

		if(matchMatrix.duplicateExBasionymAuthorships.size() > 0){

			name.setExBasionymAuthorship(matchMatrix.duplicateExBasionymAuthorships.iterator().next());

			// FIXME TODO resolve multiple duplications. We use first match for a start.

		}

	}

	/**

	 * Splits a NonViralName into its parts and calls methods to find matches for these

	 * parts in the database.

	 *

	 * @param name	The NonViralName to find matches for.

	 */

	private MatchMatrix findMatches(INonViralName name){

		MatchMatrix matchMatrix = new MatchMatrix();

		matchMatrix.duplicateNames = findMatchingLatinNames(name);

		matchMatrix.duplicateCombinationAuthorships = findMatchingAuthors(name.getCombinationAuthorship());

		matchMatrix.duplicateExCombinationAuthorships = findMatchingAuthors(name.getExCombinationAuthorship());

		matchMatrix.duplicateBasionymAuthorships = findMatchingAuthors(name.getBasionymAuthorship());

		matchMatrix.duplicateExBasionymAuthorships = findMatchingAuthors(name.getExBasionymAuthorship());

		INomenclaturalReference nomenclaturalReference = name.getNomenclaturalReference();

		// check if the reference has an inreference and also check if the inReference already exists

		if(nomenclaturalReference != null){

			Reference inReference = ((Reference)nomenclaturalReference).getInReference();

			if(inReference != null){

				doResolveInReferences = true;

				matchMatrix.duplicateInReferences = findMatchingNomenclaturalReference(inReference);

			}

		}

		matchMatrix.duplicateReferences = findMatchingNomenclaturalReference(nomenclaturalReference);

		return matchMatrix;

	}

	/**

	 * @param nomenclaturalReference	The NomenclaturalReference to find matches for.

	 * @return	A <code>List</code> of possibly matching NomenclaturalReference's.

	 */

	private List<INomenclaturalReference> findMatchingNomenclaturalReference(INomenclaturalReference nomenclaturalReference) {

		if(nomenclaturalReference == null) {

            return new ArrayList<INomenclaturalReference>();

        }

		try{

			return CdmStore.getCommonService().findMatching(nomenclaturalReference, MatchStrategy.Reference);

		}catch (MatchException e) {

			MessagingUtils.error(this.getClass(), "Error finding matching references", e);

		}

		return null;

	}

	/**

	 * @param authorTeam	The TeamOrPersonBase to find matches for.

	 * @return	A <code>List</code> of possibly matching TeamOrPersonBase's.

	 */

	private List<TeamOrPersonBase> findMatchingAuthors(TeamOrPersonBase authorTeam) {

		if(authorTeam == null){

			return new ArrayList<TeamOrPersonBase>();

		}

		try{

			return CdmStore.getCommonService().findMatching(authorTeam, MatchStrategy.TeamOrPerson);

		}catch (MatchException e) {

			MessagingUtils.error(this.getClass(), "Error finding matching authors", e);

		}

		return null;

	}

	/**

	 * @param taxonNameBase	The TaxonNameBase to find matches for.

	 * @return	A <code>List</code> of possibly matching TaxonNameBase's.

	 */

	private List<TaxonNameBase> findMatchingLatinNames(ITaxonNameBase taxonNameBase) {

		try {

			return CdmStore.getCommonService().findMatching(TaxonNameBase.castAndDeproxy(taxonNameBase), MatchStrategy.NonViralName);

		} catch (MatchException e) {

			MessagingUtils.error(this.getClass(), "Error finding matching names", e);

		}

		return null;

	}

}