EDIT

    public static final String DATA_IAPT_TYPES_100 = "iapt-types-100.xls";

    public static final String DATA_FILE = DATA_FILE_FULL;

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

import eu.etaxonomy.cdm.model.occurrence.*;

import eu.etaxonomy.cdm.model.occurrence.Collection;

    private static final Pattern typeSplitPattern =  Pattern.compile("^(?:\"*[Tt]ype: (?<type>.*?))(?:[Hh]olotype:(?<holotype>.*?)\\.?)?(?:[Ii]sotype[^:]*:(?<isotype>.*)\\.?)?\\.?$");

    // AccessionNumbers: , #.*, n°:?, 96/3293, No..*, -?\w{1,3}-[0-9\-/]*

    private static final Pattern accessionNumberOnlyPattern = Pattern.compile("^(?<accNumber>(?:n°\\:?\\s?|#|No\\.?\\s?)?[\\d\\w\\-/]*)$");

    private static final Pattern[] specimenTypePatterns = new Pattern[]{

            Pattern.compile("^(?<colCode>[A-Z]+|CPC Micropaleontology Lab\\.?)\\s+(?:\\((?<institute>.*[^\\)])\\))(?<accNumber>.*)?$"), // like: GAUF (Gansu Agricultural University) No. 1207-1222

            Pattern.compile("^(?<colCode>[A-Z]+|CPC Micropaleontology Lab\\.?)\\s+(?:Coll\\.\\s(?<subCollection>[^\\.,;]*)(.))(?<accNumber>.*)?$"), // like KASSEL Coll. Krasske, Praep. DII 78

            Pattern.compile("^(?:Coll\\.\\s(?<subCollection>[^\\.,;]*)(.))(?<institute>.*)\\2(?<accNumber>.*)?$"), // like Coll. Lange-Bertalot, Bot. Inst., Univ. Frankfurt/Main, Germany Praep. Neukaledonien OTL 62

            Pattern.compile("^(?<colCode>[A-Z]+)(?:\\s+(?<accNumber>.*))?$"), // identifies the Collection code and takes the rest as accessionNumber if any

    };

    private Map<String, Collection> collectionMap = new HashMap<>();

        BotanicalName taxonName = makeBotanicalName(state, regNumber, titleCacheStr, nameStr, authorStr, nomRefTitle);

            BotanicalName replacedSynonymName = makeBotanicalName(state, regNumber, fullSynSubstStr, synSubstStr, null, null);

            makeTypeData(typeStr, taxonName, regNumber);

    private void makeTypeData(String typeStr, BotanicalName taxonName, String regNumber) {

        Matcher m = typeSplitPattern.matcher(typeStr);

        if(m.matches()){

            String typeString = m.group(TypesName.type.name());

            boolean isFieldUnit = typeStr.matches(".*([°']|\\d+\\s?m\\s|\\d+\\s?km\\s).*"); // check for location or unit m, km

            if(isFieldUnit) {

                // type as fieldUnit

                FieldUnit fu = FieldUnit.NewInstance();

                fu.setTitleCache(typeString, true);

                getOccurrenceService().save(fu);

                // all others ..

                addSpecimenTypes(taxonName, fu, m.group(TypesName.holotype.name()), TypesName.holotype, false, regNumber);

                addSpecimenTypes(taxonName, fu, m.group(TypesName.isotype.name()), TypesName.isotype, true, regNumber);

            } else {

                TaxonNameBase typeName = nameParser.parseFullName(typeString);

                taxonName.addNameTypeDesignation(typeName, null, null, null, NameTypeDesignationStatus.AUTOMATIC(), true, true, true, true);

            }

        }

        getNameService().save(taxonName);

    }

            logger.warn(csvReportLine(regNumber, "Pub date", nomRefPupDate, "in", nomRefStr, "not parsable"));

            logger.warn(csvReportLine(regNumber, "Unknown month name", monthName));

    private void addSpecimenTypes(BotanicalName taxonName, FieldUnit fieldUnit, String typeStr, TypesName typeName, boolean multiple, String regNumber){

        Collection collection = null;

        DerivedUnit specimen = null;

        List<DerivedUnit> specimens = new ArrayList<>();

                // command to  list all complex parsabel types:

                // csvcut -t -c RegistrationNo_Pk,Type iapt.csv | csvgrep -c Type -m "Holotype" | egrep -o 'Holotype:\s([A-Z]*\s)[^.]*?'

                // csvcut -t -c RegistrationNo_Pk,Type iapt.csv | csvgrep -c Type -m "Holotype" | egrep -o 'Isotype[^:]*:\s([A-Z]*\s)[^.]*?'

                    // trying to parse the string

                    specimen = parseSpecimenType(fieldUnit, typeName, collection, t, regNumber);

                    if(specimen != null){

                        specimens.add(specimen);

                    } else {

                        // parsing was not successful make simple specimen

                        specimens.add(makeSpecimenType(fieldUnit, t));

                    }

            specimen = parseSpecimenType(fieldUnit, typeName, collection, typeStr, regNumber);

            if(specimen != null) {

                specimens.add(specimen);

                // remember current collection

                collection = specimen.getCollection();

            } else {

                // parsing was not successful make simple specimen

                specimens.add(makeSpecimenType(fieldUnit, typeStr));

            }

        for(DerivedUnit s : specimens){

            taxonName.addSpecimenTypeDesignation(s, typeName.status(), null, null, null, false, true);

    private DerivedUnit makeSpecimenType(FieldUnit fieldUnit, String titleCache) {

        DerivedUnit specimen;DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(SpecimenOrObservationType.PreservedSpecimen, fieldUnit);

        facade.setTitleCache(titleCache.trim(), true);

        specimen = facade.innerDerivedUnit();

        return specimen;

    }

    /**

     *

     * @param fieldUnit

     * @param typeName

     * @param collection

     * @param text

     * @param regNumber

     * @return

     */

    private DerivedUnit parseSpecimenType(FieldUnit fieldUnit, TypesName typeName, Collection collection, String text, String regNumber) {

        DerivedUnit specimen = null;

        String collectionCode = null;

        String subCollectionStr = null;

        String instituteStr = null;

        String accessionNumber = null;

        boolean unusualAccessionNumber = false;

        text = text.trim();

        // 1.  For Isotypes often the accession number is noted alone if the

        //     preceeding entry has a collection code.

        if(typeName .equals(TypesName.isotype) && collection != null){

            Matcher m = accessionNumberOnlyPattern.matcher(text);

            if(m.matches()){

                try {

                    accessionNumber = m.group("accNumber");

                    specimen = makeSpecimenType(fieldUnit, collection, accessionNumber);

                } catch (IllegalArgumentException e){

                    // match group acc_number not found

                }

            }

        }

        //2. try it the 'normal' way

        if(specimen == null) {

            for (Pattern p : specimenTypePatterns) {

                Matcher m = p.matcher(text);

                if (m.matches()) {

                    // collection code is mandatory

                    try {

                        collectionCode = m.group("colCode");

                    } catch (IllegalArgumentException e){

                        logger.warn(csvReportLine(regNumber, "match group colCode not found"));

                        continue;

                    }

                    try {

                        subCollectionStr = m.group("subCollection");

                    } catch (IllegalArgumentException e){

                        // match group subCollection not found

                    }

                    try {

                        instituteStr = m.group("institute");

                    } catch (IllegalArgumentException e){

                        // match group col_name not found

                    }

                    try {

                        accessionNumber = m.group("accNumber");

                        // try to improve the accessionNumber

                        if(accessionNumber!= null) {

                            accessionNumber = accessionNumber.trim();

                            Matcher m2 = accessionNumberOnlyPattern.matcher(accessionNumber);

                            String betterAccessionNumber = null;

                            if (m2.matches()) {

                                try {

                                    betterAccessionNumber = m.group("accNumber");

                                } catch (IllegalArgumentException e) {

                                    // match group acc_number not found

                                }

                            }

                            if (betterAccessionNumber != null) {

                                accessionNumber = betterAccessionNumber;

                            } else {

                                unusualAccessionNumber = true;

                            }

                        }

                    } catch (IllegalArgumentException e){

                        // match group acc_number not found

                    }

                    collection = getCollection(collectionCode, instituteStr, subCollectionStr);

                    specimen = makeSpecimenType(fieldUnit, collection, accessionNumber);

                    break;

                }

            }

        }

        if(specimen == null) {

            logger.warn(csvReportLine(regNumber, "Could not parse specimen type", typeName.name().toString(), text));

        }

        if(unusualAccessionNumber){

            logger.warn(csvReportLine(regNumber, "Unusual accession number", typeName.name().toString(), text, accessionNumber));

        }

        return specimen;

    }

    private DerivedUnit makeSpecimenType(FieldUnit fieldUnit, Collection collection, String accessionNumber) {

        DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(SpecimenOrObservationType.PreservedSpecimen, fieldUnit);

        facade.setCollection(collection);

        facade.setAccessionNumber(accessionNumber);

        return facade.innerDerivedUnit();

    }

    private BotanicalName makeBotanicalName(SimpleExcelTaxonImportState<CONFIG> state, String regNumber, String titleCacheStr, String nameStr,

            logger.warn(csvReportLine(regNumber, "Name could not be parsed", titleCacheStr));

                logger.warn(csvReportLine(regNumber, "The generated titleCache differs from the imported string", taxonNameTitleCache, " != ", titleCacheStr, " ==> original titleCacheStr has been restored"));

                logger.warn(csvReportLine(regNumber, "The parsed nameCache differs from field '" + NAMESTRING + "'", nameCache, " != ", nameCompareStr));

            //    logger.warn(regNumber + ": titleCache has changed after setting authors, will restore original titleCacheStr");

    private Collection getCollection(String collectionCode, String instituteStr, String subCollectionStr){

        Collection superCollection = null;

        if(subCollectionStr != null){

            superCollection = getCollection(collectionCode, instituteStr, null);

            collectionCode = subCollectionStr;

            instituteStr = null;

        }

        final String key = collectionCode + "-#i:" + StringUtils.defaultString(instituteStr);

        Collection collection = collectionMap.get(key);

        if(collection == null) {

            collection = Collection.NewInstance();

            collection.setCode(collectionCode);

            if(instituteStr != null){

                collection.setInstitute(Institution.NewNamedInstance(instituteStr));

            }

            if(superCollection != null){

                collection.setSuperCollection(superCollection);

            }

            collectionMap.put(key, collection);

            getCollectionService().save(collection);

        }

        return collection;

    }

        String lineNumber = "L#" + state.getCurrentLine() + ": ";

    private String csvReportLine(String regId, String message, String ... fields){

        StringBuilder out = new StringBuilder("regID#");

        out.append(regId).append(",\"").append(message).append('"');

        for(String f : fields){

            out.append(",\"").append(f).append('"');

        }

        return out.toString();

    }