D-Net

package eu.dnetlib.data.transform;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringReader;

import java.util.Arrays;

import java.util.List;

import java.util.Map;

import java.util.function.Function;

import java.util.stream.Collectors;

import javax.annotation.PostConstruct;

import com.google.common.collect.Maps;

import com.google.gson.Gson;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.rmi.enabling.ISLookUpException;

import eu.dnetlib.rmi.enabling.ISLookUpService;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

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

import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import org.springframework.stereotype.Component;

/**

 * Created by claudio on 12/12/2016.

 */

@Component

public class OntologyLoader {

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

	private static final String PATTERN = "classpath*:/eu/dnetlib/bootstrap/profiles/OntologyDSResources/OntologyDSResourceType/*.xml";

    private static UniqueServiceLocator staticServiceLocator;

    @Autowired

    private UniqueServiceLocator serviceLocator;

	public static Ontology loadOntologyFromCp(final InputStream profile) {

        return loadOntologyProfilefromPath(profile);

    }

    public static Ontologies loadOntologiesFromCp() throws IOException {

	    final PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

	    final List<InputStream> files = Arrays.asList(resolver.getResources(PATTERN)).stream().map(r -> {

		    try {

			    return r.getInputStream();

		    } catch (IOException e) {

			    throw new RuntimeException(e);

		    }

	    }).collect(Collectors.toList());

        return createOntologies(files);

    }

    public static Ontologies createOntologies(List<InputStream> files) {

        final Ontologies ontologies = new Ontologies();

        files.stream().map(

                s -> loadOntologyProfilefromPath(s))

                .collect(Collectors.toMap(Ontology::getCode, Function.identity()))

                .entrySet()

                .forEach(it -> ontologies.put(it.getKey(), it.getValue()));

        return ontologies;

    }

    public static Ontologies loadOntologiesFromIS() throws ISLookUpException {

        final ISLookUpService lookUpService = staticServiceLocator.getService(ISLookUpService.class);

        List<String> files = lookUpService.quickSearchProfile("for $x in collection('/db/DRIVER/OntologyDSResources/OntologyDSResourceType') return $x");

        final Ontologies ontologies = new Ontologies();

        files.stream().map

                (OntologyLoader::getOntologyFromProfile)

                .collect(Collectors.toMap(Ontology::getCode, Function.identity()))

                .entrySet()

                .forEach(it -> ontologies.put(it.getKey(), it.getValue()));

        return ontologies;

    }

	public static Ontologies loadOntologies(final String json) throws IOException {

		return new Gson().fromJson(json, Ontologies.class);

	}

    private static Ontology loadOntologyProfilefromPath(final InputStream profile) {

        final String profileXML;

        try {

            profileXML = IOUtils.toString(profile);

        } catch (IOException e) {

            log.error(e);

            return null;

        }

        return getOntologyFromProfile(profileXML);

    }

    private static Ontology getOntologyFromProfile(final String profile) {

        SAXReader saxReader = new SAXReader();

        Document doc = null;

        StringReader reader = new StringReader(profile);

        try {

            doc = saxReader.read(reader);

        } catch (DocumentException e) {

            e.printStackTrace();

            throw new RuntimeException(e);

        }

        return new Ontology()

                .setCode(doc.valueOf("//ONTOLOGY_NAME/@code"))

                .setDescription(doc.valueOf("//ONTOLOGY_DESCRIPTION/text()"))

                .setTerms(asTerms(doc.selectNodes("//TERMS/TERM")));

    }

	private static Map<String,OntologyTerm> asTerms(final List list) {

		final Map<String, OntologyTerm> terms = Maps.newHashMap();

		if (list != null) {

			list.forEach(o -> {

				final Element e = (Element) o;

				final OntologyTerm ot = OntologyTerm.newInstance()

						.setCode(e.attributeValue("code"))

						.setEncoding(e.attributeValue("encoding"))

						.setEnglishName(e.attributeValue("english_name"))

						.setNativeName(e.attributeValue("native_name"))

						.setInverseCode(((Node) o).valueOf("./RELATIONS/RELATION[@type = 'inverseOf']/@code"));

				terms.put(ot.getCode(), ot);

			});

		}

		return terms;

	}

    @PostConstruct

    public void init() {

        OntologyLoader.staticServiceLocator = serviceLocator;

    }

}