D-Net

package eu.dnetlib.enabling.datasources;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.stream.Collectors;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.math.NumberUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import com.google.common.collect.ImmutableMap;

import eu.dnetlib.enabling.datasources.DatasourceManagerClients.AfterSqlUpdate;

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

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

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

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

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

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

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

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

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

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

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

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

public class LocalOpenaireDatasourceManager implements LocalDatasourceManager<Datasource<Organization<?>, Identity>, Api<ApiParam>> {

	private DatasourceManagerClients datasourceManagerClients;

	private List<DbBrowsableField> browsableFields;

	private static final String QUERY_BASEDIR = "/eu/dnetlib/enabling/datasources/queries/";

	private static final Resource searchDsByType = new ClassPathResource(QUERY_BASEDIR + "searchDsByType.sql");

	private static final Resource searchApis = new ClassPathResource(QUERY_BASEDIR + "searchApisNormal.sql");

	private static final Resource searchApisUsingField = new ClassPathResource(QUERY_BASEDIR + "searchApisUsingField.sql");

	private static final Resource addDs = new ClassPathResource(QUERY_BASEDIR + "addDatasource.sql");

	private static final Resource addOrg = new ClassPathResource(QUERY_BASEDIR + "addOrganization.sql");

	private static final Resource deleteDs = new ClassPathResource(QUERY_BASEDIR + "deleteDatasource.sql");

	private static final Resource setActive = new ClassPathResource(QUERY_BASEDIR + "setActive.sql");

	private static final Resource setManaged = new ClassPathResource(QUERY_BASEDIR + "setManaged.sql");

	private static final Resource setCompliance = new ClassPathResource(QUERY_BASEDIR + "setCompliance.sql");

	private static final Resource overrideCompliance = new ClassPathResource(QUERY_BASEDIR + "overrideCompliance.sql");

	private static final Resource setLastCollectionInfo = new ClassPathResource(QUERY_BASEDIR + "setLastCollectionInfo.sql");

	private static final Resource setLastAggregationInfo = new ClassPathResource(QUERY_BASEDIR + "setLastAggregationInfo.sql");

	private static final Resource setLastDownloadInfo = new ClassPathResource(QUERY_BASEDIR + "setLastDownloadInfo.sql");

	private static final Resource insertApiParam = new ClassPathResource(QUERY_BASEDIR + "insertApiParam.sql");

	private static final Resource insertApi = new ClassPathResource(QUERY_BASEDIR + "insertApi.sql");

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

	@Override

	public List<SimpleDatasource> searchDatasourcesByType(final String type) throws DsmException {

		return datasourceManagerClients.searchSQL(searchDsByType, ImmutableMap.of("type", type))

				.stream()

				.map(DatasourceFunctions::mapToSimpleDs)

				.collect(Collectors.toList());

	}

	@Override

	public List<? extends SearchApisEntry> searchApis(final String field, final Object value) throws DsmException {

		try {

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

			if (!field.equalsIgnoreCase("__search__")) {

				sqlParams.put("field", field);

				sqlParams.put("value", value);

			} else {

				sqlParams.put("value", "%" + value + "%");

			}

			return datasourceManagerClients.searchSQL(field.equalsIgnoreCase("__search__") ? searchApis : searchApisUsingField, sqlParams)

					.stream()

					.map(DatasourceFunctions::mapToSearchApisEntry)

					.collect(Collectors.toList());

		} catch (final Exception e) {

			log.error("Error searching field " + field + " - value: " + value, e);

		}

		return new ArrayList<>();

	}

	@Override

	public void saveDs(final Datasource<Organization<?>, Identity> ds) throws DsmException {

		if (StringUtils.isBlank(ds.getAggregator())) {

			ds.setAggregator("OPENAIRE");

		}

		datasourceManagerClients.updateSQL(ds.getId(), addDs, AfterSqlUpdate.NONE, DatasourceFunctions.dsToMap(ds));

		if (ds.getOrganizations() != null) {

			for (final Organization<?> org : ds.getOrganizations()) {

				final Map<String, Object> orgParams = DatasourceFunctions.orgToMap(ds.getId(), org);

				datasourceManagerClients.updateSQL(ds.getId(), addOrg, AfterSqlUpdate.NONE, orgParams);

			}

		}

		datasourceManagerClients.regenerateProfile(ds.getId());

	}

