package eu.eudat.elastic.repository;

import eu.eudat.elastic.criteria.DatasetCriteria;
import eu.eudat.elastic.entities.Dataset;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;

@Service("datasetRepository")
public class DatasetRepository extends ElasticRepository<Dataset, DatasetCriteria> {

    @Autowired
    public DatasetRepository(RestHighLevelClient client) {
        super(client);
    }

    @Override
    public Dataset createOrUpdate(Dataset entity) throws IOException {
        XContentBuilder builder = XContentFactory.jsonBuilder();
        IndexRequest request = new IndexRequest("datasets").id(entity.getId()).source(entity.toElasticEntity(builder));//new IndexRequest("datasets", "doc", entity.getId()).source(entity.toElasticEntity(builder));
        this.getClient().index(request, RequestOptions.DEFAULT);
        return entity;
    }

    @Override
    public Dataset findDocument(String id) throws IOException {
        GetRequest request = new GetRequest("datasets",id);
        GetResponse response = this.getClient().get(request, RequestOptions.DEFAULT);
        return new Dataset().fromElasticEntity(response.getSourceAsMap());
    }

    @Override
    public List<Dataset> query(DatasetCriteria criteria) throws ExecutionException, InterruptedException, IOException {
        SearchRequest searchRequest = new SearchRequest("datasets");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        CountRequest countRequest = new CountRequest("datasets");
        countRequest.query(QueryBuilders.matchAllQuery());
        CountResponse countResponse = getClient().count(countRequest, RequestOptions.DEFAULT);
        Long count = countResponse.getCount();

        searchSourceBuilder.size(count.intValue());

        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        if (criteria.getLabel() != null && !criteria.getLabel().isEmpty()) {
            boolQuery = boolQuery.should(QueryBuilders.matchPhrasePrefixQuery("label", criteria.getLabel()));
        }

        if (criteria.getDatasetTemplates() != null && criteria.getDatasetTemplates().size() > 0) {
            boolQuery = boolQuery.should(QueryBuilders.termsQuery("template.keyword", criteria.getDatasetTemplates().stream().map(UUID::toString).collect(Collectors.toList())));
        }

        if (criteria.getStatus() != null) {
            boolQuery = boolQuery.should(QueryBuilders.termQuery("status.keyword", criteria.getStatus().toString()));
        }

        if (criteria.getDmps() != null && criteria.getDmps().size() > 0) {
            boolQuery = boolQuery.should(QueryBuilders.termsQuery("dmp.keyword", criteria.getDmps().stream().map(UUID::toString).collect(Collectors.toList())));
        }

        if (criteria.getGrants() != null && criteria.getGrants().size() > 0) {
            boolQuery = boolQuery.should(QueryBuilders.termsQuery("grant.keyword", criteria.getGrants().stream().map(UUID::toString).collect(Collectors.toList())));
        }

        if (criteria.getCollaborators() != null && criteria.getCollaborators().size() > 0) {
            boolQuery = boolQuery.should(QueryBuilders.termsQuery("collaborators.id.keyword", criteria.getCollaborators().stream().map(UUID::toString).collect(Collectors.toList())));
        }

        if (boolQuery.should().isEmpty()) {
            boolQuery.should(QueryBuilders.matchAllQuery());
        } else {
            boolQuery.minimumShouldMatch(boolQuery.should().size());
        }
        searchSourceBuilder.query(boolQuery);
        searchRequest.source(searchSourceBuilder);
        SearchResponse response = this.getClient().search(searchRequest, RequestOptions.DEFAULT);
        return Arrays.stream(response.getHits().getHits()).map(x -> this.transformFromString(x.getSourceAsString(), Dataset.class)).collect(Collectors.toList());
    }

    @Override
    public boolean exists() throws IOException {
        GetIndexRequest request = new GetIndexRequest("datasets");
//        request.indices("datasets");
        return this.getClient().indices().exists(request, RequestOptions.DEFAULT);
    }
}