D-Net

package eu.dnetlib.grid.process.utils;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import org.apache.commons.lang3.StringUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

import eu.dnetlib.data.proto.FieldTypeProtos.DataInfo;

import eu.dnetlib.data.proto.FieldTypeProtos.KeyValue;

import eu.dnetlib.data.proto.FieldTypeProtos.Qualifier;

import eu.dnetlib.data.proto.FieldTypeProtos.StringField;

import eu.dnetlib.data.proto.FieldTypeProtos.StructuredProperty;

import eu.dnetlib.data.proto.KindProtos.Kind;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.proto.OafProtos.OafRel;

import eu.dnetlib.data.proto.OrganizationProtos.Organization;

import eu.dnetlib.data.proto.RelTypeProtos.RelType;

import eu.dnetlib.data.proto.RelTypeProtos.SubRelType;

import eu.dnetlib.data.proto.TypeProtos.Type;

import eu.dnetlib.grid.process.model.GridLabel;

import eu.dnetlib.grid.process.model.GridOrganization;

import eu.dnetlib.grid.process.model.GridRel;

import eu.dnetlib.grid.process.model.GridResponse;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.miscutils.functional.hash.Hashing;

public class GridUtils {

	public static Stream<GridOrganization> streamOrganizations(final String jsonFile) {

		try {

			return StreamSupport.stream(GridUtils.getOrganizations(new FileInputStream(jsonFile)).spliterator(), false);

		} catch (final FileNotFoundException e) {

			e.printStackTrace();

			return Stream.empty();

		}

	}

	protected static Iterable<GridOrganization> getOrganizations(final InputStream input) {

		try {

			return new ObjectMapper().readValue(input, GridResponse.class).getInstitutes();

		} catch (final Throwable e) {

			e.printStackTrace();

			return new ArrayList<>();

		}

	}

	public static List<Oaf> toProtos(final GridOrganization org, final Map<String, String> parents, final Datasource ds) {

		final String gridId = org.getId();

		final String parent = findParentName(org, parents);

		final String mainName = applyPrefix(parent, org.getName());

		final String shortName = findShortName(org);

		final String mainOpenaireId = calculateOpenaireId(ds.getPrefix(), gridId, mainName);

		final Set<String> alternativeNames = calculateAlternativeNames(org);

		final Map<String, String> orgNames = alternativeNames.stream()

				.map(s -> applyPrefix(parent, s))

				.collect(Collectors.toMap(

						s -> calculateOpenaireId(ds.getPrefix(), gridId, s),

						s -> s));

		orgNames.put(mainOpenaireId, mainName);

		final Qualifier country = org.getAddresses().stream()

				.map(addr -> Qualifier.newBuilder()

						.setClassid(addr.getCountry_code())

						.setClassname(addr.getCountry())

						.setSchemeid("dnet:countries")

						.setSchemename("dnet:countries"))

				.filter(q -> StringUtils.isNotBlank(q.getClassid()))

				.filter(q -> StringUtils.isNotBlank(q.getClassname()))

				.map(q -> q.build())

				.findFirst()

				.orElse(null);

		final KeyValue collectedFrom = KeyValue.newBuilder()

				.setKey(ds.getId())

				.setValue(ds.getName()).build();

		return orgNames.entrySet()

				.stream()

				.map(e -> toProtos(e.getKey(),

						gridId,

						e.getValue(),

						shortName,

						org.getLinks().stream().findFirst().orElse(""),

						country,

						e.getKey().equals(mainOpenaireId) ? alternativeNames : new HashSet<>(),

						orgNames.keySet(),

						collectedFrom))

				.flatMap(l -> l.stream())

				.collect(Collectors.toList());

	}

	private static List<Oaf> toProtos(final String openaireId,

			final String gridId,

			final String name,

			final String shortName,

			final String url,

			final Qualifier country,

			final Set<String> alternativeNames,

			final Set<String> orgRels,

			final KeyValue collectedFrom) {

		final OafEntity.Builder entity = OafEntity.newBuilder()

				.setId(openaireId)

				.addPid(StructuredProperty.newBuilder()

						.setValue(gridId)

						.setQualifier(Qualifier.newBuilder()

								.setClassid("grid")

								.setClassname("grid")

								.setSchemeid("dnet:pid_types")

								.setSchemename("dnet:pid_types")))

				.addCollectedfrom(collectedFrom)

				.setType(Type.organization)

				.setOrganization(Organization.newBuilder()

						.setMetadata(Organization.Metadata.newBuilder()

								.setLegalname(StringField.newBuilder().setValue(name))

								.setLegalshortname(StringField.newBuilder().setValue(shortName))

								.setWebsiteurl(StringField.newBuilder().setValue(url))

								.addAllAlternativeNames(

										alternativeNames.stream().map(a -> StringField.newBuilder().setValue(a).build()).collect(Collectors.toList()))

								.setCountry(country)));

		// Relations

		final List<Oaf> oafs = orgRels.stream()

				.filter(id -> !id.equals(openaireId))

				.map(id -> Oaf.newBuilder()

						.setKind(Kind.relation)

						.setLastupdatetimestamp(DateUtils.now())

						.setRel(OafRel.newBuilder()

								.setSource(openaireId)

								.setTarget(id)

								.setRelType(RelType.organizationOrganization)

								.setSubRelType(SubRelType.dedupSimilarity)

								.setRelClass("isSimilarTo")

								.setChild(false))

						.build())

				.collect(Collectors.toList());

		// Entity

		oafs.add(Oaf.newBuilder()

				.setKind(Kind.entity)

				.setLastupdatetimestamp(DateUtils.now())

				.setEntity(entity)

				.setDataInfo(DataInfo.newBuilder()

						.setTrust("0.90")

						.setInferred(false)

						.setProvenanceaction(Qualifier.newBuilder()

								.setClassid("UNKNOWN")

								.setClassname("UNKNOWN")

								.setSchemeid("dnet:provenanceActions")

								.setSchemename("dnet:provenanceActions")))

				.build());

		return oafs;

	}

	private static String calculateOpenaireId(final String prefix, final String gridId, final String name) {

		return String.format("20|%s::%s", prefix, Hashing.md5(gridId + " " + name));

	}

	private static String applyPrefix(final String parent, final String simpleName) {

		return StringUtils.isBlank(parent) ? simpleName : parent + " - " + simpleName;

	}

	private static Set<String> calculateAlternativeNames(final GridOrganization org) {

		final Set<String> res = org.getLabels().stream()

				.map(GridLabel::getLabel)

				.collect(Collectors.toSet());

		res.addAll(org.getAcronyms());

		return res;

	}

	public static String findShortName(final GridOrganization org) {

		return org.getAcronyms()

				.stream()

				.filter(StringUtils::isNotBlank)

				.findFirst()

				.orElse(org.getName());

	}

	private static String findParentName(final GridOrganization org, final Map<String, String> parents) {

		return org.getRelationships()

				.stream()

				.filter(r -> r.getType().equalsIgnoreCase("Parent"))

				.map(GridRel::getId)

				.map(parents::get)

				.filter(StringUtils::isNotBlank)

				.findFirst()

				.orElse(null);

	}

}