D-Net

package eu.dnetlib.enabling.datasources;

import java.sql.Array;

import java.sql.Date;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import eu.dnetlib.enabling.datasources.common.Api;

import eu.dnetlib.enabling.datasources.common.ApiParam;

import eu.dnetlib.enabling.datasources.common.ApiParamImpl;

import eu.dnetlib.enabling.datasources.common.Datasource;

import eu.dnetlib.enabling.datasources.common.Identity;

import eu.dnetlib.enabling.datasources.common.Organization;

import eu.dnetlib.enabling.datasources.common.PidSystem;

import eu.dnetlib.enabling.datasources.common.SearchApisEntry;

import eu.dnetlib.enabling.datasources.common.SimpleDatasource;

public class DatasourceFunctions {

	private static final String EOSC_DATA_SOURCE = "Data Source";

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

	public static SimpleDatasource mapToSimpleDs(final Map<String, Object> map) {

		final SimpleDatasource ds = new SimpleDatasource();

		ds.setId(castObject(map.get("id"), String.class));

		ds.setName(castObject(map.get("name"), String.class));

		ds.setOrigId(castObject(map.get("id"), String.class));

		ds.setEoscDatasourceType(castObject(map.get("eosc_datasource_type"), String.class));

		ds.setValid(true);

		try {

			final Array arr = castObject(map.get("apis"), Array.class);

			if (arr != null && ((Object[]) arr.getArray()).length > 0) {

				ds.setApis(Arrays.stream((Object[]) arr.getArray())

					.filter(Objects::nonNull)

					.map(Object::toString)

					.collect(Collectors.toSet()));

			}

		} catch (final SQLException e) {

			log.error("Error parsing array (apis)", e);

			throw new RuntimeException("Error parsing array (apis)", e);

		}

		return ds;

	}

	public static Datasource<Organization<?>, Identity, PidSystem> mapToDatasource(final Map<String, Object> map) {

		final Datasource<Organization<?>, Identity, PidSystem> ds = new Datasource<>();

		ds.setId(castObject(map.get("id"), String.class));

		ds.setOfficialname(castObject(map.get("officialname"), String.class));

		ds.setEnglishname(castObject(map.get("englishname"), String.class));

		ds.setWebsiteurl(castObject(map.get("websiteurl"), String.class));

		ds.setLogourl(castObject(map.get("logourl"), String.class));

		ds.setContactemail(castObject(map.get("contactemail"), String.class));

		ds.setLatitude(castObject(map.get("latitude"), Double.class));

		ds.setLongitude(castObject(map.get("longitude"), Double.class));

		ds.setTimezone(castObject(map.get("timezone"), String.class));

		ds.setNamespaceprefix(castObject(map.get("namespaceprefix"), String.class));

		ds.setLanguages(castObject(map.get("languages"), String.class));

		ds.setCollectedfrom(castObject(map.get("collectedfrom"), String.class));

		ds.setDateofvalidation(castObject(map.get("dateofvalidation"), Date.class));

		ds.setEoscDatasourceType(castObject(map.get("eosc_datasource_type"), String.class));

		ds.setProvenanceaction(castObject(map.get("provenanceaction"), String.class));

		ds.setDateofcollection(castObject(map.get("dateofcollection"), Date.class));

		ds.setPlatform(castObject(map.get("platform"), String.class));

		ds.setActivationId(castObject(map.get("activationId"), String.class));

		ds.setDescription(castObject(map.get("description"), String.class));

		ds.setReleasestartdate(castObject(map.get("releasestartdate"), Date.class));

		ds.setReleaseenddate(castObject(map.get("releaseenddate"), Date.class));

		ds.setMissionstatementurl(castObject(map.get("missionstatementurl"), String.class));

		ds.setDatabaseaccesstype(castObject(map.get("databaseaccesstype"), String.class));

		ds.setDatauploadtype(castObject(map.get("datauploadtype"), String.class));

		ds.setDatabaseaccessrestriction(castObject(map.get("databaseaccessrestriction"), String.class));

		ds.setDatauploadrestriction(castObject(map.get("datauploadrestriction"), String.class));

		ds.setCitationguidelineurl(castObject(map.get("citationguidelineurl"), String.class));

		ds.setCertificates(castObject(map.get("certificates"), String.class));

		ds.setAggregator(castObject(map.get("aggregator"), String.class));

		ds.setIssn(castObject(map.get("issn"), String.class));

		ds.setEissn(castObject(map.get("eissn"), String.class));

		ds.setLissn(castObject(map.get("lissn"), String.class));

		ds.setRegisteredby(castObject(map.get("registeredby"), String.class));

		ds.setSubjects(castObject(map.get("subjects"), String.class));

		ds.setManaged(castObject(map.get("managed"), Boolean.class));

		ds.setConsentTermsOfUse(castObject(map.get("consenttermsofuse"), Boolean.class));

		ds.setConsentTermsOfUseDate(castObject(map.get("consenttermsofusedate"), Date.class));

		ds.setFullTextDownload(castObject(map.get("fulltextdownload"), Boolean.class));

		ds.setStatus(castObject(map.get("status"), String.class));

		return ds;

	}

