SchotzIAD/backend/SchotzIadKmTracker.Api/Services/MontantRegleService.cs

using Microsoft.EntityFrameworkCore;
using SchotzIadKmTracker.Api.Data;
using SchotzIadKmTracker.Api.Models.DTOs;
using SchotzIadKmTracker.Api.Models.Entities;
using SchotzIadKmTracker.Api.Services.Exceptions;

namespace SchotzIadKmTracker.Api.Services;

/// <inheritdoc />
public class MontantRegleService : IMontantRegleService
{
    private const decimal TauxPrevisionnel = 0.80m;

    private readonly AppDbContext _context;
    private readonly IBaremeService _baremeService;
    private readonly IPrecisionDistanceService _precisionDistanceService;

    public MontantRegleService(
        AppDbContext context, IBaremeService baremeService, IPrecisionDistanceService precisionDistanceService)
    {
        _context = context;
        _baremeService = baremeService;
        _precisionDistanceService = precisionDistanceService;
    }

    /// <inheritdoc />
    public async Task<MontantRegleDto> UpsertMontantRegleAsync(
        MontantRegleDto dto, CancellationToken cancellationToken = default)
    {
        // Défense en profondeur : le validateur FluentValidation impose déjà Montant >= 0,
        // mais le service refuse aussi les montants négatifs (Exigence 14.4).
        if (dto.Montant < 0m)
        {
            throw new MontantRegleNegatifException("Le montant réglé ne peut pas être négatif.");
        }

        // Upsert par la clé métier (Annee, Mois, VehiculeId) — index unique
        // UX_MontantsRegles_Periode_Vehicule garantit l'unicité (Property 26, Exigence 14.3).
        var existant = await _context.MontantsRegles
            .FirstOrDefaultAsync(
                m => m.Annee == dto.Annee && m.Mois == dto.Mois && m.VehiculeId == dto.VehiculeId,
                cancellationToken);

        if (existant is null)
        {
            var montantRegle = new MontantRegle
            {
                Annee = dto.Annee,
                Mois = dto.Mois,
                VehiculeId = dto.VehiculeId,
                Montant = dto.Montant,
                UpdatedAt = DateTime.UtcNow,
            };

            _context.MontantsRegles.Add(montantRegle);
            await _context.SaveChangesAsync(cancellationToken);

            return ToDto(montantRegle);
        }

        existant.Montant = dto.Montant;
        existant.UpdatedAt = DateTime.UtcNow;
        await _context.SaveChangesAsync(cancellationToken);

        return ToDto(existant);
    }

    /// <inheritdoc />
    public async Task<IReadOnlyList<MontantRegleDto>> GetMontantsReglesAsync(
        int annee, int vehiculeId, CancellationToken cancellationToken = default)
    {
        var montants = await _context.MontantsRegles
            .AsNoTracking()
            .Where(m => m.Annee == annee && m.VehiculeId == vehiculeId)
            .OrderBy(m => m.Mois)
            .ToListAsync(cancellationToken);

        return montants.Select(ToDto).ToList();
    }

    /// <inheritdoc />
    public async Task<MontantPrevisionnelDto> GetMontantPrevisionnelAsync(
        int annee, int mois, int vehiculeId, CancellationToken cancellationToken = default)
    {
        // Puissance fiscale du véhicule concerné : détermine la tranche du barème.
        var vehicule = await _context.Vehicules
            .AsNoTracking()
            .FirstOrDefaultAsync(v => v.Id == vehiculeId, cancellationToken)
            ?? throw new VehiculeNotFoundException($"Le véhicule d'identifiant {vehiculeId} est introuvable.");

        var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken);

        // Trajets de l'année pour ce véhicule, jusqu'au mois sélectionné inclus (les mois
        // postérieurs sont exclus). SQLite ne sait pas appliquer SUM sur une colonne decimal :
        // on ramène les trajets concernés et on somme côté client (distance null traitée comme 0).
        // Le mois de chaque trajet est conservé pour distinguer le mois affiché du cumul annuel.
        var trajets = await _context.Trajets
            .AsNoTracking()
            .Where(t => t.VehiculeId == vehiculeId
                        && t.Date.Year == annee
                        && t.Date.Month <= mois)
            .Select(t => new { t.Date.Month, t.Distance, t.AllerRetour })
            .ToListAsync(cancellationToken);

        // Distance_Effective_Arrondie : arrondi de la distance simple à la précision courante,
        // PUIS doublement si aller/retour (arrondi avant doublement — Exigence 4.2).
        decimal DistanceArrondie(decimal? distance, bool allerRetour) =>
            _precisionDistanceService.ArrondirDistance(distance ?? 0m, precision) * (allerRetour ? 2m : 1m);

        // Total_Mois_Km : somme des distances déjà arrondies des trajets du mois affiché (Exigence 7.1).
        var totalMoisAffiche = trajets
            .Where(t => t.Month == mois)
            .Sum(t => DistanceArrondie(t.Distance, t.AllerRetour));

        // Total_Annuel_Partiel : somme des distances déjà arrondies de tous les trajets chargés
        // (cumul jusqu'au mois inclus — Exigence 6.2).
        var totalAnnuelPartiel = trajets.Sum(t => DistanceArrondie(t.Distance, t.AllerRetour));

        // La tranche de barème est déterminée par le cumul annuel (Exigence 7.2), et son
        // coefficient/base est réutilisé tel quel pour le mois affiché (pas de nouvel appel à
        // CalculerMontantAsync avec le total du mois seul : cela re-sélectionnerait une tranche
        // différente selon le mois seul au lieu de la tranche du cumul annuel, ce qui serait faux).
        var baremeAnnuel = await _baremeService.CalculerMontantAsync(
            annee, vehicule.PuissanceFiscale, totalAnnuelPartiel, cancellationToken);

        var montantMoisSelonTrancheAnnuelle = totalMoisAffiche * baremeAnnuel.Coefficient + baremeAnnuel.Base;

        // Montant_Previsionnel_Mensuel = 80% du barème (tranche du cumul annuel) appliqué au mois affiché.
        var montantPrevisionnelMensuel = Math.Round(
            montantMoisSelonTrancheAnnuelle * TauxPrevisionnel, 2, MidpointRounding.AwayFromZero);

        // Montant_Previsionnel_Annuel = 100% du barème plein appliqué au cumul annuel.
        var montantPrevisionnelAnnuel = Math.Round(baremeAnnuel.Montant, 2, MidpointRounding.AwayFromZero);

        return new MontantPrevisionnelDto(
            Annee: annee,
            Mois: mois,
            VehiculeId: vehiculeId,
            TotalMoisKm: totalMoisAffiche,
            TotalAnnuelPartielKm: totalAnnuelPartiel,
            MontantPrevisionnelMensuel: montantPrevisionnelMensuel,
            MontantPrevisionnelAnnuel: montantPrevisionnelAnnuel);
    }

    private static MontantRegleDto ToDto(MontantRegle m) =>
        new(m.Annee, m.Mois, m.VehiculeId, m.Montant);
}