EDIT

import eu.etaxonomy.cdm.api.application.CdmApplicationController;

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

  static final ICdmDataSource cdmDestination = CdmDestinations.cdm_test_local_mysql_test();

//    static final ICdmDataSource cdmDestination = CdmDestinations.cdm_cuba_production();

	private static final String classificationName = "Cuba Checklist";

	static final String sourceReferenceTitle = "Cuba Checklist Word Documents";

            doSingleSource(asteraceae(), config, myImport, doVocabularies);

            doSingleSource(convolvulaceae(), config, myImport, doVocabularies);

            doSingleSource(cyperaceae(), config, myImport, doVocabularies);

            doSingleSource(dicotA_C(), config, myImport, doVocabularies);

            doSingleSource(dicotD_M(), config, myImport, doVocabularies);

            doSingleSource(dicotN_Z(), config, myImport, doVocabularies);

            doSingleSource(euphorbiaceae(), config, myImport, doVocabularies);

            doSingleSource(fabaceae(), config, myImport, doVocabularies);

            doSingleSource(gymnospermae(), config, myImport, doVocabularies);

            doSingleSource(lamVerbenaceae(), config, myImport, doVocabularies);

            doSingleSource(malpighiaceae(), config, myImport, doVocabularies);

            doSingleSource(melastomataceae(), config, myImport, doVocabularies);

            doSingleSource(monocots(), config, myImport, doVocabularies);

            doSingleSource(myrtaceae(), config, myImport, doVocabularies);

            doSingleSource(orchidaceae(), config, myImport, doVocabularies);

            doSingleSource(rubiaceae(), config, myImport, doVocabularies);

            doSingleSource(urticaceae(), config, myImport, doVocabularies);

		    logger.warn("Start deduplication ...");

		    ICdmApplicationConfiguration app = myImport.getCdmAppController();

			if (app == null){

                app = CdmApplicationController.NewInstance(cdmDestination, hbm2dll, false);

            }

			count = app.getAgentService().deduplicate(Team.class, null, null);

			logger.warn("Deduplicated " + count + " teams.");

    private void doSingleSource(URI source, CubaImportConfigurator config,

        String fileName = source.toString();

        fileName = fileName.substring(fileName.lastIndexOf("/") + 1 );

        String message = "Start import from ("+ fileName + ") ...";

        config.setSourceReference(getSourceReference(fileName));

    private final Reference<?> inRef = ReferenceFactory.newGeneric();

		result.setInReference(inRef);

		inRef.setTitleCache(sourceReferenceTitle, true);

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

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

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

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

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

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

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

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

                distribution.addSource(makeDescriptionSource(state));

        state.setEndemic(false);

                state.setEndemic(true);

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

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

                PresenceAbsenceTerm indigenousDoubtState = state.getTransformer().getPresenceTermByKey("?Ind.");

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

                PresenceAbsenceTerm doubtIndigenousState = state.getTransformer().getPresenceTermByKey("Ind.?");

//                PresenceAbsenceTerm doubtIndigenousState = getPresenceTerm(state, doubtIndigenousUuid, null, null, null, false);

                result.add(doubtIndigenousState);

                highestStatus = highestStatus != null ? highestStatus : doubtIndigenousState;

            }else if(isMinus(indigenousDoubtStr)){

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

                PresenceAbsenceTerm doubtIndigenousErrorState = getPresenceTerm(state, doubtIndigenousErrorUuid, null, null, null, false);

                result.add(doubtIndigenousErrorState);

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

                logger.warn(line + "doubtfully indigenous not recognized: " + indigenousDoubtStr);

                PresenceAbsenceTerm advState = state.getTransformer().getPresenceTermByKey("Adv.");

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

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

                UUID rareCasualUuid = state.getTransformer().getPresenceTermUuid("(A)");

                PresenceAbsenceTerm rareCasual = getPresenceTerm(state, rareCasualUuid, null, null, null, false);

                result.add(rareCasual);

        //can be removed, highest status is not used anymore

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

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

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

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

        if (state.getCurrentTaxon() == null){

            logger.error(line + "Current taxon is null for synonym");

            return;

        }

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

            name.addSource(makeOriginalSource(state));

            misappliedNameTaxon.addSource(makeOriginalSource(state));

            name.addSource(makeOriginalSource(state));

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

            sr.getSynonym().addSource(makeOriginalSource(state));

            name.addSource(makeOriginalSource(state));

            sr.getSynonym().addSource(makeOriginalSource(state));

            List<BotanicalName> list = handleHomotypicGroup(firstPart, state, (BotanicalName)state.getCurrentTaxon().getName(), false, homonyms, homonymPart, false);

            checkFirstSynonym(state, list, isFirstSynonym, synonymStr, false);

            BotanicalName synName = makeName(state, firstPart);

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

            sr.getSynonym().addSource(makeOriginalSource(state));

            List<BotanicalName> list = handleHomotypicGroup(secondPart, state, synName, true, homonyms, homonymPart, isDoubtful);

            checkFirstSynonym(state, list, isFirstSynonym, synonymStr, true);

        }else if (isSpecialHeterotypic(synonymStr)){

            BotanicalName synName = makeName(state, synonymStr);

            if (synName.isProtectedTitleCache()){

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

            }

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

            sr.getSynonym().addSource(makeOriginalSource(state));

    /**

     * @param state

     * @param list

     * @param isFirstSynonym

     * @param synonymStr

     * @param b

     */

    private void checkFirstSynonym(CubaImportState state, List<BotanicalName> list, boolean isFirstSynonym, String synonymStr, boolean isHeterotypicMatcher) {

        if (!isFirstSynonym){

            return;

        }

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

        BotanicalName currentName = isHeterotypicMatcher? (BotanicalName)state.getCurrentTaxon().getName(): list.get(0);

        boolean currentHasBasionym = currentName.getBasionymAuthorship() != null;

        BotanicalName firstSynonym = isHeterotypicMatcher ? list.get(0): list.get(1);

//        if (list.size() <= 1){

//            logger.error(line + "homotypic list size is 1 but shouldn't");

//            return;

//        }

        if (isHeterotypicMatcher && currentHasBasionym){

            logger.error(line + "Current taxon (" + currentName.getTitleCache() + ") has basionym author but has no homotypic basionym , but : " + synonymStr);

        }else if (isHeterotypicMatcher){

            //first synonym must not have a basionym author

            if (firstSynonym.getBasionymAuthorship() != null){

                logger.error(line + "Current taxon (" + currentName.getTitleCache() + ") has no basionym but first synonym requires basionym : " + synonymStr);

            }

        }else{  //isAcceptedMatcher

            if (currentHasBasionym){

                if (! matchAuthor(currentName.getBasionymAuthorship(), firstSynonym.getCombinationAuthorship())){

                    logger.info(line + "Current basionym author and first synonym combination author do not match: " + currentName.getTitleCache() + "<->" + firstSynonym.getTitleCache());

                }

            }else{

                if (! matchAuthor(currentName.getCombinationAuthorship(), firstSynonym.getBasionymAuthorship())){

                    logger.info(line + "Current combination author and first synonym basionym author do not match: " + currentName.getTitleCache() + "<->" + firstSynonym.getTitleCache());

                }

            }

        }

    }

    /**

     * @param synonymStr

     * @return

     */

    private boolean isSpecialHeterotypic(String synonymStr) {

        if (synonymStr == null){

            return false;

        }else if (synonymStr.equals("Rhynchospora prenleloupiana (‘prenteloupiana’) Boeckeler")){

            return true;

        }else if (synonymStr.equals("Psidium longipes var. orbiculare (O.Berg) McVaugh")){

            return true;

        }

        return false;

    }

    /**

     * @param areaKey

     * @param record

     * @param state

     * @param taxon

     */

    private void makeSingleProvinceDistribution(String areaKey,

            HashMap<String, String> record,

            CubaImportState state) {

        try {

            UUID areaUuid = state.getTransformer().getNamedAreaUuid(areaKey);

            if (areaUuid == null){

                logger.warn("Area not recognized: " + areaKey);

                return;

            }

            if (record.get(areaKey)==null){

                return; //no status defined

            }

            NamedArea area = getNamedArea(state, areaUuid, null, null, null, null, null);

            if (area == null){

                logger.warn(state.getCurrentLine() + ": Area not recognized: " + area);

            }

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

            PresenceAbsenceTerm status =  makeProvinceStatus(areaKey, record, state);

            if (status == null){

                logger.warn(state.getCurrentLine() + ": Province distribution status could not be defined: " + record.get(areaKey));

            }

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

            desc.addElement(distribution);

            distribution.addSource(makeDescriptionSource(state));

        } catch (UndefinedTransformerMethodException e) {

            e.printStackTrace();

        }

    }

    private List<BotanicalName> handleHomotypicGroup(String homotypicStrOrig,

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

        homotypicNameList.add(homotypicName);

        String homotypicStr = homotypicStrOrig;

            return homotypicNameList;

        HomotypicalGroup homotypicGroup = homotypicName.getHomotypicalGroup();

            BotanicalName newName = makeName(state, split);

            newName.setHomotypicalGroup(homotypicGroup);  //not really necessary as this is later set anyway

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

                sr.getSynonym().addSource(makeOriginalSource(state));

            handleBasionym(state, homotypicNameList, homonyms, newName);

            homotypicNameList.add(newName);

        makeHomonyms(homonyms, homonymPart, state, homotypicGroup);

        return homotypicNameList;

            HomotypicalGroup homotypicGroup) {

                handleSimpleBlockingNames(splits, state, homotypicGroup);

            BotanicalName newName = makeName(state, split);

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

     * @param homotypicGroup

    private void handleSimpleBlockingNames(String[] splitsi,

            CubaImportState state,

            HomotypicalGroup homotypicGroup) {

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

            BotanicalName newName = makeName(state, split);

            Set<BotanicalName> typifiedNames = (Set)homotypicGroup.getTypifiedNames();

                BotanicalName blockedName = candidates.iterator().next();

                newName.addRelationshipToName(blockedName, NameRelationshipType.BLOCKING_NAME_FOR(), null);

                replacementNameCandidates.add(blockedName);

        makeReplacedSynonymIfPossible(state, homotypicGroup, replacementNameCandidates);

    }

    /**

     * @param homotypicGroup

     * @param replacementNameCandidates

     */

    private void makeReplacedSynonymIfPossible(CubaImportState state,

            HomotypicalGroup homotypicGroup,

            List<BotanicalName> replacementNameCandidates) {

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

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

        for (TaxonNameBase<?, ?> typifiedName : homotypicGroup.getTypifiedNames()){

            BotanicalName candidate = (BotanicalName)typifiedName;

            if (candidate.getBasionymAuthorship() == null){

                if (candidate.getStatus().isEmpty()){

                    if (! replacementNameCandidates.contains(candidate)){

                        replacedCandidates.add(candidate);

                    }

                }

            }

        }

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

            BotanicalName replacedSynonym = replacedCandidates.iterator().next();

            for (BotanicalName replacementName : replacementNameCandidates){

                replacementName.addReplacedSynonym(replacedSynonym, null, null, null);

            }

        }else if (replacedCandidates.size() < 1){

            logger.warn(line + "No replaced synonym candidate found");

        }else{

            logger.warn(line + "More than 1 ("+replacedCandidates.size()+") replaced synonym candidates found");

        }

     * @param homotypicGroup

     */

    private void handleBasionym(CubaImportState state, List<BotanicalName> homotypicNameList,

            List<BotanicalName> homonyms, BotanicalName newName) {

        for (BotanicalName existingName : homotypicNameList){

            if (existingName != newName){  //should not happen anymore, as new name is added later

                boolean onlyIfNotYetExists = true;

                createBasionymRelationIfPossible(state, existingName, newName, homonyms.contains(newName), onlyIfNotYetExists);

            }

        }

    }

    /**

     * @param state

     * @param name1

     * @param name2

    private void createBasionymRelationIfPossible(CubaImportState state, BotanicalName name1, BotanicalName name2,

            boolean name2isHomonym, boolean onlyIfNotYetExists) {

        BotanicalName basionymName = name1;

        //exactly one name must have a basionym author

        if (name1.getBasionymAuthorship() == null && name2.getBasionymAuthorship() == null

                || name1.getBasionymAuthorship() != null && name2.getBasionymAuthorship() != null){

            return;

        }

        //switch order if necessary

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

            newCombination = name1;

        }

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

                && matchLastNamePart(basionymName, newCombination)){

            newCombination.addBasionym(basionymName);

        }else{

            if ( (newCombination.getBasionyms().isEmpty() || ! onlyIfNotYetExists)

                    && isLegitimate(basionymName)

                    && ! name2isHomonym){

                logger.info(state.getCurrentLine() + ": Names are potential basionyms but either author or name part do not match: " + basionymName.getTitleCache() + " <-> " + newCombination.getTitleCache());

            }

    }

    /**

     * @param basionymName

     * @return

     */

    private boolean isLegitimate(BotanicalName basionymName) {

        for (NomenclaturalStatus nomStatus : basionymName.getStatus()){

            if (nomStatus.getType()!= null && nomStatus.getType().isIllegitimateType()){

                    return false;

            }

        }

        for (NameRelationship nameRel : basionymName.getNameRelations()){

            if (nameRel.getType()!= null && nameRel.getType().isIllegitimateType()){

                    return false;

            }

        return true;

    }

    /**

     * @param basionymName

     * @param newCombination

     * @return

     */

    private boolean matchLastNamePart(BotanicalName name1, BotanicalName name2) {

        String lastNamePart1 = name1.getLastNamePart();

        String lastNamePart2 = name2.getLastNamePart();

        if (lastNamePart1 != null && lastNamePart2 != null){

            lastNamePart1 = normalizeBasionymNamePart(lastNamePart1);

            lastNamePart2 = normalizeBasionymNamePart(lastNamePart2);

            return (lastNamePart1.equals(lastNamePart2));

        }else{

            return false;

        }

    }

    /**

     * @param lastNamePart1

     * @return

     */

    private String normalizeBasionymNamePart(String lastNamePart) {

        String namePart = lastNamePart.toLowerCase()

                .replaceAll("(um|us|a|is|e|os|on|or)$", "")

                .replaceAll("er$", "r")    //e.g. ruber <-> rubra

                .replaceAll("ese$", "s");  //e.g.  cayanensis <-> cayanenese

                //TODO tampensis / tampense

        return namePart;

        boolean isAuct = false;

        if (taxonStr.endsWith("auct.")){

            isAuct = true;

            taxonStr.replace("auct.", "").trim();

        }

        state.setTaxonIsAbsent(isAbsent);

        BotanicalName botanicalName = makeName(state, taxonStr);

        if (isAuct){

            taxon.setAppendedPhrase("auct.");

        }

                name.addSource(makeOriginalSource(state));

                genus.addSource(makeOriginalSource(state));

        taxon.addSource(makeOriginalSource(state));

    private BotanicalName makeName(CubaImportState state, String nameStrOrig) {

        }

        boolean isNomInval = false;

        if (nameStr.endsWith("nom. inval.")){

            isNomInval = true;

            nameStr = nameStr.replace("nom. inval.", "").trim();

        result.addSource(makeOriginalSource(state));

        if (isNomInval){

            result.addStatus(NomenclaturalStatus.NewInstance(NomenclaturalStatusType.INVALID()));

        }

            orthVarName.addSource(makeOriginalSource(state));

        normalizeAuthors(result);

    /**

     * @param result

     */

    private void normalizeAuthors(BotanicalName result) {

        result.setCombinationAuthorship(normalizeAuthor(result.getCombinationAuthorship()));

        result.setExCombinationAuthorship(normalizeAuthor(result.getExCombinationAuthorship()));

        result.setExBasionymAuthorship(normalizeAuthor(result.getExBasionymAuthorship()));

        result.setBasionymAuthorship(normalizeAuthor(result.getBasionymAuthorship()));

    }

    /**

     * @param combinationAuthorship

     * @return

     */

    private TeamOrPersonBase<?> normalizeAuthor(TeamOrPersonBase<?> author) {

        if (author == null){

            return null;

        }

        TeamOrPersonBase<?> result;

        if (author.isInstanceOf(Person.class)){

            result = normalizePerson(CdmBase.deproxy(author, Person.class));

        }else{

            Team team = CdmBase.deproxy(author, Team.class);

            List<Person> list = team.getTeamMembers();

            for(int i = 0; i < list.size(); i++){

                Person person = list.get(i);

                Person tmpMember = normalizePerson(person);

                list.set(i, tmpMember);

            }

            return team;

        }

        return result;

    }

    /**

     * @param deproxy

     * @return

     */

    private Person normalizePerson(Person person) {

        String title = person.getNomenclaturalTitle();

        title = title.replaceAll("(?<=[a-zA-Z])\\.(?=[a-zA-Z])", ". ");

        person.setNomenclaturalTitle(title);

        boolean isFilius = title.endsWith(" f.");

        if (isFilius){

            title.replace(" f.", "");

        }

        String[] splits = title.split("\\s+");

        int nNotFirstName = isFilius ? 2 : 1;

        person.setLastname(splits[splits.length - nNotFirstName] + (isFilius? " f." : ""));

        person.setFirstname(CdmUtils.concat(" ", Arrays.copyOfRange(splits, 0, splits.length-nNotFirstName)));

        return person;

    }

        familyStr = familyStr.trim();

        String alternativeFamilyStr = null;

        if (familyStr.contains("/")){

            String[] splits = familyStr.split("/");

            if (splits.length > 2){

                logger.warn(state.getCurrentLine() +": " + "More than 1 alternative name:" + familyStr);

            }

            familyStr = splits[0].trim();

            alternativeFamilyStr = splits[1].trim();

        }

            BotanicalName name = makeFamilyName(state, familyStr);

            family = Taxon.NewInstance(name, sec);

            familyNode = rootNode.addChildTaxon(family, sec, null);

            state.putHigherTaxon(familyStr, family);

        }

        if (isNotBlank(alternativeFamilyStr)){

            NameRelationshipType type = NameRelationshipType.ALTERNATIVE_NAME();

            BotanicalName alternativeName = makeFamilyName(state, alternativeFamilyStr);

            BotanicalName familyName = (BotanicalName)family.getName();

            boolean hasRelation = false;

            for (NameRelationship nameRel : familyName.getRelationsToThisName()){

                if (nameRel.getType().equals(type)){

                    if (nameRel.getFromName().equals(alternativeName)){

                        hasRelation = true;

                    }

                }

            }

            if (!hasRelation){

                familyName.addRelationshipFromName(alternativeName, type, null);

            }

    /**

     * @param state

     * @param taxon

     */

    private void validateTaxonIsAbsent(CubaImportState state, Taxon taxon) {

        if (!state.isTaxonIsAbsent()){

            return;

        }

        for (DescriptionElementBase el : taxon.getDescriptions().iterator().next().getElements()){

            if (el instanceof Distribution){

                Distribution dist = (Distribution)el;

                NamedArea area = dist.getArea();

                if (isCubanArea(area)){

                    PresenceAbsenceTerm status = dist.getStatus();

                    if (status != null && !status.isAbsenceTerm()){

                        if (!isDoubtfulTerm(status)){

                            String name = taxon.getName().getTitleCache();

                            logger.error(state.getCurrentLine() +": Taxon ("+name+")is absent'[]' but has presence distribution: " + status.getTitleCache());

                            return;

                        }

                    }

                }

            }

        }

    }

    /**

     * @param state

     * @param taxon

     */

    private void validateEndemic(CubaImportState state, Taxon taxon) {

        boolean hasExternalPresence = false;

        for (DescriptionElementBase el : taxon.getDescriptions().iterator().next().getElements()){

            if (el instanceof Distribution){

                Distribution dist = (Distribution)el;

                NamedArea area = dist.getArea();

                if (!isCubanArea(area)){

                    PresenceAbsenceTerm status = dist.getStatus();

                    if (status != null && !status.isAbsenceTerm()){

                        if (!isDoubtfulTerm(status)){

                            hasExternalPresence = true;

                            if (state.isEndemic()){

                                String name = taxon.getName().getTitleCache();

                                logger.error(state.getCurrentLine() +": Taxon ("+name+")is endemic but has non-cuban distribution: " + area.getIdInVocabulary() + "-" + status.getIdInVocabulary());

                                return;

                            }

                        }

                    }

                }

            }

        }

        if (!state.isEndemic() && ! hasExternalPresence){

            String name = taxon.getName().getTitleCache();

            logger.error(state.getCurrentLine() +": Taxon ("+name+")is not endemic but has no non-cuban distribution" );

        }

    }

            BotanicalName name = makeFamilyName(state, famStr);

    /**

     * @param state

     * @param famStr

     * @return

     */

    private BotanicalName makeFamilyName(CubaImportState state, String famStr) {

        BotanicalName name = state.getFamilyName(famStr);

        if (name == null){

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

            name.setGenusOrUninomial(famStr);

            state.putFamilyName(famStr, name);

            name.addSource(makeOriginalSource(state));

        }

        return name;

    }

	    boolean isSynonymOnly = false;

                isSynonymOnly = true;

       //Taxón

        Taxon taxon = makeTaxon(record, state, familyTaxon, isSynonymOnly);

        if (taxon == null && ! isSynonymOnly){

        makeSynonyms(record, state, !isSynonymOnly);

        validateTaxonIsAbsent(state, taxon);

        if (!isSynonymOnly){

            validateEndemic(state, taxon);

        }

    /**

     * @param state

     * @return

     */

    private IdentifiableSource makeOriginalSource(CubaImportState state) {

        return IdentifiableSource.NewDataImportInstance("line: " + state.getCurrentLine(), null, state.getConfig().getSourceReference());

    }

    /**

     * @param state

     * @return

     */

    private DescriptionElementSource makeDescriptionSource(CubaImportState state) {

        return DescriptionElementSource.NewDataImportInstance("line: " + state.getCurrentLine(), null, state.getConfig().getSourceReference());

    }

    private static Set<UUID> doubtfulStatus = new HashSet<>();

    /**

     * @param status

     * @return

     */

    private boolean isDoubtfulTerm(PresenceAbsenceTerm status) {

        if (doubtfulStatus.isEmpty()){

            doubtfulStatus.add(CubaTransformer.nonNativeDoubtfullyNaturalisedUuid);

            doubtfulStatus.add(CubaTransformer.doubtfulIndigenousDoubtfulUuid);

            doubtfulStatus.add(CubaTransformer.endemicDoubtfullyPresentUuid);

            doubtfulStatus.add(CubaTransformer.naturalisedDoubtfullyPresentUuid);

            doubtfulStatus.add(CubaTransformer.nonNativeDoubtfullyPresentUuid);

            doubtfulStatus.add(CubaTransformer.occasionallyCultivatedUuid);

            doubtfulStatus.add(CubaTransformer.rareCasualUuid);

            doubtfulStatus.add(PresenceAbsenceTerm.NATIVE_PRESENCE_QUESTIONABLE().getUuid());

            doubtfulStatus.add(PresenceAbsenceTerm.CULTIVATED_PRESENCE_QUESTIONABLE().getUuid());

        }

        boolean isDoubtful = doubtfulStatus.contains(status.getUuid());

        return isDoubtful;

    }

    /**

     * @param area

     * @return

     */

    private boolean isCubanArea(NamedArea area) {

        if (area.getUuid().equals(CubaTransformer.uuidCuba)){

            return true;

        }else if (area.getPartOf()!= null){

            return isCubanArea(area.getPartOf());

        }else{

            return false;

        }

    }

    /**

        }else{

            statusStr = statusStr.trim();

//            PresenceAbsenceTerm highestStatus = state.getHighestStatusForTaxon();

//                getAbsenceTermForStatus(state, highestStatus);

                //we now handle cuban provinces same as external regions

                status = state.getTransformer().getPresenceTermByKey("--");

//                logger.warn("Unhandled status str for provinces / external regions: " + statusStr);

                if (statusUuid == null){

                    logger.error(state.getCurrentLine() + ": Undefined status str for provinces / external regions. No UUID given: '" + statusStr + "'");

                }else{

                    status = getPresenceTerm(state, statusUuid, statusStr, statusStr, statusStr, false);

                }

    private boolean taxonIsAbsent = false;

    public boolean isTaxonIsAbsent(){return this.taxonIsAbsent;}

    public void setTaxonIsAbsent(boolean taxonIsAbsent) {this.taxonIsAbsent = taxonIsAbsent;}

    private boolean isEndemic = false;

    public boolean isEndemic(){return this.isEndemic;}

    public void setEndemic(boolean isEndemic) {this.isEndemic = isEndemic;}

    protected static final UUID nonNativeDoubtfullyNaturalisedUuid = UUID.fromString("a1e26234-831e-4190-9fe3-011aca09ddba");

//    private static final UUID adventiveAlienUuid = UUID.fromString("06e48a0b-3e48-4ef8-9bdd-0755880e99ce");

//    private static final UUID cultivatedOnlyUuid = UUID.fromString("9cca5c3b-aced-41c4-accc-f800b67168f8");

    protected static final UUID occasionallyCultivatedUuid = UUID.fromString("936c3f9a-6099-4322-9792-0a72c6c2ce25");

//    private static final UUID doubtfulIndigenousUuid = UUID.fromString("f47f4f4e-9d84-459a-b747-27a1af24ab7a");

    protected static final UUID doubtfulIndigenousDoubtfulUuid = UUID.fromString("7ddfd94d-01a4-496c-a6d6-18584c00af59");

    protected static final UUID rareCasualUuid = UUID.fromString("8914ce0d-7d31-4c88-8317-985f2b3a493b");

    protected static final UUID endemicDoubtfullyPresentUuid = UUID.fromString("5f954f08-267a-4928-b073-12328f74c187");

    protected static final UUID naturalisedDoubtfullyPresentUuid = UUID.fromString("9e0b413b-5a68-4e5b-91f2-227b4f832466");

    protected static final UUID nonNativeDoubtfullyPresentUuid = UUID.fromString("c42ca644-1773-4230-a2ee-328a5d4a21ab");

    private static final UUID endemicInErrorUuid = UUID.fromString("679b215d-c231-4ee2-ae12-3ffc3dd528ad");

    private static final UUID adventiveInErrorUuid = UUID.fromString("9b910b7b-43e3-4260-961c-6063b11cb7dc");

    private static final UUID nonNativeInErrorUuid = UUID.fromString("b9153d90-9e31-465a-a28c-79077a8ed4c2");

    private static final UUID naturalisedInErrorUuid = UUID.fromString("8d918a37-3add-4e1c-a233-c37dbee209aa");

//        }else if (key.equalsIgnoreCase("Ind.")){return CyprusTransformer.indigenousUuid;

//        }else if (key.equalsIgnoreCase("+")){return CyprusTransformer.indigenousUuid;

//        }else if (key.equalsIgnoreCase("?Ind.")){return CyprusTransformer.indigenousDoubtfulUuid;

//        }else if (key.equalsIgnoreCase("?")){return CyprusTransformer.indigenousDoubtfulUuid;

//        }else if (key.equalsIgnoreCase("?Cult.")){return CyprusTransformer.cultivatedDoubtfulUuid;

//        }else if (key.equalsIgnoreCase("Ind.?")){return doubtfulIndigenousUuid;

//        }else if (key.equalsIgnoreCase("D")){return doubtfulIndigenousUuid;

        }else if (key.equalsIgnoreCase("?Ind.?")){return doubtfulIndigenousDoubtfulUuid;

//        }else if (key.equalsIgnoreCase("Adv.")){return adventiveAlienUuid;

//        }else if (key.equalsIgnoreCase("A")){return adventiveAlienUuid;

        }else if (key.equalsIgnoreCase("(A)")){return rareCasualUuid;

        }else if (key.equalsIgnoreCase("?E")){return endemicDoubtfullyPresentUuid;

        }else if (key.equalsIgnoreCase("?Nat.")){return naturalisedDoubtfullyPresentUuid;

        }else if (key.equalsIgnoreCase("?N")){return naturalisedDoubtfullyPresentUuid;

        }else if (key.equalsIgnoreCase("?Dud.")){return nonNativeDoubtfullyPresentUuid;

        }else if (key.equalsIgnoreCase("?P")){return nonNativeDoubtfullyPresentUuid;

        }else if (key.equalsIgnoreCase("+")){return PresenceAbsenceTerm.NATIVE();

        }else if (key.equalsIgnoreCase("Ind.")){return PresenceAbsenceTerm.NATIVE();

        }else if (key.equalsIgnoreCase("Ind.?")){return PresenceAbsenceTerm.NATIVE_DOUBTFULLY_NATIVE();

        }else if (key.equalsIgnoreCase("D")){return PresenceAbsenceTerm.NATIVE_DOUBTFULLY_NATIVE();

        }else if (key.equalsIgnoreCase("?Ind.")){return PresenceAbsenceTerm.NATIVE_PRESENCE_QUESTIONABLE();

        }else if (key.equalsIgnoreCase("?")){return PresenceAbsenceTerm.NATIVE_PRESENCE_QUESTIONABLE();

        }else if (key.equalsIgnoreCase("Adv.")){return PresenceAbsenceTerm.INTRODUCED_ADVENTITIOUS();

        }else if (key.equalsIgnoreCase("A")){return PresenceAbsenceTerm.INTRODUCED_ADVENTITIOUS();

        }else if (key.equalsIgnoreCase("?Cult.")){return PresenceAbsenceTerm.CULTIVATED_PRESENCE_QUESTIONABLE();

//        }else if (key.equalsIgnoreCase("-C")){return PresenceAbsenceTerm.CULTIVATED_REPORTED_IN_ERROR();