package eu.eudat.logic.managers;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import eu.eudat.commons.enums.ReferenceType;
import eu.eudat.commons.scope.user.UserScope;
import eu.eudat.data.old.ExternalDataset;
import eu.eudat.logic.builders.model.criteria.ExternalDatasetCriteriaBuilder;
import eu.eudat.logic.builders.model.models.DataTableDataBuilder;
import eu.eudat.data.dao.criteria.ExternalDatasetCriteria;
import eu.eudat.service.reference.external.criteria.ExternalReferenceCriteria;
import eu.eudat.logic.services.operations.DatabaseRepository;
import eu.eudat.models.data.externaldataset.ExternalDatasetListingModel;
import eu.eudat.data.query.items.table.externaldataset.ExternalDatasetTableRequest;
import eu.eudat.models.data.helpers.common.DataTableData;
import eu.eudat.commons.exceptions.HugeResultSetException;
import eu.eudat.service.reference.external.RemoteFetcher;
import eu.eudat.queryable.QueryableList;
import eu.eudat.logic.services.ApiContext;
import gr.cite.tools.exception.MyNotFoundException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.management.InvalidApplicationException;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

@Component
public class ExternalDatasetManager {

    private ApiContext apiContext;
    private DatabaseRepository databaseRepository;
    private RemoteFetcher remoteFetcher;
    private final UserScope userScope;
    @Autowired
    public ExternalDatasetManager(ApiContext apiContext, UserScope userScope) {
        this.apiContext = apiContext;
        this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository();
        this.remoteFetcher = apiContext.getOperationsContext().getRemoteFetcher();
        this.userScope = userScope;
    }

    public DataTableData<ExternalDatasetListingModel> getPaged(ExternalDatasetTableRequest externalDatasetTableRequest) throws Exception {
        QueryableList<ExternalDataset> items = apiContext.getOperationsContext().getDatabaseRepository().getExternalDatasetDao().getWithCriteria(externalDatasetTableRequest.getCriteria());
        QueryableList<ExternalDataset> pagedItems = PaginationManager.applyPaging(items, externalDatasetTableRequest);
        List<ExternalDatasetListingModel> externalDatasetListingmodels = pagedItems.select(item -> new ExternalDatasetListingModel().fromDataModel(item));
        return apiContext.getOperationsContext().getBuilderFactory().getBuilder(DataTableDataBuilder.class).data(externalDatasetListingmodels).totalCount(items.count()).build();
    }

    public List<ExternalDatasetListingModel> getWithExternal(String query, String type) throws HugeResultSetException, MyNotFoundException, InvalidApplicationException {
        // Fetch the local saved external Datasets that belong to the user.
        ExternalDatasetCriteria criteria = apiContext.getOperationsContext().getBuilderFactory().getBuilder(ExternalDatasetCriteriaBuilder.class).like(query).build();
        criteria.setCreationUserId(this.userScope.getUserId());
        QueryableList<ExternalDataset> items = apiContext.getOperationsContext().getDatabaseRepository().getExternalDatasetDao().getWithCriteria(criteria);

        // Fetch external Datasets from external sources.
        ExternalReferenceCriteria externalReferenceCriteria = new ExternalReferenceCriteria(query);
        List<Map<String, String>> remoteRepos = this.apiContext.getOperationsContext().getRemoteFetcher().getReferences(ReferenceType.Datasets, externalReferenceCriteria, type);

        // Parse items from external sources to listing models.
        ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        List<ExternalDatasetListingModel> externalDatasetModels = remoteRepos.stream()
                .map(item -> mapper.convertValue(item, ExternalDatasetListingModel.class))
                .collect(Collectors.toCollection(LinkedList::new));

        // Merge fetched and local.
        List<ExternalDatasetListingModel> externalDatasets = items.select(item -> new ExternalDatasetListingModel().fromDataModel(item));
        externalDatasets.addAll(externalDatasetModels);

        return externalDatasets;
    }

    public ExternalDatasetListingModel getSingle(UUID id) throws HugeResultSetException, MyNotFoundException, InstantiationException, IllegalAccessException, InvalidApplicationException {
        ExternalDataset externalDataset = databaseRepository.getExternalDatasetDao().find(id);
        ExternalDatasetListingModel externalDatasetModel = new ExternalDatasetListingModel();
        externalDatasetModel.fromDataModel(externalDataset);
        return externalDatasetModel;
    }

    public ExternalDataset create(eu.eudat.models.data.externaldataset.ExternalDatasetModel externalDatasetModel) throws Exception {
        ExternalDataset externalDataset = externalDatasetModel.toDataModel();
        externalDataset.getCreationUser().setId(this.userScope.getUserId());
        return apiContext.getOperationsContext().getDatabaseRepository().getExternalDatasetDao().createOrUpdate(externalDataset);
    }
}