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.cdm.io.cuba;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;

import eu.etaxonomy.cdm.io.excel.common.ExcelImporterBase;

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.description.Distribution;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.description.TaxonInteraction;

import eu.etaxonomy.cdm.model.description.TextData;

import eu.etaxonomy.cdm.model.location.NamedArea;

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

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

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

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

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

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;

import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;

import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;

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

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

/**

 * @author a.mueller

 * @created 05.01.2016

 */

@Component

public class CubaExcelImport extends ExcelImporterBase<CubaImportState> {

    private static final long serialVersionUID = -747486709409732371L;

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

    private static final String HOMONYM_MARKER = "\\s+homon.?$";

    private static final String DOUBTFUL_MARKER = "^\\?\\s?";

    private static UUID rootUuid = UUID.fromString("206d42e4-ac32-4f20-a093-14826014e667");

    private static UUID plantaeUuid = UUID.fromString("139e7314-dd19-4286-a01d-8cc94ef77a09");

    private static INonViralNameParser<?> nameParser = NonViralNameParserImpl.NewInstance();

    private static NomenclaturalCode nc = NomenclaturalCode.ICNAFP;

    private  static List<String> expectedKeys= Arrays.asList(new String[]{

            "Fam. default","Fam. FRC","Fam. A&S","Fam. FC",

            "Taxón","(Notas)","Syn.","End","Ind","Ind? D","Nat","Dud P","Adv","Cult C","CuW","PR PR*","Art","Hab(*)","May","Mat","IJ","CuC","VC","Ci","SS","CA","Cam","LT","CuE","Gr","Ho","SC","Gu","Esp","Ja","PR","Men","Bah","Cay","AmN","AmC","AmS","VM"});

	@Override

    protected void analyzeRecord(HashMap<String, String> record, CubaImportState state) {

	    //we do everything in firstPass here

    	return;

    }

    /**

     * @param record

     * @param state

     * @param taxon

     */

    private void makeCubanDistribution(HashMap<String, String> record, CubaImportState state) {

        try {

            NamedArea cuba = getNamedArea(state, state.getTransformer().getNamedAreaUuid("C"), null, null, null, null, null);

            TaxonDescription desc = getTaxonDescription(state.getCurrentTaxon(), false, true);

            List<PresenceAbsenceTerm> statuss =  makeCubanStatuss(record, state);

            for (PresenceAbsenceTerm status : statuss){

                Distribution distribution = Distribution.NewInstance(cuba, status);

                desc.addElement(distribution);

            }

        } catch (UndefinedTransformerMethodException e) {

            e.printStackTrace();

        }

    }

    /**

     * @param record

     * @param state

     * @return

     * @throws UndefinedTransformerMethodException

     */

