EDIT

*

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

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

	private static int modCount = 30000;

	public EfloraTaxonImport(){

		super();

	}

	@Override

	public boolean doCheck(EfloraImportState state){

		boolean result = true;

		return result;

	}

	private UnmatchedLeads unmatchedLeads;

	@Override

	public void doInvoke(EfloraImportState state){

		logger.info("start make Taxa ...");

		//FIXME reset state

		state.putTree(null, null);

//		UnmatchedLeads unmatchedLeads = state.getOpenKeys();

			unmatchedLeads = UnmatchedLeads.NewInstance();

		}

		state.setUnmatchedLeads(unmatchedLeads);

		TransactionStatus tx = startTransaction();

		unmatchedLeads.saveToSession(getPolytomousKeyNodeService());

		//TODO generally do not store the reference object in the config

		Reference sourceReference = state.getConfig().getSourceReference();

		getReferenceService().saveOrUpdate(sourceReference);

		Set<TaxonBase> taxaToSave = new HashSet<TaxonBase>();

		ResultWrapper<Boolean> success = ResultWrapper.NewInstance(true);

		Element elbody= getBodyElement(state.getConfig());

		List<Element> elTaxonList = elbody.getChildren();

		int i = 0;

		Set<String> unhandledTitleClassess = new HashSet<String>();

		Set<String> unhandledNomeclatureChildren = new HashSet<String>();

		Set<String> unhandledDescriptionChildren = new HashSet<String>();

		Taxon lastTaxon = getLastTaxon(state);

		//for each taxon

		for (Element elTaxon : elTaxonList){

			try {

				if (! elTaxon.getName().equalsIgnoreCase("taxon")){

					logger.warn("body has element other than 'taxon'");

				}

				BotanicalName botanicalName = BotanicalName.NewInstance(Rank.SPECIES());

				Taxon taxon = Taxon.NewInstance(botanicalName, state.getConfig().getSourceReference());

				handleTaxonAttributes(elTaxon, taxon, state);

				List<Element> children = elTaxon.getChildren();

				handleTaxonElement(state, unhandledTitleClassess, unhandledNomeclatureChildren,	unhandledDescriptionChildren, taxon, children);

				handleTaxonRelation(state, taxon, lastTaxon);

				lastTaxon = taxon;

				taxaToSave.add(taxon);

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

			} catch (Exception e) {

				logger.warn("Exception occurred in Sapindacea taxon import: " + e);

				e.printStackTrace();

			}

		}

		System.out.println(state.getUnmatchedLeads().toString());

		logger.warn("There are taxa with attributes 'excluded' and 'dubious'");

		logger.info("Children for nomenclature are: " + unhandledNomeclatureChildren);

		logger.info("Children for description are: " + unhandledDescriptionChildren);

		logger.info("Children for homotypes are: " + unhandledHomotypeChildren);

		logger.info("Children for nom are: " + unhandledNomChildren);

		//invokeRelations(source, cdmApp, deleteAll, taxonMap, referenceMap);

		logger.info(i + " taxa handled. Saving ...");

		getTaxonService().saveOrUpdate(taxaToSave);

		getFeatureTreeService().saveOrUpdateFeatureNodesAll(state.getFeatureNodesToSave());

		state.getFeatureNodesToSave().clear();

		commitTransaction(tx);

		logger.info("end makeTaxa ...");

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

//		invokeDoKey(state);

		logger.info("end makeKey ...");

		if (! success.getValue()){

			state.setUnsuccessfull();

		}

//	private void invokeDoKey(SapindaceaeImportState state) {

//		TransactionStatus tx = startTransaction();

//		Set<FeatureNode> nodesToSave = new HashSet<FeatureNode>();

//		ITaxonService taxonService = getTaxonService();

//		ResultWrapper<Boolean> success = ResultWrapper.NewInstance(true);

//

//		Element elbody= getBodyElement(state.getConfig());

//		List<Element> elTaxonList = elbody.getChildren();

//		int i = 0;

//		//for each taxon

//		for (Element elTaxon : elTaxonList){