	public static Identity mapToDsIdentity(final Map<String, Object> map) {

		final Identity id = new Identity();

		id.setPid(castObject(map.get("pid"), String.class));

		id.setIssuertype(castObject(map.get("issuertype"), String.class));

		return id;

	}

	public static Organization<Datasource<?, ?, ?>> mapToDsOrganization(final Map<String, Object> map) {

		final Organization<Datasource<?, ?, ?>> org = new Organization<>();

		org.setId(castObject(map.get("id"), String.class));

		org.setLegalshortname(castObject(map.get("legalshortname"), String.class));

		org.setLegalname(castObject(map.get("legalname"), String.class));

		org.setWebsiteurl(castObject(map.get("websiteurl"), String.class));

		org.setLogourl(castObject(map.get("logourl"), String.class));

		org.setCountry(castObject(map.get("country"), String.class));

		org.setCollectedfrom(castObject(map.get("collectedfrom"), String.class));

		org.setDateofcollection(castObject(map.get("dateofcollection"), Date.class));

		org.setProvenanceaction(castObject(map.get("provenanceaction"), String.class));

		return org;

	}

	public static SearchApisEntry mapToSearchApisEntry(final Map<String, Object> map) {

		final SearchApisEntry a = new SearchApisEntry();

		a.setId(castObject(map.get("id"), String.class));

		a.setCompliance(castObject(map.get("compliance"), String.class));

		a.setActive(castObject(map.get("active"), Boolean.class));

		a.setRepoId(castObject(map.get("dsId"), String.class));

		a.setRepoName(castObject(map.get("name"), String.class));

		a.setRepoCountry(castObject(map.get("country"), String.class));

		a.setRepoPrefix(castObject(map.get("prefix"), String.class));

		a.setAggrDate(castObject(map.get("aggrDate"), String.class));

		a.setAggrTotal(castObject(map.get("aggrTotal"), Integer.class));

		a.setAggrBackend(calculateMdstoreBackendById(castObject(map.get("aggrMdId"), String.class)));

		a.setCollDate(castObject(map.get("collDate"), String.class));

		a.setCollTotal(castObject(map.get("collTotal"), Integer.class));

		a.setCollBackend(calculateMdstoreBackendById(castObject(map.get("collMdId"), String.class)));

		a.setProtocol(castObject(map.get("protocol"), String.class));

		a.setAlternativeName(castObject(map.get("alternativeName"), String.class));

		a.setRepoOrganization(castObject(map.get("organization"), String.class));

		return a;

	}

	private static String calculateMdstoreBackendById(final String mdId) {

		if (StringUtils.isBlank(mdId)) {

			return "";

		} else if (StringUtils.trim(mdId).startsWith("md-")) {

			return "HDFS";

		} else {

			return "MONGO";

		}

	}

	public static Api<ApiParam> mapToApi(final Map<String, Object> map) {

		final Api<ApiParam> a = new Api<>();

		a.setId(castObject(map.get("id"), String.class));

		a.setProtocol(castObject(map.get("protocol"), String.class));

		a.setDatasource(castObject(map.get("datasource"), String.class));

		a.setContentdescription(castObject(map.get("contentdescription"), String.class));

		a.setActive(castObject(map.get("active"), Boolean.class));

		a.setRemovable(castObject(map.get("removable"), Boolean.class));

		a.setCompatibility(castObject(map.get("compatibility"), String.class));

		a.setCompatibilityOverrided(castObject(map.get("isCompatibilityOverrided"), Boolean.class));

		a.setMetadataIdentifierPath(castObject(map.get("metadataIdentifierPath"), String.class));

		a.setLastCollectionTotal(castObject(map.get("lastCollectionTotal"), Integer.class));

		a.setLastCollectionDate(castObject(map.get("lastCollectionDate"), Timestamp.class));

		a.setLastCollectionMdid(castObject(map.get("lastCollectionMdid"), String.class));

		a.setLastAggregationTotal(castObject(map.get("lastAggregationTotal"), Integer.class));

		a.setLastAggregationDate(castObject(map.get("lastAggregationDate"), Timestamp.class));

		a.setLastAggregationMdid(castObject(map.get("lastAggregationMdid"), String.class));

		a.setLastDownloadTotal(castObject(map.get("lastDownloadTotal"), Integer.class));

		a.setLastDownloadDate(castObject(map.get("lastDownloadDate"), Timestamp.class));

		a.setLastDownloadObjid(castObject(map.get("lastDownloadObjid"), String.class));

		a.setLastValidationJob(castObject(map.get("lastValidationJob"), String.class));

		a.setBaseurl(castObject(map.get("baseUrl"), String.class));

		try {

			final Array arr = castObject(map.get("params"), Array.class);

			if (arr != null) {

				a.setApiParams(Arrays.stream((Object[]) arr.getArray())

					.filter(Objects::nonNull)

					.map(Object::toString)

					.map(s -> {

						final ApiParam p = new ApiParamImpl();

						p.setParam(StringUtils.substringBefore(s, "="));

						p.setValue(StringUtils.substringAfter(s, "="));

						return p;

					})

					.collect(Collectors.toSet()));

			}

		} catch (final SQLException e) {

			log.error("Error parsing array params", e);

			throw new RuntimeException("Error parsing array params", e);

		}

		return a;

	}