    private List<PresenceAbsenceTerm> makeCubanStatuss(HashMap<String, String> record, CubaImportState state) throws UndefinedTransformerMethodException {

        boolean isAbsent = false;  //TODO

        PresenceAbsenceTerm highestStatus = null;

        String line = state.getCurrentLine() + ": ";

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

        String endemicStr = getValue(record, "End");

        String indigenousStr = getValue(record, "Ind");

        String indigenousDoubtStr = getValue(record, "Ind? D");

        String naturalisedStr = getValue(record, "Nat");

        String dudStr = getValue(record, "Dud P");

        String advStr = getValue(record, "Adv");

        String cultStr = getValue(record, "Cult C");

        if (endemicStr != null){

            if(endemicStr.equals("+")){

                PresenceAbsenceTerm endemicState = state.getTransformer().getPresenceTermByKey("E");

                result.add(endemicState);

                highestStatus = endemicState;

            }else if(isMinus(endemicStr)){

                UUID endemicUuid = state.getTransformer().getPresenceTermUuid("-E");

                PresenceAbsenceTerm endemicState = getPresenceTerm(state, endemicUuid, null, null, null, false);

                result.add(endemicState);

                checkAbsentHighestState(highestStatus, line, "endemic", false);

            }else if(endemicStr.equals("?")){

                UUID endemicDoubtfulUuid = state.getTransformer().getPresenceTermUuid("?E");

                PresenceAbsenceTerm endemicState = getPresenceTerm(state, endemicDoubtfulUuid, null, null, null, false);

                result.add(endemicState);

                checkAbsentHighestState(highestStatus, line, "endemic", false);

            }else{

                logger.warn(line + "Endemic not recognized: " + endemicStr);

            }

        }

        if (indigenousStr != null){

            if(indigenousStr.equals("+")){

                UUID indigenousUuid = state.getTransformer().getPresenceTermUuid("Ind.");

                PresenceAbsenceTerm indigenousState = getPresenceTerm(state, indigenousUuid, null, null, null, false);

                result.add(indigenousState);

                highestStatus = highestStatus != null ? highestStatus : indigenousState;

            }else if(isMinus(indigenousStr)){

                PresenceAbsenceTerm indigenousState = state.getTransformer().getPresenceTermByKey("-Ind.");

                result.add(indigenousState);

                checkAbsentHighestState(highestStatus, line, "indigenous", false);

            }else if(indigenousStr.equals("?")){

                UUID indigenousDoubtUuid = state.getTransformer().getPresenceTermUuid("?Ind.");

                PresenceAbsenceTerm indigenousDoubtState = getPresenceTerm(state, indigenousDoubtUuid, null, null, null, false);

                result.add(indigenousDoubtState);

                checkAbsentHighestState(highestStatus, line, "indigenous", true);

            }else{

                logger.warn(line + "Indigenous not recognized: " + indigenousStr);

            }

        }

        if(indigenousDoubtStr != null){

            if(indigenousDoubtStr.equals("D")){

                UUID indigenousDoubtUuid = state.getTransformer().getPresenceTermUuid("Ind.?");

                PresenceAbsenceTerm indigenousDoubtState = getPresenceTerm(state, indigenousDoubtUuid, null, null, null, false);

                result.add(indigenousDoubtState);

                highestStatus = highestStatus != null ? highestStatus : indigenousDoubtState;

            }else{

                logger.warn(line + "Indigenous doubtful not recognized: " + indigenousDoubtStr);

            }

        }

        if(naturalisedStr != null){

            if(naturalisedStr.equals("N")){

                PresenceAbsenceTerm haturalizedState = state.getTransformer().getPresenceTermByKey("Nat.");

                result.add(haturalizedState);

                highestStatus = highestStatus != null ? highestStatus : haturalizedState;

            }else if(isMinus(naturalisedStr)){

                UUID naturalisedErrorUuid = state.getTransformer().getPresenceTermUuid("-Nat.");

                PresenceAbsenceTerm naturalisedErrorState = getPresenceTerm(state, naturalisedErrorUuid, null, null, null, false);

                result.add(naturalisedErrorState);

                checkAbsentHighestState(highestStatus, line, "naturalized", false);

            }else if(naturalisedStr.equals("?")){

                UUID naturalisedDoubtUuid = state.getTransformer().getPresenceTermUuid("?Nat.");

                PresenceAbsenceTerm naturalisedDoubtState = getPresenceTerm(state, naturalisedDoubtUuid, null, null, null, false);

                result.add(naturalisedDoubtState);

                checkAbsentHighestState(highestStatus, line, "naturalized", true);

            }else{

                logger.warn(line + "Naturalized not recognized: " + naturalisedStr);

            }

        }

        if(dudStr != null){

            if(dudStr.equals("P")){

                UUID dudUuid = state.getTransformer().getPresenceTermUuid("Dud.");

                PresenceAbsenceTerm dudState = getPresenceTerm(state, dudUuid, null, null, null, false);

                result.add(dudState);

                highestStatus = highestStatus != null ? highestStatus : dudState;

            }else if(isMinus(dudStr)){

                UUID nonNativeErrorUuid = state.getTransformer().getPresenceTermUuid("-Dud.");

                PresenceAbsenceTerm nonNativeErrorState = getPresenceTerm(state, nonNativeErrorUuid, null, null, null, false);

                result.add(nonNativeErrorState);

                checkAbsentHighestState(highestStatus, line, "non-native and doubtfully naturalised", false);

            }else if(dudStr.equals("?")){

                UUID naturalisedDoubtUuid = state.getTransformer().getPresenceTermUuid("?Dud.");

                PresenceAbsenceTerm naturalisedDoubtState = getPresenceTerm(state, naturalisedDoubtUuid, null, null, null, false);

                result.add(naturalisedDoubtState);

                checkAbsentHighestState(highestStatus, line, "non-native and doubtfully naturalised", true);

            }else{

                logger.warn(line + "non-native and doubtfully naturalised not recognized: " + dudStr);

            }

        }

        if(advStr != null){

            if(advStr.equals("A")){

                UUID advUuid = state.getTransformer().getPresenceTermUuid("Adv.");

                PresenceAbsenceTerm advState = getPresenceTerm(state, advUuid, null, null, null, false);

                result.add(advState);

                highestStatus = highestStatus != null ? highestStatus : advState;

            }else if(isMinus(advStr)){

                UUID advUuid = state.getTransformer().getPresenceTermUuid("-Adv.");

                PresenceAbsenceTerm advState = getPresenceTerm(state, advUuid, null, null, null, false);

                result.add(advState);

                checkAbsentHighestState(highestStatus, line, "adventive", false);

            }else{

                logger.warn(line + "'adventive (casual) alien' not recognized: " + advStr);

            }

        }else if(cultStr != null){

            if (! (cultStr.matches("(C|\\(C\\)|\\?|–)"))){

                logger.warn("'cultivated' not recognized: " + cultStr);

            }else if(cultStr.equals("C")){

                PresenceAbsenceTerm cultivatedState = state.getTransformer().getPresenceTermByKey("Cult.");

                result.add(cultivatedState);

                highestStatus = highestStatus != null ? highestStatus : cultivatedState;

            }else if(cultStr.equals("?")){

                PresenceAbsenceTerm cultivatedState = state.getTransformer().getPresenceTermByKey("?Cult.");

                result.add(cultivatedState);

                checkAbsentHighestState(highestStatus, line, "cultivated", true);

            }else if(cultStr.equals("(C)")){

                UUID ocassualCultUuid = state.getTransformer().getPresenceTermUuid("(C)");

                PresenceAbsenceTerm cultivatedState = getPresenceTerm(state, ocassualCultUuid, null, null, null, false);

                result.add(cultivatedState);

            }else if(isMinus(cultStr)){

                PresenceAbsenceTerm cultivatedState = state.getTransformer().getPresenceTermByKey("-Cult.");

                result.add(cultivatedState);

                checkAbsentHighestState(highestStatus, line, "cultivated", false);

            }else{

                logger.warn(line + "'cultivated' not recognized: " + cultStr);

            }

        }

        state.setHighestStatusForTaxon(highestStatus);

        return result;

    }

