package fr.titionfire.ffsaf.domain.service;

import fr.titionfire.ffsaf.data.model.LicenceModel;
import fr.titionfire.ffsaf.data.model.MembreModel;
import fr.titionfire.ffsaf.data.repository.CombRepository;
import fr.titionfire.ffsaf.data.repository.LicenceRepository;
import fr.titionfire.ffsaf.rest.from.LicenceForm;
import fr.titionfire.ffsaf.utils.Utils;
import io.quarkus.hibernate.reactive.panache.Panache;
import io.quarkus.hibernate.reactive.panache.common.WithSession;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.unchecked.Unchecked;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.BadRequestException;
import org.eclipse.microprofile.jwt.JsonWebToken;
import org.hibernate.reactive.mutiny.Mutiny;

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

@WithSession
@ApplicationScoped
public class LicenceService {

    @Inject
    LicenceRepository repository;

    @Inject
    CombRepository combRepository;

    public Uni<List<LicenceModel>> getLicence(long id, Consumer<MembreModel> checkPerm) {
        return combRepository.findById(id).invoke(checkPerm).chain(combRepository -> Mutiny.fetch(combRepository.getLicences()));
    }

    public Uni<List<LicenceModel>> getCurrentSaisonLicence(JsonWebToken idToken) {
        if (idToken == null)
            return repository.find("saison = ?1", Utils.getSaison()).list();

        return combRepository.find("userId = ?1", idToken.getSubject()).firstResult().map(MembreModel::getClub)
                .chain(clubModel -> combRepository.find("club = ?1", clubModel).list())
                .chain(membres -> repository.find("saison = ?1 AND membre IN ?2", Utils.getSaison(), membres).list());
    }

    public Uni<LicenceModel> setLicence(long id, LicenceForm form) {
        if (form.getId() == -1) {
            return combRepository.findById(id).chain(combRepository -> {
                LicenceModel model = new LicenceModel();
                model.setMembre(combRepository);
                model.setSaison(form.getSaison());
                model.setCertificate(form.isCertificate());
                model.setValidate(form.isValidate());
                return Panache.withTransaction(() -> repository.persist(model));
            });
        } else {
            return repository.findById(form.getId()).chain(model -> {
                model.setCertificate(form.isCertificate());
                model.setValidate(form.isValidate());
                return Panache.withTransaction(() -> repository.persist(model));
            });
        }
    }

    public Uni<?> deleteLicence(long id) {
        return Panache.withTransaction(() -> repository.deleteById(id));
    }

    public Uni<LicenceModel> askLicence(long id, LicenceForm form, Consumer<MembreModel> checkPerm) {
        return combRepository.findById(id).invoke(checkPerm).chain(membreModel -> {
            if (form.getId() == -1) {
                return repository.find("saison = ?1 AND membre = ?2", Utils.getSaison(), membreModel).count().invoke(Unchecked.consumer(count -> {
                    if (count > 0)
                        throw new BadRequestException();
                })).chain(__ -> combRepository.findById(id).chain(combRepository -> {
                    LicenceModel model = new LicenceModel();
                    model.setMembre(combRepository);
                    model.setSaison(Utils.getSaison());
                    model.setCertificate(form.isCertificate());
                    model.setValidate(false);
                    return Panache.withTransaction(() -> repository.persist(model));
                }));
            } else {
                return repository.findById(form.getId()).chain(model -> {
                    model.setCertificate(form.isCertificate());
                    return Panache.withTransaction(() -> repository.persist(model));
                });
            }
        });
    }

    public Uni<?> deleteAskLicence(long id, Consumer<MembreModel> checkPerm) {
        return repository.findById(id)
                .call(licenceModel -> Mutiny.fetch(licenceModel.getMembre()).invoke(checkPerm))
                .chain(__ -> Panache.withTransaction(() -> repository.deleteById(id)));
    }
}