EDIT

/**

 * Copyright (C) 2009 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.markup;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Queue;

import java.util.Set;

import java.util.UUID;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.xml.stream.FactoryConfigurationError;

import javax.xml.stream.Location;

import javax.xml.stream.XMLEventReader;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.events.Attribute;

import javax.xml.stream.events.StartElement;

import javax.xml.stream.events.XMLEvent;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.access.PermissionEvaluator;

import org.springframework.security.authentication.AuthenticationManager;

import org.springframework.security.core.Authentication;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

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

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

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

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.ext.geo.GeoServiceArea;

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

import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;

import eu.etaxonomy.cdm.io.markup.UnmatchedLeads.UnmatchedLeadsKey;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.reference.IArticle;

import eu.etaxonomy.cdm.model.reference.IJournal;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.model.reference.ReferenceType;

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

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

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

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

import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;

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

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

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

import eu.etaxonomy.cdm.strategy.parser.SpecimenTypeParser.TypeInfo;

/**

 * @author a.mueller

 * 

 */

@Component

public class MarkupDocumentImport extends MarkupImportBase implements ICdmIO<MarkupImportState> {

	private static final String FREQUENCY = "frequency";

	private static final String TAXONTYPE = "taxontype";

	private static final String DEDICATION = "dedication";

	private static final String QUOTE = "quote";

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

	private static final boolean CREATE_NEW = true;

	private static final boolean IS_IMAGE_GALLERY = true;

	private static final boolean NO_IMAGE_GALLERY = false;

	private static final String ACCEPTED = "accepted";

	private static final String ACCEPTED_NAME = "acceptedName";

	private static final String ADDENDA = "addenda";

	private static final String ALTERNATEPUBTITLE = "alternatepubtitle";

	private static final String ALTERNATIVE_COLLECTION_TYPE_STATUS = "alternativeCollectionTypeStatus";

	private static final String ALTERNATIVE_COLLECTOR = "alternativeCollector";

	private static final String ALTERNATIVE_FIELD_NUM = "alternativeFieldNum";

	private static final String ALTITUDE = "altitude";

	private static final String ANNOTATION = "annotation";

	private static final String AUTHOR = "author";

	private static final String BIBLIOGRAPHY = "bibliography";

	private static final String BIOGRAPHIES = "biographies";

	private static final String BOLD = "bold";

	private static final String BR = "br";

	private static final String CHAR = "char";

	private static final String CITATION = "citation";

	private static final String COLLECTION_TYPE_STATUS = "collectionTypeStatus";

	private static final String COLLECTOR = "collector";

	private static final String COORDINATES = "coordinates";

	private static final String COUPLET = "couplet";

	private static final String DATES = "dates";

	private static final String DEFAULT_MEDIA_URL = "defaultMediaUrl";

	private static final String DESTROYED = "destroyed";

	private static final String DETAILS = "details";

	private static final String DISTRIBUTION_LIST = "distributionList";

	private static final String DISTRIBUTION_LOCALITY = "distributionLocality";

	private static final String EDITION = "edition";

	private static final String EDITORS = "editors";

	private static final String FEATURE = "feature";

	private static final String FIGURE = "figure";

	private static final String FIGURE_LEGEND = "figureLegend";

	private static final String FIGURE_PART = "figurePart";

	private static final String FIGURE_REF = "figureRef";

	private static final String FIGURE_TITLE = "figureTitle";

	private static final String FOOTNOTE = "footnote";

	private static final String FOOTNOTE_REF = "footnoteRef";

	private static final String FOOTNOTE_STRING = "footnoteString";

	private static final String FIELD_NUM = "fieldNum";

	private static final String FULL_NAME = "fullName";

	private static final String FULL_TYPE = "fullType";

	private static final String GATHERING = "gathering";

	private static final String HEADING = "heading";

	private static final String HABITAT = "habitat";

	private static final String HABITAT_LIST = "habitatList";

	private static final String HOMONYM = "homonym";

	private static final String HOMOTYPES = "homotypes";

	private static final String ID = "id";

	private static final String INFRANK = "infrank";

	private static final String INFRAUT = "infraut";

	private static final String INFRPARAUT = "infrparaut";

	private static final String IS_SPOTCHARACTERS = "isSpotcharacters";

	private static final String ISSUE = "issue";

	private static final String ITALICS = "italics";

	private static final String KEY = "key";

	private static final String KEY_TITLE = "keyTitle";