    /**

     * @param highestStatus

     * @param line

     */

    private void checkAbsentHighestState(PresenceAbsenceTerm highestStatus, String line, String stateLabel, boolean doubtful) {

        if (highestStatus == null){

            String absentStr = doubtful ? "doubtful" : "absent";

            logger.warn(line + "Highest cuban state is " + absentStr + " " + stateLabel);

        }

    }

    /**

     * @param indigenousStr

     * @return

     */

    private boolean isMinus(String str) {

        return str.equals("-") || str.equals("–");

    }

    /**

     * @param indigenousStr

     * @return

     */

    private boolean checkPlusMinusDoubt(String str) {

        return str.equals("+") || isMinus(str)|| str.equals("?");

    }

    /**

     * @param indigenousStr

     * @param indigenousDoubtStr

     * @param naturalisedStr

     * @param dudStr

     * @param advStr

     * @param cultStr

     */

    private boolean checkAllNull(String ... others) {

        for (String other : others){

            if (other != null){

                return false;

            }

        }

        return true;

    }

    private static final String acceptedRegExStr = "\\(([^\\[\\]“”]{6,})\\)";

//    String heterotypicRegExStr2 = "([^\\(]{5,}" +"(\\(.+\\))?" + "[^\\)\\(]{2,})" +

//                    + "(\\((.{6,})\\))?";

