package fr.norsys.api.ws.controller;

import fr.norsys.api.ws.dto.CompteursDto;
import fr.norsys.api.ws.dto.DtoWithErrors;
import fr.norsys.api.ws.extern.CongePayeService;
import fr.norsys.api.ws.extern.RttService;
import lombok.extern.slf4j.Slf4j;
import org.javatuples.Pair;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;
import rx.Observable;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

@Slf4j
@RestController
@RequestMapping("/conges")
public class CongesController {

    @Autowired
    private CongePayeService congePayeService;

    @Autowired
    private RttService rttService;

    @RequestMapping(value = "/compteurs", produces = MediaType.APPLICATION_JSON_VALUE)
    public DeferredResult<CompteursDto> getTousLesCompteurs() {
        log.info("Récupération des compteurs");

        CompteursDto compteursDto = new CompteursDto();

        return call(compteursDto,
                Arrays.asList(rttService.getCompteur(), congePayeService.getCompteur()),
                Arrays.<Consumer<Integer>>asList(compteursDto::setRtt, compteursDto::setCp));
    }

    private <T> Observable<T> wrapObservable(Observable<T> observable, DtoWithErrors dto) {
        return observable.onErrorResumeNext(throwable -> {
            dto.getErrors().add(throwable.getMessage());
            log.error("Error", throwable);
            return Observable.just(null);
        });
    }

    private <T extends DtoWithErrors> DeferredResult<T> call(T dto, List<Observable<Integer>> observables, List<Consumer<Integer>> setters) {
        DeferredResult<T> result = new DeferredResult<>();
        Observable<Integer> concat = Observable.concat(Observable.from(observables.stream().map(o -> wrapObservable(o, dto)).collect(Collectors.toList())));
        Observable<Pair<Integer, Consumer<Integer>>> observable = Observable.zip(concat, Observable.from(setters), (value, setter) -> new Pair<>(value, setter));
        observable.subscribe(
                valueAndFunction -> valueAndFunction.getValue1().accept(valueAndFunction.getValue0()),
                e -> {
                    log.error("Observable error", e);
                    result.setErrorResult(e);
                },
                () -> {
                    log.debug("Observable finished");
                    result.setResult(dto);
                });
        return result;
    }
}