	private static final String KEYNOTES = "keynotes";

	private static final String LIFE_CYCLE_PERIODS = "lifeCyclePeriods";

	private static final String LOCALITY = "locality";

	private static final String LOST = "lost";

	private static final String META_DATA = "metaData";

	private static final String NAME = "name";

	private static final String NAME_TYPE = "nameType";

	private static final String NOM = "nom";

	private static final String NOMENCLATURE = "nomenclature";

	private static final String NOT_FOUND = "notFound";

	private static final String NOT_SEEN = "notSeen";

	private static final String NOTES = "notes";

	private static final String NUM = "num";

	private static final String ORIGINAL_DETERMINATION = "originalDetermination";

	private static final String PARAUT = "paraut";

	private static final String PUBFULLNAME = "pubfullname";

	private static final String PUBLICATION = "publication";

	private static final String PUBNAME = "pubname";

	private static final String PUBTITLE = "pubtitle";

	private static final String PUBTYPE = "pubtype";

	private static final String QUESTION = "question";

	private static final String RANK = "rank";

	private static final String REF = "ref";

	private static final String REF_NUM = "refNum";

	private static final String REF_PART = "refPart";

	private static final String REFERENCE = "reference";

	private static final String REFERENCES = "references";

	private static final String TAXON = "taxon";

	private static final String TAXONTITLE = "taxontitle";

	private static final String TEXT = "text";

	private static final String TEXT_SECTION = "textSection";

	private static final String TO_COUPLET = "toCouplet";

	private static final String TO_KEY = "toKey";

	private static final String TO_TAXON = "toTaxon";

	private static final String TYPE = "type";

	private static final String TYPE_STATUS = "typeStatus";

	private static final String TREATMENT = "treatment";

	private static final String SERIALS_ABBREVIATIONS = "serialsAbbreviations";

	private static final String SPECIMEN_TYPE = "specimenType";

	private static final String STATUS = "status";

	private static final String STRING = "string";

	private static final String SUB_HEADING = "subHeading";

	private static final String SUB_COLLECTION = "subCollection";

	private static final String SYNONYM = "synonym";

	private static final String UNKNOWN = "unknown";

	private static final String URL = "url";

	private static final String USAGE = "usage";

	private static final String VOLUME = "volume";

	private static final String WRITER = "writer";

	private static final String YEAR = "year";

	private NonViralNameParserImpl parser = new NonViralNameParserImpl();

	// TODO make part of state, but state is renewed when invoking the import a

	// second time

	private UnmatchedLeads unmatchedLeads;

	// TODO remove preliminary

	@Autowired

	private AuthenticationManager authenticationManager;

	private Authentication authentication;

	private PermissionEvaluator permissionEvaluator;

	public MarkupDocumentImport() {

		super();

		System.out.println("TODO remove preliminary authentication");

		// UsernamePasswordAuthenticationToken token = new

		// UsernamePasswordAuthenticationToken("admin", "0000");

		// authentication = authenticationManager.authenticate(token);

		// SecurityContext context = SecurityContextHolder.getContext();

		// context.setAuthentication(authentication);

		// permissionEvaluator = new CdmPermissionEvaluator();

	}

	@Override

	public boolean doCheck(MarkupImportState state) {

		state.setCheck(true);

		doInvoke(state);

		state.setCheck(false);

		return state.isSuccess();

	}

	@Override

	public void doInvoke(MarkupImportState state) { 

		fireProgressEvent("Start import markup document", "Before start of document");

		Queue<CdmBase> outputStream = new LinkedList<CdmBase>();

		TransactionStatus tx = startTransaction();

		// FIXME reset state

		doAllTheOldOtherStuff(state);

		// START

		try {

			// StAX

			XMLEventReader reader = getStaxReader(state);

			state.setReader(reader);

			// start document

			if (!validateStartOfDocument(reader)) {

				state.setUnsuccessfull();

				return;

			}

			// publication

			String elName = PUBLICATION;

			boolean hasPublication = false;

			while (reader.hasNext()) {

				XMLEvent nextEvent = reader.nextEvent();

				if (isStartingElement(nextEvent, elName)) {

					handlePublication(state, reader, nextEvent, elName);

					hasPublication = true;

				} else if (nextEvent.isEndDocument()) {

					if (!hasPublication) {

						String message = "No publication root element found";

						fireWarningEvent(message, nextEvent, 8);

					}

					// done

				} else {

					fireSchemaConflictEventExpectedStartTag(elName, reader);

				}

			}

			commitTransaction(tx);

			// //SAX

			// ImportHandlerBase handler= new PublicationHandler(this);

			// parseSAX(state, handler);

		} catch (FactoryConfigurationError e1) {

			fireWarningEvent("Some error occurred while setting up xml factory. Data can't be imported", "Start", 16);

			state.setUnsuccessfull();

		} catch (XMLStreamException e1) {

			fireWarningEvent("An XMLStreamException occurred while parsing. Data can't be imported", "Start", 16);

			state.setUnsuccessfull();

			// } catch (ParserConfigurationException e) {

			// fireWarningEvent("A ParserConfigurationException occurred while parsing. Data can't be imported",

			// "Start", 16);

			// } catch (SAXException e) {

			// fireWarningEvent("A SAXException occurred while parsing. Data can't be imported",

			// "Start", 16);

			// } catch (IOException e) {

			// fireWarningEvent("An IO exception occurred while parsing. Data can't be imported",

			// "Start", 16);

		}

		return;

	}