    private static final String heterotypicRegExStr = "([^\\(\\[\\]“”]{5,})"

                                                     +"(\\((.{6,})\\))?";

    private static final String heterotypicRegExStr_TEST = "([^\\(]{5,}" +"(\\(.+\\))?" + "[^\\)\\(]{2,})"

            +"(\\((.{6,})\\))?";

    private static final String auctRegExStr = "auct\\."

            +"((\\sFC(\\-S)?(\\s&\\sA&S)?)|(\\sA&S)|\\sSagra|\\sCombs|\\sBritton|\\sGriseb\\.|\\sWright"

            + "|\\sHammer|\\sEngl\\.||\\sMaza|\\sMiers|\\sRoig|\\sBorhidi|\\sFRC|\\sCoL"

            + "|\\sAckerman|\\sMújica|\\sDíaz|\\sUrb\\.)?(\\s+p\\.\\s*p\\.)?";

    private static final String missapliedRegExStr = "(\\?\\s)?“(.*{5,})”\\s+(" + auctRegExStr + "|sensu\\s+.{2,})";

    private static final String sphalmRegExStr = "“(.*{5,})”\\s+((FC-S|A&S)\\s)?sphalm\\.(\\s(FC(-S)?|A&S|inval\\.))?";

    private static final String nomInvalRegExStr = "“(.*{5,})”\\s+nom\\.\\s+inval\\.(\\s(West|Moldenke|FC|Jacq.))?";

    private static final String homonymRegExStr = "\\s*(\\[.*\\])*\\s*";

    private static final Pattern acceptedRegEx = Pattern.compile(acceptedRegExStr + homonymRegExStr);

    private static final Pattern heterotypicRegEx = Pattern.compile(heterotypicRegExStr + homonymRegExStr);

    private static final Pattern missapliedRegEx = Pattern.compile(missapliedRegExStr);

    private static final Pattern nomInvalRegEx = Pattern.compile(nomInvalRegExStr);

    private static final Pattern sphalmRegEx = Pattern.compile(sphalmRegExStr);

    /**

     * @param record

     * @param state

     * @param taxon

     */

