D-Net

package eu.dnetlib.wds.utils;

import eu.dnetlib.data.transform.Ontologies;

import eu.dnetlib.data.transform.OntologyLoader;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.miscutils.collections.Pair;

import eu.dnetlib.miscutils.functional.xml.DnetXsltFunctions;

import eu.dnetlib.rmi.enabling.ISLookUpException;

import eu.dnetlib.rmi.enabling.ISLookUpService;

import org.apache.commons.lang3.StringEscapeUtils;

import org.apache.commons.lang3.StringUtils;

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

import javax.annotation.PostConstruct;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class WDSUtils {

    public static Ontologies ontologies;

    public final static Map<String, Pair<String, String>> hostedByMap = new HashMap<>();

    public final static Map<String, Pair<String, String>> collectedFromMap = new HashMap<>();

    public static String HOSTED_BY_MAP_QUERY = "for $x in collection('/db/DRIVER/RepositoryServiceResources/RepositoryServiceResourceType') " +

            "where $x//FIELD/key/text()= 'archive_center'  return " +

            "concat($x//DATASOURCE_ORIGINAL_ID, '<-->', $x//FIELD[./key/text()= 'archive_center' ]/value/string(), '<-->', $x//OFFICIAL_NAME)";

    public static String COLLECTEDFROM_DATASOURCE_MAP_QUERY = "for $x in collection('/db/DRIVER/RepositoryServiceResources/RepositoryServiceResourceType')  " +

            "where $x//FIELD/key/text()!= 'archive_center'  return  concat($x//DATASOURCE_ORIGINAL_ID, '<-->', " +

            "$x//FIELD[./key/text()= 'NamespacePrefix' ]/value/string(), '<-->', $x//OFFICIAL_NAME)";

    private static WDSUtils instance;

    @Autowired

    private UniqueServiceLocator serviceLocator;

    public static String getInverse(final String relation) throws Exception {

        if (ontologies == null) {

            ontologies = OntologyLoader.loadOntologiesFromIS();

        }

        final String normalizedRelation = normalizeRelation(relation);

        try {

            return ontologies.getTerms(normalizedRelation).stream().findFirst().get().getInverseCode();

        } catch (Throwable e) {

            System.out.println("Relation not found = " + normalizedRelation);

            return "related";

        }

    }

    public static String normalizeRelation(final String relation) {

        if (relation == null || StringUtils.isEmpty(relation)) {

            return null;

        }

        return Character.toLowerCase(relation.charAt(0)) + relation.substring(1);

    }

    public static void generateDSMapFromQuery(final Map<String, Pair<String, String>> aMap, final String aQUERY) throws Exception {

        final ISLookUpService lookUpService = instance.getServiceLocator().getService(ISLookUpService.class);

        final List<String> hostedByList = lookUpService.quickSearchProfile(aQUERY);

        aMap.clear();

        aMap.putAll(

                hostedByList.stream()

                        .map(s -> s.split("<-->"))

                        .map(s -> new Pair<>(StringEscapeUtils.escapeXml11(s[1]), new Pair<>(s[0], s[2])))

                        .collect(Collectors.toMap(

                                Pair::getKey,

                                Pair::getValue)));

    }

    public static String getNameFromDataSourcePrefix(final String datasourcePrefix) throws Exception {

        if (collectedFromMap.keySet().size() == 0) {

            generateDSMapFromQuery(collectedFromMap, COLLECTEDFROM_DATASOURCE_MAP_QUERY);

        }

        if (!collectedFromMap.containsKey(datasourcePrefix))

            return "";

        return collectedFromMap.get(datasourcePrefix).getValue();

    }

    public static String getIdFromDataSourcePrefix(final String datasourcePrefix) throws Exception {

        if (collectedFromMap.keySet().size() == 0) {

            generateDSMapFromQuery(collectedFromMap, COLLECTEDFROM_DATASOURCE_MAP_QUERY);

        }

        if (!collectedFromMap.containsKey(datasourcePrefix))

            return "";

        return collectedFromMap.get(datasourcePrefix).getKey();

    }

    public static String getDatasourceName(final String dataCenter) throws Exception {

        if (hostedByMap.keySet().isEmpty()) {

            generateDSMapFromQuery(hostedByMap, HOSTED_BY_MAP_QUERY);

        }

        final Pair<String, String> result = hostedByMap.get(dataCenter);

        return result == null ? null : result.getValue();

    }

    public static String getDatasourceId(final String dataCenter) throws Exception {

        if (hostedByMap.keySet().isEmpty()) {

            generateDSMapFromQuery(hostedByMap, HOSTED_BY_MAP_QUERY);

        }

        final Pair<String, String> result = hostedByMap.get(dataCenter);

        return result == null ? null : result.getKey();

    }

    public static String generateWDSNsPrefix(final String input, final String prefix, final int maxLength) {

        if (StringUtils.isNotEmpty(input) && StringUtils.isNotEmpty(prefix)) {

            String cleanedString = input.replace("/", "_");

            int remainingLength = maxLength - prefix.length();

            if (cleanedString.length() > remainingLength)

                cleanedString = cleanedString.substring(0, remainingLength);

            else

                cleanedString = StringUtils.rightPad(cleanedString, remainingLength, "_");

            return prefix + cleanedString;

        }

        return null;

    }

    public static String getDOI(final String pid){

        final Pattern pattern = Pattern.compile("10\\.\\d{4,9}/[-._;()/:A-Z0-9]+$", Pattern.CASE_INSENSITIVE);

        final Matcher matcher = pattern.matcher(pid);

        if (matcher.find()) {

            return(matcher.group());

        }

        return "";

    }

    public static boolean isDate(final String date){

        //final Pattern pattern = Pattern.compile("(\\d{4})|(\\d{4}-\\d{2})|(\\d{4}-\\d{2}--\\d{4}-d{2}|(\\d{4}--\\d{4}))");

        final Pattern pattern = Pattern.compile("\\d{4}");

        final Matcher matcher = pattern.matcher(date);

        return matcher.find();

    }

    /**

     * This method is used only for test Scope

     *

     * @param mockInstance

     */

    public static void setInstance(final WDSUtils mockInstance) {

        instance = mockInstance;

    }

    @PostConstruct

    public void registerInstance() throws Exception {

        instance = this;

    }

    public UniqueServiceLocator getServiceLocator() {

        return serviceLocator;

    }

    public void setServiceLocator(UniqueServiceLocator serviceLocator) {

        this.serviceLocator = serviceLocator;

    }

    public static String generateIdentifier(final String pid, final String pidtype) {

        if (StringUtils.isBlank(pid) || StringUtils.isBlank(pidtype))

            throw new RuntimeException("Error pid or pidtype cannot be null");

        return DnetXsltFunctions.md5(String.format("%s::%s", pid.toLowerCase().trim(), pidtype.toLowerCase().trim()));

    }

}