package pl.bpo.archiwumallegro.services;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import org.elasticsearch.common.collect.Lists;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FilterBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.FacetedPage;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import pl.bpo.archiwumallegro.model.Auction;
import pl.bpo.archiwumallegro.model.index.auctions.AuctionIndex;
import pl.bpo.archiwumallegro.model.index.auctions.AuctionIndexSearchParams;
import pl.bpo.archiwumallegro.repositories.AuctionIndexRepository;
import pl.bpo.archiwumallegro.repositories.AuctionRepository;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.query.FilterBuilders;

import static org.elasticsearch.index.query.FilterBuilders.*;
import org.elasticsearch.index.query.FilteredQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import static org.elasticsearch.index.query.QueryBuilders.*;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.metrics.MetricsAggregationBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import static org.elasticsearch.search.sort.SortOrder.DESC;
import org.elasticsearch.search.suggest.Suggest.Suggestion.Sort;
import org.springframework.data.elasticsearch.core.ResultsExtractor;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import pl.bpo.archiwumallegro.helpers.StoperHelper;

@Service
public class AuctionService {

    private AuctionRepository auctionRepository;
    private AuctionIndexRepository auctionIndexRepository;

    @Autowired
    public AuctionService(AuctionRepository auctionRepository, AuctionIndexRepository auctionIndexRepository) {
        this.auctionRepository = auctionRepository;
        this.auctionIndexRepository = auctionIndexRepository;
    }
    @Autowired
    private ElasticsearchTemplate searchTemplate;

    public Auction findAuctionById(Long auctionId) {
        return auctionRepository.findAuctionById(auctionId);
    }

    public List<Auction> findByUserId(Long userId) {
        return auctionRepository.findAuctionByUserId(userId);
    }

    public NativeSearchQueryBuilder getSearchQuery(AuctionIndexSearchParams searchParams, Pageable pageable) {
        final List<FilterBuilder> filters = Lists.newArrayList();
        final NativeSearchQueryBuilder searchQuery = new NativeSearchQueryBuilder();

        Optional.ofNullable(searchParams.getCategoryId()).ifPresent(v -> filters.add(boolFilter().must(termFilter("cat", v))));
        Optional.ofNullable(searchParams.getCurrency()).ifPresent(v -> filters.add(boolFilter().must(termFilter("curr", v))));
        Optional.ofNullable(searchParams.getTreeCategoryId()).ifPresent(v -> filters.add(boolFilter().must(termFilter("tcat", v))));
        Optional.ofNullable(searchParams.getUid()).ifPresent(v -> filters.add(boolFilter().must(termFilter("uid", v))));
        final BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();

        //access for many uids
        if (searchParams.getUids() != null) {
            if (searchParams.getItemId() != null || searchParams.getTitle() != null) {
                Optional.ofNullable(searchParams.getUids().split(",")).ifPresent(v -> {
                    filters.add(boolFilter().must(termsFilter("uid", v)));
                });
            } else {
                for (String user : searchParams.getUids().split(",")) {
                    boolQueryBuilder.should(queryStringQuery(user).field("uid"));
                }
            }
        }
        //access for many categories
        if (searchParams.getCategories() != null) {
            Optional.ofNullable(searchParams.getCategories().split(",")).ifPresent(v -> {
                filters.add(boolFilter().must(termsFilter("cat", v)));
            });
        }

        if (searchParams.getItemId() != null) {
            boolQueryBuilder.must(queryStringQuery(searchParams.getItemId()).field("_id"));
        }
        if (Optional.ofNullable(searchParams.getTitle()).isPresent()) {
            boolQueryBuilder.must(queryStringQuery(searchParams.getTitle()).analyzeWildcard(true).field("raw.title"));
        }

        if (Optional.ofNullable(searchParams.getStartDateFrom()).isPresent()
                || Optional.ofNullable(searchParams.getStartDateTo()).isPresent()) {

            filters.add(rangeFilter("start_date").from(searchParams.getStartDateFrom()).to(searchParams.getStartDateTo()));
        }

        if (Optional.ofNullable(searchParams.getEndDateFrom()).isPresent()
                || Optional.ofNullable(searchParams.getEndDateTo()).isPresent()) {
            filters.add(rangeFilter("end_date").from(searchParams.getEndDateFrom()).to(searchParams.getEndDateTo()));
        }

        if (Optional.ofNullable(searchParams.getPriceFrom()).isPresent()
                || Optional.ofNullable(searchParams.getPriceTo()).isPresent()) {
            filters.add(rangeFilter("price").from(searchParams.getPriceFrom()).to(searchParams.getPriceTo()));
        }

        searchQuery.withQuery(boolQueryBuilder);

        FilterBuilder[] filterArr = new FilterBuilder[filters.size()];
        filterArr = filters.toArray(filterArr);
        searchQuery.withFilter(andFilter(filterArr));

        if (searchParams.getOrderBy() != null && searchParams.getOrderDir() != null) {
            if (searchParams.getOrderDir().toLowerCase().equals("asc")) {
                searchQuery.withSort(SortBuilders.fieldSort(searchParams.getOrderBy()).order(SortOrder.ASC));
            } else {
                searchQuery.withSort(SortBuilders.fieldSort(searchParams.getOrderBy()).order(SortOrder.DESC));
            }
        }
        if (pageable != null) {
            searchQuery.withPageable(pageable);
        }
        return searchQuery;
    }