	@Override

	public void deleteDs(final String dsId) throws DsmException {

		datasourceManagerClients.updateSQL(dsId, deleteDs, AfterSqlUpdate.DELETE_DS_PROFILE, ImmutableMap.of("dsId", dsId));

	}

	@Override

	public Datasource<Organization<?>, Identity> getDs(final String dsId) throws DsmException {

		return datasourceManagerClients.getDatasourceById(dsId);

	}

	@Override

	public List<Api<ApiParam>> getApis(final String dsId) throws DsmException {

		return datasourceManagerClients.getApis(dsId);

	}

	@Override

	public void setManaged(final String dsId, final boolean managed) throws DsmException {

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

		params.put("managed", managed);

		params.put("dsId", dsId);

		datasourceManagerClients.updateSQL(dsId, setManaged, AfterSqlUpdate.UPDATE_DS_PROFILE, params);

	}

	@Override

	public boolean isManaged(final String dsId) throws DsmException {

		final String q = "SELECT * from dsm_datasources WHERE id = :dsId AND managed = true";

		return !datasourceManagerClients.searchSQL(q, ImmutableMap.of("dsId", dsId)).isEmpty();

	}

	@Override

	public void setActive(final String dsId, final String apiId, final boolean active) throws DsmException {

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

		params.put("active", active);

		params.put("apiId", apiId);

		params.put("dsId", dsId);

		datasourceManagerClients.updateSQL(dsId, setActive, AfterSqlUpdate.UPDATE_DS_PROFILE, params);

		if (!active) {

			setLastCollectionInfo(dsId, apiId, null, null, null);

			setLastAggregationInfo(dsId, apiId, null, null, null);

			setLastDownloadInfo(dsId, apiId, null, null, null);

		}

	}

	@Override

	public boolean isActive(final String dsId, final String apiId) throws DsmException {

		final String q = "SELECT * from dsm_api WHERE id = :apiId AND datasource = :dsId AND active = true";

		return !datasourceManagerClients.searchSQL(q, ImmutableMap.of("dsId", dsId, "apiId", apiId)).isEmpty();

	}

	@Override

	public boolean isRemovable(final String dsId, final String apiId) throws DsmException {

		final String q = "SELECT * from dsm_api WHERE id = :apiId AND datasource = :dsId AND active != true AND removable = true";

		return !datasourceManagerClients.searchSQL(q, ImmutableMap.of("dsId", dsId, "apiId", apiId)).isEmpty();

	}

	@Override

	public void updateCompliance(final String dsId, final String apiId, final String level, final boolean override) throws DsmException {

		final Map<String, Object> params = ImmutableMap.of("level", level, "apiId", apiId, "dsId", dsId);

		datasourceManagerClients.updateSQL(dsId, override ? overrideCompliance : setCompliance, AfterSqlUpdate.UPDATE_DS_PROFILE, params);

	}

	@Override

	public void setLastCollectionInfo(final String dsId, final String apiId, final String mdId, final Integer size, final Date date)

			throws DsmException {

		setLastOperationInfo(setLastCollectionInfo, dsId, apiId, mdId, size, date);

	}

	@Override

	public void setLastAggregationInfo(final String dsId, final String apiId, final String mdId, final Integer size, final Date date)

			throws DsmException {

		setLastOperationInfo(setLastAggregationInfo, dsId, apiId, mdId, size, date);

	}

	@Override

	public void setLastDownloadInfo(final String dsId, final String apiId, final String objId, final Integer size, final Date date)

			throws DsmException {

		setLastOperationInfo(setLastDownloadInfo, dsId, apiId, objId, size, date);

	}

	private void setLastOperationInfo(final Resource sqlResource, final String dsId, final String apiId, final String mdId, final Integer size, final Date date)

			throws DsmException {

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

		params.put("dsId", dsId);

		params.put("apiId", apiId);

		params.put("mdId", mdId);

		params.put("size", size);

		params.put("date", date);

		datasourceManagerClients.updateSQL(dsId, sqlResource, AfterSqlUpdate.UPDATE_DS_PROFILE, params);

	}

	@Override

