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.specimen.abcd206.in;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URI;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

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

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;

import eu.etaxonomy.cdm.common.UriUtils;

import eu.etaxonomy.cdm.io.specimen.SpecimenImportBase;

import eu.etaxonomy.cdm.io.specimen.SpecimenUserInteraction;

import eu.etaxonomy.cdm.io.specimen.UnitsGatheringArea;

import eu.etaxonomy.cdm.io.specimen.UnitsGatheringEvent;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.media.Media;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.query.MatchMode;

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

/**

 * @author p.kelbert

 * @created 20.10.2008

 */

@Component

public class Abcd206Import extends SpecimenImportBase<Abcd206ImportConfigurator, Abcd206ImportState> {

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

    private final boolean DEBUG = true;

    private static final String PREFERRED = "_preferred_";

    private static final String CODE = "_code_";

    private static final String COLON = ":";

    private static final String SPLITTER = "--";

    private static String prefix = "";

    //TODO make all fields ABCD206ImportState variables

    private Classification classification = null;

    private Reference<?> ref = null;

    private Abcd206DataHolder dataHolder;

    private DerivedUnit derivedUnitBase;

    private List<OriginalSourceBase<?>> associationRefs = new ArrayList<OriginalSourceBase<?>>();

    boolean associationSourcesSet=false;

    private List<OriginalSourceBase<?>> descriptionRefs = new ArrayList<OriginalSourceBase<?>>();

    boolean descriptionSourcesSet=false;

    private List<OriginalSourceBase<?>> derivedUnitSources = new ArrayList<OriginalSourceBase<?>>();

    boolean derivedUnitSourcesSet=false;

    private boolean descriptionGroupSet = false;

    private TaxonDescription descriptionGroup = null;

    public Abcd206Import() {

        super();

    }

    @Override

    protected boolean doCheck(Abcd206ImportState state) {

        logger.warn("Checking not yet implemented for " + this.getClass().getSimpleName());

        return true;

    }

    @Override

    @SuppressWarnings("rawtypes")

