EDIT

/**

 * Copyright (C) 2007 EDIT

 * 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.

 */

/**

 * This class is not used yet. It is meant for refactoring the SDD import.

 * @author a.mueller

 * @created 06.01.2011

 * @version 1.0

	private Map<String,NamedArea> namedAreas = new HashMap<String,NamedArea>();

	private Map<String,DerivedUnit> specimens = new HashMap<String,DerivedUnit>();

	private Map<String,DefinedTerm> modifiers = new HashMap<String,DefinedTerm>();

	private Set<MarkerType> markerTypes = new HashSet<MarkerType>();

	private Set<TermVocabulary> vocabularies = new HashSet<TermVocabulary>();

	private String generatorName = "";

	private String generatorVersion = "";

	private Set<StatisticalMeasure> statisticalMeasures = new HashSet<StatisticalMeasure>();

	private Set<VersionableEntity> featureData = new HashSet<VersionableEntity>();

	private int taxonNamesCount = 0;

	protected Class<ICdmIO>[] ioClassList;

	public SDDDataSetImport(){

		super();

	}

				SDDImport.class

		};

	};

	@Override

	public boolean doCheck(SDDImportState state){

		boolean result = true;

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

	@Override

	public void doInvoke(SDDImportState state){

		TransactionStatus ts = startTransaction();

		SDDImportConfigurator sddConfig = state.getConfig();

		IProgressMonitor progressMonitor = sddConfig.getProgressMonitor();

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

		// <Datasets xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://rs.tdwg.org/UBIF/2006/" xsi:schemaLocation="http://rs.tdwg.org/UBIF/2006/ ../SDD.xsd">

		Element root = sddConfig.getSourceRoot();

		Namespace sddNamespace = sddConfig.getSddNamespace();

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

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)

	 */

		return false;

	}

	       </Representation>

		 */

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

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

		String detail = (String)ImportHelper.getXmlInputValue(elRepresentation, "Detail",sddNamespace);

		//new

		Representation representation = Representation.NewInstance(detail, label, null, datasetLanguage);

		workingSet.addRepresentation(representation);

		//old

//		sec.setTitleCache(label, true);

//			annotation.setAnnotationType(AnnotationType.EDITORIAL());

//			sec.addAnnotation(annotation);