	private void handlePublication(MarkupImportState state,

			XMLEventReader reader, XMLEvent currentEvent, String elName)

			throws XMLStreamException {

		// attributes

		StartElement element = currentEvent.asStartElement();

		Map<String, Attribute> attributes = getAttributes(element);

		handleUnexpectedAttributes(element.getLocation(), attributes,

				"noNamespaceSchemaLocation");

		while (reader.hasNext()) {

			XMLEvent event = readNoWhitespace(reader);

			// TODO cardinality of alternative

			if (event.isEndElement()) {

				if (isEndingElement(event, elName)) {

					return;

				} else {

					if (isEndingElement(event, BIOGRAPHIES)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(event.asEndElement());

					} else if (isEndingElement(event, REFERENCES)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(event.asEndElement());

					} else if (isEndingElement(event, TEXT_SECTION)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(event.asEndElement());

					} else if (isEndingElement(event, ADDENDA)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(event.asEndElement());

					} else {

						handleUnexpectedElement(event);

					}

				}

			} else if (event.isStartElement()) {

				if (isStartingElement(event, META_DATA)) {

					handleMetaData(state, reader, event);

				} else if (isStartingElement(event, TREATMENT)) {

					handleTreatment(state, reader, event);

				} else if (isStartingElement(event, BIOGRAPHIES)) {

					handleNotYetImplementedElement(event);

				} else if (isStartingElement(event, REFERENCES)) {

					handleNotYetImplementedElement(event);

				} else if (isStartingElement(event, TEXT_SECTION)) {

					handleNotYetImplementedElement(event);

				} else if (isStartingElement(event, ADDENDA)) {

					handleNotYetImplementedElement(event);

				} else {

					handleUnexpectedStartElement(event);

				}

			} else {

				handleUnexpectedElement(event);

			}

		}

		throw new IllegalStateException("Publication has no ending element");

	}

	private void handleMetaData(MarkupImportState state, XMLEventReader reader,

			XMLEvent parentEvent) throws XMLStreamException {

		checkNoAttributes(parentEvent);

		while (reader.hasNext()) {

			XMLEvent next = readNoWhitespace(reader);

			if (isMyEndingElement(next, parentEvent)) {

				return;

			} else if (isStartingElement(next, DEFAULT_MEDIA_URL)) {

				String baseUrl = getCData(state, reader, next);

				try {

					new URL(baseUrl);

					state.setBaseMediaUrl(baseUrl);

				} catch (MalformedURLException e) {

					String message = "defaultMediaUrl '%s' is not a valid URL";

					message = String.format(message, baseUrl);

					fireWarningEvent(message, next, 8);

				}

			} else {

				handleUnexpectedElement(next);

			}

		}

		throw new IllegalStateException("MetaData has no ending element");

	}