    public Map findAllByIndexParams(AuctionIndexSearchParams searchParams, Pageable pageable) {
        List rows = new ArrayList();
        Map response = new HashMap();

        final List<FilterBuilder> filters = Lists.newArrayList();
        final NativeSearchQueryBuilder searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery());
        Optional.ofNullable(searchParams.getCategoryId()).ifPresent(v -> filters.add(boolFilter().must(termFilter("cat", v))));
        Optional.ofNullable(searchParams.getCurrency()).ifPresent(v -> filters.add(boolFilter().must(termFilter("curr", v))));
        Optional.ofNullable(searchParams.getTreeCategoryId()).ifPresent(v -> filters.add(boolFilter().must(termFilter("tcat", v))));
        Optional.ofNullable(searchParams.getUid()).ifPresent(v -> filters.add(boolFilter().must(termFilter("uid", v))));

//        //access for many uids
//        if (searchParams.getUids() != null) {
//            Optional.ofNullable(searchParams.getUids().split(",")).ifPresent(v -> {
//                filters.add(boolFilter().must(termsFilter("uid", v)));
//            });
//        }
//
//        //access for many categories
//        if (searchParams.getCategories() != null) {
//            Optional.ofNullable(searchParams.getCategories().split(",")).ifPresent(v -> {
//                filters.add(boolFilter().must(termsFilter("cat", v)));
//            });
//        }
        final BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
        //access for many uids
        if (searchParams.getUids() != null) {
            if (searchParams.getItemId() != null || searchParams.getTitle() != null) {
                Optional.ofNullable(searchParams.getUids().split(",")).ifPresent(v -> {
                    filters.add(boolFilter().must(termsFilter("uid", v)));
                });
            } else {
                for (String user : searchParams.getUids().split(",")) {
                    boolQueryBuilder.should(queryStringQuery(user).field("uid"));
                }
            }
        }
        //access for many categories
        if (searchParams.getCategories() != null) {
            Optional.ofNullable(searchParams.getCategories().split(",")).ifPresent(v -> {
                filters.add(boolFilter().must(termsFilter("cat", v)));
            });
        }
        if (searchParams.getItemId() != null) {
            boolQueryBuilder.must(queryStringQuery(searchParams.getItemId()).field("_id"));
        }
        if (Optional.ofNullable(searchParams.getTitle()).isPresent()) {
            boolQueryBuilder.must(queryStringQuery(searchParams.getTitle()).analyzeWildcard(true).field("title"));
        }

