package com.wabestway.recall.web;

import com.wabestway.recall.model.Order;
import com.wabestway.recall.model.OrderList;
import com.wabestway.recall.model.Record;
import com.wabestway.recall.model.ResObj;
import com.wabestway.recall.repository.OrderRepository;
import com.wabestway.recall.repository.RecordRepository;
import org.springframework.data.domain.*;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.List;


@RestController
@RequestMapping("/order")
public class OrderController {
    private final RecordRepository recordRepository;
    private final OrderRepository orderRepository;

    public OrderController(RecordRepository recordRepository, OrderRepository orderRepository) {
        this.recordRepository = recordRepository;
        this.orderRepository = orderRepository;
    }

    @GetMapping
    public Flux<Order> getAllOrders() {
        return orderRepository.findAll();
    }

    @PostMapping("/list")
    public Mono<ResObj> list(@RequestBody Order order) {
        PageRequest pageRequest = PageRequest.of(0, 1);
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreNullValues().withIgnorePaths("createAt", "last");

        Example<Order> ep = Example.of(order, matcher);
        Sort s = Sort.by("createAt");
//        Mono<List<Integer>> listMono = flux.collectList();
//        listMono.subscribe(list -> System.out.println(list));
        Flux<Order> flux = orderRepository.findAll(ep, s).skip(pageRequest.getOffset()).limitRate(pageRequest.getPageSize());
        OrderList resList = new OrderList();
        Mono<List<Order>> listMono = flux.collectList();
        listMono.subscribe(list -> resList.setList(list));
        return Mono.just(ResObj.ok(resList));
    }

    @PostMapping("/info/{orderId}")
    public Mono<ResObj> findByOrderId(@PathVariable String orderId) {
        Mono<Order> forder = orderRepository.findByOrderId(orderId);
        return forder.flatMap(fo -> {
            Flux<Record> rs = recordRepository.findAllByTraceIdOrderByCreateAtAsc(fo.getTraceId());
            Mono<List<List<String>>> es = rs.map(rr -> rr.getEvents()).collectList();
            Mono<List<String>> events = es.flatMapIterable(lists -> lists).flatMapIterable(list -> list).collectList();
            return events.flatMap(e -> {
                fo.setEvents(e);
                return Mono.just(ResObj.ok(fo));
            });
        });
    }
}