	private void handleTreatment(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {

		checkNoAttributes(parentEvent);

		Taxon lastTaxon = null;

		while (reader.hasNext()) {

			XMLEvent next = readNoWhitespace(reader);

			if (isStartingElement(next, TAXON)) {

				Taxon thisTaxon = handleTaxon(state, reader, next.asStartElement());

				doTaxonRelation(state, thisTaxon, lastTaxon, parentEvent.getLocation());

				lastTaxon = thisTaxon;

				// TODO for imports spanning multiple documents ?? Still needed?

				state.getConfig().setLastTaxonUuid(lastTaxon.getUuid());

			} else if (isMyEndingElement(next, parentEvent)) {

				Set<PolytomousKeyNode> keyNodesToSave = state.getPolytomousKeyNodesToSave();

				//better save the key then the nodes

				Set<PolytomousKey> keySet = new HashSet<PolytomousKey>();

				for (PolytomousKeyNode node : keyNodesToSave){

					PolytomousKey key = node.getKey();

					keySet.add(key);

				}

				save(keySet, state);

				//unmatched key leads

				UnmatchedLeads unmatched = state.getUnmatchedLeads();

				if (unmatched.size() > 0){

					String message = "The following key leads are unmatched: %s";

					message = String.format(message, state.getUnmatchedLeads().toString());

					fireWarningEvent(message, next, 6);

				}

//				save(keyNodesToSave, state);

				return;

			} else {

				handleUnexpectedElement(next);

			}

		}

		return;

	}

	/**

	 * @param taxon

	 * @param lastTaxon

	 */

	private void doTaxonRelation(MarkupImportState state, Taxon taxon,

			Taxon lastTaxon, Location dataLocation) {

		Classification tree = makeTree(state, dataLocation);

		if (lastTaxon == null) {

			tree.addChildTaxon(taxon, null, null, null);

			return;

		}

		Rank thisRank = taxon.getName().getRank();

		Rank lastRank = lastTaxon.getName().getRank();

		if (lastTaxon.getTaxonNodes().size() > 0) {

			TaxonNode lastNode = lastTaxon.getTaxonNodes().iterator().next();

			if (thisRank.isLower(lastRank)) {

				lastNode.addChildTaxon(taxon, null, null, null);

				fillMissingEpithetsForTaxa(lastTaxon, taxon);

			} else if (thisRank.equals(lastRank)) {

				TaxonNode parent = lastNode.getParent();

				if (parent != null) {

					parent.addChildTaxon(taxon, null, null, null);

					fillMissingEpithetsForTaxa(parent.getTaxon(), taxon);

				} else {

					tree.addChildTaxon(taxon, null, null, null);

				}

			} else if (thisRank.isHigher(lastRank)) {

				doTaxonRelation(state, taxon, lastNode.getParent().getTaxon(),

						dataLocation);

				// TaxonNode parentNode = handleTaxonRelation(state, taxon,

				// lastNode.getParent().getTaxon());

				// parentNode.addChildTaxon(taxon, null, null, null);

			}

		} else {

			String message = "Last taxon has no node";

			fireWarningEvent(message, makeLocationStr(dataLocation), 6);

		}

	}

	/**

	 * @param state

	 * @param dataLocation 

	 * @return

	 */

	private Classification makeTree(MarkupImportState state, Location dataLocation) {

		Classification result = state.getTree(null);

		if (result == null) {

			UUID uuid = state.getConfig().getClassificationUuid();

			if (uuid == null) {

				String message = "No classification uuid is defined";

				fireWarningEvent(message, makeLocationStr(dataLocation), 6);

				result = createNewClassification(state);

			} else {

				result = getClassificationService().find(uuid);

				if (result == null) {

					result = createNewClassification(state);

					result.setUuid(uuid);

				}

			}

			state.putTree(null, result);

		}

		save(result, state);

		return result;

	}

	private Classification createNewClassification(MarkupImportState state) {

		Classification result;

		result = Classification.NewInstance(state.getConfig().getClassificationTitle());

		state.putTree(null, result);

		return result;

	}

	private Taxon handleTaxon(MarkupImportState state, XMLEventReader reader, StartElement parentEvent) throws XMLStreamException {

		// TODO progress monitoring

		Map<String, Attribute> attributes = getAttributes(parentEvent);

		Taxon taxon = createTaxonAndName(state, attributes);

		state.setCurrentTaxon(taxon);

		boolean hasTitle = false;

		boolean hasNomenclature = false;

		String taxonTitle = null;

		while (reader.hasNext()) {

			XMLEvent next = readNoWhitespace(reader);

			if (next.isEndElement()) {

				if (isMyEndingElement(next, parentEvent)) {

					checkMandatoryElement(hasTitle, parentEvent, TAXONTITLE);

					checkMandatoryElement(hasNomenclature, parentEvent,	NOMENCLATURE);

					handleUnexpectedAttributes(parentEvent.getLocation(),attributes);

					makeKeyNodes(state, parentEvent, taxonTitle);

					state.setCurrentTaxon(null);

					state.setCurrentTaxonNum(null);

					save(taxon, state);

					return taxon;

				} else {

					if (isEndingElement(next, HEADING)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(next.asEndElement());

					} else if (isEndingElement(next, TEXT_SECTION)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(next.asEndElement());

					} else if (isEndingElement(next, REFERENCES)) {

						// NOT YET IMPLEMENTED

						popUnimplemented(next.asEndElement());

					} else {

						handleUnexpectedEndElement(next.asEndElement());

					}

				}

			} else if (next.isStartElement()) {

				if (isStartingElement(next, HEADING)) {

					handleNotYetImplementedElement(next);

				} else if (isStartingElement(next, TAXONTITLE)) {

					taxonTitle = handleTaxonTitle(state, reader, next);

					hasTitle = true;

				} else if (isStartingElement(next, WRITER)) {

					makeKeyWriter(state, reader, taxon, taxonTitle, next);

				} else if (isStartingElement(next, TEXT_SECTION)) {

					handleNotYetImplementedElement(next);

				} else if (isStartingElement(next, KEY)) {

					handleKey(state, reader, next);

				} else if (isStartingElement(next, NOMENCLATURE)) {

					handleNomenclature(state, reader, next);

					hasNomenclature = true;

				} else if (isStartingElement(next, FEATURE)) {

					handleFeature(state, reader, next);

				} else if (isStartingElement(next, NOTES)) {

					// TODO is this the correct way to handle notes?

					String note = handleNotes(state, reader, next);

					UUID notesUuid;

					try {

						notesUuid = state.getTransformer().getFeatureUuid(

								"notes");

						Feature feature = getFeature(state, notesUuid, "Notes",

								"Notes", "note", null);

						TextData textData = TextData.NewInstance(feature);

						textData.putText(Language.DEFAULT(), note);

						TaxonDescription description = getTaxonDescription(

								taxon, false, true);

						description.addElement(textData);

					} catch (UndefinedTransformerMethodException e) {

						String message = "getFeatureUuid method not yet implemented";

						fireWarningEvent(message, next, 8);

					}

				} else if (isStartingElement(next, REFERENCES)) {

					handleNotYetImplementedElement(next);

				} else if (isStartingElement(next, FIGURE)) {

					handleFigure(state, reader, next);

				} else if (isStartingElement(next, FOOTNOTE)) {

					FootnoteDataHolder footnote = handleFootnote(state, reader,

							next);

					if (footnote.isRef()) {

						String message = "Ref footnote not implemented here";

						fireWarningEvent(message, next, 4);

					} else {

						registerGivenFootnote(state, footnote);

					}

				} else {

					handleUnexpectedStartElement(next);

				}

			} else {

				handleUnexpectedElement(next);

			}

		}

		throw new IllegalStateException("<Taxon> has no closing tag");

	}

	private void makeKeyNodes(MarkupImportState state, XMLEvent event, String taxonTitle) {

		Taxon taxon = state.getCurrentTaxon();

		String num = state.getCurrentTaxonNum();

		String nameString = CdmBase.deproxy(taxon.getName(), NonViralName.class).getNameCache();

//		String nameString = taxonTitle;

		//try to find matching lead nodes 

		UnmatchedLeadsKey leadsKey = UnmatchedLeadsKey.NewInstance(num, nameString);

		Set<PolytomousKeyNode> matchingNodes = handleMatchingNodes(state, taxon, leadsKey);

		if (num != null){//same without using the num

			UnmatchedLeadsKey noNumLeadsKey = UnmatchedLeadsKey.NewInstance("", nameString);

			Set<PolytomousKeyNode> noNumMatchingNodes = handleMatchingNodes(state, taxon, noNumLeadsKey);

			if(noNumMatchingNodes.size() > 0){

				String message ="Taxon matches additional key node when not considering <num> attribute in taxontitle. This may be correct but may also indicate an error.";

				fireWarningEvent(message, event, 1);

			}

		}

		//report missing match, if num exists

		if (matchingNodes.isEmpty() && num != null){

			String message = "Taxon has <num> attribute in taxontitle but no matching key nodes exist: %s, Key: %s";

			message = String.format(message, num, leadsKey.toString());

			fireWarningEvent(message, event, 1);

		}

	}

	private Set<PolytomousKeyNode> handleMatchingNodes(MarkupImportState state, Taxon taxon, UnmatchedLeadsKey leadsKey) {

		Set<PolytomousKeyNode> matchingNodes = state.getUnmatchedLeads().getNodes(leadsKey);

		for (PolytomousKeyNode matchingNode : matchingNodes){

			state.getUnmatchedLeads().removeNode(leadsKey, matchingNode);

			matchingNode.setTaxon(taxon);

			state.getPolytomousKeyNodesToSave().add(matchingNode);

		}

		return matchingNodes;

	}

	private void handleKey(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent) throws XMLStreamException {

		// attributes

		Map<String, Attribute> attributes = getAttributes(parentEvent);

		String isSpotcharacters = getAndRemoveAttributeValue(attributes, IS_SPOTCHARACTERS);

		if (isNotBlank(isSpotcharacters) ) {

			//TODO isSpotcharacters

			String message = "Attribute isSpotcharacters not yet implemented for <key>";

			fireWarningEvent(message, parentEvent, 4);

		}

		PolytomousKey key = PolytomousKey.NewInstance();

		key.addTaxonomicScope(state.getCurrentTaxon());

		state.setCurrentKey(key);

		boolean isFirstCouplet = true;

		while (reader.hasNext()) {

			XMLEvent next = readNoWhitespace(reader);

			if (isMyEndingElement(next, parentEvent)) {

				save(key, state);

				state.setCurrentKey(null);

				return;

			} else if (isEndingElement(next, KEYNOTES)){

				popUnimplemented(next.asEndElement());

			} else if (isStartingElement(next, KEY_TITLE)) {

					handleKeyTitle(state, reader, next);

			} else if (isStartingElement(next, KEYNOTES)) {

				//TODO

				handleNotYetImplementedElement(next);

			} else if (isStartingElement(next, COUPLET)) {

				PolytomousKeyNode node = null;

				if (isFirstCouplet){

					node = key.getRoot();

					isFirstCouplet = false;

				}

				handleCouplet(state, reader, next, node);

			} else {

				handleUnexpectedElement(next);

			}

		}

		throw new IllegalStateException("<key> has no closing tag");

	}

	/**

	 * @param state

	 * @param reader

	 * @param key

	 * @param next

	 * @throws XMLStreamException

	 */

	private void handleKeyTitle(MarkupImportState state, XMLEventReader reader, XMLEvent next) throws XMLStreamException {

		PolytomousKey key = state.getCurrentKey();

		String keyTitle = getCData(state, reader, next);

		String standardTitles = "(?i)(Key\\sto\\sthe\\s(genera|species|varieties|forms))";

		if (isNotBlank(keyTitle) ){

			if (!state.getConfig().isReplaceStandardKeyTitles() || ! keyTitle.matches(standardTitles)){

				key.setTitleCache(keyTitle, true);

			}

		}

	}

	private void handleCouplet(MarkupImportState state, XMLEventReader reader, XMLEvent parentEvent, PolytomousKeyNode parentNode) throws XMLStreamException {

		String num = getOnlyAttribute(parentEvent, NUM, true);

		List<PolytomousKeyNode> childList = new ArrayList<PolytomousKeyNode>(); 

		while (reader.hasNext()) {

			XMLEvent next = readNoWhitespace(reader);

			if (isMyEndingElement(next, parentEvent)) {

				completeCouplet(state, parentEvent, parentNode, num, childList);

				return;

			} else if (isStartingElement(next, QUESTION)) {

				handleQuestion(state, reader, next, childList);

			} else if (isStartingElement(next, KEYNOTES)) {

				//TODO

				handleNotYetImplementedElement(next);

			} else if (isEndingElement(next, KEYNOTES)) {

				//TODO

				popUnimplemented(next.asEndElement());

			} else {

				handleUnexpectedElement(next);

			}

		}

		throw new IllegalStateException("<couplet> has no closing tag");

	}

	/**

	 * @param state

	 * @param parentEvent

	 * @param parentNode

	 * @param num

	 * @param childList

	 */

	private void completeCouplet(MarkupImportState state, XMLEvent parentEvent,

			PolytomousKeyNode parentNode, String num,

			List<PolytomousKeyNode> childList) {

		if (parentNode != null){

			for (PolytomousKeyNode childNode : childList){

				parentNode.addChild(childNode);

			}

		}else if (isNotBlank(num)){

			UnmatchedLeadsKey unmatchedKey = UnmatchedLeadsKey.NewInstance(state.getCurrentKey(), num);

			Set<PolytomousKeyNode> nodes = state.getUnmatchedLeads().getNodes(unmatchedKey);