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.data.repository.SequenceRepository;
import fr.titionfire.ffsaf.rest.exception.DBadRequestException;
import fr.titionfire.ffsaf.rest.from.LicenceForm;
import fr.titionfire.ffsaf.utils.SecurityCtx;
import fr.titionfire.ffsaf.utils.SequenceType;
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 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;

    @Inject
    SequenceRepository sequenceRepository;

    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(SecurityCtx securityCtx) {
        if (securityCtx == null || securityCtx.getSubject() == null)
            return repository.find("saison = ?1", Utils.getSaison()).list();

        return combRepository.find("userId = ?1", securityCtx.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(membreModel -> {
                LicenceModel model = new LicenceModel();
                model.setMembre(membreModel);
                model.setClub_id((membreModel.getClub() == null) ? null : membreModel.getClub().getId());
                model.setSaison(form.getSaison());
                model.setCertificate(form.getCertificate());
                model.setValidate(form.isValidate());
                return Panache.withTransaction(() -> repository.persist(model)
                        .call(m -> (m.isValidate() && membreModel.getLicence() <= 0) ?
                                sequenceRepository.getNextValueInTransaction(SequenceType.Licence)
                                        .invoke(i -> membreModel.setLicence(Math.toIntExact(i)))
                                        .chain(() -> combRepository.persist(membreModel))
                                : Uni.createFrom().nullItem()
                        ));
            });
        } else {
            return repository.findById(form.getId()).chain(model -> {
                model.setCertificate(form.getCertificate());
                model.setValidate(form.isValidate());
                return Panache.withTransaction(() -> repository.persist(model)
                        .call(m -> m.isValidate() ? Mutiny.fetch(m.getMembre())
                                .call(membreModel -> (membreModel.getLicence() <= 0) ?
                                        sequenceRepository.getNextValueInTransaction(SequenceType.Licence)
                                                .invoke(i -> membreModel.setLicence(Math.toIntExact(i)))
                                                .chain(() -> combRepository.persist(membreModel))
                                        : Uni.createFrom().nullItem())
                                : Uni.createFrom().nullItem()
                        ));
            });
        }
    }

    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 DBadRequestException("Licence déjà demandée");
                        })).chain(__ -> combRepository.findById(id).chain(membreModel2 -> {
                            LicenceModel model = new LicenceModel();
                            model.setClub_id((membreModel2.getClub() == null) ? null : membreModel2.getClub().getId());
                            model.setMembre(membreModel2);
                            model.setSaison(Utils.getSaison());
                            model.setCertificate(form.getCertificate());
                            model.setValidate(false);
                            return Panache.withTransaction(() -> repository.persist(model));
                        }));
            } else {
                return repository.findById(form.getId()).chain(model -> {
                    model.setCertificate(form.getCertificate());
                    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))
                .invoke(Unchecked.consumer(licenceModel -> {
                    if (licenceModel.isValidate())
                        throw new DBadRequestException("Impossible de supprimer une licence déjà validée");
                }))
                .chain(__ -> Panache.withTransaction(() -> repository.deleteById(id)));
    }

    public Uni<?> setImport(int licence, int saison, boolean valid) {
        return combRepository.find("licence = ?1", licence).firstResult()
                .chain(membreModel ->
                        repository.find("saison = ?1 AND membre = ?2", saison, membreModel).firstResult()
                                .chain(licenceModel -> {
                                    if (licenceModel != null) {
                                        if (licenceModel.getClub_id() == null)
                                            licenceModel.setClub_id(
                                                    (membreModel.getClub() == null) ? null : membreModel.getClub()
                                                            .getId());
                                        licenceModel.setValidate(valid);
                                        return Panache.withTransaction(() -> repository.persist(licenceModel));
                                    } else {
                                        LicenceModel model = new LicenceModel();
                                        model.setClub_id(
                                                (membreModel.getClub() == null) ? null : membreModel.getClub().getId());
                                        model.setMembre(membreModel);
                                        model.setSaison(saison);
                                        model.setCertificate("¤");
                                        model.setValidate(valid);
                                        return Panache.withTransaction(() -> repository.persist(model));
                                    }
                                }))
                .map(__ -> "OK");
    }
}