875 lines
39 KiB
Java
875 lines
39 KiB
Java
package com.pmumali.ch10_multi.service;
|
|
|
|
import com.pmumali.ch10_multi.model.*;
|
|
import com.pmumali.ch10_multi.repository.*;
|
|
import lombok.RequiredArgsConstructor;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import java.time.LocalDateTime;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
@Service
|
|
@RequiredArgsConstructor
|
|
public class ServiceMulti {
|
|
|
|
private final PariMultiRepository pariRepository;
|
|
private final CourseMultiRepository courseRepository;
|
|
private final ChevalMultiRepository chevalRepository;
|
|
private final PaiementMultiRepository paiementRepository;
|
|
private final ResultatCourseMultiRepository resultatRepository;
|
|
private final CagnotteMultiRepository cagnotteRepository;
|
|
private final ParieurMultiRepository parieurRepository;
|
|
|
|
private static final Double MISE_BASE = 500.0;
|
|
private static final Double MISE_MAX = 200 * MISE_BASE;
|
|
private static final Integer NOMBRE_CHEVAUX_MINIMUM = 10;
|
|
|
|
// Coefficients pour le calcul des rapports (Article 5)
|
|
private static final Map<TypeMulti, Integer> COEFFICIENTS = Map.of(
|
|
TypeMulti.MULTI_4, 105,
|
|
TypeMulti.MULTI_5, 21,
|
|
TypeMulti.MULTI_6, 7,
|
|
TypeMulti.MULTI_7, 3
|
|
);
|
|
|
|
// Rapports minimum (Article 6)
|
|
private static final Map<TypeMulti, Double> RAPPORTS_MINIMUM = Map.of(
|
|
TypeMulti.MULTI_4, 1.6,
|
|
TypeMulti.MULTI_5, 1.4,
|
|
TypeMulti.MULTI_6, 1.2,
|
|
TypeMulti.MULTI_7, 1.1
|
|
);
|
|
|
|
@Transactional
|
|
public PariMulti placerPari(RequetePariMulti requete) {
|
|
// Validation de la mise
|
|
if (requete.getMise() < MISE_BASE) {
|
|
throw new IllegalArgumentException("La mise doit être au moins " + MISE_BASE + " FCFA");
|
|
}
|
|
|
|
CourseMulti course = courseRepository.findById(requete.getCourseId())
|
|
.orElseThrow(() -> new RuntimeException("Course non trouvée"));
|
|
|
|
// Vérification du nombre minimum de chevaux
|
|
if (course.getNombreChevauxPartants() < NOMBRE_CHEVAUX_MINIMUM) {
|
|
throw new IllegalArgumentException("La course doit avoir au moins " + NOMBRE_CHEVAUX_MINIMUM + " chevaux partants");
|
|
}
|
|
|
|
List<ChevalMulti> chevaux = chevalRepository.findAllById(requete.getChevalIds());
|
|
|
|
// Validation du nombre de chevaux selon le type MULTI
|
|
validerNombreChevaux(requete.getTypeMulti(), chevaux.size());
|
|
|
|
// Vérification des non-partants
|
|
long nonPartants = chevaux.stream().filter(ChevalMulti::getNonPartant).count();
|
|
validerNonPartants(requete.getTypeMulti(), nonPartants);
|
|
|
|
// Limitation de mise selon l'article 2
|
|
Double miseEffective = Math.min(requete.getMise(), MISE_MAX);
|
|
|
|
ParieurMulti parieur = parieurRepository.findById(requete.getParieurId())
|
|
.orElseThrow(() -> new RuntimeException("Parieur non trouvé"));
|
|
|
|
PariMulti pari = PariMulti.builder()
|
|
.course(course)
|
|
.chevauxSelectionnes(chevaux)
|
|
.mise(miseEffective)
|
|
.heurePari(LocalDateTime.now())
|
|
.typeMulti(requete.getTypeMulti())
|
|
.typeFormule(requete.getTypeFormule())
|
|
.parieur(parieur)
|
|
.nombreChevauxBase(requete.getNombreChevauxBase())
|
|
.build();
|
|
|
|
return pariRepository.save(pari);
|
|
}
|
|
|
|
private void validerNombreChevaux(TypeMulti typeMulti, int nombreChevaux) {
|
|
switch (typeMulti) {
|
|
case MULTI_4:
|
|
if (nombreChevaux != 4) throw new IllegalArgumentException("MULTI en 4 nécessite exactement 4 chevaux");
|
|
break;
|
|
case MULTI_5:
|
|
if (nombreChevaux != 5) throw new IllegalArgumentException("MULTI en 5 nécessite exactement 5 chevaux");
|
|
break;
|
|
case MULTI_6:
|
|
if (nombreChevaux != 6) throw new IllegalArgumentException("MULTI en 6 nécessite exactement 6 chevaux");
|
|
break;
|
|
case MULTI_7:
|
|
if (nombreChevaux != 7) throw new IllegalArgumentException("MULTI en 7 nécessite exactement 7 chevaux");
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void validerNonPartants(TypeMulti typeMulti, long nonPartants) {
|
|
switch (typeMulti) {
|
|
case MULTI_4:
|
|
if (nonPartants >= 1) throw new IllegalArgumentException("MULTI en 4 ne permet pas de chevaux non-partants");
|
|
break;
|
|
case MULTI_5:
|
|
if (nonPartants >= 2) throw new IllegalArgumentException("MULTI en 5 permet maximum 1 cheval non-partant");
|
|
break;
|
|
case MULTI_6:
|
|
if (nonPartants >= 3) throw new IllegalArgumentException("MULTI en 6 permet maximum 2 chevaux non-partants");
|
|
break;
|
|
case MULTI_7:
|
|
if (nonPartants >= 4) throw new IllegalArgumentException("MULTI en 7 permet maximum 3 chevaux non-partants");
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Transactional
|
|
public List<ReponsePaiementMulti> calculerPaiements(RequeteResultatMulti requete) {
|
|
ResultatCourseMulti resultat = creerResultat(requete);
|
|
List<PariMulti> paris = pariRepository.findByCourseId(requete.getCourseId());
|
|
List<ReponsePaiementMulti> paiements = new ArrayList<>();
|
|
|
|
// Vérifier si la course a moins de 10 chevaux (Article 1)
|
|
if (resultat.getCourse().getNombreChevauxPartants() < NOMBRE_CHEVAUX_MINIMUM) {
|
|
transfererEnCagnotte(resultat);
|
|
return paiements;
|
|
}
|
|
|
|
// Calcul de la masse à partager selon l'article 5
|
|
Double masseAPartager = calculerMasseAPartager(resultat);
|
|
resultat.setMasseAPartager(masseAPartager);
|
|
resultatRepository.save(resultat);
|
|
|
|
// Gérer les cas de dead-heat si nécessaire
|
|
TypeDeadHeat typeDeadHeat = detecterDeadHeat(resultat);
|
|
if (typeDeadHeat != null) {
|
|
return gererDeadHeat(resultat, typeDeadHeat);
|
|
}
|
|
|
|
// Calcul normal des paiements
|
|
Map<TypeMulti, List<PariMulti>> parisGagnantsParType = new HashMap<>();
|
|
Map<TypeMulti, Integer> nombreParisGagnantsParType = new HashMap<>();
|
|
|
|
for (PariMulti pari : paris) {
|
|
ReponsePaiementMulti paiement = calculerPaiementPari(pari, resultat, masseAPartager);
|
|
if (paiement != null) {
|
|
paiements.add(paiement);
|
|
enregistrerPaiement(pari, paiement);
|
|
|
|
// Compter les paris gagnants par type
|
|
TypeMulti typePari = getTypeMultiFromPaiement(paiement.getTypePaiement());
|
|
parisGagnantsParType.computeIfAbsent(typePari, k -> new ArrayList<>()).add(pari);
|
|
nombreParisGagnantsParType.put(typePari,
|
|
nombreParisGagnantsParType.getOrDefault(typePari, 0) + 1);
|
|
}
|
|
}
|
|
|
|
// Appliquer les règles de rapport minimum (Article 6)
|
|
appliquerReglesRapportMinimum(paiements, masseAPartager, nombreParisGagnantsParType);
|
|
|
|
return paiements;
|
|
}
|
|
|
|
private ReponsePaiementMulti calculerPaiementPari(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
|
|
long nonPartants = chevauxPari.stream().filter(ChevalMulti::getNonPartant).count();
|
|
|
|
// Article 4: Gestion des non-partants et transformations
|
|
if (doitEtreRembourse(pari.getTypeMulti(), nonPartants)) {
|
|
return new ReponsePaiementMulti(pari.getId(), pari.getMise(),
|
|
TypePaiementMulti.REMBOURSEMENT, "Remboursement selon article 4");
|
|
}
|
|
|
|
// Transformer les paris avec non-partants (Article 4)
|
|
TypeMulti typeTransforme = transformerPari(pari.getTypeMulti(), nonPartants);
|
|
List<ChevalMulti> chevauxParticipants = chevauxPari.stream()
|
|
.filter(cheval -> !cheval.getNonPartant())
|
|
.collect(Collectors.toList());
|
|
|
|
// Vérifier si les chevaux sont dans les 4 premiers
|
|
boolean estGagnant = estCombinaisonGagnante(chevauxParticipants, resultat);
|
|
|
|
if (estGagnant) {
|
|
Double montant = calculerMontantPari(typeTransforme, masseAPartager);
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(typeTransforme);
|
|
return new ReponsePaiementMulti(pari.getId(), montant, typePaiement,
|
|
"Paiement MULTI " + typeTransforme + " transformé");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private boolean doitEtreRembourse(TypeMulti typeMulti, long nonPartants) {
|
|
switch (typeMulti) {
|
|
case MULTI_4: return nonPartants >= 1;
|
|
case MULTI_5: return nonPartants >= 2;
|
|
case MULTI_6: return nonPartants >= 3;
|
|
case MULTI_7: return nonPartants >= 4;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
private TypeMulti transformerPari(TypeMulti typeOriginal, long nonPartants) {
|
|
// Article 4: Transformations des paris avec non-partants
|
|
if (nonPartants == 0) return typeOriginal;
|
|
|
|
switch (typeOriginal) {
|
|
case MULTI_5:
|
|
return nonPartants == 1 ? TypeMulti.MULTI_4 : typeOriginal;
|
|
case MULTI_6:
|
|
if (nonPartants == 1) return TypeMulti.MULTI_5;
|
|
if (nonPartants == 2) return TypeMulti.MULTI_4;
|
|
return typeOriginal;
|
|
case MULTI_7:
|
|
if (nonPartants == 1) return TypeMulti.MULTI_6;
|
|
if (nonPartants == 2) return TypeMulti.MULTI_5;
|
|
if (nonPartants == 3) return TypeMulti.MULTI_4;
|
|
return typeOriginal;
|
|
default:
|
|
return typeOriginal;
|
|
}
|
|
}
|
|
|
|
private boolean estCombinaisonGagnante(List<ChevalMulti> chevauxPari, ResultatCourseMulti resultat) {
|
|
// Vérifier si au moins 4 chevaux sont dans les 4 premiers
|
|
long countDansTop4 = chevauxPari.stream()
|
|
.filter(cheval -> estDansTop4(cheval, resultat))
|
|
.count();
|
|
return countDansTop4 >= 4;
|
|
}
|
|
|
|
private boolean estDansTop4(ChevalMulti cheval, ResultatCourseMulti resultat) {
|
|
return estDansListe(cheval, resultat.getPremiers()) ||
|
|
estDansListe(cheval, resultat.getSeconds()) ||
|
|
estDansListe(cheval, resultat.getTroisiemes()) ||
|
|
estDansListe(cheval, resultat.getQuatriemes());
|
|
}
|
|
|
|
private boolean estDansListe(ChevalMulti cheval, List<ChevalMulti> liste) {
|
|
return liste != null && liste.contains(cheval);
|
|
}
|
|
|
|
private Double calculerMontantPari(TypeMulti typeMulti, Double masseAPartager) {
|
|
// Article 5: Calcul basé sur les coefficients
|
|
int coefficient = COEFFICIENTS.get(typeMulti);
|
|
|
|
// Calcul simplifié - en réalité, il faudrait compter le nombre de paris gagnants
|
|
return (masseAPartager * 0.25) / coefficient; // 25% de la masse pour chaque type
|
|
}
|
|
|
|
private TypePaiementMulti getTypePaiementFromTypeMulti(TypeMulti typeMulti) {
|
|
switch (typeMulti) {
|
|
case MULTI_4: return TypePaiementMulti.MULTI_4;
|
|
case MULTI_5: return TypePaiementMulti.MULTI_5;
|
|
case MULTI_6: return TypePaiementMulti.MULTI_6;
|
|
case MULTI_7: return TypePaiementMulti.MULTI_7;
|
|
default: return TypePaiementMulti.REMBOURSEMENT;
|
|
}
|
|
}
|
|
|
|
private TypeMulti getTypeMultiFromPaiement(TypePaiementMulti typePaiement) {
|
|
switch (typePaiement) {
|
|
case MULTI_4: return TypeMulti.MULTI_4;
|
|
case MULTI_5: return TypeMulti.MULTI_5;
|
|
case MULTI_6: return TypeMulti.MULTI_6;
|
|
case MULTI_7: return TypeMulti.MULTI_7;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
private void appliquerReglesRapportMinimum(List<ReponsePaiementMulti> paiements, Double masseAPartager,
|
|
Map<TypeMulti, Integer> nombreParisGagnantsParType) {
|
|
// Article 6: Application des règles de rapport minimum
|
|
|
|
// Étape 1: Vérifier MULTI_7
|
|
Double rapportMulti7 = calculerRapportMoyen(paiements, TypeMulti.MULTI_7);
|
|
if (rapportMulti7 < RAPPORTS_MINIMUM.get(TypeMulti.MULTI_7)) {
|
|
ajusterRapportsMulti7(paiements, masseAPartager, nombreParisGagnantsParType);
|
|
// Recalculer après ajustement
|
|
rapportMulti7 = RAPPORTS_MINIMUM.get(TypeMulti.MULTI_7);
|
|
}
|
|
|
|
// Étape 2: Vérifier MULTI_6
|
|
Double rapportMulti6 = calculerRapportMoyen(paiements, TypeMulti.MULTI_6);
|
|
if (rapportMulti6 < RAPPORTS_MINIMUM.get(TypeMulti.MULTI_6)) {
|
|
ajusterRapportsMulti6(paiements, masseAPartager, nombreParisGagnantsParType);
|
|
rapportMulti6 = RAPPORTS_MINIMUM.get(TypeMulti.MULTI_6);
|
|
}
|
|
|
|
// Étape 3: Vérifier MULTI_5
|
|
Double rapportMulti5 = calculerRapportMoyen(paiements, TypeMulti.MULTI_5);
|
|
if (rapportMulti5 < RAPPORTS_MINIMUM.get(TypeMulti.MULTI_5)) {
|
|
ajusterRapportsMulti5(paiements, masseAPartager, nombreParisGagnantsParType);
|
|
rapportMulti5 = RAPPORTS_MINIMUM.get(TypeMulti.MULTI_5);
|
|
}
|
|
|
|
// Étape 4: Vérifier MULTI_4
|
|
Double rapportMulti4 = calculerRapportMoyen(paiements, TypeMulti.MULTI_4);
|
|
if (rapportMulti4 < RAPPORTS_MINIMUM.get(TypeMulti.MULTI_4)) {
|
|
ajusterRapportsMulti4(paiements, masseAPartager, nombreParisGagnantsParType);
|
|
}
|
|
}
|
|
|
|
private Double calculerRapportMoyen(List<ReponsePaiementMulti> paiements, TypeMulti typeMulti) {
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(typeMulti);
|
|
List<ReponsePaiementMulti> paiementsType = paiements.stream()
|
|
.filter(p -> p.getTypePaiement() == typePaiement)
|
|
.collect(Collectors.toList());
|
|
|
|
if (paiementsType.isEmpty()) {
|
|
return 0.0;
|
|
}
|
|
|
|
return paiementsType.stream()
|
|
.mapToDouble(ReponsePaiementMulti::getMontant)
|
|
.average()
|
|
.orElse(0.0);
|
|
}
|
|
|
|
private void ajusterRapportsMulti7(List<ReponsePaiementMulti> paiements, Double masseAPartager,
|
|
Map<TypeMulti, Integer> nombreParisGagnantsParType) {
|
|
// Article 6.1: Ajustement MULTI_7
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(TypeMulti.MULTI_7);
|
|
int nombreGagnants = nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_7, 0);
|
|
|
|
if (nombreGagnants > 0) {
|
|
Double montantTotal = RAPPORTS_MINIMUM.get(TypeMulti.MULTI_7) * nombreGagnants;
|
|
|
|
// Ajuster les montants
|
|
for (ReponsePaiementMulti paiement : paiements) {
|
|
if (paiement.getTypePaiement() == typePaiement) {
|
|
paiement.setMontant(RAPPORTS_MINIMUM.get(TypeMulti.MULTI_7));
|
|
}
|
|
}
|
|
|
|
// Réduire la masse à partager
|
|
masseAPartager -= montantTotal;
|
|
}
|
|
}
|
|
|
|
private void ajusterRapportsMulti6(List<ReponsePaiementMulti> paiements, Double masseAPartager,
|
|
Map<TypeMulti, Integer> nombreParisGagnantsParType) {
|
|
// Article 6.2: Ajustement MULTI_6
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(TypeMulti.MULTI_6);
|
|
int nombreGagnants = nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_6, 0);
|
|
|
|
if (nombreGagnants > 0) {
|
|
// Calculer le rapport de base
|
|
Double rapportBase = masseAPartager / (nombreGagnants * 1 +
|
|
nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_5, 0) * 3 +
|
|
nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_4, 0) * 15);
|
|
|
|
// Ajuster les montants
|
|
for (ReponsePaiementMulti paiement : paiements) {
|
|
TypeMulti typeMulti = getTypeMultiFromPaiement(paiement.getTypePaiement());
|
|
if (typeMulti == TypeMulti.MULTI_6) {
|
|
paiement.setMontant(rapportBase);
|
|
} else if (typeMulti == TypeMulti.MULTI_5) {
|
|
paiement.setMontant(rapportBase * 3);
|
|
} else if (typeMulti == TypeMulti.MULTI_4) {
|
|
paiement.setMontant(rapportBase * 15);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ajusterRapportsMulti5(List<ReponsePaiementMulti> paiements, Double masseAPartager,
|
|
Map<TypeMulti, Integer> nombreParisGagnantsParType) {
|
|
// Article 6.3: Ajustement MULTI_5
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(TypeMulti.MULTI_5);
|
|
int nombreGagnants = nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_5, 0);
|
|
|
|
if (nombreGagnants > 0) {
|
|
// Calculer le rapport de base
|
|
Double rapportBase = masseAPartager / (nombreGagnants * 1 +
|
|
nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_4, 0) * 5);
|
|
|
|
// Ajuster les montants
|
|
for (ReponsePaiementMulti paiement : paiements) {
|
|
TypeMulti typeMulti = getTypeMultiFromPaiement(paiement.getTypePaiement());
|
|
if (typeMulti == TypeMulti.MULTI_5) {
|
|
paiement.setMontant(rapportBase);
|
|
} else if (typeMulti == TypeMulti.MULTI_4) {
|
|
paiement.setMontant(rapportBase * 5);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ajusterRapportsMulti4(List<ReponsePaiementMulti> paiements, Double masseAPartager,
|
|
Map<TypeMulti, Integer> nombreParisGagnantsParType) {
|
|
// Article 6.4: Ajustement MULTI_4
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(TypeMulti.MULTI_4);
|
|
int nombreGagnants = nombreParisGagnantsParType.getOrDefault(TypeMulti.MULTI_4, 0);
|
|
|
|
if (nombreGagnants > 0) {
|
|
// Calculer le rapport de base
|
|
Double rapportBase = masseAPartager / nombreGagnants;
|
|
|
|
// Forcer le rapport minimum si nécessaire
|
|
if (rapportBase < RAPPORTS_MINIMUM.get(TypeMulti.MULTI_4)) {
|
|
rapportBase = RAPPORTS_MINIMUM.get(TypeMulti.MULTI_4);
|
|
}
|
|
|
|
// Ajuster les montants
|
|
for (ReponsePaiementMulti paiement : paiements) {
|
|
if (paiement.getTypePaiement() == typePaiement) {
|
|
paiement.setMontant(rapportBase);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Méthodes pour le calcul des combinaisons (Article 7)
|
|
public CalculCombinaisonMulti calculerCombinaison(TypeMulti typeMulti, TypeFormuleMulti typeFormule,
|
|
Integer nombreChevauxTotal, Integer nombreChevauxBase) {
|
|
Integer nombreCombinaisons = calculerNombreCombinaisons(typeMulti, typeFormule, nombreChevauxTotal, nombreChevauxBase);
|
|
Double valeurMise = nombreCombinaisons * MISE_BASE;
|
|
|
|
return CalculCombinaisonMulti.builder()
|
|
.typeMulti(typeMulti)
|
|
.typeFormule(typeFormule)
|
|
.nombreChevauxTotal(nombreChevauxTotal)
|
|
.nombreChevauxBase(nombreChevauxBase)
|
|
.nombreCombinaisons(nombreCombinaisons)
|
|
.valeurMise(valeurMise)
|
|
.build();
|
|
}
|
|
|
|
private Integer calculerNombreCombinaisons(TypeMulti typeMulti, TypeFormuleMulti typeFormule,
|
|
Integer n, Integer p) {
|
|
if (typeFormule == TypeFormuleMulti.UNITAIRE) {
|
|
return 1;
|
|
}
|
|
|
|
// Implémentation des formules de combinaison selon l'article 7
|
|
switch (typeMulti) {
|
|
case MULTI_4:
|
|
return calculerCombinaisonsMulti4(typeFormule, n, p);
|
|
case MULTI_5:
|
|
return calculerCombinaisonsMulti5(typeFormule, n, p);
|
|
case MULTI_6:
|
|
return calculerCombinaisonsMulti6(typeFormule, n, p);
|
|
case MULTI_7:
|
|
return calculerCombinaisonsMulti7(typeFormule, n, p);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private Integer calculerCombinaisonsMulti4(TypeFormuleMulti typeFormule, Integer n, Integer p) {
|
|
if (typeFormule == TypeFormuleMulti.CHAMP_TOTAL) {
|
|
if (p == 3) return n - 3;
|
|
if (p == 2) return (n - 2) * (n - 3) / 2;
|
|
if (p == 1) return (n - 1) * (n - 2) * (n - 3) / 6;
|
|
} else {
|
|
if (p == 3) return p;
|
|
if (p == 2) return p * (p - 1) / 2;
|
|
if (p == 1) return p * (p - 1) * (p - 2) / 6;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private Integer calculerCombinaisonsMulti5(TypeFormuleMulti typeFormule, Integer n, Integer p) {
|
|
if (typeFormule == TypeFormuleMulti.CHAMP_TOTAL) {
|
|
if (p == 4) return n - 4;
|
|
if (p == 3) return (n - 3) * (n - 4) / 2;
|
|
if (p == 2) return (n - 2) * (n - 3) * (n - 4) / 6;
|
|
if (p == 1) return (n - 1) * (n - 2) * (n - 3) * (n - 4) / 24;
|
|
} else {
|
|
if (p == 4) return p;
|
|
if (p == 3) return p * (p - 1) / 2;
|
|
if (p == 2) return p * (p - 1) * (p - 2) / 6;
|
|
if (p == 1) return p * (p - 1) * (p - 2) * (p - 3) / 24;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private Integer calculerCombinaisonsMulti6(TypeFormuleMulti typeFormule, Integer n, Integer p) {
|
|
if (typeFormule == TypeFormuleMulti.CHAMP_TOTAL) {
|
|
if (p == 5) return n - 5;
|
|
if (p == 4) return (n - 4) * (n - 5) / 2;
|
|
if (p == 3) return (n - 3) * (n - 4) * (n - 5) / 6;
|
|
if (p == 2) return (n - 2) * (n - 3) * (n - 4) * (n - 5) / 24;
|
|
if (p == 1) return (n - 1) * (n - 2) * (n - 3) * (n - 4) * (n - 5) / 120;
|
|
} else {
|
|
if (p == 5) return p;
|
|
if (p == 4) return p * (p - 1) / 2;
|
|
if (p == 3) return p * (p - 1) * (p - 2) / 6;
|
|
if (p == 2) return p * (p - 1) * (p - 2) * (p - 3) / 24;
|
|
if (p == 1) return p * (p - 1) * (p - 2) * (p - 3) * (p - 4) / 120;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private Integer calculerCombinaisonsMulti7(TypeFormuleMulti typeFormule, Integer n, Integer p) {
|
|
if (typeFormule == TypeFormuleMulti.CHAMP_TOTAL) {
|
|
if (p == 6) return n - 6;
|
|
if (p == 5) return (n - 5) * (n - 6) / 2;
|
|
if (p == 4) return (n - 4) * (n - 5) * (n - 6) / 6;
|
|
if (p == 3) return (n - 3) * (n - 4) * (n - 5) * (n - 6) / 24;
|
|
if (p == 2) return (n - 2) * (n - 3) * (n - 4) * (n - 5) * (n - 6) / 120;
|
|
if (p == 1) return (n - 1) * (n - 2) * (n - 3) * (n - 4) * (n - 5) * (n - 6) / 720;
|
|
} else {
|
|
if (p == 6) return p;
|
|
if (p == 5) return p * (p - 1) / 2;
|
|
if (p == 4) return p * (p - 1) * (p - 2) / 6;
|
|
if (p == 3) return p * (p - 1) * (p - 2) * (p - 3) / 24;
|
|
if (p == 2) return p * (p - 1) * (p - 2) * (p - 3) * (p - 4) / 120;
|
|
if (p == 1) return p * (p - 1) * (p - 2) * (p - 3) * (p - 4) * (p - 5) / 720;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Gestion des dead-heat (Article 3)
|
|
private TypeDeadHeat detecterDeadHeat(ResultatCourseMulti resultat) {
|
|
if (resultat.getPremiers().size() >= 4) return TypeDeadHeat.QUATRE_PREMIERS_OU_PLUS;
|
|
if (resultat.getPremiers().size() >= 3 && resultat.getQuatriemes().size() >= 1)
|
|
return TypeDeadHeat.TROIS_PREMIERS_UN_QUATRIEME;
|
|
if (resultat.getPremiers().size() >= 2 && resultat.getTroisiemes().size() >= 2)
|
|
return TypeDeadHeat.DEUX_PREMIERS_DEUX_TROISIEMES;
|
|
if (resultat.getPremiers().size() >= 2 && resultat.getTroisiemes().size() == 1 && resultat.getQuatriemes().size() >= 1)
|
|
return TypeDeadHeat.DEUX_PREMIERS_UN_TROISIEME_UN_QUATRIEME;
|
|
if (resultat.getSeconds().size() >= 3)
|
|
return TypeDeadHeat.TROIS_SECONDS_OU_PLUS;
|
|
if (resultat.getSeconds().size() >= 2 && resultat.getQuatriemes().size() >= 1)
|
|
return TypeDeadHeat.DEUX_SECONDS_UN_QUATRIEME;
|
|
if (resultat.getTroisiemes().size() >= 2)
|
|
return TypeDeadHeat.DEUX_TROISIEMES_OU_PLUS;
|
|
if (resultat.getQuatriemes().size() >= 2)
|
|
return TypeDeadHeat.DEUX_QUATRIEMES_OU_PLUS;
|
|
|
|
return null;
|
|
}
|
|
|
|
private List<ReponsePaiementMulti> gererDeadHeat(ResultatCourseMulti resultat, TypeDeadHeat typeDeadHeat) {
|
|
List<PariMulti> paris = pariRepository.findByCourseId(resultat.getCourse().getId());
|
|
List<ReponsePaiementMulti> paiements = new ArrayList<>();
|
|
Double masseAPartager = resultat.getMasseAPartager();
|
|
|
|
for (PariMulti pari : paris) {
|
|
ReponsePaiementMulti paiement = calculerPaiementDeadHeat(pari, resultat, masseAPartager, typeDeadHeat);
|
|
if (paiement != null) {
|
|
paiements.add(paiement);
|
|
enregistrerPaiement(pari, paiement);
|
|
}
|
|
}
|
|
|
|
return paiements;
|
|
}
|
|
|
|
private ReponsePaiementMulti calculerPaiementDeadHeat(PariMulti pari, ResultatCourseMulti resultat,
|
|
Double masseAPartager, TypeDeadHeat typeDeadHeat) {
|
|
// Implémentation spécifique pour chaque type de dead-heat
|
|
switch (typeDeadHeat) {
|
|
case QUATRE_PREMIERS_OU_PLUS:
|
|
return gererDeadHeatQuatrePremiers(pari, resultat, masseAPartager);
|
|
case TROIS_PREMIERS_UN_QUATRIEME:
|
|
return gererDeadHeatTroisPremiersUnQuatrieme(pari, resultat, masseAPartager);
|
|
case DEUX_PREMIERS_DEUX_TROISIEMES:
|
|
return gererDeadHeatDeuxPremiersDeuxTroisiemes(pari, resultat, masseAPartager);
|
|
case DEUX_PREMIERS_UN_TROISIEME_UN_QUATRIEME:
|
|
return gererDeadHeatDeuxPremiersUnTroisiemeUnQuatrieme(pari, resultat, masseAPartager);
|
|
case TROIS_SECONDS_OU_PLUS:
|
|
return gererDeadHeatTroisSeconds(pari, resultat, masseAPartager);
|
|
case DEUX_SECONDS_UN_QUATRIEME:
|
|
return gererDeadHeatDeuxSecondsUnQuatrieme(pari, resultat, masseAPartager);
|
|
case DEUX_TROISIEMES_OU_PLUS:
|
|
return gererDeadHeatDeuxTroisiemes(pari, resultat, masseAPartager);
|
|
case DEUX_QUATRIEMES_OU_PLUS:
|
|
return gererDeadHeatDeuxQuatriemes(pari, resultat, masseAPartager);
|
|
default:
|
|
return calculerPaiementPari(pari, resultat, masseAPartager);
|
|
}
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatQuatrePremiers(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3a: Dead-heat de 4+ chevaux premiers
|
|
List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
|
|
|
|
// Vérifier si tous les chevaux du pari sont parmi les premiers
|
|
if (chevauxPari.stream().allMatch(cheval -> estDansListe(cheval, resultat.getPremiers()))) {
|
|
int nombreCombinaisons = calculerNombreCombinaisonsDeadHeat(resultat.getPremiers().size(), 4);
|
|
Double montant = masseAPartager / nombreCombinaisons;
|
|
return new ReponsePaiementMulti(pari.getId(), montant,
|
|
TypePaiementMulti.MULTI_4, "Dead-Heat 4+ premiers");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatTroisPremiersUnQuatrieme(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3b: Dead-heat de 3 premiers + 1+ quatrième
|
|
List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
|
|
|
|
boolean troisPremiersOk = chevauxPari.subList(0, 3).stream()
|
|
.allMatch(cheval -> estDansListe(cheval, resultat.getPremiers()));
|
|
boolean quatriemeOk = estDansListe(chevauxPari.get(3), resultat.getQuatriemes());
|
|
|
|
if (troisPremiersOk && quatriemeOk) {
|
|
int nombreCombinaisons = resultat.getPremiers().size() * resultat.getQuatriemes().size();
|
|
Double montant = (masseAPartager * 0.4) / (nombreCombinaisons * 6); // 40% pour l'ordre exact, 6 permutations
|
|
return new ReponsePaiementMulti(pari.getId(), montant,
|
|
TypePaiementMulti.MULTI_4, "Dead-Heat 3 premiers + 1 quatrième");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// Implémentations similaires pour les autres types de dead-heat...
|
|
private ReponsePaiementMulti gererDeadHeatDeuxPremiersDeuxTroisiemes(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3c: Implémentation spécifique
|
|
return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 2.0);
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatDeuxPremiersUnTroisiemeUnQuatrieme(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3d: Implémentation spécifique
|
|
return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatTroisSeconds(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3e: Implémentation spécifique
|
|
return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 2.0);
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatDeuxSecondsUnQuatrieme(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3f: Implémentation spécifique
|
|
return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatDeuxTroisiemes(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3g: Implémentation spécifique
|
|
return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
|
|
}
|
|
|
|
private ReponsePaiementMulti gererDeadHeatDeuxQuatriemes(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
|
|
// Article 3h: Implémentation spécifique
|
|
return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
|
|
}
|
|
|
|
private ReponsePaiementMulti calculerPaiementGeneriqueDeadHeat(PariMulti pari, ResultatCourseMulti resultat,
|
|
Double masseAPartager, Double coefficient) {
|
|
// Méthode générique pour les dead-heat avec coefficient spécifique
|
|
List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
|
|
|
|
if (chevauxPari.stream().allMatch(cheval ->
|
|
estDansListe(cheval, resultat.getPremiers()) ||
|
|
estDansListe(cheval, resultat.getSeconds()) ||
|
|
estDansListe(cheval, resultat.getTroisiemes()) ||
|
|
estDansListe(cheval, resultat.getQuatriemes()))) {
|
|
|
|
int nombreCombinaisons = compterCombinaisonsGagnantesDeadHeat(resultat);
|
|
Double montant = (masseAPartager * 0.4) / (nombreCombinaisons * coefficient);
|
|
return new ReponsePaiementMulti(pari.getId(), montant,
|
|
TypePaiementMulti.MULTI_4, "Dead-Heat générique");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private int calculerNombreCombinaisonsDeadHeat(int nombreChevaux, int prise) {
|
|
// Calcul des combinaisons C(n, k)
|
|
if (prise == 0) return 1;
|
|
if (nombreChevaux < prise) return 0;
|
|
|
|
int resultat = 1;
|
|
for (int i = 1; i <= prise; i++) {
|
|
resultat = resultat * (nombreChevaux - i + 1) / i;
|
|
}
|
|
return resultat;
|
|
}
|
|
|
|
private int compterCombinaisonsGagnantesDeadHeat(ResultatCourseMulti resultat) {
|
|
// Comptage simplifié des combinaisons gagnantes
|
|
// Implémentation réelle dépendrait de la structure exacte du dead-heat
|
|
return 1;
|
|
}
|
|
|
|
// Gestion de la cagnotte (Articles 9 et 10)
|
|
private void transfererEnCagnotte(ResultatCourseMulti resultat) {
|
|
CagnotteMulti cagnotte = CagnotteMulti.builder()
|
|
.montant(resultat.getMasseAPartager())
|
|
.dateCreation(LocalDateTime.now())
|
|
.utilisee(false)
|
|
.courseSourceId(resultat.getCourse().getId())
|
|
.build();
|
|
cagnotteRepository.save(cagnotte);
|
|
}
|
|
|
|
@Transactional
|
|
public void utiliserCagnotte(Long cagnotteId, Long courseId) {
|
|
CagnotteMulti cagnotte = cagnotteRepository.findById(cagnotteId)
|
|
.orElseThrow(() -> new RuntimeException("Cagnotte non trouvée"));
|
|
|
|
if (cagnotte.getUtilisee()) {
|
|
throw new RuntimeException("Cagnotte déjà utilisée");
|
|
}
|
|
|
|
cagnotte.setUtilisee(true);
|
|
cagnotte.setDateUtilisation(LocalDateTime.now());
|
|
cagnotteRepository.save(cagnotte);
|
|
|
|
// Ajouter le montant à la masse à partager de la course
|
|
ResultatCourseMulti resultat = resultatRepository.findByCourseId(courseId);
|
|
if (resultat != null) {
|
|
resultat.setMasseAPartager(resultat.getMasseAPartager() + cagnotte.getMontant());
|
|
resultatRepository.save(resultat);
|
|
}
|
|
}
|
|
|
|
// Méthodes utilitaires
|
|
private Double calculerMasseAPartager(ResultatCourseMulti resultat) {
|
|
// Article 5: MAP = RNET - MREMB - PRELEV
|
|
return resultat.getRecetteNette() -
|
|
resultat.getMontantRembourse() -
|
|
resultat.getPrelevementsLegaux();
|
|
}
|
|
|
|
private ResultatCourseMulti creerResultat(RequeteResultatMulti requete) {
|
|
CourseMulti course = courseRepository.findById(requete.getCourseId())
|
|
.orElseThrow(() -> new RuntimeException("Course non trouvée"));
|
|
|
|
return ResultatCourseMulti.builder()
|
|
.course(course)
|
|
.premiers(chevalRepository.findAllById(requete.getPremiersIds()))
|
|
.seconds(chevalRepository.findAllById(requete.getSecondsIds()))
|
|
.troisiemes(chevalRepository.findAllById(requete.getTroisiemesIds()))
|
|
.quatriemes(chevalRepository.findAllById(requete.getQuatriemesIds()))
|
|
.ordreArrivee(chevalRepository.findAllById(requete.getOrdreArriveeIds()))
|
|
.recetteNette(requete.getRecetteNette())
|
|
.prelevementsLegaux(requete.getPrelevementsLegaux())
|
|
.montantRembourse(0.0)
|
|
.build();
|
|
}
|
|
|
|
private void enregistrerPaiement(PariMulti pari, ReponsePaiementMulti reponse) {
|
|
PaiementMulti paiement = PaiementMulti.builder()
|
|
.pari(pari)
|
|
.montant(reponse.getMontant())
|
|
.heurePaiement(LocalDateTime.now())
|
|
.typePaiement(reponse.getTypePaiement())
|
|
.build();
|
|
paiementRepository.save(paiement);
|
|
}
|
|
|
|
// Méthodes supplémentaires pour la gestion des cas particuliers (Article 9)
|
|
@Transactional
|
|
public List<ReponsePaiementMulti> gererCasParticuliers(RequeteResultatMulti requete) {
|
|
ResultatCourseMulti resultat = creerResultat(requete);
|
|
List<PariMulti> paris = pariRepository.findByCourseId(requete.getCourseId());
|
|
|
|
// Article 9: Cas où il n'y a aucune mise sur la combinaison gagnante
|
|
if (!existeParisGagnants(paris, resultat)) {
|
|
return appliquerReglesDegradation(resultat, paris);
|
|
}
|
|
|
|
return calculerPaiements(requete);
|
|
}
|
|
|
|
private boolean existeParisGagnants(List<PariMulti> paris, ResultatCourseMulti resultat) {
|
|
for (PariMulti pari : paris) {
|
|
if (estCombinaisonGagnante(pari.getChevauxSelectionnes(), resultat)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private List<ReponsePaiementMulti> appliquerReglesDegradation(ResultatCourseMulti resultat, List<PariMulti> paris) {
|
|
// Article 9: Application des règles de dégradation
|
|
List<ReponsePaiementMulti> paiements = new ArrayList<>();
|
|
Double masseAPartager = resultat.getMasseAPartager();
|
|
|
|
// Essayer successivement les combinaisons dégradées
|
|
for (int i = 0; i < 4; i++) {
|
|
for (PariMulti pari : paris) {
|
|
ReponsePaiementMulti paiement = calculerPaiementDegrade(pari, resultat, masseAPartager, i);
|
|
if (paiement != null) {
|
|
paiements.add(paiement);
|
|
enregistrerPaiement(pari, paiement);
|
|
return paiements; // On s'arrête au premier succès
|
|
}
|
|
}
|
|
}
|
|
|
|
// Si aucune combinaison dégradée ne fonctionne, transférer en cagnotte
|
|
transfererEnCagnotte(resultat);
|
|
return paiements;
|
|
}
|
|
|
|
private ReponsePaiementMulti calculerPaiementDegrade(PariMulti pari, ResultatCourseMulti resultat,
|
|
Double masseAPartager, int niveauDegradation) {
|
|
// Implémentation des règles de dégradation selon l'article 9
|
|
List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
|
|
|
|
// Vérifier différents patterns de dégradation
|
|
boolean estGagnant = false;
|
|
switch (niveauDegradation) {
|
|
case 0: // 1er, 2ème, 3ème, 5ème
|
|
estGagnant = estPatternDegrade(chevauxPari, resultat, 0, 1, 2, 4);
|
|
break;
|
|
case 1: // 1er, 2ème, 4ème, 5ème
|
|
estGagnant = estPatternDegrade(chevauxPari, resultat, 0, 1, 3, 4);
|
|
break;
|
|
case 2: // 1er, 3ème, 4ème, 5ème
|
|
estGagnant = estPatternDegrade(chevauxPari, resultat, 0, 2, 3, 4);
|
|
break;
|
|
case 3: // 2ème, 3ème, 4ème, 5ème
|
|
estGagnant = estPatternDegrade(chevauxPari, resultat, 1, 2, 3, 4);
|
|
break;
|
|
}
|
|
|
|
if (estGagnant) {
|
|
Double montant = calculerMontantPari(pari.getTypeMulti(), masseAPartager);
|
|
TypePaiementMulti typePaiement = getTypePaiementFromTypeMulti(pari.getTypeMulti());
|
|
return new ReponsePaiementMulti(pari.getId(), montant, typePaiement,
|
|
"Paiement dégradé niveau " + niveauDegradation);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private boolean estPatternDegrade(List<ChevalMulti> chevauxPari, ResultatCourseMulti resultat,
|
|
int pos1, int pos2, int pos3, int pos4) {
|
|
// Vérifier un pattern spécifique de dégradation
|
|
if (resultat.getOrdreArrivee().size() < 5) return false;
|
|
|
|
ChevalMulti cheval1 = resultat.getOrdreArrivee().get(pos1);
|
|
ChevalMulti cheval2 = resultat.getOrdreArrivee().get(pos2);
|
|
ChevalMulti cheval3 = resultat.getOrdreArrivee().get(pos3);
|
|
ChevalMulti cheval4 = resultat.getOrdreArrivee().get(pos4);
|
|
|
|
return chevauxPari.contains(cheval1) &&
|
|
chevauxPari.contains(cheval2) &&
|
|
chevauxPari.contains(cheval3) &&
|
|
chevauxPari.contains(cheval4);
|
|
}
|
|
|
|
// Méthodes pour les statistiques et rapports
|
|
public Map<TypeMulti, Integer> getStatistiquesParis(Long courseId) {
|
|
List<PariMulti> paris = pariRepository.findByCourseId(courseId);
|
|
return paris.stream()
|
|
.collect(Collectors.groupingBy(PariMulti::getTypeMulti,
|
|
Collectors.summingInt(p -> 1)));
|
|
}
|
|
|
|
public Map<TypeFormuleMulti, Integer> getStatistiquesFormules(Long courseId) {
|
|
List<PariMulti> paris = pariRepository.findByCourseId(courseId);
|
|
return paris.stream()
|
|
.collect(Collectors.groupingBy(PariMulti::getTypeFormule,
|
|
Collectors.summingInt(p -> 1)));
|
|
}
|
|
|
|
public Double getMasseAPartagerCourse(Long courseId) {
|
|
ResultatCourseMulti resultat = resultatRepository.findByCourseId(courseId);
|
|
return resultat != null ? resultat.getMasseAPartager() : 0.0;
|
|
}
|
|
|
|
public List<CagnotteMulti> getCagnottesDisponibles() {
|
|
return cagnotteRepository.findByUtilisee(false);
|
|
}
|
|
|
|
public List<PaiementMulti> getHistoriquePaiementsParieur(Long parieurId) {
|
|
List<PariMulti> paris = pariRepository.findByParieurId(parieurId);
|
|
return paris.stream()
|
|
.flatMap(pari -> paiementRepository.findByPariId(pari.getId()).stream())
|
|
.collect(Collectors.toList());
|
|
}
|
|
} |