D-Net

package eu.dnetlib.openaire.context;

import java.io.StringReader;

import java.text.ParseException;

import java.util.*;

import java.util.stream.Collectors;

import com.google.common.base.Functions;

import com.google.common.collect.Lists;

import eu.dnetlib.openaire.funders.domain.FunderDetails;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.time.DateUtils;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

public class ContextMappingUtils {

	private static final List<String> DATE_PATTERN = Lists.newArrayList(

			"yyyy-MM-dd'T'hh:mm:ss", "yyyy-MM-dd'T'hh:mm:ssXXX", "yyyy-MM-dd'T'hh:mm:ss+00:00");

	public static Context parseContext(final String s, final Queue<Throwable> errors) {

		final SAXReader reader = new SAXReader();

		final Document doc;

		try {

			doc = reader.read(new StringReader(s));

		} catch (DocumentException e) {

			errors.add(e);

			return new Context();

		}

		try {

			final Element eContext = (Element) doc.selectSingleNode("/RESOURCE_PROFILE/BODY/CONFIGURATION/context");

			return new Context()

					.setId(eContext.attributeValue("id"))

					.setLabel(eContext.attributeValue("label"))

					.setType(eContext.attributeValue("type"))

					.setDateofcreation(asDate(doc.valueOf("/RESOURCE_PROFILE/HEADER/DATE_OF_CREATION/@value")))

					.setParams(parseParams(eContext))

					.setCategories(parseCategories(eContext));

		} catch (Throwable e) {

			errors.add(e);

			return new Context();

		}

	}

	private static Date asDate(final String s) {

		for(String pattern : DATE_PATTERN) {

			try {

				return DateUtils.parseDate(s, pattern);

			} catch (final ParseException e) {}

		}

		return null;

	}

	private static Map<String, Category> parseCategories(final Element eContext) {

		final List<Element> eCategory = (List<Element>) eContext.selectNodes("//category");

		return eCategory.stream()

				.map(eCat -> new Category()

						.setClaim(getClaim(eCat))

						.setId(eCat.attributeValue("id"))

						.setLabel(eCat.attributeValue("label"))

						.setParams(parseParams(eCat))

						.setConcepts(parseConcepts(eCat)))

				.collect(Collectors.toMap(

						Category::getId,

						Functions.identity()

				));

	}

	private static List<Concept> parseConcepts(final Element eCategory) {

		final List<Element> eConcepts = (List<Element>) eCategory.selectNodes("./concept");

		return eConcepts.stream()

				.map(eCon -> new Concept()

						.setClaim(getClaim(eCon))

						.setId(eCon.attributeValue("id"))

						.setLabel(eCon.attributeValue("label"))

						.setParams(parseParams(eCon))

						.setConcepts(parseConcepts(eCon)))

				.collect(Collectors.toList());

	}

	private static Boolean getClaim(final Element eCon) {

		final String claim = eCon.attributeValue("claim");

		return BooleanUtils.toBooleanObject(StringUtils.isNotBlank(claim) ? claim : "false");

	}

	private static Map<String, List<Param>> parseParams(final Element e) {

		final List<Element> params = (List<Element>) e.selectNodes("./param");

		return params.stream()

				.map(p -> new Param()

						.setName(p.attributeValue("name"))

						.setValue(p.getTextTrim()))

				.collect(Collectors.toMap(

						Param::getName,

						Lists::newArrayList,

						(p1, p2) -> {

							List<Param> p = new ArrayList<>(p1);

							p.addAll(p2);

							return p;

						}));

	}

	public static FunderDetails asFunderDetails(final Context c) {

		return new FunderDetails()

				.setId(c.getId())

				.setName(c.getLabel())

				.setShortname(c.getId());

	}

}