    public void doInvoke(Abcd206ImportState state) {

        state.setTx(startTransaction());

        logger.info("INVOKE Specimen Import from ABCD2.06 XML ");

        SpecimenUserInteraction sui = state.getConfig().getSpecimenUserInteraction();

        List<Reference> references = getReferenceService().list(Reference.class, null, null, null, null);

        if (state.getConfig().isInteractWithUser()){

            Map<String,Reference> refMap = new HashMap<String, Reference>();

            for (Reference tree : references) {

                if (! StringUtils.isBlank(tree.getTitleCache())) {

                    refMap.put(tree.getTitleCache(),tree);

                }

            }

            ref = sui.askForReference(refMap);

            if (ref == null){

                String cla = sui.createNewReference();

                if (refMap.get(cla)!= null) {

                    ref = refMap.get(cla);

                } else {

                    ref = ReferenceFactory.newGeneric();

                    ref.setTitle(cla);

                }

            }

            else{

                ref = getReferenceService().find(ref.getUuid());

            }

        }else{

            if (ref==null){

                String name = NB(state.getConfig().getSourceReferenceTitle());

                for (Reference tree : references) {

                    if (! StringUtils.isBlank(tree.getTitleCache())) {

                        if (tree.getTitleCache().equalsIgnoreCase(name)) {

                            ref=tree;

//                            System.out.println("FIND SAME REFERENCE");

                        }

                    }

                }

                if (ref == null){

                    ref = ReferenceFactory.newGeneric();

                    ref.setTitle("ABCD classic");

                }

            }

        }

        save(ref, state);

        state.getConfig().setSourceReference(ref);

        List<Classification> classificationList = getClassificationService().list(Classification.class, null, null, null, null);

        if (state.getConfig().isUseClassification() && state.getConfig().isInteractWithUser()){

            Map<String,Classification> classMap = new HashMap<String, Classification>();

            for (Classification tree : classificationList) {

                if (! StringUtils.isBlank(tree.getTitleCache())) {

                    classMap.put(tree.getTitleCache(),tree);

                }

            }

            classification = sui.askForClassification(classMap);

            if (classification == null){

                String cla = sui.createNewClassification();

                if (classMap.get(cla)!= null) {

                    classification = classMap.get(cla);

                } else {

                    classification = Classification.NewInstance(cla, ref, Language.DEFAULT());

                }

            }

            save(classification, state);

        }

        else{

            if (classification == null) {

                String name = NB(state.getConfig().getClassificationName());

                for (Classification classif : classificationList){

                    if (classif.getTitleCache().equalsIgnoreCase(name) && classif.getCitation().equals(ref)) {

                        classification=classif;

//                        System.out.println("FIND SAME CLASSIF");

                    }

                }

                if (classification == null){

                    classification = Classification.NewInstance(name, ref, Language.DEFAULT());

                }

                //                if (state.getConfig().getClassificationUuid() != null) {

                //                    classification.setUuid(state.getConfig().getClassificationUuid());

                //                }

                save(classification, state);

            }

        }

        InputStream source = state.getConfig().getSource();

        NodeList unitsList = getUnitsNodeList(source);

        if (unitsList != null) {

            String message = "nb units to insert: " + unitsList.getLength();

            logger.info(message);

            updateProgress(state, message);

            dataHolder = new Abcd206DataHolder();

            Abcd206XMLFieldGetter abcdFieldGetter = new Abcd206XMLFieldGetter(dataHolder, prefix);

            prepareCollectors(state, unitsList, abcdFieldGetter);

            associationRefs = new ArrayList<OriginalSourceBase<?>>();

            descriptionRefs = new ArrayList<OriginalSourceBase<?>>();

            derivedUnitSources = new ArrayList<OriginalSourceBase<?>>();

            for (int i = 0; i < unitsList.getLength(); i++) {

                System.out.println("------------------------------------------------------------------------------------------");

                this.setUnitPropertiesXML( (Element) unitsList.item(i), abcdFieldGetter);

                //				refreshTransaction(state);

                this.handleSingleUnit(state);

                // compare the ABCD elements added in to the CDM and the

                // unhandled ABCD elements

                //compareABCDtoCDM(sourceName, dataHolder.knownABCDelements, abcdFieldGetter);

                // reset the ABCD elements added in CDM

                // knownABCDelements = new ArrayList<String>();

                dataHolder.allABCDelements = new HashMap<String, String>();

            }

            getReferenceService().deduplicate(Reference.class, null, null);

            getClassificationService().deduplicate(Classification.class, null, null);

        }

        commitTransaction(state.getTx());

        return;

    }

    protected NodeList getUnitsNodeList(URI source) {

        try {

            InputStream is = UriUtils.getInputStream(source);

            return getUnitsNodeList(is);

        } catch (Exception e) {

            logger.warn(e);

            throw new RuntimeException(e);

        }

    }

    /**

     * Return the list of root nodes for an ABCD 2.06 XML file

     * @param fileName: the file's location

     * @return the list of root nodes ("Unit")

     */

    protected NodeList getUnitsNodeList(InputStream inputStream) {

        NodeList unitList = null;

        try {

            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

            DocumentBuilder builder = factory.newDocumentBuilder();

            Document document = builder.parse(inputStream);

            Element root = document.getDocumentElement();

            unitList = root.getElementsByTagName("Unit");

            if (unitList.getLength() == 0) {

                unitList = root.getElementsByTagName("abcd:Unit");

                prefix = "abcd:";

            }

        } catch (Exception e) {

            logger.warn(e);

        }

        return unitList;

    }

    /**

     * Handle a single unit

     * @param state

     */

    @SuppressWarnings("rawtypes")

