D-Net

package eu.dnetlib.data.utils;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.Arrays;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import eu.dnetlib.data.mdstore.plugins.objects.Project;

/**

 * Created by sandro on 12/6/16.

 */

public class XsltFunctions {

	private static final Log log = LogFactory.getLog(XsltFunctions.class);

	public static String cleanNames(final String s) {

		if (StringUtils.isBlank(s)) { return ""; }

		return cleanNames(s, StringUtils.countMatches(s, ",") > 1 ? "," : ";");

	}

	public static String extractYear(final String s) {

		if (StringUtils.isBlank(s)) { return ""; }

		final Matcher m = Pattern.compile("^.*(\\d{4}).*$").matcher(s);

		return m.matches() ? m.group(1) : "";

	}

	private static String cleanNames(final String s, final String sep) {

		return Arrays.stream(s.split(sep))

				.map(String::trim)

				.map(XsltFunctions::clean)

				.map(XsltFunctions::capitalize)

				.filter(StringUtils::isNotBlank)

				.collect(Collectors.joining("#"));

	}

	private static String clean(final String s) {

		return s.replaceAll("\\(.*\\)", "")

				.replaceAll("\\[.*\\]", "")

				.replaceAll("(?i)^et\\.? al(\\.|\\s)*$", "")

				.replaceAll("(?i)\\s*et\\.? al(\\.|\\s)*$", "")

				.replaceAll("\\d|\\*", "")

				.replaceAll("^(\\s|\\-|\\.)+", "")

				.replaceAll("\\,", "")

				.replaceAll("\\.", ". ")

				.trim();

	}

	public static String cleanDoi(final String doi) {

		if (StringUtils.isBlank(doi)) { return ""; }

		final String x = doi.replaceAll("\\?", "")

				.replaceAll("\\s*\\/\\s*", "/")

				.replaceAll("\\s*\\-\\s*", "-")

				.trim()

				.replaceAll("\\s", "_")

				.toLowerCase();

		if (!x.equals(doi)) {

			log.info("Cleaning doi: " + doi + " -> " + x);

		}

		return x;

	}

	public static String capitalize(final String s) {

		return Arrays.stream(fixApostrophes(s.toLowerCase()).split(" "))

				.map(p -> Arrays.stream(p.split("-"))

						.map(StringUtils::capitalize)

						.collect(Collectors.joining("-")))

				.map(StringUtils::capitalize)

				.collect(Collectors.joining(" "));

	}

	public static String fixApostrophes(final String s) {

		return s.replaceAll("'a", "'A").replaceAll("'e", "'E").replaceAll("'i", "'I").replaceAll("'o", "'O").replaceAll("'u", "'U")

				.replaceAll("a'", "à").replaceAll("e'", "è").replaceAll("i'", "ì").replaceAll("o'", "ò").replaceAll("u'", "ù");

	}

	public static boolean isValidProject(final String id) {

		return Project.isValid(id);

	}

	public static String projectLongId(final String funder,

			final String program,

			final String code,

			final String jurisdiction,

			final String name,

			final String acronym) {

		return String.format("info:eu-repo/grantAgreement/%s/%s/%s/%s/%s/%s",

				funder.replaceAll("/", "%2F"),

				program.replaceAll("/", "%2F"),

				code.replaceAll("/", "%2F"),

				jurisdiction.replaceAll("/", "%2F"),

				name.replaceAll("/", "%2F"),

				acronym.replaceAll("/", "%2F"));

	}

	public static String calculatePersonName(final String s) {

		final Pattern pattern = Pattern.compile("info:cnr-pdr\\/author\\/(.+):(.+)\\/(.+)\\/(.+)");

		final Matcher matcher = pattern.matcher(s);

		return matcher.find() ? capitalize(String.format("%s, %s", matcher.group(3), matcher.group(4))) : "";

	}

	public static String serverName(final String s) {

		try {

			return new URL(s).getHost();

		} catch (final MalformedURLException e) {

			return "Unknown";

		}

	}

	public static String md5(final String s) {

		return DigestUtils.md5Hex(s);

	}

	// <xsl:for-each select="tokenize(istiFunction:cleanName(.), ';')">

	// <xsl:choose>

	// <xsl:when test="matches(normalize-space(.), ',(\s*[a-zA-Z]\.)+$')">

	// <creator>

	// <creatorName>

	// <xsl:value-of select="normalize-space(translate(.,',',' '))"/>

	// </creatorName>

	// </creator>

	// </xsl:when>

	//

	// <xsl:when test="matches(normalize-space(.), '(^[a-zA-Z\.]+,\s?[a-zA-Z\.\s]+$)|(^[a-zA-Z\.\s]+,\s?[a-zA-Z\.]+$)')">

	// <creator>

	// <creatorName>

	// <xsl:value-of select="normalize-space(translate(.,',',' '))"/>

	// </creatorName>

	// </creator>

	// </xsl:when>

	//

	// <xsl:otherwise>

	// <xsl:for-each select="tokenize(., ',')">

	// <creator>

	// <creatorName>

	// <xsl:value-of select="normalize-space(.)"/>

	// </creatorName>

	// </creator>

	// </xsl:for-each>

	// </xsl:otherwise>

	// </xsl:choose>

	// </xsl:for-each>

	//

}