def compute_km_for_entry(
    journey_profile_id: str | None,
    journeys: dict,
    motor_vehicle_id: str | None = None,
) -> dict[str, int]:
    """
    Calcule les distances parcourues par véhicule pour une entrée de journal donnée.

    Cette fonction associe un profil de trajet à ses distances configurées. Si le profil
    contient une clé générique 'moteur', celle-ci est remplacée par l'identifiant réel du
    véhicule motorisé (`motor_vehicle_id`) s'il est fourni. Si aucun véhicule motorisé n'est
    fourni, la distance associée à la clé 'moteur' est ignorée.

    Paramètres :
        journey_profile_id (str | None) : L'identifiant du profil de trajet (ex: "domicile_travail").
                                          Si None, retourne un dictionnaire vide.
        journeys (dict) : La configuration des trajets (généralement issue de config.toml).
        motor_vehicle_id (str | None) : L'identifiant du véhicule motorisé utilisé (ex: "citadine").

    Retour :
        dict[str, int] : Un dictionnaire associant chaque identifiant de véhicule (ex: "velo", "citadine")
                         à la distance parcourue en kilomètres.
    """
    if not journey_profile_id:
        return {}
    profile = journeys.get(journey_profile_id, {})
    distances = dict(profile.get("distances", {}))

    if "moteur" in distances:
        motor_km = distances.pop("moteur")
        if motor_vehicle_id:
            distances[motor_vehicle_id] = motor_km
        # Si pas de motor_vehicle_id, la distance moteur est ignorée

    return distances


def compute_co2_grams(km_by_vehicle: dict[str, int], vehicles: dict) -> float:
    """
    Calcule la quantité totale de CO2 émise en grammes pour un ensemble de distances parcourues.

    Paramètres :
        km_by_vehicle (dict[str, int]) : Un dictionnaire associant chaque identifiant de véhicule
                                         à la distance parcourue en kilomètres.
        vehicles (dict) : La configuration des véhicules (généralement issue de config.toml)
                          contenant le taux d'émission de CO2 par kilomètre (`co2_per_km`).

    Retour :
        float : La quantité totale de CO2 émise en grammes.
    """
    total = 0.0
    for vehicle_id, km in km_by_vehicle.items():
        vehicle = vehicles.get(vehicle_id, {})
        co2 = vehicle.get("co2_per_km", 0)
        total += km * co2
    return total


def compute_frais_reels(
    total_km_moteur: float, tranches: list[dict], electric: bool = False
) -> float:
    """
    Calcule le montant des frais réels déductibles selon le barème kilométrique fiscal.

    Le calcul s'effectue tranche par tranche en fonction du kilométrage annuel total parcouru
    avec un véhicule motorisé. Une tranche avec `km_max = 0` signifie l'absence de limite
    supérieure et est conventionnellement la dernière tranche du barème.

    Une majoration de 20 % est appliquée sur le montant final si le véhicule est électrique.

    Paramètres :
        total_km_moteur (float) : Le kilométrage annuel total parcouru avec le véhicule motorisé.
        tranches (list[dict]) : La liste des tranches du barème kilométrique pour la puissance fiscale
                                du véhicule (ex: taux, forfait, km_max).
        electric (bool) : Indique si le véhicule est électrique (applique une majoration de 20 % si True).

    Retour :
        float : Le montant total calculé des frais réels en euros.
    """
    if not tranches or total_km_moteur <= 0:
        return 0.0
    for tranche in tranches:
        km_max = tranche["km_max"]
        if km_max == 0 or total_km_moteur <= km_max:
            result = total_km_moteur * tranche["taux"] + tranche.get("forfait", 0)
            return result * 1.2 if electric else result
    last = tranches[-1]
    result = total_km_moteur * last["taux"] + last.get("forfait", 0)
    return result * 1.2 if electric else result