    private void handleSingleUnit(Abcd206ImportState state) {

        if (DEBUG) {

            logger.info("handleSingleUnit "+ref);

        }

        try {

            updateProgress(state, "Importing data for unit: " + dataHolder.unitID);

            // create facade

            DerivedUnitFacade derivedUnitFacade = getFacade();

            derivedUnitBase = derivedUnitFacade.innerDerivedUnit();

            /**

             * GATHERING EVENT

             */

            // gathering event

            UnitsGatheringEvent unitsGatheringEvent = new UnitsGatheringEvent(getTermService(), dataHolder.locality, dataHolder.languageIso,

                    dataHolder.longitude, dataHolder.latitude, dataHolder.gatheringAgentList, dataHolder.gatheringTeamList,state.getConfig());

            // country

            UnitsGatheringArea unitsGatheringArea = new UnitsGatheringArea();

            //  unitsGatheringArea.setConfig(state.getConfig(),getOccurrenceService(), getTermService());

            unitsGatheringArea.setParams(dataHolder.isocountry, dataHolder.country, state.getConfig(), getTermService(), getOccurrenceService());

            DefinedTermBase<?> areaCountry =  unitsGatheringArea.getCountry();

            // other areas

            unitsGatheringArea = new UnitsGatheringArea();

            //            unitsGatheringArea.setConfig(state.getConfig(),getOccurrenceService(),getTermService());

            unitsGatheringArea.setAreas(dataHolder.namedAreaList,state.getConfig(), getTermService());

            ArrayList<DefinedTermBase> nas = unitsGatheringArea.getAreas();

            for (DefinedTermBase namedArea : nas) {

                unitsGatheringEvent.addArea(namedArea);

            }

            // copy gathering event to facade

            GatheringEvent gatheringEvent = unitsGatheringEvent.getGatheringEvent();

            derivedUnitFacade.setLocality(gatheringEvent.getLocality());

            derivedUnitFacade.setExactLocation(gatheringEvent.getExactLocation());

            derivedUnitFacade.setCollector(gatheringEvent.getCollector());

            derivedUnitFacade.setCountry((NamedArea)areaCountry);

            for(DefinedTermBase<?> area:unitsGatheringArea.getAreas()){

                derivedUnitFacade.addCollectingArea((NamedArea) area);

            }

            //            derivedUnitFacade.addCollectingAreas(unitsGatheringArea.getAreas());

            // TODO exsiccatum

            // add fieldNumber

            derivedUnitFacade.setFieldNumber(NB(dataHolder.fieldNumber));

            // //add Multimedia URLs

            if (dataHolder.multimediaObjects.size() != -1) {

                for (String multimediaObject : dataHolder.multimediaObjects) {

                    Media media;

                    try {

                        media = getImageMedia(multimediaObject, READ_MEDIA_DATA);

                        derivedUnitFacade.addDerivedUnitMedia(media);

                    } catch (MalformedURLException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }

            }

            //			/*

            //			 * merge AND STORE DATA

            //			 */

            //			getTermService().saveOrUpdate(areaCountry);// TODO save area sooner

            //

            //			for (NamedArea area : otherAreas) {

            //				getTermService().saveOrUpdate(area);// merge it sooner (foreach area)

            //			}

            save(unitsGatheringEvent.getLocality(), state);

            // handle collection data

            setCollectionData(state, derivedUnitFacade);

            //Reference stuff

            SpecimenUserInteraction sui = state.getConfig().getSpecimenUserInteraction();

            Map<String,OriginalSourceBase<?>> sourceMap = new HashMap<String, OriginalSourceBase<?>>();

            dataHolder.docSources = new ArrayList<String>();

            for (String[] fullReference : dataHolder.referenceList) {

                String strReference=fullReference[0];

                String citationDetail = fullReference[1];

                String citationURL = fullReference[2];

                if (!citationURL.isEmpty()) {

                    citationDetail+=", "+citationURL;

                }

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

                reference.setTitleCache(strReference);

                IdentifiableSource sour = getIdentifiableSource(reference,citationDetail);

                try{

                    if (sour.getCitation() != null){

                        if(StringUtils.isNotBlank(sour.getCitationMicroReference())) {

                            dataHolder.docSources.add(sour.getCitation().getTitleCache()+ "---"+sour.getCitationMicroReference());

                        } else {

                            dataHolder.docSources.add(sour.getCitation().getTitleCache());

                        }

                    }

                }catch(Exception e){

                    logger.warn("oups");

                }

                reference.addSource(sour);

                save(reference, state);

            }

            List<IdentifiableSource> issTmp = getCommonService().list(IdentifiableSource.class, null, null, null, null);

            List<DescriptionElementSource> issTmp2 = getCommonService().list(DescriptionElementSource.class, null, null, null, null);

            Set<OriginalSourceBase> osbSet = new HashSet<OriginalSourceBase>();

            if(issTmp2!=null) {

                osbSet.addAll(issTmp2);

            }

            if(issTmp!=null) {

                osbSet.addAll(issTmp);

            }

            for( OriginalSourceBase<?> osb:osbSet) {

                if(osb.getCitationMicroReference() !=null  && !osb.getCitationMicroReference().isEmpty()) {

                    try{

                        sourceMap.put(osb.getCitation().getTitleCache()+ "---"+osb.getCitationMicroReference(),osb);

                    }catch(NullPointerException e){logger.warn("null pointer problem (no ref?) with "+osb);}

                } else{

                    try{

                        sourceMap.put(osb.getCitation().getTitleCache(),osb);

                    }catch(NullPointerException e){logger.warn("null pointer problem (no ref?) with "+osb);}

                }

            }

            if( state.getConfig().isInteractWithUser()){

                List<OriginalSourceBase<?>>sources=null;

                if(!derivedUnitSourcesSet){

                    sources= sui.askForSource(sourceMap, "the unit itself","",getReferenceService(), dataHolder.docSources);

                    derivedUnitSources=sources;

                    derivedUnitSourcesSet=true;

                }

                else{

                    sources=derivedUnitSources;

                }

//                System.out.println("nb sources: "+sources.size());

//                System.out.println("derivedunitfacade : "+derivedUnitFacade.getTitleCache());

                for (OriginalSourceBase<?> sour:sources){

                    if(sour.isInstanceOf(IdentifiableSource.class)){

                        if(sourceNotLinkedToElement(derivedUnitFacade,sour)) {

//                            System.out.println("add source to derivedunitfacade1 "+derivedUnitFacade.getTitleCache());

                            derivedUnitFacade.addSource((IdentifiableSource)sour.clone());

                        }

                    }else{

                        if(sourceNotLinkedToElement(derivedUnitFacade,sour)) {

//                            System.out.println("add source to derivedunitfacade2 "+derivedUnitFacade.getTitleCache());

                            derivedUnitFacade.addSource(OriginalSourceType.Import,sour.getCitation(),sour.getCitationMicroReference(), ioName);

                        }

                    }

                }

            }else{

                for (OriginalSourceBase<?> sr : sourceMap.values()){

                    if(sr.isInstanceOf(IdentifiableSource.class)){

                        if(sourceNotLinkedToElement(derivedUnitFacade,sr)) {

//                            System.out.println("add source to derivedunitfacade3 "+derivedUnitFacade.getTitleCache());

                            derivedUnitFacade.addSource((IdentifiableSource)sr.clone());

                        }

                    }else{

                        if(sourceNotLinkedToElement(derivedUnitFacade,sr)) {

//                            System.out.println("add source to derivedunitfacade4 "+derivedUnitFacade.getTitleCache());

                            derivedUnitFacade.addSource(OriginalSourceType.Import,sr.getCitation(),sr.getCitationMicroReference(), ioName);

                        }

                    }

                }

            }

            save(derivedUnitBase, state);

            // handle identifications

            handleIdentifications(state, derivedUnitFacade);

            if(DEBUG) {

                logger.info("saved ABCD specimen ...");

            }

        } catch (Exception e) {

            logger.warn("Error when reading record!!");

            e.printStackTrace();

            state.setUnsuccessfull();

        }

        return;

    }

    /**

     * @param derivedUnitFacade

     * @param sour

     * @return

     */

    private boolean sourceNotLinkedToElement(DerivedUnitFacade derivedUnitFacade, OriginalSourceBase<?> source) {

        Set<IdentifiableSource> linkedSources = derivedUnitFacade.getSources();

        for (IdentifiableSource is:linkedSources){

            if (is.getCitation()!=null && source.getCitation()!=null &&

                    is.getCitation().getTitleCache().equalsIgnoreCase(source.getCitation().getTitleCache())){

                String isDetail =  is.getCitationMicroReference();

                if ((StringUtils.isBlank(isDetail) && StringUtils.isBlank(source.getCitationMicroReference()))

                        || (isDetail != null && isDetail.equalsIgnoreCase(source.getCitationMicroReference())) ) {

                    return false;

                }

            }

        }

        return true;

    }

    /**

     * @param reference

     * @param citationDetail

     * @return

     */

    //FIXME this method is highly critical, because

    //  * it will have serious performance and memory problems with large databases

    //        (databases may easily have >1 Mio source records)

    //  * it does not make sense to search for existing sources and then clone them

    //    we need to search for existing references instead and use them (if exist)

    //    for our new source.

    private IdentifiableSource getIdentifiableSource(Reference<?> reference, String citationDetail) {

        List<IdentifiableSource> issTmp = getCommonService().list(IdentifiableSource.class, null, null, null, null);

        if (reference != null){

            try {

                for (OriginalSourceBase<?> osb: issTmp){

                    if (osb.getCitation() != null && reference!=null && osb.getCitation().getTitleCache().equalsIgnoreCase(reference.getTitleCache())){

                        String osbDetail = osb.getCitationMicroReference();

                        if ((StringUtils.isBlank(osbDetail) && StringUtils.isBlank(citationDetail))

                                || (osbDetail != null && osbDetail.equalsIgnoreCase(citationDetail)) ) {

//                            System.out.println("REFERENCE FOUND RETURN EXISTING SOURCE");

                            return (IdentifiableSource) osb.clone();

                        }

                    }

                }

            } catch (CloneNotSupportedException e) {

                throw new RuntimeException(e);

            } catch (Exception e1){

                e1.printStackTrace();

            }

        }

        IdentifiableSource sour = IdentifiableSource.NewInstance(OriginalSourceType.Import,null,null, reference,citationDetail);

        return sour;

    }

    //    /**

    //     * @param reference

    //     * @param citationDetail

    //     * @return

    //     */

    //    private DescriptionElementSource getDescriptionSource(Reference<?> reference, String citationDetail) {

    //

    //        List<OriginalSourceBase> issTmp2 = getCommonService().list(DescriptionElementSource.class, null, null, null, null);

    //

    //        try {

    //            for (OriginalSourceBase<?> osb:issTmp2){

    //                if (osb.getCitation().equals(reference) && osb.getCitationMicroReference().equalsIgnoreCase(citationDetail)) {

    //                    return (DescriptionElementSource) osb.clone();

    //                }

    //            }

    //        } catch (CloneNotSupportedException e) {

    //            // TODO Auto-generated catch block

    //            e.printStackTrace();

    //        }

    //

    //        DescriptionElementSource sour = DescriptionElementSource.NewInstance(OriginalSourceType.Import,null,null, reference,citationDetail);

    //        return sour;

    //    }

    /**

     * Very fast and dirty implementation to allow handling of transient objects as described in

     * https://dev.e-taxonomy.eu/trac/ticket/3726

     *

     * Not yet complete.

     *

     * @param cdmBase

     * @param state

     */

    private void save(CdmBase cdmBase, Abcd206ImportState state) {

        ICdmApplicationConfiguration cdmRepository = state.getConfig().getCdmAppController();

        if (cdmRepository == null){

            cdmRepository = this;

        }

        if (cdmBase.isInstanceOf(LanguageString.class)){

            cdmRepository.getTermService().saveLanguageData(CdmBase.deproxy(cdmBase, LanguageString.class));

        }else if (cdmBase.isInstanceOf(SpecimenOrObservationBase.class)){

            cdmRepository.getOccurrenceService().saveOrUpdate(CdmBase.deproxy(cdmBase, SpecimenOrObservationBase.class));

        }else if (cdmBase.isInstanceOf(Reference.class)){

            cdmRepository.getReferenceService().saveOrUpdate(CdmBase.deproxy(cdmBase, Reference.class));

        }else if (cdmBase.isInstanceOf(Classification.class)){

            cdmRepository.getClassificationService().saveOrUpdate(CdmBase.deproxy(cdmBase, Classification.class));

        }else if (cdmBase.isInstanceOf(AgentBase.class)){

            cdmRepository.getAgentService().saveOrUpdate(CdmBase.deproxy(cdmBase, AgentBase.class));

        }else if (cdmBase.isInstanceOf(Collection.class)){

            cdmRepository.getCollectionService().saveOrUpdate(CdmBase.deproxy(cdmBase, Collection.class));

        }else if (cdmBase.isInstanceOf(DescriptionBase.class)){

            cdmRepository.getDescriptionService().saveOrUpdate(CdmBase.deproxy(cdmBase, DescriptionBase.class));

        }else if (cdmBase.isInstanceOf(TaxonBase.class)){

            cdmRepository.getTaxonService().saveOrUpdate(CdmBase.deproxy(cdmBase, TaxonBase.class));

        }else if (cdmBase.isInstanceOf(TaxonNameBase.class)){

            cdmRepository.getNameService().saveOrUpdate(CdmBase.deproxy(cdmBase, TaxonNameBase.class));

        }else{

            throw new IllegalArgumentException("Class not supported in save method: " + CdmBase.deproxy(cdmBase, CdmBase.class).getClass().getSimpleName());

        }

    }

    /**

     * setCollectionData : store the collection object into the

     * derivedUnitFacade

     *

     * @param state

     */

    private void setCollectionData(Abcd206ImportState state, DerivedUnitFacade derivedUnitFacade) {

        // set catalogue number (unitID)

        derivedUnitFacade.setCatalogNumber(NB(dataHolder.unitID));

        derivedUnitFacade.setAccessionNumber(NB(dataHolder.accessionNumber));

        // derivedUnitFacade.setCollectorsNumber(NB(dataHolder.collectorsNumber));

        /*

         * INSTITUTION & COLLECTION

         */

        // manage institution

        Institution institution = this.getInstitution(NB(dataHolder.institutionCode), state);

        // manage collection

        Collection collection = this.getCollection(institution, NB(dataHolder.collectionCode), state);

        // link specimen & collection

        derivedUnitFacade.setCollection(collection);

    }

    /**

     * getFacade : get the DerivedUnitFacade based on the recordBasis

     *

     * @return DerivedUnitFacade

     */

    private DerivedUnitFacade getFacade() {

        if(DEBUG) {

            logger.info("getFacade()");

        }

        SpecimenOrObservationType type = null;

        // create specimen

        if (NB((dataHolder.recordBasis)) != null) {

            if (dataHolder.recordBasis.toLowerCase().startsWith("s") || dataHolder.recordBasis.toLowerCase().indexOf("specimen")>-1) {// specimen

                type = SpecimenOrObservationType.PreservedSpecimen;

            }

            if (dataHolder.recordBasis.toLowerCase().startsWith("o") ||dataHolder.recordBasis.toLowerCase().indexOf("observation")>-1 ) {

                type = SpecimenOrObservationType.Observation;

            }

            if (dataHolder.recordBasis.toLowerCase().indexOf("fossil")>-1){

                type = SpecimenOrObservationType.Fossil;

            }

            if (dataHolder.recordBasis.toLowerCase().indexOf("living")>-1) {

                type = SpecimenOrObservationType.LivingSpecimen;

            }

            if (type == null) {

                logger.info("The basis of record does not seem to be known: " + dataHolder.recordBasis);

                type = SpecimenOrObservationType.DerivedUnit;

            }

            // TODO fossils?

        } else {

            logger.info("The basis of record is null");

            type = SpecimenOrObservationType.DerivedUnit;

        }

        DerivedUnitFacade derivedUnitFacade = DerivedUnitFacade.NewInstance(type);

        return derivedUnitFacade;

    }

    private void getCollectorsFromXML(Element root, Abcd206XMLFieldGetter abcdFieldGetter) {

        NodeList group;

        group = root.getChildNodes();

        for (int i = 0; i < group.getLength(); i++) {

            if (group.item(i).getNodeName().equals(prefix + "Identifications")) {

                group = group.item(i).getChildNodes();

                break;

            }

        }

        dataHolder.gatheringAgentList = new ArrayList<String>();

        dataHolder.gatheringTeamList = new ArrayList<String>();

        abcdFieldGetter.getType(root);

        abcdFieldGetter.getGatheringPeople(root);

    }

    /**

     * Store the unit's properties into variables Look which unit is the

     * preferred one Look what kind of name it is supposed to be, for the

     * parsing (Botanical, Zoological)

     *

     * @param racine: the root node for a single unit

     */

    private void setUnitPropertiesXML(Element root, Abcd206XMLFieldGetter abcdFieldGetter) {

        try {

            NodeList group;

            group = root.getChildNodes();

            for (int i = 0; i < group.getLength(); i++) {

                if (group.item(i).getNodeName().equals(prefix + "Identifications")) {

                    group = group.item(i).getChildNodes();

                    break;

                }

            }

            dataHolder.identificationList = new ArrayList<String>();

            dataHolder.statusList = new ArrayList<SpecimenTypeDesignationStatus>();

            dataHolder.atomisedIdentificationList = new ArrayList<HashMap<String, String>>();

            dataHolder.referenceList = new ArrayList<String[]>();

            dataHolder.multimediaObjects = new ArrayList<String>();

            abcdFieldGetter.getScientificNames(group);

            abcdFieldGetter.getType(root);

            if(DEBUG) {

                logger.info("this.identificationList "+dataHolder.identificationList.toString());

            }

            abcdFieldGetter.getIDs(root);

            abcdFieldGetter.getRecordBasis(root);

            abcdFieldGetter.getMultimedia(root);

            abcdFieldGetter.getNumbers(root);

            abcdFieldGetter.getGeolocation(root);

            abcdFieldGetter.getGatheringPeople(root);

            boolean referencefound = abcdFieldGetter.getReferences(root);

            if (!referencefound) {

                String[]a = {ref.getTitleCache(),"",""};

                dataHolder.referenceList.add(a);

            }

        } catch (Exception e) {

            logger.info("Error occured while parsing XML file" + e);

        }

    }

    /**

     * Look if the Institution does already exist

     * @param institutionCode: a string with the institutioncode

     * @param config : the configurator

     * @return the Institution (existing or new)

     */

    @SuppressWarnings("rawtypes")

    private Institution getInstitution(String institutionCode, Abcd206ImportState state) {

        Institution institution=null;

        List<Institution> institutions;

        try {

            institutions = getAgentService().list(Institution.class, null, null, null, null);

        } catch (Exception e) {

            institutions = new ArrayList<Institution>();

            logger.warn(e);

        }

        if (institutions.size() > 0 && state.getConfig().isReUseExistingMetadata()) {

            for (Institution institut:institutions){

                try{

                    if (institut.getCode().equalsIgnoreCase(institutionCode)) {

                        institution=institut;

                    }

                }catch(Exception e){logger.warn("no institution code in the db");}

            }

        }

        if(DEBUG) {

            if(institution !=null) {

                logger.info("getinstitution " + institution.toString());

            }

        }

        if (institution == null){

            // create institution

            institution = Institution.NewInstance();

            institution.setCode(institutionCode);

            institution.setTitleCache(institutionCode, true);

        }

        save(institution, state);

        return institution;

    }

    /**

     * Look if the Collection does already exist

     * @param collectionCode

     * @param collectionCode: a string

     * @param config : the configurator

     * @return the Collection (existing or new)

     */

    private Collection getCollection(Institution institution, String collectionCode, Abcd206ImportState state) {

        Collection collection = null;

        List<Collection> collections;

        try {

            collections = getCollectionService().list(Collection.class, null, null, null, null);

        } catch (Exception e) {