	public void updateApiDetails(final String dsId,

			final String apiId,

			final String metadataIdentifierPath,

			final String baseUrl,

			final Map<String, String> params)

			throws DsmException {

		// Delete old params

		datasourceManagerClients.updateSQL(dsId, "DELETE FROM dsm_apiparams WHERE api = :api", AfterSqlUpdate.NONE, ImmutableMap.of("api", apiId));

		// Insert new params

		for (final Map.Entry<String, String> e : params.entrySet()) {

			final Map<String, Object> sqlParams = ImmutableMap.of("param", e.getKey(), "value", e.getValue(), "api", apiId);

			datasourceManagerClients.updateSQL(dsId, insertApiParam, AfterSqlUpdate.NONE, sqlParams);

		}

		// Update the BaseURL

		datasourceManagerClients.updateSQL(dsId,

				"UPDATE dsm_api SET baseurl = :baseurl WHERE id = :api",

				AfterSqlUpdate.NONE,

				ImmutableMap.of("baseurl", baseUrl, "api", apiId));

		// Update the metadata_identifier_path

		datasourceManagerClients.updateSQL(dsId,

				"UPDATE dsm_api SET metadata_identifier_path = :path WHERE id = :api",

				AfterSqlUpdate.NONE,

				ImmutableMap.of("path", metadataIdentifierPath, "api", apiId));

		// Update the IS profile

		datasourceManagerClients.regenerateProfile(dsId);

	}

	@Override

	public List<? extends BrowsableField> listBrowsableFields() throws DsmException {

		return getBrowsableFields();

	}

	@Override

	public List<BrowseTerm> browseField(final String field) throws DsmException {

		final Optional<DbBrowsableField> bf = getBrowsableFields()

				.stream()

				.filter(f -> f.getId().equals(field))

				.findFirst();

		if (bf.isPresent()) {

			return datasourceManagerClients.searchSQL(bf.get().getSql(), new HashMap<>())

					.stream()

					.filter(m -> m.get("term") != null)

					.filter(m -> m.get("count") != null)

					.filter(m -> StringUtils.isNotBlank(m.get("term").toString()))

					.map(m -> new BrowseTermImpl(m.get("term").toString(), NumberUtils.toInt(m.get("count").toString(), 0)))

					.collect(Collectors.toList());

		} else {

			log.error("Not browsable field:" + field);

			throw new DsmException("Not browsable field:" + field);

		}

	}

	@Override

	public void addApi(final Api<ApiParam> api) throws DsmException {

		datasourceManagerClients.updateSQL(api.getDatasource(), insertApi, AfterSqlUpdate.NONE, DatasourceFunctions.apiToMap(api));

		api.getApiParams().forEach(p -> {

			final ImmutableMap<String, Object> sqlParams = ImmutableMap.of("param", p.getParam(), "value", p.getValue(), "api", api.getId());

			try {

				datasourceManagerClients.updateSQL(api.getDatasource(), insertApiParam, AfterSqlUpdate.NONE, sqlParams);

			} catch (final DsmException e) {

				throw new RuntimeException(e);

			}

		});

		datasourceManagerClients.regenerateProfile(api.getDatasource());

	}

	@Override

	public void deleteApi(final String dsId, final String apiId) throws DsmException {

		if (!isRemovable(dsId, apiId)) { throw new DsmException("The api " + apiId + " can't be deleted"); }

		datasourceManagerClients.updateSQL(dsId, "DELETE FROM dsm_apiparams WHERE api = :api", AfterSqlUpdate.NONE, ImmutableMap.of("api", apiId));

		datasourceManagerClients.updateSQL(dsId, "DELETE FROM dsm_api WHERE id = :api", AfterSqlUpdate.UPDATE_DS_PROFILE, ImmutableMap.of("api", apiId));

	}

	public DatasourceManagerClients getDatasourceManagerClients() {

		return datasourceManagerClients;

	}

	@Required

	public void setDatasourceManagerClients(final DatasourceManagerClients datasourceManagerClients) {

		this.datasourceManagerClients = datasourceManagerClients;

	}

	public List<DbBrowsableField> getBrowsableFields() {

		return browsableFields;

	}

	@Required

	public void setBrowsableFields(final List<DbBrowsableField> browsableFields) {

		this.browsableFields = browsableFields;

	}

}