	public static Map<String, Object> dsToMap(final Datasource<Organization<?>, Identity, PidSystem> ds) {

		final Map<String, Object> map = new HashMap<>();

		map.put("id", ds.getId());

		map.put("officialname", ds.getOfficialname());

		map.put("englishname", ds.getEnglishname());

		map.put("websiteurl", ds.getWebsiteurl());

		map.put("logourl", ds.getLogourl());

		map.put("contactemail", ds.getContactemail());

		map.put("latitude", ds.getLatitude());

		map.put("longitude", ds.getLongitude());

		map.put("timezone", ds.getTimezone());

		map.put("namespaceprefix", ds.getNamespaceprefix());

		map.put("languages", ds.getLanguages());

		map.put("collectedfrom", ds.getCollectedfrom());

		map.put("dateofvalidation", ds.getDateofvalidation());

		map.put("eosctype", EOSC_DATA_SOURCE);

		map.put("eoscdatasourcetype", ds.getEoscDatasourceType());

		map.put("provenanceaction", ds.getProvenanceaction());

		map.put("platform", ds.getPlatform());

		map.put("activationid", ds.getActivationId());

		map.put("description", ds.getDescription());

		map.put("releasestartdate", ds.getReleasestartdate());

		map.put("releaseenddate", ds.getReleaseenddate());

		map.put("missionstatementurl", ds.getMissionstatementurl());

		map.put("databaseaccesstype", ds.getDatabaseaccesstype());

		map.put("datauploadtype", ds.getDatauploadtype());

		map.put("databaseaccessrestriction", ds.getDatabaseaccessrestriction());

		map.put("datauploadrestriction", ds.getDatauploadrestriction());

		map.put("citationguidelineurl", ds.getCitationguidelineurl());

		map.put("pidsystems", ds.getPidsystems());

		map.put("certificates", ds.getCertificates());

		map.put("aggregator", ds.getAggregator());

		map.put("issn", ds.getIssn());

		map.put("eissn", ds.getEissn());

		map.put("lissn", ds.getLissn());

		map.put("registeredby", ds.getRegisteredby());

		map.put("subjects", ds.getSubjects());

		map.put("managed", ds.getManaged());

		map.put("status", ds.getStatus());

		return map;

	}

	public static Map<String, Object> orgToMap(final String dsId, final Organization<?> org) {

		final Map<String, Object> map = new HashMap<>();

		map.put("dsId", dsId);

		map.put("orgId", org.getId());

		map.put("legalname", org.getLegalname());

		map.put("legalshortname", org.getLegalshortname());

		map.put("websiteurl", org.getWebsiteurl());

		map.put("logourl", org.getLogourl());

		map.put("country", org.getCountry());

		map.put("collectedfrom", org.getCollectedfrom());

		return map;

	}

	public static Map<String, Object> apiToMap(final Api<?> api) {

		final Map<String, Object> map = new HashMap<>();

		map.put("apiId", api.getId());

		map.put("protocol", api.getProtocol());

		map.put("baseUrl", api.getBaseurl());

		map.put("dsId", api.getDatasource());

		map.put("contentDescription", api.getContentdescription());

		map.put("compatibility", api.getCompatibility());

		map.put("metadataIdentifierPath", api.getMetadataIdentifierPath());

		map.put("removable", api.getRemovable());

		// The other fields are not required in the INSERT operation

		return map;

	}

	@SuppressWarnings("unchecked")

	private static <T> T castObject(final Object o, final Class<T> clazz) {

		if (o == null) { return null; }

		if (clazz.isInstance(o)) { return (T) o; }

		throw new IllegalArgumentException("Type not managed: " + clazz.getSimpleName());

	}

}