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) {
        OrderList resList = new OrderList();
        PageRequest pageRequest = PageRequest.of(order.getPage(), order.getPageSize());
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreNullValues().withIgnorePaths("createAt", "last");

        Example<Order> ep = Example.of(order, matcher);
        Sort s = Sort.by("createAt");

        Flux<Order> flux = orderRepository.findAll(ep, s);
        flux.count().subscribe(c -> resList.setTotal(c));
        Mono<List<Order>> listMono = flux.skip(pageRequest.getOffset()).limitRequest(pageRequest.getPageSize()).collectList();
        return listMono.flatMap(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));
            });
        });
    }
}