// ParisService.java
package com.pmumali.jumeleordre.service;

import com.pmumali.jumeleordre.dto.ParisDto;
import com.pmumali.jumeleordre.exception.ParisInvalideException;
import com.pmumali.jumeleordre.model.Cheval;
import com.pmumali.jumeleordre.model.Course;
import com.pmumali.jumeleordre.model.Paris;
import com.pmumali.jumeleordre.repository.ChevalRepository;
import com.pmumali.jumeleordre.repository.CourseRepository;
import com.pmumali.jumeleordre.repository.ParisRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class ParisService {

    private static final double MISE_MINIMUM = 500;
    private static final double MISE_MAXIMUM_PAR_PARIS = 20 * MISE_MINIMUM;

    @Autowired
    private ParisRepository parisRepository;

    @Autowired
    private CourseRepository courseRepository;

    @Autowired
    private ChevalRepository chevalRepository;

    @Transactional
    public Paris enregistrerParis(ParisDto parisDto) throws ParisInvalideException {
        Course course = courseRepository.findById(parisDto.getIdCourse())
                .orElseThrow(() -> new ParisInvalideException("Course non trouvée"));

        if (course.isEstTerminee()) {
            throw new ParisInvalideException("Impossible de parier sur une course terminée");
        }

        Cheval premier = chevalRepository.findById(parisDto.getIdChevalPremier())
                .orElseThrow(() -> new ParisInvalideException("Cheval premier non trouvé"));

        Cheval deuxieme = chevalRepository.findById(parisDto.getIdChevalDeuxieme())
                .orElseThrow(() -> new ParisInvalideException("Cheval deuxième non trouvé"));

        if (premier.equals(deuxieme)) {
            throw new ParisInvalideException("Impossible de parier sur le même cheval pour les deux positions");
        }

        if (premier.isNonPartant() || deuxieme.isNonPartant()) {
            throw new ParisInvalideException("Impossible de parier sur des chevaux non partants");
        }

        if (parisDto.getMise() < MISE_MINIMUM) {
            throw new ParisInvalideException("La mise doit être d'au moins " + MISE_MINIMUM + " FCFA");
        }

        // Vérification du total des mises sur cette combinaison
        double totalMisesCombinaison = parisRepository.findByCourseIdAndStatut(course.getId(), Paris.StatutParis.EN_ATTENTE)
                .stream()
                .filter(p -> p.getPremier().equals(premier) && p.getDeuxieme().equals(deuxieme))
                .mapToDouble(Paris::getMise)
                .sum();

        if (totalMisesCombinaison + parisDto.getMise() > MISE_MAXIMUM_PAR_PARIS) {
            throw new ParisInvalideException("Mise maximale pour cette combinaison dépassée");
        }

        Paris paris = new Paris();
        paris.setCourse(course);
        paris.setPremier(premier);
        paris.setDeuxieme(deuxieme);
        paris.setMise(parisDto.getMise());
        paris.setDateParis(LocalDateTime.now());
        paris.setIdParieur(parisDto.getIdParieur());
        paris.setStatut(Paris.StatutParis.EN_ATTENTE);

        return parisRepository.save(paris);
    }

    public List<Paris> getParisParParieur(String idParieur) {
        return parisRepository.findByIdParieur(idParieur);
    }
}