        if (Optional.ofNullable(searchParams.getStartDateFrom()).isPresent()
                || Optional.ofNullable(searchParams.getStartDateTo()).isPresent()) {
            filters.add(rangeFilter("start_date").from(searchParams.getStartDateFrom()).to(searchParams.getStartDateTo()));
        }

        if (Optional.ofNullable(searchParams.getEndDateFrom()).isPresent()
                || Optional.ofNullable(searchParams.getEndDateTo()).isPresent()) {
            filters.add(rangeFilter("end_date").from(searchParams.getEndDateFrom()).to(searchParams.getEndDateTo()));
        }

        if (Optional.ofNullable(searchParams.getPriceFrom()).isPresent()
                || Optional.ofNullable(searchParams.getPriceTo()).isPresent()) {
            filters.add(rangeFilter("price").from(searchParams.getPriceFrom()).to(searchParams.getPriceTo()));
        }

        searchQuery.withQuery(boolQueryBuilder);

        FilterBuilder[] filterArr = new FilterBuilder[filters.size()];
        filterArr = filters.toArray(filterArr);
        searchQuery.withFilter(andFilter(filterArr));

        if (searchParams.getOrderBy() != null && searchParams.getOrderDir() != null) {
            if (searchParams.getOrderDir().toLowerCase().equals("asc")) {
                searchQuery.withSort(SortBuilders.fieldSort(searchParams.getOrderBy()).order(SortOrder.ASC));
            } else {
                searchQuery.withSort(SortBuilders.fieldSort(searchParams.getOrderBy()).order(SortOrder.DESC));
            }
        }

        String scrollId = searchTemplate.scan(searchQuery.build(), 100000, false);

        Page<AuctionIndex> page = searchTemplate.scroll(scrollId, 500000, AuctionIndex.class);

        if (page.hasContent()) {
            while (true) {
                for (AuctionIndex hit : page.getContent()) {
                    rows.add(auctionRepository.findAuctionById(Long.valueOf(hit.getId())));
                }
                page = searchTemplate.scroll(scrollId, 500000, AuctionIndex.class);
                if (page.hasContent() == false) {
                    break;
                }
            }

        }

        response.put("content", rows);
        return response;
    }

    public Map searchByIndexParams(AuctionIndexSearchParams searchParams, Pageable pageable) {
        Map response = new HashMap();
        NativeSearchQuery searchQuery = this.getSearchQuery(searchParams, pageable).build();

//        Aggregations aggregations = searchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {
//            @Override
//            public Aggregations extract(SearchResponse response) {
//                return response.getAggregations();
//            }
//        });
        final FacetedPage<AuctionIndex> search = auctionIndexRepository.search(searchQuery);

        List<AuctionIndex> content = search.getContent();

        response.put("content", content.stream().map(row -> {
            return Auction.builder()
                    .cat(row.getCat())
                    .item(Long.parseLong(row.getId()))
                    .endts(row.getEnd_date())
                    .startts(row.getStart_date())
                    .loc(row.getLoc())
                    .pow(row.getPow())
                    .woj(row.getWoj())
                    .price(row.getPrice())
                    .qty(row.getQty())
                    .title(row.getTitle())
                    .user(row.getUid())
                    .catName(row.getCat_name())
                    .build();
        }).collect(Collectors.toList()));

//        response.put("content", search.map(index -> auctionRepository
//                .findAuctionById(Long.valueOf(index.getId())))
//                .getContent());
        response.put("first", search.isFirst());
        response.put("last", search.isLast());
        response.put("number", search.getNumber());
        response.put("numberOfElements", search.getNumberOfElements());
        response.put("size", search.getSize());
        response.put("sort", search.getSort());
        response.put("totalElements", search.getTotalElements());
        response.put("totalPages", search.getTotalPages());

        return response;
    }
}