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

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.concurrent.CopyOnWriteArrayList;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

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

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

import eu.etaxonomy.cdm.io.common.ICdmIO;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.strategy.parser.NonViralNameParserImpl;

/**

 * @author p.kelbert

 * @created 20.10.2008

 * @version 1.0

 */

@Component

public class Abcd206Import extends

SpecimenImportBase<Abcd206ImportConfigurator, Abcd206ImportState>

implements ICdmIO<Abcd206ImportState> {

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

	private static String prefix = "";

	private Classification classification = null;

	private Reference<?> ref = null;

	private Abcd206ImportState abcdstate;

	private Abcd206DataHolder dataHolder;

	private DerivedUnitBase derivedUnitBase;

	private TransactionStatus tx;

	private Abcd206XMLFieldGetter abcdFileGetter;

	public Abcd206Import() {

		super();

	}

	@Override

	protected boolean doCheck(Abcd206ImportState state) {

		logger.warn("Checking not yet implemented for "

				+ this.getClass().getSimpleName());

		this.abcdstate = state;

		return true;

	}

	/**

	 * getClassification : get the classification declared in the ImportState

	 * 

	 * @param state

	 * @return

	 */

	private void setClassification(Abcd206ImportState state) {

		if (classification == null) {

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

			classification = Classification.NewInstance(name, ref,

					Language.DEFAULT());

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

				classification.setUuid(state.getConfig()

						.getClassificationUuid());

			}

			getClassificationService().saveOrUpdate(classification);

			refreshTransaction();

		}

	}

	@Override

	public void doInvoke(Abcd206ImportState state) {

		abcdstate = state;

		tx = startTransaction();

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

		URI sourceName = this.abcdstate.getConfig().getSource();

		NodeList unitsList = getUnitsNodeList(sourceName);

		this.abcdstate.getConfig().getClassificationName();

		this.abcdstate.getConfig().getClassificationUuid();

		ref = this.abcdstate.getConfig().getSourceReference();

		setClassification(abcdstate);

		if (unitsList != null) {

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

			logger.info(message);

			updateProgress(this.abcdstate, message);

			dataHolder = new Abcd206DataHolder();

			abcdFileGetter = new Abcd206XMLFieldGetter(dataHolder, prefix);

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

				// logger.info("UNIT NUMBER " + i);

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

				refreshTransaction();

				this.handleSingleUnit(i);

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

				// unhandled ABCD elements

				compareABCDtoCDM(sourceName, dataHolder.knownABCDelements);

				// reset the ABCD elements added in CDM

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

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

				refreshTransaction();

			}

		}

		commitTransaction(tx);

		return;

	}

	/*

	 * 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(URI urlFileName) {

		NodeList unitList = null;

		try {

			DocumentBuilderFactory factory = DocumentBuilderFactory

					.newInstance();

			DocumentBuilder builder = factory.newDocumentBuilder();

			URL url = urlFileName.toURL();

			Object o = url.getContent();

			InputStream is = (InputStream) o;

			Document document = builder.parse(is);

			Element root = document.getDocumentElement();

			// logger.info("root nodename " + root.getNodeName());

			unitList = root.getElementsByTagName("Unit");

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

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

				prefix = "abcd:";

			}

		} catch (Exception e) {

			logger.warn(e);

		}

		return unitList;

	}

	/*

	 * Stores the unit with its Gathering informations in the CDM

	 */

	private void handleSingleUnit(int i) {

		logger.info("handleSingleUnit");

		try {

			updateProgress(this.abcdstate, "Importing data for unit: "

					+ dataHolder.unitID);

			// create facade

			DerivedUnitFacade derivedUnitFacade = getFacade();

			derivedUnitBase = derivedUnitFacade.innerDerivedUnit();

			//			getOccurrenceService().saveOrUpdate(derivedUnitBase);

			//			refreshTransaction();

			/**

			 * GATHERING EVENT

			 */

			// gathering event

			UnitsGatheringEvent unitsGatheringEvent = new UnitsGatheringEvent(

					getTermService(), dataHolder.locality, dataHolder.languageIso,

					dataHolder.longitude, dataHolder.latitude,

					dataHolder.gatheringAgentList);

			// country

			UnitsGatheringArea unitsGatheringArea = new UnitsGatheringArea(

					dataHolder.isocountry, dataHolder.country,

					getOccurrenceService());

			NamedArea areaCountry = unitsGatheringArea.getArea();

			// other areas

			unitsGatheringArea = new UnitsGatheringArea(dataHolder.namedAreaList);

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

			for (NamedArea 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(areaCountry);

			derivedUnitFacade.addCollectingAreas(unitsGatheringArea.getAreas());

			// TODO exsiccatum

			// add fieldNumber

			derivedUnitFacade.setFieldNumber(dataHolder.fieldNumber);

			// //add Multimedia URLs

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

				for (String multimediaObject : dataHolder.multimediaObjects) {

					Media media;

					try {

						media = getImageMedia(multimediaObject, READ_MEDIA_DATA,

								false);

						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 : nas) {

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

				// area)

			}

			getTermService().saveLanguageData(unitsGatheringEvent.getLocality());

			// handle collection data

			setCollectionData(this.abcdstate.getConfig(), derivedUnitFacade);

			getOccurrenceService().saveOrUpdate(derivedUnitBase);

			refreshTransaction();

			// getOccurrenceService().saveOrUpdate(derivedUnitFacade.innerFieldObservation());

			// handle identifications

			handleIdentifications(this.abcdstate.getConfig(), derivedUnitFacade);

			/*

			 * getOccurrenceService().saveOrUpdate(

			 * derivedUnitFacade.innerFieldObservation());

			 */

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

		} catch (Exception e) {

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

			e.printStackTrace();

			this.abcdstate.setUnsuccessfull();

		}

		return;

	}

	/**

	 * setCollectionData : store the collection object into the

	 * derivedUnitFacade

	 * 

	 * @param config

	 */

	private void setCollectionData(Abcd206ImportConfigurator config,

			DerivedUnitFacade derivedUnitFacade) {

		// set catalogue number (unitID)

		derivedUnitFacade.setCatalogNumber(dataHolder.unitID);

		derivedUnitFacade.setAccessionNumber(dataHolder.accessionNumber);

		// derivedUnitFacade.setCollectorsNumber(dataHolder.collectorsNumber);

		/**

		 * INSTITUTION & COLLECTION

		 */

		// manage institution

		Institution institution = this.getInstitution(

				dataHolder.institutionCode, config);

		// manage collection

		Collection collection = this.getCollection(dataHolder.collectionCode,

				institution, config);

		// link specimen & collection

		derivedUnitFacade.setCollection(collection);

	}

	/**

	 * getFacade : get the DerivedUnitFacade based on the recordBasis

	 * 

	 * @return DerivedUnitFacade

	 */

	private DerivedUnitFacade getFacade() {

		// logger.info("GETFACADE");

		/**

		 * SPECIMEN OR OBSERVATION OR LIVING

		 */

		// DerivedUnitBase derivedThing = null;

		DerivedUnitType type = null;

		// create specimen

		if (dataHolder.recordBasis != null) {

			if (dataHolder.recordBasis.toLowerCase().startsWith("s")

					|| dataHolder.recordBasis.toLowerCase()

					.contains("specimen")) {// specimen

				type = DerivedUnitType.Specimen;

			}

			if (dataHolder.recordBasis.toLowerCase().startsWith("o")) {

				type = DerivedUnitType.Observation;

			}

			if (dataHolder.recordBasis.toLowerCase().contains("fossil"))

				type = DerivedUnitType.Fossil;

			if (dataHolder.recordBasis.toLowerCase().startsWith("l")) {

				type = DerivedUnitType.LivingBeing;

			}

			if (type == null) {

				logger.info("The basis of record does not seem to be known: "

						+ dataHolder.recordBasis);

				type = DerivedUnitType.DerivedUnit;

			}

			// TODO fossils?

		} else {

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

			type = DerivedUnitType.DerivedUnit;

		}

		DerivedUnitFacade derivedUnitFacade = DerivedUnitFacade

				.NewInstance(type);

		return derivedUnitFacade;

	}

	/*

	 * 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) {

		try {

			NodeList group;

			// try{afficherInfos(racine, 0);}catch (Exception e)

			// {logger.info(e);}

			group = root.getChildNodes();

			// logger.info("prefix et ident : "+prefix+"Identifications");

			// logger.info("ABCD ELEMENT not stored: "+group.item(i).getNodeName().toString()+" - value: "+group.item(i).getTextContent());

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

			abcdFileGetter.getScientificNames(group);

			abcdFileGetter.getType(root);

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

			abcdFileGetter.getIDs(root);

			abcdFileGetter.getRecordBasis(root);

			abcdFileGetter.getMultimedia(root);

			abcdFileGetter.getNumbers(root);

			abcdFileGetter.getGeolocation(root);

			abcdFileGetter.getGatheringPeople(root);

			boolean referencefound = abcdFileGetter.getReferences(root);

			if (!referencefound) {

				dataHolder.referenceList.add(ref.getTitleCache());

			}

		} catch (Exception e) {

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

		}

	}

	private Institution getInstitution(String institutionCode,

			Abcd206ImportConfigurator config) {

		Institution institution;

		List<Institution> institutions;

		try {

			// logger.info(dataHolder.institutionCode);

			institutions = getAgentService().searchInstitutionByCode(

					dataHolder.institutionCode);

		} catch (Exception e) {

			institutions = new ArrayList<Institution>();

		}

		if (institutions.size() == 0 || !config.isReUseExistingMetadata()) {

			// logger.info("Institution (agent) unknown or not allowed to reuse existing metadata");

			// create institution

			institution = Institution.NewInstance();

			institution.setCode(dataHolder.institutionCode);

		} else {

			// logger.info("Institution (agent) already in the db");

			institution = institutions.get(0);

		}

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

		return institution;

	}

	/*

	 * Look if the Collection does already exists

	 * 

	 * @param collectionCode: a string

	 * 

	 * @param institution: the current Institution

	 * 

	 * @param app

	 * 

	 * @return the Collection (existing or new)

	 */

	private Collection getCollection(String collectionCode,

			Institution institution, Abcd206ImportConfigurator config) {

		Collection collection = Collection.NewInstance();

		List<Collection> collections;

		try {

			collections = getCollectionService().searchByCode(

					dataHolder.collectionCode);

		} catch (Exception e) {

			collections = new ArrayList<Collection>();

		}

		if (collections.size() == 0 || !config.isReUseExistingMetadata()) {

			// logger.info("Collection not found or do not reuse existing metadata  "

			//		+ dataHolder.collectionCode);

			// create new collection

			collection.setCode(dataHolder.collectionCode);

			collection.setCodeStandard("GBIF");

			collection.setInstitute(institution);

		} else {

			boolean collectionFound = false;

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

				collection = collections.get(i);

				try {

					if (collection.getInstitute().getCode()

							.equalsIgnoreCase(institution.getCode())) {

						// found a collection with the same code and the same

						// institution

						collectionFound = true;

						break;

					}

				} catch (NullPointerException e) {

				}

			}

			if (!collectionFound) {

				collection.setCode(dataHolder.collectionCode);

				collection.setCodeStandard("GBIF");

				collection.setInstitute(institution);

			}

		}

		return collection;

	}

	/**

	 * join DeterminationEvent to the Taxon Object

	 * 

	 * @param taxon

	 *            : current Taxon Object

	 * @param preferredFlag

	 *            : preferred name, boolean

	 * @param config

	 *            : current ABCD Import configurator

	 */

	private void linkDeterminationEvent(Taxon taxon, boolean preferredFlag,

			Abcd206ImportConfigurator config, 

			DerivedUnitFacade derivedFacade) {

		// logger.info("start linkdetermination with taxon:" + taxon.getUuid()+", "+taxon);

		refreshTransaction();

		try {

			taxon = (Taxon) getTaxonService().find(taxon.getUuid());

		} catch (Exception e) {

			// logger.info("taxon uptodate");

		}

		DeterminationEvent determinationEvent = DeterminationEvent.NewInstance();

		determinationEvent.setTaxon(taxon);

		determinationEvent.setPreferredFlag(preferredFlag);

		determinationEvent.setIdentifiedUnit(derivedUnitBase);

		derivedUnitBase.addDetermination(determinationEvent);

		refreshTransaction();

		////		

		//		Set<DerivationEvent> dset = derivedUnitBase.getDeterminations();

		//		logger.info("dset: "+dset);

		try {

			// logger.info("NB TYPES INFO: "+ dataHolder.statusList.size());

			for (SpecimenTypeDesignationStatus specimenTypeDesignationstatus : dataHolder.statusList) {

				if (specimenTypeDesignationstatus != null) {

					// logger.info("specimenTypeDesignationstatus :"+ specimenTypeDesignationstatus);

					try {

						taxon = (Taxon) getTaxonService().find(taxon.getUuid());

					} catch (Exception e) {

						// logger.info("taxon uptodate");

					}

					specimenTypeDesignationstatus = (SpecimenTypeDesignationStatus) getTermService().find(specimenTypeDesignationstatus.getUuid());

					//Designation

					TaxonNameBase<?,?> name = taxon.getName();

					SpecimenTypeDesignation designation = SpecimenTypeDesignation.NewInstance();

					designation.setTypeStatus(specimenTypeDesignationstatus);

					designation.setTypeSpecimen(derivedUnitBase);

					name.addTypeDesignation(designation, true);

					refreshTransaction();

				}

			}

		} catch (Exception e) {

			logger.warn("PB addding SpecimenType " + e);

		}

		for (String strReference : dataHolder.referenceList) {

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

			reference.setTitleCache(strReference, true);

            getReferenceService().saveOrUpdate(reference);

			determinationEvent.addReference(reference);

		}

        getOccurrenceService().saveOrUpdate(derivedUnitBase);

		refreshTransaction();

		if (config.isDoCreateIndividualsAssociations()) {

			// logger.info("isDoCreateIndividualsAssociations");

			// TaxonDescription taxonDescription = null;

			if (config.isDoMatchToExistingDescription()) {

				logger.warn("The import option 'DoMatchToExistingDescription' is not yet implemented.");

			} else {

				// UUID taxonDescriptionUUID =

				// config.getTaxonToDescriptionMap().get(taxon.getUuid()); //

				// rather

				// logger.info("UUID taxondescription "+taxonDescriptionUUID);

				// if (taxonDescriptionUUID != null) {

				// try{

				// taxonDescription = (TaxonDescription)

				// getDescriptionService().load(taxonDescriptionUUID);

				// }catch(Exception

				// e){logger.warn("BLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");

				// taxonDescription = TaxonDescription.NewInstance(taxon);

				// }

				// }

				// if (taxonDescription == null) {

				// taxonDescription = TaxonDescription.NewInstance(taxon);

				// config.getTaxonToDescriptionMap().put(taxon.getUuid(),taxonDescription.getUuid());

				//

				// // taxonDescriptionUUID = config.getTaxonToDescriptionMap()

				// .get(taxon.getUuid());

				// }

				/*

				 * Set<TaxonDescription> tds = taxon.getDescriptions();

				 * TaxonDescription td = null; if (tds.size() >0) { td=

				 * tds.iterator().next(); taxonDescription =

				 * CdmBase.deproxy(td,TaxonDescription.class); }

				 * 

				 * if (taxonDescription == null){ // taxonDescription =

				 * TaxonDescription.NewInstance(); //

				 * logger.info("taxondescr "+taxonDescription.getUuid()); //

				 * //taxonDescription.setTaxon(taxon);

				 * //taxon.addDescription(taxonDescription);

				 * //getTaxonService().merge(taxon);

				 * 

				 * /*}

				 */

				// taxonDescription.setTaxon(taxon);

				// }

			}

			makeIndividualsAssociation(taxon, determinationEvent);

		}

	}

	private void makeIndividualsAssociation(Taxon taxon, DeterminationEvent determinationEvent) {

		TaxonDescription taxonDescription = TaxonDescription.NewInstance();

		taxonDescription.setTitleCache(ref.getTitleCache(), true);

		getDescriptionService().saveOrUpdate(taxonDescription);

		refreshTransaction();

		try{taxon = (Taxon) getTaxonService().find(taxon.getUuid());

		}catch(Exception e){

			//logger.info("taxon uptodate");

			}

		taxonDescription = (TaxonDescription) getDescriptionService().find(taxonDescription.getUuid());

		taxon.addDescription(taxonDescription);

		IndividualsAssociation indAssociation = IndividualsAssociation.NewInstance();

		Feature feature = makeFeature(derivedUnitBase);

		indAssociation.setAssociatedSpecimenOrObservation(derivedUnitBase);

		indAssociation.setFeature(feature);

		for (Reference<?> citation : determinationEvent.getReferences()) {

			indAssociation.addSource(DescriptionElementSource.NewInstance(null,

					null, citation, null));

		}

		taxonDescription.addElement(indAssociation);

		getDescriptionService().saveOrUpdate(taxonDescription);

		getTaxonService().saveOrUpdate(taxon);

	}

	private Feature makeFeature(SpecimenOrObservationBase unit) {

		if (unit.isInstanceOf(DerivedUnit.class)) {

			return Feature.INDIVIDUALS_ASSOCIATION();

		} else if (unit.isInstanceOf(FieldObservation.class)

				|| unit.isInstanceOf(Observation.class)) {

			return Feature.OBSERVATION();

		} else if (unit.isInstanceOf(Fossil.class)

				|| unit.isInstanceOf(LivingBeing.class)

				|| unit.isInstanceOf(Specimen.class)) {

			return Feature.SPECIMEN();

		}

		logger.warn("No feature defined for derived unit class: "

				+ unit.getClass().getSimpleName());

		return null;

	}

	private void refreshTransaction(){

		commitTransaction(tx);

		tx = startTransaction();

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

		classification = getClassificationService().find(classification.getUuid());

		try{

			derivedUnitBase = (DerivedUnitBase) getOccurrenceService().find(derivedUnitBase.getUuid());

		}catch(Exception e){

			//logger.warn("derivedunit up to date or not created yet");

			}

	}

	/**

	 * getParentTaxon : get the taxonomic hierarchy for the current Taxon

	 * 

	 * @param taxon

	 * @param taxonName

	 * @param originalName

	 * @param config

	 * @return a map with the parenttaxon and the parenttaxonname

	 */

	private HashMap<Taxon, NonViralName<?>> getParentTaxon(Taxon taxon,

			NonViralName<?> taxonName, NonViralName<?> originalName,

			Abcd206ImportConfigurator config) {

		Taxon parenttaxon = null;

		NonViralName<?> parentName = null;

		List<TaxonBase> c = null;

		List<String> highername = new ArrayList<String>();

		Rank higherrank = null;

		Rank taxonrank = taxonName.getRank();

		// logger.info("getParentTaxon childname " + taxonName.getFullTitleCache()

		//		+ ", rank " + taxonrank + ", originalname "

		//		+ originalName.getFullTitleCache());

		HashMap<Taxon, NonViralName<?>> map = new HashMap<Taxon, NonViralName<?>>();

		refreshTransaction();

		taxon = (Taxon) getTaxonService().find(taxon.getUuid());

		if (taxonrank.isGenus()) {

			// to change and add test DoReusetaxa

			for (TaxonNode p : classification.getAllNodes()) {

				// logger.info("p UUID "+p.getUuid().toString());

				if (classification.getTopmostNode(p.getTaxon()) == null) {

					// logger.info("taxon1 "+p.getTaxon().getTitleCache());

					// logger.info("taxon2 "+taxon.getTitleCache());

					if (taxon.getTitleCache().contains(p.getTaxon().getTitleCache().split("sec. " + ref)[0])) {

						this.addParentChild(p.getTaxon(), taxon);

						refreshTransaction();

						taxon = (Taxon) getTaxonService().find(taxon.getUuid());

						break;

					}

				}// else

				// logger.info("getTopMostNode "+classification.getTopmostNode(p.getTaxon()));

			}

			// add the genus to the root of the classification

			TaxonNode p = this.addChildTaxon(taxon);

			this.addChildNode(p);

			refreshTransaction();

			taxon = (Taxon) getTaxonService().find(taxon.getUuid());

			return map;

		}

		if (taxonrank.isInfraGeneric()) {

			// logger.info("isInfrageneric");

			highername.add(originalName.getGenusOrUninomial());

			higherrank = Rank.GENUS();

		}

		if (taxonrank.isSpecies()) {

			// logger.info("isSpecies");

			if (originalName.getGenusOrUninomial() != null) {

				highername.add(originalName.getGenusOrUninomial());

				higherrank = Rank.GENUS();

			} else {

				highername.add(originalName.getFullTitleCache().trim()

						.split(" ")[0]);

				higherrank = Rank.GENUS();

			}

			if (originalName.getInfraGenericEpithet() != null) {

				highername.add(originalName.getInfraGenericEpithet());

				higherrank = Rank.INFRAGENUS();

			}

		}

		if (taxonrank.isInfraSpecific()) {

			// logger.info("isInfraSpecies");

			if (originalName.getGenusOrUninomial() != null)

				highername.add(originalName.getGenusOrUninomial());

			if (originalName.getInfraGenericEpithet() != null) {

				highername.add(originalName.getInfraGenericEpithet());

			}

			if (originalName.getSpecificEpithet() != null)

				highername.add(originalName.getSpecificEpithet());

			higherrank = Rank.SPECIES();

		}

		String highernamestr = StringUtils.join(highername.iterator(), " ")

				.split("sec. " + ref.getTitleCache())[0].trim();

		// logger.info("higherNamest :: " + highernamestr);

		if (config.isDoReUseTaxon() && highername != null

				&& highername.size() > 0 && highernamestr != "") {

			boolean parentFound = false;

			try {

				c = getTaxonService().searchTaxaByName(highernamestr, ref);

				for (TaxonBase b : c) {

					parenttaxon = (Taxon) b;

					Iterator it = parenttaxon.getTaxonNodes().iterator();

					// logger.warn("ICI2");

					while (it.hasNext()) {

						TaxonNode tmpNode = (TaxonNode) it.next();

						Taxon tmp = tmpNode.getTaxon();

						if (tmp.getTitleCache().split(

								"sec. " + ref.getTitleCache())[0].trim()

								.equalsIgnoreCase(highernamestr)) {

							parenttaxon = tmp;

							parentName = (NonViralName<?>) b.getName();

							parentFound = true;

						}

					}

//					if (!parentFound)

//						logger.info("parent pas trouvé");

//					else

//						logger.info("parent trouvé "

//								+ parenttaxon.getTitleCache());

				}

			} catch (Exception e) {

				logger.info("Problem while trying to reuse existing taxon" + e);

				parenttaxon = null;

			}

			if (!parentFound)

				parenttaxon = null;

		}

		if ((parenttaxon == null && highername != null && highername.size() > 0 && highernamestr != "")

				|| !config.isDoReUseTaxon()) {

			// logger.info("ICI BIS");

			parentName = NonViralName.NewInstance(null);

			parentName.setFullTitleCache(highernamestr);

			parentName.setNameCache(highernamestr);

			parentName.setRank(higherrank);

			if (higherrank == Rank.GENUS())

				parentName.setGenusOrUninomial(highernamestr.split(" ")[0]);

			getNameService().save(parentName);

			parenttaxon = Taxon.NewInstance(parentName, ref);

			getTaxonService().save(parenttaxon);

		}

		map.put(parenttaxon, parentName);

		return map;

		// return parenttaxon;

	}

	/**

	 * add the ParenTaxon to the current Classification, link it with the

	 * "child" taxon

	 * 

	 * @param child

	 * @param childName

	 * @param config

	 * @return the current child that was set as inputparameter (needed??)

	 */

	private Taxon addParentTaxon(Taxon child, NonViralName<?> childName,

			Abcd206ImportConfigurator config) {

		refreshTransaction();

		NonViralName<?> originalName = childName;

		HashMap<Taxon, Taxon> map = new HashMap<Taxon, Taxon>();

		HashMap<Taxon, NonViralName<?>> maptn = new HashMap<Taxon, NonViralName<?>>();

		HashMap<Taxon, NonViralName<?>> tmpmaptn = getParentTaxon(child,