    private void makeSynonyms(HashMap<String, String> record, CubaImportState state) {

//        boolean forAccepted = true;

        String synonymStr = record.get("Syn.");

        String line = state.getCurrentLine() + ": ";

        if (synonymStr == null){

            //TODO test that this is not a synonym only line

            return;

        }

        synonymStr = synonymStr.trim();

//        String heterotypicRegExStr = "([^\\(]{5,}(\\(.+\\))?[^\\)\\(]{2,})(\\((.{6,})\\))?";

//        String heterotypicRegExStr = "([^\\(]{5,})(\\((.{6,})\\))?";

//        Pattern heterotypicRegEx = Pattern.compile(heterotypicRegExStr + homonymRegExStr);

        Matcher missapliedMatcher = missapliedRegEx.matcher(synonymStr);

        Matcher nomInvalMatcher = nomInvalRegEx.matcher(synonymStr);

        Matcher acceptedMatcher = acceptedRegEx.matcher(synonymStr);

        Matcher heterotypicMatcher = heterotypicRegEx.matcher(synonymStr);

        Matcher sphalmMatcher = sphalmRegEx.matcher(synonymStr);

        List<BotanicalName> homonyms = new ArrayList<>();

        if (missapliedMatcher.matches()){

            boolean doubtful = missapliedMatcher.group(1) != null;

            String firstPart = missapliedMatcher.group(2);

            BotanicalName name = (BotanicalName)nameParser.parseSimpleName(firstPart, state.getConfig().getNomenclaturalCode(), Rank.SPECIES());

            String secondPart = missapliedMatcher.group(3);

            Taxon misappliedNameTaxon = Taxon.NewInstance(name, null);

            misappliedNameTaxon.setDoubtful(doubtful);

            if (secondPart.startsWith("sensu")){

                secondPart = secondPart.substring(5).trim();

                if (secondPart.contains(" ")){

                    logger.warn(line + "CHECK: Second part contains more than 1 word. Check if this is correct: " + secondPart);

                }

                Reference<?> sensu = ReferenceFactory.newGeneric();

                Team team = Team.NewTitledInstance(secondPart, null);

                sensu.setAuthorship(team);

                misappliedNameTaxon.setSec(sensu);

            }else if (secondPart.matches(auctRegExStr)){

                secondPart = secondPart.replace("p. p.", "p.p.");

                misappliedNameTaxon.setAppendedPhrase(secondPart);

            }else{

                logger.warn(line + "Misapplied second part not recognized: " + secondPart);

            }

            //TODO

            Reference<?> relRef = null;

            state.getCurrentTaxon().addMisappliedName(misappliedNameTaxon, relRef, null);

        }else if (nomInvalMatcher.matches()){

            String firstPart = nomInvalMatcher.group(1);

            String afterInval = nomInvalMatcher.group(2);

            if (StringUtils.isNotBlank(afterInval)){

                logger.warn(state.getCurrentLine() + ": After inval to be implemented: " + afterInval);

            }

            BotanicalName name = (BotanicalName)nameParser.parseSimpleName(firstPart, state.getConfig().getNomenclaturalCode(), Rank.SPECIES());

            NomenclaturalStatus status = NomenclaturalStatus.NewInstance( NomenclaturalStatusType.INVALID());

            name.addStatus(status);

            state.getCurrentTaxon().addSynonymName(name, SynonymRelationshipType.SYNONYM_OF());

        }else if (sphalmMatcher.matches()){

            String firstPart = sphalmMatcher.group(1);

            String sphalmPart = synonymStr.replace(firstPart, "").replace("“","").replace("”","").trim();

            BotanicalName name = (BotanicalName)nameParser.parseSimpleName(firstPart, state.getConfig().getNomenclaturalCode(), Rank.SPECIES());

//            NomenclaturalStatus status = NomenclaturalStatus.NewInstance( NomenclaturalStatusType.INVALID());

//            name.addStatus(status);

            SynonymRelationship sr = state.getCurrentTaxon().addSynonymName(name, SynonymRelationshipType.SYNONYM_OF());

            sr.getSynonym().setAppendedPhrase(sphalmPart);

            sr.getSynonym().setSec(null);

        }else if (acceptedMatcher.matches()){

            String firstPart = acceptedMatcher.group(1);

            String homonymPart = acceptedMatcher.groupCount() < 2 ? null : acceptedMatcher.group(2);

            handleHomotypicGroup(firstPart, state, (BotanicalName)state.getCurrentTaxon().getName(), false, homonyms, homonymPart, false);

        }else if(heterotypicMatcher.matches()){

            String firstPart = heterotypicMatcher.group(1).trim();

            String secondPart = heterotypicMatcher.groupCount() < 3 ? null : heterotypicMatcher.group(3);

            String homonymPart = heterotypicMatcher.groupCount() < 4 ? null : heterotypicMatcher.group(4);

            boolean isDoubtful = firstPart.matches("^\\?\\s*.*");

            firstPart = replaceHomonIlleg(firstPart);

            boolean isHomonym = firstPart.matches(".*" + HOMONYM_MARKER);

            BotanicalName synName = makeName(firstPart);

            if (synName.isProtectedTitleCache()){

                logger.warn(line + " heterotypic base synonym could not be parsed correctly:" + firstPart);

            }

            if (isHomonym){

                homonyms.add(synName);

            }

            SynonymRelationship sr = state.getCurrentTaxon().addHeterotypicSynonymName(synName);

            sr.getSynonym().setDoubtful(isDoubtful);

            handleHomotypicGroup(secondPart, state, synName, true, homonyms, homonymPart, isDoubtful);

        }else{

            logger.warn(line + "Synonym entry does not match: " + synonymStr);

        }

    }