//		}

		List<Element> listMediaObjects = elRepresentation.getChildren("MediaObject",sddNamespace);

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

	protected void importRepresentation(Element parent, Namespace sddNamespace, VersionableEntity ve, String id, SDDImportState state){

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

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

		handleRepresentationLabels(sddNamespace, elRepresentation, langLabDet);

			langLabDet.put(language, labDet);

		}

	}

	/**

	 * @param media

	 * @param langLabDet

	 */

	/**

	 * Handles representations for terms. Adds one representation per language in langLabDet.

	 * @param ve

	 * @param langLabDet

	 */

					if (td.getSources().size() > 0) {

						this.associateImageWithCdmBase(ref, td.getSources().iterator().next().getCitation());

					} else {

						sources.add(descriptionSource);

						//TODO type

						td.addSource(OriginalSourceType.Unknown, null, null, descriptionSource, null);

	 * @param langLabDet

	 * @return

	 */

					Element elRepresentation, Map<Language, List<String>> langLabDet) {

		List<String> labDet = null;

		}

		return language;

	}

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

	protected void importTechnicalMetadata(Element root, Namespace sddNamespace, SDDImportConfigurator sddConfig){

		importDescriptiveConcepts(elDataset, sddNamespace, state);

		importCharacters(elDataset, sddNamespace, state);

		importCharacterTrees(elDataset, sddNamespace, state);

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

		MarkerType descriptiveConceptMarkerType = getMarkerType(state, SDDTransformer.uuidMarkerDescriptiveConcept, "DescriptiveConcept", "Descriptive Concept", "DC");

		markerTypes.add(editorMarkerType);

		markerTypes.add(geographicAreaMarkerType);

		markerTypes.add(descriptiveConceptMarkerType);

		//saving of all imported data into the CDM db

		saveVocabularies();

		saveFeatures();

		saveModifiers();

		saveStates();

		saveMarkerType();

		saveUnits();

		saveAnnotationType();

		importCodedDescriptions(elDataset, sddNamespace, state);

		importTaxonHierarchies(elDataset, sddNamespace, state);

		importGeographicAreas(elDataset, sddNamespace, state);

		importSpecimens(elDataset,sddNamespace, state);

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

			Team team = Team.NewInstance();

			if (authors != null) {

			sourceReference.addRights(copyright);

			sec.addRights(copyright);

		}

		// Returns a CdmApplicationController created by the values of this configuration.

		IDescriptionService descriptionService = getDescriptionService();

		for (TaxonDescription taxonDescription : taxonDescriptions.values()){

			// Persists a Description

			descriptionService.save(taxonDescription);

		}

		for (String ref : taxonDescriptions.keySet()){

			TaxonDescription td = taxonDescriptions.get(ref);

			if (citations.containsKey(ref)) {

				if (locations.containsKey(ref)) {

					Annotation location = Annotation.NewInstance(locations.get(ref), datasetLanguage);

					AnnotationType annotationType = AnnotationType.NewInstance("", "location", "");

			}

		}

		saveFeatures();

		for (Reference publication : publications.values()){

		}

		for (Reference source : sources){

		}

		for (FeatureTree featureTree : featureTrees) {

			getOccurrenceService().save(specimen);

		}

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

		return;

	}

	/**

	 */

	private void saveVocabularies() {

		for (TermVocabulary vocabulary : vocabularies ){

			getVocabularyService().save(vocabulary);

		}

	}

	private void saveAnnotationType() {

		for (AnnotationType annotationType: annotationTypes){

		}

	}

	private void saveStatisticalMeasure() {

		for (StatisticalMeasure sm : statisticalMeasures){

		}

	}

		if (units != null) {

			for (MeasurementUnit unit : units.values()){

				if (unit != null) {

				}

			}

		}

			datasetLanguage = Language.DEFAULT();

		}

	}

	// imports the specimens

	protected void importSpecimens(Element elDataset, Namespace sddNamespace, SDDImportState cdmState) {

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

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

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

		}*/

		return;

	}

				// <StateDefinition id="s1">

				List<Element> elStateDefinitions = elStates.getChildren("StateDefinition",sddNamespace);

				TermVocabulary<State> termVocabularyState = TermVocabulary.NewInstance(TermType.State, null, null, null, null);

				vocabularies.add(termVocabularyState);

				int k = 0;

				//for each StateDefinition

				for (Element elStateDefinition : elStateDefinitions){

	// imports the descriptions of taxa

	protected void importCodedDescriptions(Element elDataset, Namespace sddNamespace, SDDImportState cdmState){

		// <CodedDescriptions>

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

		Element elCodedDescriptions = elDataset.getChild("CodedDescriptions",sddNamespace);

		// <CodedDescription id="D101">

		if (elCodedDescriptions != null) {

			List<Element> listCodedDescriptions = elCodedDescriptions.getChildren("CodedDescription", sddNamespace);

			if (taxon != null) {

				taxon.addDescription(taxonDescription);

			}

			workingSet.addDescription(taxonDescription);

//OLD			taxonDescription.setDescriptiveSystem(featureSet);

			taxonDescriptions.put(idCD, taxonDescription);//FIXME

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

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

		importRepresentation(elCodedDescription, sddNamespace, nonViralName, id, cdmState);

		if(cdmState.getConfig().isReuseExistingTaxaWhenPossible()){

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

		}

		if(taxon != null){

			nonViralName = HibernateProxyHelper.deproxy(taxon.getName(), NonViralName.class);

//							taxonNameBases.put(id ,tnb);

		} else {

			nonViralName.addSource(source);

			taxonNameBases.put(id ,nonViralName);

			logger.info("creating new Taxon from TaxonName " + nonViralName.getTitleCache());

			taxon = Taxon.NewInstance(nonViralName, sec);

		}

	 * @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);

		if(cdmState.getConfig().isReuseExistingTaxaWhenPossible()){

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

		}

		if(taxon != null){

			logger.info("using existing Taxon" + taxon.getTitleCache());

			if(!nonViralName.getUuid().equals(taxon.getName().getUuid())){

				logger.warn("TaxonNameBase entity of existing taxon does not match Name in list -> replacing Name in list");

				nonViralName = HibernateProxyHelper.deproxy(taxon.getName(), NonViralName.class);

			logger.info("creating new Taxon from TaxonName '" + nonViralName.getTitleCache()+"'");

			taxon = Taxon.NewInstance(nonViralName, sec);

		}

		//citation

		Element elCitation = elScope.getChild("Citation",sddNamespace);

		if (elCitation != null) {

			// <Measure type="Min" value="2.3"/>

			List<Element> elMeasures = elQuantitative.getChildren("Measure", sddNamespace);

			int l = 0;

			//for each State

			for (Element elMeasure : elMeasures){

				if ((++l % modCount) == 0){ logger.info("States handled: " + (l-1));}

			// <State ref="s3"/>

			List<Element> elStates = elCategorical.getChildren("State", sddNamespace);

			int l = 0;

			//for each State

			for (Element elState : elStates){

				if ((++l % modCount) == 0){ logger.info("States handled: " + (l-1));}

							} catch (Exception e) {

								//FIXME

								logger.warn("Import of Link " + k + " failed.");

							}

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

						if (href.substring(0,7).equals("http://")) {

							try{

								URL url = new URL(href);

								imageMetaData = ImageInfo.NewInstance(url.toURI(), 0);

								image = ImageFile.NewInstance(url.toURI(), null, imageMetaData);

							} catch (MalformedURLException e) {

					}

					featureTrees.add(featureTree);

					if (workingSet.getDescriptiveSystem() != null){

						logger.warn("Multiple feature trees not yet supported");

					}else{

						workingSet.setDescriptiveSystem(featureTree);

				Element elCharacter = elCharNode.getChild("Character", sddNamespace);

				Element elDependencyRules = elCharNode.getChild("DependencyRules", sddNamespace);

				FeatureNode fn = FeatureNode.NewInstance();

				if (elDependencyRules!=null){

					Element elInapplicableIf = elCharNode.getChild("InapplicableIf", sddNamespace);

					if (elInapplicableIf!=null){

						}

					}

				}

				if (elParent!=null){

					String refP = elParent.getAttributeValue("ref");

					if ((refP!=null)&&(!refP.equals(""))) {

					fn.setFeature(character);

					featureNodes.put(refC, fn);

				}

		}

	}

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

						Classification classification =  Classification.NewInstance(label);

						importRepresentation(elTaxonHierarchy, sddNamespace, classification, "", cdmState);

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

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

						List<Element> listNodes = elNodes.getChildren("Node", sddNamespace);

						for (Element elNode : listNodes){

							String idN = elNode.getAttributeValue("id");

							TaxonNameBase tnb = null;

		}

	}

	protected void importGeographicAreas(Element elDataset, Namespace sddNamespace, SDDImportState cdmState) {

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

		if (elGeographicAreas != null) {

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

			int j = 0;

			for (Element elGeographicArea : listGeographicAreas){

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