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

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

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;

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 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<? extends SearchApisEntry> searchApis(final String field, final Object value) throws DatasourceManagerException {

		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 DatasourceManagerException {

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

			ds.setAggregator("OPENAIRE");

		}

		final Map<String, Object> dsParams = DatasourceFunctions.dsToMap(ds);

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

		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 DatasourceManagerException {

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

	}

	@Override

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

		return datasourceManagerClients.getDatasourceById(dsId);

	}

	@Override

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

		return datasourceManagerClients.getApis(dsId);

	}

	@Override

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

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 DatasourceManagerException {

		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 baseUrl, final Map<String, String> params)

			throws DatasourceManagerException {

		// 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 and the IS profile

		datasourceManagerClients.updateSQL(dsId, "UPDATE dsm_api SET baseurl = :baseurl WHERE id = :api", AfterSqlUpdate.UPDATE_DS_PROFILE,

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

	}

	@Override

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

		return getBrowsableFields();

	}

	@Override

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

		return getBrowsableFields()

				.stream()

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

				.map(f -> {

					try {

						return datasourceManagerClients.searchSQL(f.getSql(), new HashMap<>());

					} catch (final DatasourceManagerException e) {

						return null;

					}

				})

				.filter(Objects::nonNull)

				.flatMap(List::stream)

				.map(m -> new BrowseTermImpl(

						m.get("term").toString(),

						NumberUtils.toInt(m.get("count").toString())))

				.collect(Collectors.toList());

	}

	@Override

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

		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 DatasourceManagerException e) {

				throw new RuntimeException(e);

			}

		});

		datasourceManagerClients.regenerateProfile(api.getDatasource());

	}

	@Override

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

		if (!isRemovable(dsId, apiId)) { throw new DatasourceManagerException("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;

	}

}