    /**

     * @param synonymStr

     * @param state

     * @param homonyms

     * @param homonymPart

     * @param isDoubtful

     * @param taxon

     * @param homotypicalGroup

     */

    private void handleHomotypicGroup(String homotypicStr,

            CubaImportState state,

            BotanicalName homotypicName,

            boolean isHeterotypic,

            List<BotanicalName> homonyms,

            String homonymPart,

            boolean isDoubtful) {

        if (homotypicStr == null){

            return;

        }else if (homotypicStr.startsWith("(") && homotypicStr.endsWith("")){

            homotypicStr = homotypicStr.substring(1, homotypicStr.length() - 1);

        }

        BotanicalName currentBasionym = homotypicName;

        String[] splits = homotypicStr.split("\\s*,\\s*");

        for (String split : splits){

            split = replaceHomonIlleg(split);

            boolean isHomonym = split.matches(".*" + HOMONYM_MARKER);

            BotanicalName newName = makeName(split);

            if (newName.isProtectedTitleCache()){

                logger.warn(state.getCurrentLine() + ": homotypic name part could not be parsed: " + split);

            }

            if (isHomonym){

                homonyms.add(newName);

            }

            if (isHeterotypic){

                SynonymRelationship sr = state.getCurrentTaxon().addHeterotypicSynonymName(newName, homotypicName.getHomotypicalGroup(), null, null);

                sr.getSynonym().setDoubtful(isDoubtful);

//                newName.addBasionym(homotypicName);

                currentBasionym = handleBasionym(currentBasionym, newName);

            }else{

                state.getCurrentTaxon().addHomotypicSynonymName(newName, null, null);

                handleBasionym(currentBasionym, newName);

            }

        }

        makeHomonyms(homonyms, homonymPart, state, currentBasionym);

    }

    /**

     * @param split

     * @return

     */

    private String replaceHomonIlleg(String split) {

        String result = split.trim().replace("homon. illeg.", "nom. illeg. homon.").trim();

        return result;

    }

    /**

     * @param homonyms

     * @param homonymPart

     * @param state

     * @param currentBasionym

     */

    private void makeHomonyms(List<BotanicalName> homonyms, String homonymPartOrig, CubaImportState state,

            BotanicalName currentBasionym) {

        String line = state.getCurrentLine() + ": ";

        String homonymPart = homonymPartOrig == null ? "" : homonymPartOrig.trim();

        if (homonyms.isEmpty() && homonymPart.equals("")){

            return;

        }else if (homonymPart.equals("")){

            logger.warn(line + "SynonymPart has homonyms but homonymPart is empty");

            return;

        }

        homonymPart = homonymPart.substring(1, homonymPart.length() - 1);

        String[] splits = homonymPart.split("\\]\\s*\\[");

        if (splits.length != homonyms.size()){

            if(homonyms.size() == 0 && splits.length >= 1){

                handleSimpleBlockingNames(splits, state, currentBasionym);

            }else{

                logger.warn(line + "Number of homonyms (" + homonyms.size() + ") and homonymParts ("+splits.length+") does not match");

            }

            return;

        }

        int i = 0;

        for (String split : splits){

            split = split.replaceAll("^non\\s+", "");

            BotanicalName newName = makeName(split);

//            BotanicalName newName = (BotanicalName)nameParser.parseReferencedName(split, state.getConfig().getNomenclaturalCode(), Rank.SPECIES());

            if (newName.isProtectedTitleCache()){

                logger.warn(state.getCurrentLine() + ": homonym name could not be parsed: " + split);

            }

            newName.addRelationshipToName(homonyms.get(i), NameRelationshipType.LATER_HOMONYM(), null);

            i++;

        }

    }

