EDIT

/**

* Copyright (C) 2007 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.taxeditor.parser;

import java.util.ArrayList;

import java.util.List;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import eu.etaxonomy.cdm.api.service.INameService;

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

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

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

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

 * @author a.mueller

 */

public class ParseHandler{

    public static final Logger logger = LogManager.getLogger(ParseHandler.class);

	private static NonViralNameParserImpl nonViralNameParser = NonViralNameParserImpl.NewInstance();

	/**

	 * The name that should get parsed

	 */

	private TaxonName name;

	/**

	 * Creates a new instance

	 */

	private ParseHandler(TaxonName name){

		if(name == null){

			this.name = createEmptyName();

		}else{

			this.name = 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(TaxonName name){

		return new ParseHandler(name);

	}

	/**

	 * Parses a given string and returns a <code>TaxonName</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 INonViralName parseReferencedName(String unparsedNameString, Rank rank){

	    INonViralName name = nonViralNameParser.parseReferencedName(unparsedNameString,

				PreferencesUtil.getPreferredNomenclaturalCode(), rank);

		return name;

	}

	public static TaxonName parseName(String unparsedNameString, Rank rank){

		INonViralName name = nonViralNameParser.parseFullName(unparsedNameString,

				PreferencesUtil.getPreferredNomenclaturalCode(), rank);

		return (TaxonName)name;

	}

	/**

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

	 * currently set in preferences.

	 *

	 * @return the newly created {@link TaxonName}.

	 */

	public static TaxonName createEmptyName(){

		return TaxonNameFactory.NewNameInstance(PreferencesUtil.getPreferredNomenclaturalCode(), null);

	}

	/**

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

		nonViralNameParser.parseReferencedName(name, unparsedNameString,

				name.getRank(), true);

		return name;

	}

	public INonViralName parseAndResolveDuplicates(String unparsedNameString){

//	    Instant time = java.time.Instant.now();

//	    logger.warn("Start resolve duplicate");

	    INonViralName result = parseAndResolveDuplicatesNew(unparsedNameString);

//	    INonViralName result = parseAndResolveDuplicatesOld(unparsedNameString);

//	    logger.warn("End resolve duplicate: "+ time.until(Instant.now(), ChronoUnit.MILLIS));

	    return result;

	}

	/**

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

	 * TaxonName 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 TaxonName parseAndResolveDuplicatesNew(String unparsedNameString){

		CdmStore.getService(INameService.class).parseName(name, unparsedNameString, null, true, true);

		return name;

	}

//********************************** OLD can be removed once parseAndResolveDuplicatesNew is stable ************************************/

    private class MatchMatrix {

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

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

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

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

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

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

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

    }

    /**

     * 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 TaxonName createEmptyNameOld(){

        return (TaxonName)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.

     *

     * 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 parseAndResolveDuplicatesOld(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 != null && matchMatrix.duplicateNames != null && 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);

        }

        //if reference is new but the in reference is already in db

        if (matchMatrix.duplicateReferences.size() == 0 && (name.getNomenclaturalReference() != null && name.getNomenclaturalReference().getInReference() != null) && matchMatrix.duplicateInReferences.size() > 0){

            resolveDuplicateInReferences(name, matchMatrix);

        }

    }

    /**

     * @param name The name to resolve duplicates for.

     */

    private void resolveDuplicateInReferences(INonViralName name, MatchMatrix matchMatrix) {

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

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

        }

        try{

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

        }catch (MatchException e) {

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

        }

        return null;

    }

    /**

     * @param taxonName The TaxonNameBase to find matches for.

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

     */

    private List<TaxonName> findMatchingLatinNames(ITaxonNameBase taxonName) {

        try {

            return CdmStore.getCommonService().findMatching(TaxonName.castAndDeproxy(taxonName), MatchStrategy.NonViralName);

        } catch (MatchException e) {

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

        }

        return null;

    }

}