EDIT

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

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

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

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

import eu.etaxonomy.cdm.io.sdd.SDDTransformer;

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

	//	@Override

	//	public boolean doInvoke(IImportConfigurator config, Map<String, MapWrapper<? extends CdmBase>> stores){

	@Override

		TransactionStatus ts = startTransaction();

		SDDImportConfigurator sddConfig = state.getConfig();

		logger.info("start Dataset ...");

		progressMonitor.beginTask("Importing SDD data", elDatasets.size());

		for (Element elDataset : elDatasets){

//			if ((++i % modCount) == 0){ logger.info("dataset(s) handled: " + i);}

//			logger.info(i + " dataset(s) handled");

			progressMonitor.worked(1);

		commitTransaction(ts);

		progressMonitor.done();

		logger.info("End of transaction");

	}

	/* (non-Javadoc)

	}

	// imports the representation (label, detail, lang) of a particular SDD element

		Element elRepresentation = parent.getChild("Representation",sddNamespace);

		Map<Language,List<String>> langLabDet = new HashMap<Language,List<String>>();

	}

	// imports the complete dataset information

		workingSet = WorkingSet.NewInstance();

		importDatasetRepresentation(elDataset, sddNamespace);

		importRevisionData(elDataset, sddNamespace);

		MarkerType editorMarkerType = getMarkerType(state, SDDTransformer.uuidMarkerEditor, "editor", "Editor", "edt");

		MarkerType geographicAreaMarkerType = getMarkerType(state, SDDTransformer.uuidMarkerSDDGeographicArea, "SDDGeographicArea", "SDDGeographicArea", "ga"); 

		saveStatisticalMeasure();		

		saveAnnotationType();

		if ((authors != null)||(editors != null)) {

		}

		logger.info("end of persistence ...");

	}

	/**

	}

	// imports the default language of the dataset

		String nameLang = elDataset.getAttributeValue("lang",xmlNamespace);

		if (StringUtils.isNotBlank(nameLang)) {

	}

	// imports the specimens

		logger.info("start Specimens ...");

		/*	<Specimens>

        		<Specimen id="sp1">

				if (!id.equals("")) {

					specimen = Specimen.NewInstance();

					specimens.put(id,specimen);

				}

			}

	}

	// imports ipr statements associated with a dataset

		// <IPRStatements>

		logger.info("start IPRStatements ...");

		Element elIPRStatements = elDataset.getChild("IPRStatements",sddNamespace);

	}

	// imports the taxon names

		// <TaxonNames>

		logger.info("start TaxonNames ...");

		Element elTaxonNames = elDataset.getChild("TaxonNames",sddNamespace);

				// <Representation>

				// <Label xml:lang="la">Viola hederacea Labill.</Label>

				if ((++j % modCount) == 0){ logger.info("TaxonNames handled: " + j);}

	}

	// imports the characters (categorical, quantitative and text ; sequence characters not supported) which correspond to CDM Features

		// <Characters>

		logger.info("start Characters ...");

		Element elCharacters = elDataset.getChild("Characters", sddNamespace);

		// <CategoricalCharacter id="c1">

		if (elCharacters != null) {

		}

		/*for (Iterator<Feature> f = features.values().iterator() ; f.hasNext() ;){

			featureSet.add(f.next()); //XIM Why this line ?

		}*/

	}

	/**

	 * @param sddNamespace

	 * @param elCharacters

	 * @return

	 */

		List<Element> elCategoricalCharacters = elCharacters.getChildren("CategoricalCharacter", sddNamespace);

		int j = 0;

		for (Element elCategoricalCharacter : elCategoricalCharacters){

				String idCC = elCategoricalCharacter.getAttributeValue("id");

				Feature categoricalCharacter = Feature.NewInstance();

				categoricalCharacter.setKindOf(Feature.DESCRIPTION());

				categoricalCharacter.setSupportsCategoricalData(true);

				// <States>

					}else{

						logger.debug("State duplicate found");

					}

					termVocabularyState.addTerm(state);

					states.put(idS,state);

			} catch (Exception e) {

				logger.warn("Import of CategoricalCharacter " + j + " failed.");

			}

			if ((++j % modCount) == 0){ logger.info("CategoricalCharacters handled: " + j);}

		}

	}

	/**

	 * @param sddConfig

	 * @param elCharacters

	 */

		int j;

		// <QuantitativeCharacter id="c2">

		List<Element> elQuantitativeCharacters = elCharacters.getChildren("QuantitativeCharacter", sddNamespace);

				// </Representation>

				Feature quantitativeCharacter = Feature.NewInstance();

				quantitativeCharacter.setKindOf(Feature.DESCRIPTION());

				quantitativeCharacter.setSupportsQuantitativeData(true);

			} catch (Exception e) {

				//FIXME

				logger.warn("Import of QuantitativeCharacter " + j + " failed.");

			}

			if ((++j % modCount) == 0){ logger.info("QuantitativeCharacters handled: " + j);}

		}

	}

		int j;

		// <TextCharacter id="c3">

		List<Element> elTextCharacters = elCharacters.getChildren("TextCharacter", sddNamespace);

				// </Representation>

				Feature textCharacter = Feature.NewInstance();

				textCharacter.setKindOf(Feature.DESCRIPTION());

				textCharacter.setSupportsTextData(true);

			} catch (Exception e) {

				//FIXME

				logger.warn("Import of TextCharacter " + j + " failed.");

			}

			if ((++j % modCount) == 0){ logger.info("TextCharacters handled: " + j);}

		}

	}

	// imports the descriptions of taxa

		// <CodedDescriptions>

		logger.info("start CodedDescriptions ...");

			int j = 0;

			//for each CodedDescription

			for (Element elCodedDescription : listCodedDescriptions){

				if ((++j % modCount) == 0){ logger.info("CodedDescriptions handled: " + j);}

			}

		}

	}

	/**

	 * @param elCodedDescription

	 * @return

	 */

		try {

			String idCD = elCodedDescription.getAttributeValue("id");

				Annotation annotation = Annotation.NewInstance(generatorName, AnnotationType.TECHNICAL(),Language.DEFAULT());

				taxonDescription.addAnnotation(annotation);

			}

			// <Scope>

			//  <TaxonName ref="t1"/>

			Element elScope = elCodedDescription.getChild("Scope", sddNamespace);

			Taxon taxon;

			if (elScope != null) {

			} else {//in case no taxon is linked to the description, a new one is created

			}

			// <SummaryData>

		} catch (Exception e) {

			//FIXME

			logger.warn("Import of CodedDescription " + j + " failed.", e);

		}

	}

	/**

	 * @return

	 */

	private Taxon handleCDNoScope(Namespace sddNamespace,

		Taxon taxon = null;

		NonViralName nonViralName = NonViralName.NewInstance(null);

		String id = new String("" + taxonNamesCount);

		IdentifiableSource source = IdentifiableSource.NewInstance(id, "TaxonName");

			taxon = getTaxonService().findBestMatchingTaxon(nonViralName.getTitleCache());

		}

	 * @param taxon

	 * @return

	 */

			String idCD, Element elScope) {

		Taxon taxon = null;

		Element elTaxonName = elScope.getChild("TaxonName", sddNamespace);

		String ref = elTaxonName.getAttributeValue("ref");

		NonViralName nonViralName = taxonNameBases.get(ref);

			taxon = getTaxonService().findBestMatchingTaxon(nonViralName.getTitleCache());

		}

	}

	// imports the persons associated with the dataset creation, modification, related publications

		// <Agents>

		logger.info("start Agents ...");

		Element elAgents = elDataset.getChild("Agents",sddNamespace);

					//   <Detail role="Description">Ali Baba is also known as r.a.m.</Detail>

					//  </Representation>

					Person person = Person.NewInstance();

					person.addSource(IdentifiableSource.NewInstance(idA, "Agent"));

					/*XIM <Links>

				} catch (Exception e) {

					//FIXME

					logger.warn("Import of Agent " + j + " failed.");

				}

				if ((++j % modCount) == 0){ logger.info("Agents handled: " + j);}

	}

	// imports publications related with the data set

		/* <Publications>

			  <Publication id="p112">

			    <Representation>

					String idP = elPublication.getAttributeValue("id");

					Reference publication = ReferenceFactory.newArticle();

					publications.put(idP,publication);

				} catch (Exception e) {

					logger.warn("Import of Publication " + j + " failed.");

				}

				if ((++j % modCount) == 0){ logger.info("Publications handled: " + j);}

	}

	// imports media objects such as images //FIXME check mediaobj

		// <MediaObjects>

		logger.info("start MediaObjects ...");

		Element elMediaObjects = elDataset.getChild("MediaObjects",sddNamespace);

					//   <Label>Image description, e.g. to be used for alt-attribute in html.</Label>

					//  </Representation>

					Media media = Media.NewInstance();

					// <Type>Image</Type>

					// <Source href="http://test.edu/test.jpg"/>

								logger.error("Malformed URL", e);

							}

						} else {

							File f = new File(sns);

							File parent = f.getParentFile();

							String fi = parent.toString() + File.separator + href;

				} catch (Exception e) {

					//FIXME

					logger.warn("Could not attach MediaObject " + j + "(SDD: " + id + ") to several objects.");

				}

				if ((++j % modCount) == 0){ logger.info("MediaObjects handled: " + j);

	// imports the <DescriptiveConcepts> block ; DescriptiveConcepts are used as nodes in CharacterTrees and Characters as leaves

	// but since Modifiers can be linked to DescriptiveConcepts they are stored as features with a particular Marker

		/* <DescriptiveConcepts>

		      <DescriptiveConcept id="dc0">

			        <Representation>

					if (!id.equals("")) {

					//	 <Representation>

					//       <Label>Body</Label>

						features.put(id, feature);

						getTermService().save(feature);//XIM

						descriptiveConcepts.add(feature);

						for (Element elModifier : listModifiers) {

								Modifier modif = Modifier.NewInstance();

								String idmod = elModifier.getAttributeValue("id");

								termVocabularyState.addTerm(modif);

								//termVocabularyStates.add(termVocabularyState);

								getVocabularyService().save(termVocabularyState);//XIM

	}

	// imports the <CharacterTrees> block

		// <CharacterTrees>

		logger.info("start CharacterTrees ...");

		Element elCharacterTrees = elDataset.getChild("CharacterTrees",sddNamespace);

					//Element elDesignedFor = elCharacterTree.getChild("DesignedFor",sddNamespace);//TODO ?

					FeatureTree featureTree =  FeatureTree.NewInstance();

					FeatureNode root = featureTree.getRoot();

					List<Element> listeOfNodes = elCharacterTree.getChildren("Nodes", sddNamespace);

				catch (Exception e) {

					logger.warn("Import of Character tree " + j + " failed.");

				}

				if ((++j % modCount) == 0){ logger.info("CharacterTrees handled: " + j);}

	}

	// imports the <TaxonHierarchies> block

		logger.info("start TaxonHierarchies ...");

		Element elTaxonHierarchies = elDataset.getChild("TaxonHierarchies",sddNamespace);

					Element elRepresentation = elTaxonHierarchy.getChild("Representation",sddNamespace);

					String label = (String)ImportHelper.getXmlInputValue(elRepresentation,"Label",sddNamespace);

						Classification classification =  Classification.NewInstance(label);

						Set<TaxonNode> root = classification.getChildNodes();

						Element elNodes = elTaxonHierarchy.getChild("Nodes", sddNamespace); // There can be only one <Nodes> block for TaxonHierarchies

				catch (Exception e) {

					//FIXME

					logger.warn("Import of Taxon Hierarchy " + j + " failed.");

				}

				if ((++j % modCount) == 0){ logger.info("TaxonHierarchies handled: " + j);}

	// imports the <GeographicAreas> block 

		Element elGeographicAreas = elDataset.getChild("GeographicAreas",sddNamespace);

		if (elGeographicAreas != null) {

			List<Element> listGeographicAreas = elGeographicAreas.getChildren("GeographicArea", sddNamespace);

				String id = elGeographicArea.getAttributeValue("id");

				NamedArea na = new NamedArea();

				namedAreas.put(id,na);

								}

			if ((++j % modCount) == 0){ logger.info("GeographicAreas handled: " + j);}