    /**

     * @param homonymPart

     * @param state

     * @param currentBasionym

     */

    private void handleSimpleBlockingNames(String[] splitsi, CubaImportState state,

            BotanicalName currentBasionym) {

        for (String spliti : splitsi){

            String split = spliti.replaceAll("^non\\s+", "");

            BotanicalName newName = makeName(split);

            if (newName.isProtectedTitleCache()){

                logger.warn(state.getCurrentLine() + ": blocking name could not be parsed: " + split);

            }

            Set<BotanicalName> typifiedNames = (Set)currentBasionym.getHomotypicalGroup().getTypifiedNames();

            Set<BotanicalName> candidates = new HashSet<>();

            for (BotanicalName name : typifiedNames){

                if (name.getGenusOrUninomial() != null && name.getGenusOrUninomial().equals(newName.getGenusOrUninomial())){

                    if (name.getStatus().isEmpty() || ! name.getStatus().iterator().next().getType().equals(NomenclaturalStatusType.ILLEGITIMATE())){

                        candidates.add(name);

                    }

                }

            }

            if (candidates.size() == 1){

                newName.addRelationshipToName(candidates.iterator().next(), NameRelationshipType.BLOCKING_NAME_FOR(), null);

            }else{

                logger.warn(state.getCurrentLine() + ": Blocking name could not be handled. " + candidates.size() + " candidates.");

            }

        }

    }

    /**

     * @param newName

     * @param homotypicName

     * @return

     */

    private BotanicalName handleBasionym(BotanicalName currentBasionym, BotanicalName name2) {

        BotanicalName basionymName = currentBasionym;

        BotanicalName newCombination = name2;

        //switch if necessary

        if (basionymName.getBasionymAuthorship() != null && newCombination.getBasionymAuthorship() == null){

            basionymName = name2;

            newCombination = currentBasionym;

        }

//        newCombination.getHomotypicalGroup().removeGroupBasionym(xxx);

        if (matchAuthor(basionymName.getCombinationAuthorship(), newCombination.getBasionymAuthorship())){

            newCombination.getHomotypicalGroup().setGroupBasionym(basionymName);

        }

        return basionymName;

    }

    /**

     * @param combinationAuthorship

     * @param basi

     * @return

     */

    private boolean matchAuthor(TeamOrPersonBase<?> author1, TeamOrPersonBase<?> author2) {

        if (author1 == null || author2 == null){

            return false;

        }else {

            return author1.getNomenclaturalTitle().equals(author2.getNomenclaturalTitle());

        }

    }

    /**

     * @param record

     * @param state

     * @param taxon

     */

    private void makeNotes(HashMap<String, String> record, CubaImportState state) {

        String notesStr = getValue(record, "(Notas)");

        if (notesStr == null){

            return;

        }else{

            Annotation annotation = Annotation.NewDefaultLanguageInstance(notesStr);

            //TODO

            annotation.setAnnotationType(AnnotationType.TECHNICAL());

            state.getCurrentTaxon().addAnnotation(annotation);

        }

    }

    /**

     * @param record

     * @param state

     * @param familyTaxon

     * @return

     */

