D-Net

package eu.dnetlib.openaire.common;

import java.io.IOException;

import java.nio.charset.Charset;

import java.util.List;

import java.util.Map;

import java.util.Queue;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.function.Function;

import java.util.stream.Collectors;

import com.google.common.collect.Lists;

import com.google.common.escape.Escaper;

import com.google.common.xml.XmlEscapers;

import eu.dnetlib.OpenaireExporterConfig;

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

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

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryException;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryService;

import eu.dnetlib.openaire.dsm.dao.utils.IndexDsInfo;

import eu.dnetlib.openaire.context.Context;

import eu.dnetlib.openaire.context.ContextMappingUtils;

import eu.dnetlib.openaire.dsm.domain.ApiDetails;

import eu.dnetlib.openaire.dsm.domain.DatasourceDetails;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.http.HttpStatus;

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

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.core.io.ClassPathResource;

import org.springframework.stereotype.Component;

import static eu.dnetlib.openaire.dsm.dao.utils.DsmMappingUtils.asRepositoryInterfce;

import static eu.dnetlib.openaire.dsm.dao.utils.DsmMappingUtils.asRepositoryProfile;

import static eu.dnetlib.openaire.common.Utils.escape;

/**

 * Created by claudio on 20/10/2016.

 */

@Component

public class ISClientImpl implements ISClient {

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

	@Autowired

	private OpenaireExporterConfig config;

	@Autowired

	private ISLookUpService isLookUpService;

	@Autowired

	private ISRegistryService isRegistryService;

	@Autowired

	private OperationManager operationManager;

	@Override

	@Cacheable("indexdsinfo-cache")

	public IndexDsInfo calculateCurrentIndexDsInfo() throws DsmException {

		log.warn("calculateCurrentIndexDsInfo(): not using cache");

		final String[] arr;

		try {

			arr = _isLookUp(_getQuery(config.getFindIndexDsInfo())).split("@@@");

			return new IndexDsInfo(

				_isLookUp(_getQuery(config.getFindSolrIndexUrl())),

				arr[0].trim(), arr[1].trim(), arr[2].trim());

		} catch (IOException | ISLookUpException e) {

			throw new DsmException("unable fetch index DS information from IS");

		}

	}

	@Override

	@Cacheable("objectstoreid-cache")

	public String getObjectStoreId(final String dsId, final Queue<Throwable> errors) throws IOException {

		log.warn(String.format("getObjectStoreId(%s): not using cache", dsId));

		final String xqueryTemplate = _getQuery(config.getFindObjectStore());

		try {

			return _isLookUp(String.format(xqueryTemplate, dsId));

		} catch (ISLookUpException e) {

			errors.add(new DsmException("unable to find objectStore for datasource " + dsId));

			return "";

		}

	}

	@Override

	@Cacheable("context-cache")

	public Map<String, Context> getFunderContextMap() throws IOException {

		return _processContext(

				new LinkedBlockingQueue<>(),

				_getQuery(config.getFindFunderContexts()));

	}

	@Override

	@Cacheable("context-cache")

	public Map<String, Context> getCommunityContextMap() throws IOException {

		return _processContext(

				new LinkedBlockingQueue<>(),

				_getQuery(config.getFindCommunityContexts()));

	}

	@Override

	@CacheEvict(value = "context-cache", allEntries = true)

	public void updateContextParam(final String id, final String name, final String value) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		final Escaper esc = XmlEscapers.xmlContentEscaper();

