EDIT

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

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

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

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

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

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

        if (missapliedMatcher.matches()){

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

            String firstPart = missapliedMatcher.group(2);

            name.addSource(makeOriginalSource(state));

            String secondPart = missapliedMatcher.group(3);

            if (StringUtils.isNotBlank(afterInval)){

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

            }

            name.addSource(makeOriginalSource(state));

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

            name.addStatus(status);

        }else if (sphalmMatcher.matches()){

            String firstPart = sphalmMatcher.group(1);

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

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

//            name.addStatus(status);

            name.addSource(makeOriginalSource(state));

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

            firstPart = replaceHomonIlleg(firstPart);

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

            if (synName.isProtectedTitleCache()){

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

            }

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

        }else if (isSpecialHeterotypic(synonymStr)){

            if (synName.isProtectedTitleCache()){

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

            }

        for (String split : splits){

            split = replaceHomonIlleg(split);

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

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

            if (newName.isProtectedTitleCache()){

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

        int i = 0;

        for (String split : splits){

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

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

        for (String spliti : splitsi){

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

            if (newName.isProtectedTitleCache()){

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

            }

                }

            }

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

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

                replacementNameCandidates.add(blockedName);

            }else{

            HomotypicalGroup homotypicGroup,

            List<IBotanicalName> replacementNameCandidates) {

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

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

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

                    if (! replacementNameCandidates.contains(candidate)){

            }

        }

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

            for (IBotanicalName replacementName : replacementNameCandidates){

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

            }

    private void createBasionymRelationIfPossible(CubaImportState state, IBotanicalName name1,

            IBotanicalName name2,

            boolean name2isHomonym, boolean onlyIfNotYetExists) {

        //exactly one name must have a basionym author

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

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

        //switch order if necessary

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

        }

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

                && BasionymRelationCreator.matchLastNamePart(basionymName, newCombination)){

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

        }

        state.setTaxonIsAbsent(isAbsent);

        Reference sec = getSecReference(state);

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

        if (isAuct){

            if (genus != null){

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

            }else{

                name.addSource(makeOriginalSource(state));

                name.setGenusOrUninomial(genusStr);

                genus = Taxon.NewInstance(name, sec);

     * @param taxonStr

     * @return

     */

        //normalize

        String nameStr = normalizeStatus(nameStrOrig);

        //orthVar

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

        }

        result.addSource(makeOriginalSource(state));

        if (isNomInval){

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

        }

        if (orthVar != null){

            orthVarName.addSource(makeOriginalSource(state));

            //TODO

            Reference citation = null;

        if (family != null){

            familyNode = family.getTaxonNodes().iterator().next();

        }else{

            Reference sec = getSecReference(state);

            family = Taxon.NewInstance(name, sec);

            ITaxonTreeNode rootNode = getClassification(state);

        if (isNotBlank(alternativeFamilyStr)){

            NameRelationshipType type = NameRelationshipType.ALTERNATIVE_NAME();

            boolean hasRelation = false;

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

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

        String key = famRef.getTitle() + ":"+ famStr;

        Taxon family = state.getHigherTaxon(key);

        if (family == null){

            family = Taxon.NewInstance(name, famRef);

            state.putHigherTaxon(key, family);

        }

     * @param famStr

     * @return

     */

        if (name == null){

            name = TaxonNameFactory.NewBotanicalInstance(Rank.FAMILY());

            name.setGenusOrUninomial(famStr);

                classification.getRootNode().setUuid(rootUuid);

            }

            plantaeName.setGenusOrUninomial("Plantae");

            Taxon plantae = Taxon.NewInstance(plantaeName, sec);

            TaxonNode plantaeNode = classification.addChildTaxon(plantae, null, null);