    private Taxon makeTaxon(HashMap<String, String> record, CubaImportState state, TaxonNode familyNode, boolean isSynonym) {

        String taxonStr = getValue(record, "Taxón");

        if (taxonStr == null){

            return isSynonym ? state.getCurrentTaxon() : null;

        }

        boolean isAbsent = false;

        if (taxonStr.startsWith("[") && taxonStr.endsWith("]")){

            taxonStr = taxonStr.substring(1, taxonStr.length() - 1);

            isAbsent = true;

        }

        BotanicalName botanicalName = makeName(taxonStr);

        Reference<?> sec = getSecReference(state);

        Taxon taxon = Taxon.NewInstance(botanicalName, sec);

        TaxonNode higherNode;

        if (botanicalName.isProtectedTitleCache()){

            logger.warn(state.getCurrentLine() + ": Taxon could not be parsed: " + taxonStr);

            higherNode = familyNode;

        }else{

            String genusStr = botanicalName.getGenusOrUninomial();

            Taxon genus = state.getHigherTaxon(genusStr);

            if (genus != null){

                higherNode = genus.getTaxonNodes().iterator().next();

            }else{

                BotanicalName name = BotanicalName.NewInstance(Rank.GENUS());

                name.setGenusOrUninomial(genusStr);

                genus = Taxon.NewInstance(name, sec);

                higherNode = familyNode.addChildTaxon(genus, null, null);

                state.putHigherTaxon(genusStr, genus);

            }

        }

        higherNode.addChildTaxon(taxon, null, null);

        return taxon;

    }

    private final String orthVarRegExStr = "[A-Z][a-z]+\\s[a-z]+\\s(\\(‘([a-z]){3,}’\\))\\s(\\([A-Z][a-z]+\\.?\\)\\s)?[A-Z][a-zó]+\\.?";

    private final Pattern orthVarRegEx = Pattern.compile(orthVarRegExStr);

    /**

     * @param taxonStr

     * @return

     */

    private BotanicalName makeName(String nameStrOrig) {

        //normalize

        String nameStr = normalizeStatus(nameStrOrig);

        //orthVar

        Matcher orthVarMatcher = orthVarRegEx.matcher(nameStr);

        String orthVar = null;

        if (orthVarMatcher.matches()) {

            orthVar = orthVarMatcher.group(1);

            nameStr = nameStr.replace(" " + orthVar, "").trim().replaceAll("\\s{2,}", " ");

            orthVar = orthVar.substring(2, orthVar.length() - 2);

        }

        BotanicalName result = (BotanicalName)nameParser.parseReferencedName(nameStr, nc, Rank.SPECIES());

        if (orthVar != null){

            BotanicalName orthVarName = (BotanicalName)result.clone();

            //TODO

            Reference<?> citation = null;

            orthVarName.addRelationshipToName(result, NameRelationshipType.ORTHOGRAPHIC_VARIANT(), citation, null, null);

            orthVarName.setSpecificEpithet(orthVar);

        }

        return result;

    }

    /**

     * @param state

     * @return

     */

    private Reference<?> getSecReference(CubaImportState state) {

        Reference<?> result = state.getSecReference();

        if (result == null){

            result = ReferenceFactory.newDatabase();

            result.setTitle("Flora of Cuba");

            state.setSecReference(result);

        }

        return result;

    }

    private static final String[] nomStatusStrings = new String[]{"nom. cons.", "ined.", "nom. illeg.",

            "nom. rej.","nom. cons. prop.","nom. altern.","nom. confus.","nom. dub.", "nom. nud."};

    /**

     * @param taxonStr

     * @return

     */

    private String normalizeStatus(String nameStr) {

        if (nameStr == null){

            return null;

        }

        String result = nameStr.replaceAll(HOMONYM_MARKER, "").trim();

        for (String nomStatusStr : nomStatusStrings){

            nomStatusStr = " " + nomStatusStr;

            if (result.endsWith(nomStatusStr)){

                result = result.replace(nomStatusStr, "," + nomStatusStr);

            }

        }

        result = result.replaceAll(DOUBTFUL_MARKER, "").trim();

        result = result.replace("[taxon]", "[infraspec.]");

        return result;

    }

    /**

     * @param record

     * @param state

     * @return

     */

    private TaxonNode getFamilyTaxon(HashMap<String, String> record, CubaImportState state) {