D-Net

package eu.dnetlib.enabling.datasources;

import java.io.IOException;

import java.sql.Array;

import java.sql.Date;

import java.sql.SQLException;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import org.apache.commons.lang.StringUtils;

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.io.SAXReader;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

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.SearchApisEntry;

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

import eu.dnetlib.miscutils.datetime.DateUtils;

public class DatasourceFunctions {

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

	private static final Resource baseDsProfile = new ClassPathResource("/eu/dnetlib/enabling/datasources/templates/datasource_base.xml");

	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.setTypology(castObject(map.get("typology"), String.class));

		ds.setValid(true);

		try {

			ds.setApis(Arrays.stream((Object[]) castObject(map.get("apis"), Array.class).getArray())

					.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> mapToDatasource(final Map<String, Object> map) {

		final Datasource<Organization<?>, Identity> 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.setOd_contenttypes(castObject(map.get("od_contenttypes"), String.class));

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

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

		ds.setTypology(castObject(map.get("typology"), 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.setDataprovider(castObject(map.get("dataprovider"), Boolean.class));

		ds.setServiceprovider(castObject(map.get("serviceprovider"), Boolean.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.setVersioning(castObject(map.get("versioning"), Boolean.class));

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

		ds.setQualitymanagementkind(castObject(map.get("qualitymanagementkind"), String.class));

		ds.setPidsystems(castObject(map.get("pidsystems"), 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));

		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.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;

	}

	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.setTypology(castObject(map.get("typology"), String.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"), Date.class));

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

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

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

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

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

		a.setLastDownloadDate(castObject(map.get("lastDownloadDate"), Date.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 {

			a.setApiParams(Arrays.stream((Object[]) castObject(map.get("params"), Array.class).getArray())

					.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 String dsToProfile(final Datasource<Organization<?>, Identity> ds, final List<Api<ApiParam>> apis, final String profId)

			throws DocumentException, IOException {

		final Document doc = new SAXReader().read(baseDsProfile.getInputStream());

		doc.selectSingleNode("//DATASOURCE_TYPE").setText(ds.getPlatform());

		doc.selectSingleNode("//DATASOURCE_ORIGINAL_ID").setText(ds.getId());

		doc.selectSingleNode("//TYPOLOGY").setText(ds.getTypology());

		doc.selectSingleNode("//OFFICIAL_NAME").setText(ds.getOfficialname());

		doc.selectSingleNode("//ENGLISH_NAME").setText(ds.getEnglishname());

		doc.selectSingleNode("//ICON_URI").setText(ds.getLogourl());

		doc.selectSingleNode("//COUNTRY").setText(ds.getOrganizations().stream().map(Organization::getCountry).findFirst().orElse(""));

		doc.selectSingleNode("//LONGITUDE").setText("" + ds.getLongitude());

		doc.selectSingleNode("//LATITUDE").setText("" + ds.getLatitude());

		doc.selectSingleNode("//TIMEZONE").setText("" + ds.getTimezone());

		doc.selectSingleNode("//REPOSITORY_WEBPAGE").setText(ds.getWebsiteurl());

		doc.selectSingleNode("//REPOSITORY_INSTITUTION").setText(ds.getOrganizations().stream().map(Organization::getLegalname).findFirst().orElse(""));

		doc.selectSingleNode("//ADMIN_INFO").setText(ds.getContactemail());

		doc.selectSingleNode("//REGISTERED_BY").setText(ds.getRegisteredby());

		doc.selectSingleNode("//LAST_UPDATE/@value").setText(DateUtils.now_ISO8601());

		final Element ef = (Element) doc.selectSingleNode("//EXTRA_FIELDS");

		addExtraField(ef, "OpenAireDataSourceId", ds.getId());

		addExtraField(ef, "NamespacePrefix", ds.getNamespaceprefix());

		addExtraField(ef, "VERIFIED", "NO");

		addExtraField(ef, "aggregatorName", ds.getAggregator());

		addExtraField(ef, "dateOfValidation", ds.getDateofvalidation());

		addExtraField(ef, "dateOfCollection", ds.getDateofcollection());

		addExtraField(ef, "mergeHomonyms", "NO");

		addExtraField(ef, "ACTID", ds.getActivationId());

		if (apis != null) {

			final Element ifaces = (Element) doc.selectSingleNode("//INTERFACES");

			apis.forEach(api -> addInterface(ifaces, api));

		}

		return doc.asXML();

	}

	private static void addInterface(final Element ifaces, final Api<?> api) {

		final Element ifc = ifaces.addElement("INTERFACE");

		ifc.addAttribute("id", api.getId());

		ifc.addAttribute("label", String.format("%s (%s)", api.getTypology(), api.getCompatibility()));

		ifc.addAttribute("typology", api.getTypology());

		ifc.addAttribute("active", "" + api.getActive());

		ifc.addAttribute("compliance", api.getCompatibility());

		ifc.addAttribute("contentDescription", api.getContentdescription());

		ifc.addAttribute("removable", "" + api.getRemovable());

		final Element ap = ifc.addElement("ACCESS_PROTOCOL");

		api.getApiParams().forEach(p -> ap.addAttribute(p.getParam(), p.getValue()));

		ap.setText(api.getProtocol());

		ifc.addElement("BASE_URL").setText(api.getBaseurl());

		if (api.isCompatibilityOverrided()) {

			addInterfaceExtraField(ifc, "overriding_compliance", true);

		}

		addInterfaceExtraField(ifc, "metadata_identifier_path", api.getMetadataIdentifierPath());

		addInterfaceExtraField(ifc, "last_collection_date", api.getLastCollectionDate());

		addInterfaceExtraField(ifc, "last_collection_mdId", api.getLastCollectionMdid());

		addInterfaceExtraField(ifc, "last_collection_total", api.getLastCollectionTotal());

		addInterfaceExtraField(ifc, "last_aggregation_date", api.getLastAggregationDate());

		addInterfaceExtraField(ifc, "last_aggregation_mdId", api.getLastAggregationMdid());

		addInterfaceExtraField(ifc, "last_aggregation_total", api.getLastAggregationTotal());

		addInterfaceExtraField(ifc, "last_download_date", api.getLastDownloadDate());

		addInterfaceExtraField(ifc, "last_download_objId", api.getLastDownloadObjid());

		addInterfaceExtraField(ifc, "last_download_total", api.getLastDownloadTotal());

	}

	private static void addExtraField(final Element parent, final String field, final Object value) {

		if (value != null && StringUtils.isNotBlank(value.toString())) {

			final Element f = parent.addElement("FIELD");

			f.addElement("key").setText(field);

			f.addElement("value").setText(value.toString());

		}

	}

	private static void addInterfaceExtraField(final Element parent, final String field, final Object value) {

		if (value != null && StringUtils.isNotBlank(value.toString())) {

			final Element f = parent.addElement("INTERFACE_EXTRA_FIELD");

			f.addAttribute("name", field);

			f.setText(value.toString());

		}

	}

	public static Map<String, Object> dsToMap(final Datasource<Organization<?>, Identity> 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("od_contenttypes", ds.getOd_contenttypes());

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

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

		map.put("typology", ds.getTypology());

		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("dataprovider", ds.isDataprovider());

		map.put("serviceprovider", ds.isServiceprovider());

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

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

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

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

		map.put("versioning", ds.isVersioning());

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

		map.put("qualitymanagementkind", ds.getQualitymanagementkind());

		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.isManaged());

		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());

		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("typology", api.getTypology());

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

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

		// 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());

	}

}