//			if ((i++ % modCount) == 0 && i > 1){ logger.info("Taxa handled: " + (i-1));}

//			if (! elTaxon.getName().equalsIgnoreCase("taxon")){

//				continue;

//			}

//			List<Element> children = elTaxon.getChildren("key");

//			for (Element element : children){

//				handleKeys(state, element, null);

//			nodesToSave.add(taxon);

//

//		}

//	}

		AnnotatableEntity lastEntity = null;

		for (Element element : children){

			String elName = element.getName();

			if (elName.equalsIgnoreCase("title")){

				handleTitle(state, element, taxon, unhandledTitleClassess);

				lastEntity = null;

			}

		}

	}

	private void handleVernaculars(EfloraImportState state, Element elVernacular, Taxon taxon) {

		verifyNoAttribute(elVernacular);

		verifyNoChildren(elVernacular, false);

		if (matcher.find()){

			String dialect = singleDialect.substring(matcher.start(), matcher.end());

			dialect = dialect.replace("(dial. ", "").replace(")", "");

			Language language = null;

			try {

				language = this.getLanguage(state, state.getTransformer().getLanguageUuid(dialect), dialect, dialect, dialect);

			} catch (UndefinedTransformerMethodException e) {

				logger.error(e.getMessage());

			}

			String commonNames = singleDialect.substring(0, matcher.start());

			String[] splitNames = commonNames.split(",");

			for (String commonNameString : splitNames){

	private void handleReferences(EfloraImportState state, Element elReferences, Taxon taxon, AnnotatableEntity lastEntity) {

		verifyNoAttribute(elReferences);

		verifyNoChildren(elReferences, true);

		if (lastEntity == null){

			logger.warn("No last entity defined: " + refString);

			return;

		}

		Annotation annotation = Annotation.NewInstance(refString, AnnotationType.EDITORIAL(), Language.DEFAULT());

		lastEntity.addAnnotation(annotation);

	}

	private PolytomousKey handleKeys(EfloraImportState state, Element elKey, Taxon taxon) {

		UnmatchedLeads openKeys = state.getUnmatchedLeads();

		//title

		String title = makeKeyTitle(elKey);

		//key

		PolytomousKey key = PolytomousKey.NewTitledInstance(title);

		//TODO add covered taxa etc.

		verifyNoAttribute(elKey);

		//notes

		makeKeyNotes(elKey, key);

		//keycouplets

		List<Element> keychoices = new ArrayList<Element>();

		keychoices.addAll(elKey.getChildren("keycouplet"));

		keychoices.addAll(elKey.getChildren("keychoice"));

		for (Element elKeychoice : keychoices){

			handleKeyChoices(state, openKeys, key, elKeychoice, taxon);

			elKey.removeContent(elKeychoice);

		}

		//

		verifyNoChildren(elKey);

		logger.info("Unmatched leads after key handling:" + openKeys.toString());

		if (state.getConfig().isDoPrintKeys()){

			key.print(System.err);

	 * @param openKeys

	 * @param key

	 * @param elKeychoice

	 */

	private void handleKeyChoices(EfloraImportState state, UnmatchedLeads openKeys, PolytomousKey key, Element elKeychoice, Taxon taxon) {

		//char Attribute

		//or if it is handled as question. Therefore both cases are handled but feature

		//is finally not yet set

		KeyStatement question = handleKeychoiceChar(state, elKeychoice);

		Feature feature = handleKeychoiceCharAsFeature(state, elKeychoice);

		//lead

		List<PolytomousKeyNode> childNodes = handleKeychoiceLeads(state, key, elKeychoice, taxon, question, feature);

		//num -> match with unmatched leads

		handleKeychoiceNum(openKeys, key, elKeychoice, childNodes);

				key.getRoot().addChild(childNode);

			}

		}

		elKeychoice.removeAttribute("num");

	}

		}

		return statement;

	}

	/**

	 * @param state

	 * @param elKeychoice

		//needs to be discussed on model side

		node.setQuestion(question);

//		node.setFeature(feature);

		//text

		String text = handleLeadText(elLead, node);

		//num

		handleLeadNum(elLead, text);

		//goto

		handleLeadGoto(state, key, elLead, taxon, node);

		//others

		verifyNoAttribute(elLead);

		return node;

	}

		String strGenusName = CdmBase.deproxy(taxon.getName(), NonViralName.class).getGenusOrUninomial();

		strGoto = strGoto.replaceAll("\\([^\\(\\)]*\\)", "");  //replace all brackets

		strGoto = strGoto.replaceAll("\\s+", " "); //replace multiple whitespaces by exactly one whitespace

		String[] split = strGoto.split("\\s");

		for (int i = 0; i<split.length; i++){

			String single = split[i];

		if (! single.matches("[A-Z]\\.?")) {

			return false;

		}else if (single.length() == 0 || strGenusName == null || strGenusName.length() == 0){

		}else{

			return single.charAt(0) == strGenusName.charAt(0);

		}

		String chromosomesPart = getChromosomesPart(value);

		String references = value.replace(chromosomesPart, "").trim();

		chromosomesPart = chromosomesPart.replace(":", "").trim();

	}

	/**

	 * @return

	 */

	private void makeOriginalSourceReferences(ISourceable sourcable, String splitter, String refAll) {

			String refDetail = parseReferenceYearAndDetail(ref);

			sourcable.addSource(OriginalSourceType.PrimaryTaxonomicSource, null, null, ref, refDetail);

		}

//TODO use regex instead

/*		String detailResult = null;

		String titleToParse = ref.getTitleCache();

		String reYear = "\\([1-2]{1}[0-9]{3}\\)";

		String reYearPeriod = reYear + "(-" + reYear + ")+";

		String reDetail = "\\.{1,10}$";

	}

		value = replaceStart(value, "Uses");

		Feature feature = Feature.USES();

		return addDescriptionElement(state, taxon, value, feature, null);

	}

	 * @param state

	 * @param element

	 * @param taxon

	 */

	private void handleNomenclature(EfloraImportState state, Element elNomenclature, Taxon taxon, Set<String> unhandledChildren) {

		verifyNoAttribute(elNomenclature);

		List<Element> elements = elNomenclature.getChildren();

		for (Element element : elements){

			if (element.getName().equals("homotypes")){

				unhandledChildren.add(element.getName());

			}

		}

	}

	 */

	private void handleHomotypes(EfloraImportState state, Element elHomotypes, Taxon taxon) {

		verifyNoAttribute(elHomotypes);

		List<Element> elements = elHomotypes.getChildren();

		HomotypicalGroup homotypicalGroup = null;

		for (Element element : elements){

				unhandledHomotypeChildren.add(element.getName());

			}

		}

	}

	private static Set<String> unhandledNomChildren = new HashSet<String>();

	 */

	private HomotypicalGroup handleNom(EfloraImportState state, Element elNom, Taxon taxon, HomotypicalGroup homotypicalGroup) {

		List<Attribute> attributes = elNom.getAttributes();

		boolean taxonBaseClassType = false;

		for (Attribute attribute : attributes){

			if (! attribute.getName().equalsIgnoreCase("class")){

				}else{

					logger.warn("Unhandled class value for nom: " + classValue);

				}

			}

		}

		List<Element> elements = elNom.getChildren();

		for (Element element : elements){

			if (element.getName().equals("name") || element.getName().equals("homonym") ){

				unhandledNomChildren.add(element.getName());

			}

		}

		return homotypicalGroup;

	}

	/**

	 * @param state

	 * @param elNom

	 * @param taxon

	 */

	protected void handleTypeRef(EfloraImportState state, Element elNom, Taxon taxon, HomotypicalGroup homotypicalGroup) {

		verifyNoChildren(elNom);

		String typeRef = elNom.getTextNormalize();

		typeRef = removeStartingTypeRefMinus(typeRef);

		String[] split = typeRef.split(":");

		if (split.length < 2){

			logger.warn("typeRef has no ':' : " + typeRef);

			StringBuffer typeType = new StringBuffer(split[0]);

			String typeText = split[1].trim();

			TypeDesignationBase typeDesignation = getTypeDesignationAndReference(typeType);

			//Name Type Desitnations

			if (typeDesignation instanceof NameTypeDesignation){

				makeNameTypeDesignations(typeType, typeText, typeDesignation);

	private HomotypicalGroup handleNomTaxon(EfloraImportState state, Element elNom, Taxon taxon, HomotypicalGroup homotypicalGroup, boolean isSynonym) {

		NonViralName name = makeName(taxon, homotypicalGroup, isSynonym);

		String num = null;

		boolean hasGenusInfo = false;

		TeamOrPersonBase lastTeam = null;

		//genus

		List<Element> elGenus = XmlHelp.getAttributedChildListWithValue(elNom, "name", "class", "genus");

		if (elGenus.size() > 0){

		List<Element> elInfraRank = XmlHelp.getAttributedChildListWithValue(elNom, "name", "class", "infrank");

		Rank infraRank = null;

		infraRank = handleInfRank(name, elInfraRank, infraRank);

		//get left over elements

		List<Element> elements = elNom.getChildren();

		elements.removeAll(elInfraRank);

		for (Element element : elements){

			if (element.getName().equals("name")){

				String classValue = element.getAttributeValue("class");

				unhandledNomChildren.add(element.getName());

			}

		}

		//handle key

		if (! isSynonym){

			String taxonString = name.getNameCache();

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

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

			//same without using the num

				logger.warn("Taxon has num but no matching nodes exist: " + num+ ", Key: " + leadsKey.toString());

			}

		}

		//test nom element has no text

		if (StringUtils.isNotBlank(elNom.getTextNormalize().replace("—", "").replace("\u002d","").replace("\u2013", ""))){

			String strElNom = elNom.getTextNormalize();

			//System.out.println(CharUtils.unicodeEscaped(c));

			logger.warn("Nom tag has text: " + strElNom);

		}

		return name.getHomotypicalGroup();

	}

	}

	private void handleHomonym(EfloraImportState state, Element elHomonym, NonViralName upperName) {

		verifyNoAttribute(elHomonym);

		//hommonym name

		BotanicalName homonymName = BotanicalName.NewInstance(upperName.getRank());

		homonymName.setGenusOrUninomial(upperName.getGenusOrUninomial());

			}

		}

		//TODO verify other information

		//rel

		boolean homonymIsLater = false;

		}else{

			upperName.addRelationshipToName(homonymName, relType, null);

		}

	}

	protected TeamOrPersonBase handleNameUsage(Taxon taxon, NonViralName<?> name, String referenceTitle, TeamOrPersonBase lastTeam) {

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

		referenceTitle = removeStartingSymbols(referenceTitle, ref);

		ref.setTitleCache(referenceTitle, true);

		String microReference = parseReferenceYearAndDetail(ref);

		TeamOrPersonBase<?> team = getReferenceAuthor(ref);

			team = lastTeam;

		}

		ref.setAuthorship(team);

		TaxonDescription description = getDescription(taxon);

		TextData textData = TextData.NewInstance(Feature.CITATION());

		textData.addSource(OriginalSourceType.PrimaryTaxonomicSource, null, null, ref, microReference, name, null);

			ref.setType(ReferenceType.Book);

			return;

		}

		title = title.substring(3);

		//in reference

		//no ,

			book.setDatePublished(ref.getDatePublished());

			ref.setTitle(null);

			ref.setInBook(book);

	}

			//no author is given

			return null;

		}

		//,-references

		split = (referenceTitle).split(",\\s*[A-Z]");

		if (split.length > 1){

			return detail;

		}

		//non RE

		String reNon = "(\\s|,)non\\s";

		Pattern patReference = Pattern.compile(reNon);

		if (matcher.find()){

			int start = matcher.start();

			int end = matcher.end();

			if (detail != null){

				logger.warn("Unhandled non part: " + detail.substring(start));

				return detail;

			}

			result = detail.substring(0, start);

			//homonym string

			String homonymString = detail.substring(end);

			//hommonym name

			BotanicalName homonymName = BotanicalName.NewInstance(name.getRank());

			homonymName.setGenusOrUninomial(name.getGenusOrUninomial());

			homonymNomRef.setAuthorship(team);

			homonymNomRef.setTitle("");

			homonymNomRef.setProtectedTitleCache(false);

			//rel

			boolean homonymIsLater = false;

			NameRelationshipType relType = NameRelationshipType.LATER_HOMONYM();

			}else{

				name.addRelationshipToName(homonymName, relType, null);

			}

		}else{

			return detail;

		}

		name.setNomenclaturalReference(nomRef);

		microReference = parseHomonym(microReference, name);

		name.setNomenclaturalMicroReference(microReference);

		if (team == null){

			logger.warn("Name has nom. ref. but no author team. Name: " + name.getTitleCache() + ", Nom.Ref.: " + value);

		}else{

			strAuthor = strAuthor.substring(0, strAuthor.length() -1);

		}

		TeamOrPersonBase[] team = getTeam(strAuthor);

			logger.warn("Try to write combination author for a name that already has a combination author. Neglected.");

		}else{

		}

	}

			logger.warn("Brackets are missing for original combination author " + strAuthor);

		}

		TeamOrPersonBase[] basionymTeam = getTeam(strAuthor);

			logger.warn("Try to write basionym author for a name that already has a basionym author. Neglected.");

		}else{

		}

	}

	/**

	 * @param elAuthors

	 * @param name

	 */

	private void handleNameAuthors(Element elAuthor, NonViralName name) {

			logger.warn("Name already has a combination author. Name: " +  name.getTitleCache() + ", Author: " + elAuthor.getTextNormalize());

		}

		String strAuthor = elAuthor.getValue().trim();

			logger.warn("Author has brackets. Basionym authors should be handled in separate tags: " + strAuthor);

		}

		TeamOrPersonBase[] team = getTeam(strAuthor);

	}

		String[] split = strAuthor.split(" ex ");

		String strBaseAuthor = null;

		String strExAuthor = null;

		if (split.length == 2){

		}else if (split.length == 1){

			strBaseAuthor = split[0];

		}else{

				result[1].setTitleCache(strExAuthor, true);

				teamMap.put(strExAuthor, result[1].getUuid());

			}

		return result;

	}

	private void handleDescription(EfloraImportState state, Element elDescription, Taxon taxon, Set<String> unhandledChildren) {

		verifyNoAttribute(elDescription);

		List<Element> elements = elDescription.getChildren();

		for (Element element : elements){

			if (element.getName().equalsIgnoreCase("char")){

				logger.warn("Unhandled description child: " + element.getName());

			}

		}

	}

	/**

	 * @param state

	 * @param element

					String value = element.getValue();

					addDescriptionElement(state, taxon, value, feature, null);

				}

			}

		}

		List<Element> elements = element.getChildren();

		if (! elements.isEmpty()){

			logger.warn("Char has unhandled children");

	/**

	 * @param classValue

	 * @return

	 */

	private Feature getFeature(String classValue, EfloraImportState state) {

		UUID uuid;

	 * @param state

	 * @param element

	 * @param taxon

	 */

	private void handleTitle(EfloraImportState state, Element element, Taxon taxon, Set<String> unhandledTitleClassess) {

		// attributes

		UUID uuidTitle = EfloraTransformer.uuidTitle;

		ExtensionType titleExtension = this.getExtensionType(state, uuidTitle, "title", "title", "title");

		taxon.addExtension(element.getTextNormalize(), titleExtension);

	}

	/**

	 * @param value

	 */

	private void handleSubGenus(String value, TaxonNameBase taxonNameBase) {

		String name = value.replace("Subgenus", "").trim();

		((NonViralName)taxonNameBase).setInfraGenericEpithet(name);

	}

	/**

	 * @param value

	 */

	private void handleSection(String value, TaxonNameBase taxonNameBase) {

		String name = value.replace("Section", "").trim();

		((NonViralName)taxonNameBase).setInfraGenericEpithet(name);

	}

	/**

	 * @param value

	 */

	private void handleSpecies(String value, TaxonNameBase taxonNameBase) {

		//do nothing

	}

	/**

	 * @param value

	 */

	private void handleVariety(String value, TaxonNameBase taxonNameBase) {

		//do nothing

	}

	/**

	 * @param value

	 */

	private void handleSubSpecies(String value, TaxonNameBase taxonNameBase) {

		//do nothing

	}

	/**

	 * @param value

	 */

	protected void handleGenus(String value, TaxonNameBase taxonName) {

		Matcher matcher = rexGenusAuthor.matcher(value);

			Credit credit = Credit.NewInstance(team, null);

			taxonName.addCredit(credit);

//			NonViralName nvn = (NonViralName)taxonName;

//			nvn.setGenusOrUninomial(genus);

		}else{

			logger.info("No Author match for " + value);

		}

	}

	/**

	 * @param taxon

	 * @param lastTaxon

	 */

	private void handleTaxonRelation(EfloraImportState state, Taxon taxon, Taxon lastTaxon) {

		Classification tree = getTree(state);

		if (lastTaxon == null){

			tree.addChildTaxon(taxon, null, null);

	/**

	 * @param state

	 */

	private Classification getTree(EfloraImportState state) {

		Classification result = state.getTree(null);

	/**

	 * @param taxon

	 * @param value

	 * @param feature

	 */

	private TextData addDescriptionElement(EfloraImportState state, Taxon taxon, String value, Feature feature, String references) {

		TextData textData = TextData.NewInstance(feature);

			logger.warn(element.getName() + " has unhandled attributes: " + attributes.get(0).getValue() + "..." );

		}

	}

	/**

	 * @param elNomenclature

	 */

	protected void verifyNoChildren(Element element) {

		verifyNoChildren(element, false);

	}

	/**

	 * @param elNomenclature

	 */

			}

		}

	}

	/**

	 * Parses the nomenclatural status from the references titleCache. If a nomenclatural status

	 * removed. Requires protected title cache.

	 * @param ref

	 * @param nonViralName

	 */

	protected void parseNomStatus(Reference ref, NonViralName nonViralName) {

		String titleToParse = ref.getTitleCache();

		String noStatusTitle = parser.parseNomStatus(titleToParse, nonViralName, true);

		if (! noStatusTitle.equals(titleToParse)){

			ref.setTitleCache(noStatusTitle, true);

		}

	}

	/**

	 * Extracts the date published part and returns micro reference

	 * @param ref

		String oneMonth = "(Feb.|Dec.|March|June|July)";

		String reYear = oneMonth + "?\\s?[1-2]\\s?[0-9]\\s?[0-9]\\s?[0-9]\\s?";

		String secondYear = "(\\s?[1-2]\\s?[0-9])?\\s?[0-9]\\s?[0-9]\\s?";

		String reYearPeriod = "\\(" + reYear + "(\\-" + secondYear + ")?\\)";

		String reDetail = "\\.{1,10}$";

		//pattern for the whole string

		Pattern patReference = Pattern.compile(/*reReference +*/ reYearPeriod /*+ reDetail */);

		Matcher matcher = patReference.matcher(titleToParse);

		if (matcher.find()){

			int start = matcher.start();

			int end = matcher.end();

			//title and other information precedes the year part

			String title = titleToParse.substring(0, start).trim();

			//detail follows the year part

			String detail = titleToParse.substring(end).trim();

			//time period

			String strPeriod = matcher.group().trim();

			strPeriod = strPeriod.substring(1, strPeriod.length()-1);   //remove brackets

				strPeriod = strPeriod.substring(0, end) + " " + strPeriod.substring(end);

				startMonth = getMonth(strPeriod.substring(0, end));

			}

			TimePeriod datePublished = TimePeriodParser.parseString(strPeriod);

			if (startMonth != null){

				datePublished.setStartMonth(startMonth);

			logger.warn("Could not parse reference: " +  titleToParse);

		}

		return detailResult;

	}

	private Integer getMonth(String month) {

		if (month.startsWith("Jan")){

			return 1;

	/* (non-Javadoc)

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

	 */

		return ! state.getConfig().isDoTaxa();

	}