		_quickSeachProfile(String.format(

				"update value collection('/db/DRIVER/ContextDSResources/ContextDSResourceType')" +

				"/RESOURCE_PROFILE/BODY/CONFIGURATION/context[./@id = '%s']/param[./@name = '%s']/text() with '%s'", id, name, escape(esc, value)),

				errors);

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e));

		}

	}

	@Override

	@CacheEvict(value = "context-cache", allEntries = true)

	public void updateContextAttribute(final String id, final String name, final String value) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		final Escaper esc = XmlEscapers.xmlAttributeEscaper();

		_quickSeachProfile(String.format(

				"update value collection('/db/DRIVER/ContextDSResources/ContextDSResourceType')" +

						"/RESOURCE_PROFILE/BODY/CONFIGURATION/context[./@id = '%s']/@%s with '%s'", id, name, escape(esc, value)),

				errors);

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e));

		}

	}

	@Override

	@CacheEvict(value = "context-cache", allEntries = true)

	public void addConcept(final String id, final String categoryId, final String data) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		_quickSeachProfile(String.format(

				"update insert %s into collection('/db/DRIVER/ContextDSResources/ContextDSResourceType')" +

				"/RESOURCE_PROFILE/BODY/CONFIGURATION/context[./@id = '%s']/category[./@id = '%s']", data, id, categoryId), errors);

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e));

		}

	}

	@Override

	@CacheEvict(value = "context-cache", allEntries = true)

	public void removeConcept(final String id, final String categoryId, final String conceptId) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		_quickSeachProfile(String.format(

				"for $concept in collection('/db/DRIVER/ContextDSResources/ContextDSResourceType')" +

						"/RESOURCE_PROFILE/BODY/CONFIGURATION/context[./@id = '%s']" +

						"/category[./@id = '%s']/concept[./@id = '%s']" +

						"return update delete $concept", id, categoryId, conceptId),

				errors);

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e.getMessage()));

		}

	}

	@Override

	public void updateDatasourceFields(final String dsId, final Map<String, String> changes) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		operationManager.addOperation(() -> {

			Thread.currentThread().setName("update-ds:" + dsId);

			changes.forEach((xpath, value) -> {

				try {

					_isLookUp(String.format(

							"for $x in collection('/db/DRIVER/RepositoryServiceResources/RepositoryServiceResourceType')\n" +

							"where $x/RESOURCE_PROFILE/BODY/CONFIGURATION/DATASOURCE_ORIGINAL_ID[@provenance='OPENAIRE']/text() = '%s'\n" +

							"return update value $x%s with '%s'", dsId, xpath, value));

				} catch (ISLookUpException e) {

					errors.add(e);

				}

			});

		});

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e.getMessage()));

		}

	}

	@Override

	public void updateAPIField(final String dsId, final String apiId, final Map<String, String> changes) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		operationManager.addOperation(() -> {

			Thread.currentThread().setName("update-api:" + dsId);

			changes.forEach((xpath, value) -> {

				try {

					_isLookUp(String.format(

							"let $x:=/RESOURCE_PROFILE/BODY/CONFIGURATION/DATASOURCE_ORIGINAL_ID[@provenance='OPENAIRE' and ./text() = '%s']\n" +

							"return update value $x/..//INTERFACE[./@id = '%s']%s with '%s'",

							dsId, apiId, xpath, value));

				} catch (ISLookUpException e) {

					errors.add(e);

				}

			});

		});

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e.getMessage()));

		}

	}

	@Override

	public void registerDS(final DatasourceDetails d) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		operationManager.addOperation(() -> {

			Thread.currentThread().setName("save-ds:" + d.getId());

			try {

				final String id = isRegistryService.registerProfile(asRepositoryProfile(d));

				log.debug(String.format("registered DS profile %s", id));

			} catch (ISRegistryException e) {

				errors.add(e);

			}

		});

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e.getMessage()));

		}

	}

	@Override

	public void registerAPI(final ApiDetails api) {

		final Queue<Throwable> errors = Lists.newLinkedList();

		operationManager.addOperation(() -> {

			Thread.currentThread().setName("save-api:" + api.getId());

			try {

				final String dsId = api.getDatasource();

				final String iface = asRepositoryInterfce(api);

				_isLookUp(String.format(

						"let $x:=/RESOURCE_PROFILE/BODY/CONFIGURATION/DATASOURCE_ORIGINAL_ID[@provenance='OPENAIRE' and ./text() = '%s']\n" +

						"return update insert %s into $x/../INTERFACES", dsId, iface));

				log.debug(String.format("registered API %s", api.getId()));

			} catch (ISLookUpException e) {

				errors.add(e);

			}

		});

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e.getMessage()));

		}

	}

	@Override

	public void removeAPI(final String apiId) throws DsmForbiddenException {

		final Queue<Throwable> errors = Lists.newLinkedList();

		try {

			final List<String> metaWorkflows = _quickSeachProfile(String.format(

					"distinct-values(for $x in collection('/db/DRIVER/MetaWorkflowDSResources/MetaWorkflowDSResourceType')\n" +

					"where $x/RESOURCE_PROFILE/BODY/DATAPROVIDER[./@interface = '%s']\n" +

					"return $x/RESOURCE_PROFILE/BODY/DATAPROVIDER/@id/string())", apiId),

					errors);

			if (!metaWorkflows.isEmpty()) {

				throw new DsmForbiddenException(

						HttpStatus.SC_FORBIDDEN,

						String.format("cannot remove api '%s', it has workflows associated", apiId));

			}

			_isLookUp(String.format(

					"update delete /RESOURCE_PROFILE/BODY/CONFIGURATION/INTERFACES/INTERFACE[./@id = '%s']", apiId));

			log.debug(String.format("deleted API %s", apiId));

		} catch (ISLookUpException e) {

			errors.add(e);

		}

		if (!errors.isEmpty()) {

			errors.forEach(e -> log.error(e.getMessage()));

		}

	}

	/// HELPERS

	private Map<String, Context> _processContext(final Queue<Throwable> errors, final String xquery) throws IOException {

		try {

			return getContextProfiles(errors, xquery).stream()

					.filter(StringUtils::isNotBlank)

					.map(s -> ContextMappingUtils.parseContext(s, errors))

					.collect(Collectors.toMap(

							Context::getId,

							Function.identity()));

		} finally {

			if (!errors.isEmpty()) {

				log.error(errors);

				errors.forEach(e -> e.printStackTrace());

			}

		}

	}

	private List<String> getContextProfiles(final Queue<Throwable> errors, final String xquery) throws IOException {

		log.warn("getContextProfiles(): not using cache");

		return _quickSeachProfile(xquery, errors);

	}

	private String _getQuery(final ClassPathResource resource) throws IOException {

		return IOUtils.toString(resource.getInputStream(), Charset.defaultCharset());

	}

	private String _isLookUp(final String xquery) throws ISLookUpException {

		log.debug(String.format("running xquery:\n%s", xquery));

		final String res = isLookUpService.getResourceProfileByQuery(xquery);

		//log.debug(String.format("query result: %s", res));

		return res;

	}

	private List<String> _quickSeachProfile(final String xquery, final Queue<Throwable> errors) {

		final List<String> res = Lists.newArrayList();

		try {

			log.debug(String.format("running xquery:\n%s", xquery));

			final List<String> list = isLookUpService.quickSearchProfile(xquery);

			if (list != null) {

				res.addAll(list);

			}

			log.debug(String.format("query result size: %s", res.size()));

		} catch (Throwable e) {

			errors.add(e);

			return Lists.newArrayList();

		} finally {

			return res;

		}

	}

	@CacheEvict(cacheNames = { "context-cache", "indexdsinfo-cache", "objectstoreid-cache" }, allEntries = true)

	public void dropCache() {

		log.info("dropped dsManager IS cache");

	}

}