"""Astreinte : événements, durée réelle arrondie au quart d'heure supérieur, repos de 11h et retour décalé."""
from calcul import (
    compute_week, decompte_astreinte, heures_dues, heures_travaillees, hhmm_to_minutes,
    jour_astreinte_qualifie, exclusion_retour, nominaux_du_jour, fenetre_astreinte_jour,
    retour_apres_repos, regle_journee_astreinte, DEFAULT_PLAGES, PAS_ASTREINTE_MIN,
    ASTREINTE_DEBUT_MIN,
)
import models

HEURES_JOUR_MIN = 468  # 7h48
PLAGES = dict(DEFAULT_PLAGES)


def _pointage(date, matin_entree=None, matin_sortie=None, aprem_entree=None, aprem_sortie=None,
              astreinte_events=None):
    return {
        "date": date,
        "matin_entree": matin_entree, "matin_sortie": matin_sortie,
        "aprem_entree": aprem_entree, "aprem_sortie": aprem_sortie,
        "astreinte_events": astreinte_events,
    }


# ── Qualification ─────────────────────────────────────────────────────────────

def test_jour_astreinte_qualifie():
    astreintes = ["2026-07-14"]
    assert jour_astreinte_qualifie("2026-07-14", astreintes)   # jour d'astreinte
    assert jour_astreinte_qualifie("2026-07-15", astreintes)   # lendemain
    assert not jour_astreinte_qualifie("2026-07-13", astreintes)
    assert not jour_astreinte_qualifie("2026-07-15", [])


# ── Heures dues : exclusion avant l'heure de retour ───────────────────────────

def test_heures_dues_retour_avant_ouverture_sans_effet():
    assert heures_dues("2026-07-13", [], HEURES_JOUR_MIN, PLAGES, hhmm_to_minutes("08:30")) == HEURES_JOUR_MIN


def test_heures_dues_retour_midi_retire_la_presence_du_matin():
    # 13:00 → plage matin 09:00-12:00 (180 min) retirée du décompte
    assert heures_dues("2026-07-13", [], HEURES_JOUR_MIN, PLAGES, hhmm_to_minutes("13:00")) == HEURES_JOUR_MIN - 180


def test_heures_dues_retour_apres_midi_retire_matin_et_partie_aprem():
    # 15:00 → matin (180) + 14:00→15:00 (60)
    assert heures_dues("2026-07-13", [], HEURES_JOUR_MIN, PLAGES, hhmm_to_minutes("15:00")) == HEURES_JOUR_MIN - 240


def test_heures_dues_conge_matin_pas_de_double_exclusion():
    conges = [{"date": "2026-07-13", "type": "matin"}]
    # base = demi-journée aprem (234) ; le matin déjà en congé n'est pas décompté deux fois
    assert heures_dues("2026-07-13", conges, HEURES_JOUR_MIN, PLAGES, hhmm_to_minutes("13:00")) == 234
    assert heures_dues("2026-07-13", conges, HEURES_JOUR_MIN, PLAGES, hhmm_to_minutes("15:00")) == 234 - 60


def test_exclusion_retour_sans_retour():
    assert exclusion_retour(set(), None, PLAGES) == (0, 0)


# ── Heures travaillées : la présence avant le retour ne compte pas ────────────

def test_heures_travaillees_presence_avant_retour_non_comptee():
    p = _pointage("2026-07-13", "09:00", "12:00", "14:00", "18:00")
    # matin 09:00→12:00 entièrement avant le retour 13:00 → 0 ; aprem 14:00→18:00 → 240
    assert heures_travaillees(p, hhmm_to_minutes("13:00")) == 240
    assert heures_travaillees(p) == 180 + 240


def test_heures_travaillees_entree_chevauchant_le_retour():
    p = _pointage("2026-07-13", "08:00", "12:00")
    # entrée décalée à 10:30 → 90 min comptées
    assert heures_travaillees(p, hhmm_to_minutes("10:30")) == 90


# ── Retour au plus tôt après 11h de repos (depuis le dernier événement) ───────

def test_retour_fin_nocturne_sur_le_lendemain():
    """Event 01:00→02:00 saisi sur le lendemain de l'astreinte → retour 13:00."""
    p_by_date = {"2026-07-15": _pointage("2026-07-15",
                                         astreinte_events=[{"debut": "01:00", "fin": "02:00"}])}
    # 02:00 + 11h = 13:00
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 13 * 60


def test_retour_activite_matinale_sur_le_lendemain_qualifie():
    """Event 05:00→06:00 saisi sur le lendemain de l'astreinte : le matin du
    lendemain est dans la fenêtre 18:00→18:00, l'activité s'est terminée à 06:00
    ce jour-là → repos jusqu'à 17:00 le même jour."""
    p_by_date = {"2026-07-15": _pointage("2026-07-15",
                                         astreinte_events=[{"debut": "05:00", "fin": "06:00"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 17 * 60


def test_retour_intervention_avant_18h_sur_le_jour_as_ignoree():
    """L'astreinte couvre 18:00 → 18:00 : une intervention du matin du jour
    déclaré (avant 18:00) n'est pas de l'astreinte et ne déclenche pas de repos."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "10:00", "fin": "12:00"}])}
    assert retour_apres_repos("2026-07-14", p_by_date, PLAGES, ["2026-07-14"]) is None
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) is None


def test_retour_intervention_finissant_avant_18h_la_veille_ignoree():
    """Event 16:00→17:30 la veille déclarée AS : fin 17:30 arrondie 17:30, avant
    le début de la fenêtre (18:00) → pas de contrainte de retour."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "16:00", "fin": "17:30"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) is None


def test_retour_fin_du_soir_sur_le_jour_d_astreinte():
    """Event 21:00→23:30 sur le jour d'astreinte → repos terminé 10:30 le lendemain."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "21:00", "fin": "23:30"}])}
    # 23:30 + 11h = 10:30 le lendemain
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 10 * 60 + 30


def test_retour_fin_hors_quart_arrondie_au_quart_entame():
    """Event 21:00→23:37 : durée réelle 157 min arrondie à 165, fin comptée
    23:45 → repos terminé 10:45 le lendemain."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "21:00", "fin": "23:37"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 10 * 60 + 45


def test_retour_fin_nocturne_hors_quart_arrondie():
    """Event 23:00→01:07 (à cheval sur minuit) : durée 127 min arrondie à 135,
    fin comptée 01:15 → retour 12:15."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "23:00", "fin": "01:07"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 12 * 60 + 15


def test_retour_toujours_sur_un_quart_dhorloge_fixe():
    """Event 22:39→23:49 : durée 70 min arrondie à 75, fin comptée 23:54,
    retour brut 10:54 → arrondi au quart d'horloge fixe supérieur 11:00.
    Le retour tombe toujours sur :00, :15, :30 ou :45."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "22:39", "fin": "23:49"}])}
    retour = retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"])
    assert retour == 11 * 60
    assert retour % PAS_ASTREINTE_MIN == 0

    # Début déjà hors quart : 22:41→23:52 (durée 71 → 75, fin comptée 23:56,
    # retour brut 10:56) → 11:00 également.
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "22:41", "fin": "23:52"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 11 * 60


def test_retour_event_a_cheval_sur_minuit_saisi_la_veille():
    """Event 23:00→01:00 (fin < début) saisi la veille : fin réelle 01:00 le jour
    même → 01:00 + 11h = 12:00."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "23:00", "fin": "01:00"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 12 * 60


def test_retour_nuit_d_astreinte_finissant_au_matin():
    """Event 23:00→06:00 (à cheval sur minuit) sur le jour d'astreinte : fin réelle
    06:00 le lendemain → retour 17:00 le lendemain."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "23:00", "fin": "06:00"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 17 * 60


def test_retour_la_plus_tardive_des_deux_fins_gagne():
    """Fins veille 23:30 (retour 10:30) ET jour 02:00 (retour 13:00) : la plus tardive gagne."""
    p_by_date = {
        "2026-07-14": _pointage("2026-07-14", astreinte_events=[{"debut": "21:00", "fin": "23:30"}]),
        "2026-07-15": _pointage("2026-07-15", astreinte_events=[{"debut": "01:00", "fin": "02:00"}]),
    }
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) == 13 * 60


def test_retour_event_sans_astreinte_ignore():
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "21:00", "fin": "23:30"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, []) is None


def test_retour_fin_tot_ne_contraint_rien():
    """Event 17:15→17:30 → repos terminé 04:30, avant l'ouverture : pas de contrainte."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "17:15", "fin": "17:30"}])}
    assert retour_apres_repos("2026-07-15", p_by_date, PLAGES, ["2026-07-14"]) is None


# ── Décompte astreinte : durée réelle arrondie au quart supérieur, par règle ───

def test_decompte_duree_reelle_arrondie_au_quart_superieur():
    """22:07→22:20 = 13 min réelles → arrondies à 15 min (et non aux tranches
    d'horloge 22:00 et 22:15 qui auraient donné 30)."""
    d = decompte_astreinte("2026-07-13", [{"debut": "22:07", "fin": "22:20"}])
    assert d["tranches"] == 1                    # 15 min = 1 quart d'heure
    assert d["total_min"] == PAS_ASTREINTE_MIN
    assert d["total_h"] == "0h15"
    assert d["categories"][0]["nom"] == "Nuit"   # lundi 22:xx → Nuit ×1,5
    assert d["total_pondere_min"] == 23          # 15 × 1,5


def test_decompte_arrondi_examples_minutes_reelles():
    """2, 5 ou 12 minutes réelles → 15 min ; 22 ou 28 → 30 min — même si
    l'arrondi ne tombe pas juste sur un quart d'heure de l'horloge."""
    for deb, fin, attendu in [("22:00", "22:02", 15), ("22:00", "22:05", 15),
                             ("22:00", "22:12", 15), ("22:00", "22:22", 30),
                             ("22:00", "22:28", 30), ("22:39", "23:49", 75)]:
        d = decompte_astreinte("2026-07-13", [{"debut": deb, "fin": fin}])
        assert d["total_min"] == attendu, f"{deb} → {fin}"


def test_decompte_arrondi_des_bornes():
    """09:50→10:05 = 15 min réelles → 15 min, en Journée ×1."""
    d = decompte_astreinte("2026-07-13", [{"debut": "09:50", "fin": "10:05"}])
    assert d["tranches"] == 1
    assert d["total_min"] == 15
    assert d["categories"][0]["nom"] == "Journée"  # lundi en journée ×1
    assert d["total_pondere_min"] == 15


def test_decompte_evenement_a_cheval_sur_minuit():
    """Mardi 14/07 (férié), 23:00→01:00 : 8 tranches, tout en Nuit ×1,5."""
    d = decompte_astreinte("2026-07-14", [{"debut": "23:00", "fin": "01:00"}])
    assert d["tranches"] == 8                    # 23:00→01:00 = 120 min = 8 × 15
    assert d["total_min"] == 120
    assert d["categories"][0]["nom"] == "Nuit"
    assert d["total_pondere_min"] == 180         # 120 × 1,5


def test_decompte_jour_ferie_en_journee():
    """14 juillet : la journée compte en « Dimanche / férié » ×2."""
    d = decompte_astreinte("2026-07-14", [{"debut": "10:00", "fin": "12:00"}])
    assert d["total_min"] == 120                 # 2h = 8 tranches
    assert d["categories"][0]["nom"] == "Dimanche / férié"
    assert d["total_pondere_min"] == 240         # 120 × 2
    assert d["total_pondere_h"] == "4h00"


def test_decompte_vendredi_vers_samedi_reste_en_nuit():
    """23:00→02:00 le vendredi : 12 tranches, toutes en Nuit (même après minuit)."""
    d = decompte_astreinte("2026-07-17", [{"debut": "23:00", "fin": "02:00"}])
    assert d["tranches"] == 12                   # 180 min
    assert d["total_min"] == 180
    assert [c["nom"] for c in d["categories"]] == ["Nuit"]
    assert d["total_pondere_min"] == 270         # 180 × 1,5


def test_decompte_chevauchement_dedouble():
    """10:00→10:20 et 10:10→10:30 se recouvrent : les minutes réelles communes
    ne comptent qu'une fois (attribuées au premier événement) ; chaque
    intervention est arrondie sur ses seules minutes non déjà comptées."""
    d = decompte_astreinte("2026-07-13", [
        {"debut": "10:00", "fin": "10:20"},
        {"debut": "10:10", "fin": "10:30"},
    ])
    assert len(d["events"]) == 2
    assert d["events"][0]["min"] == 30           # 20 min réelles → arrondies à 30
    assert d["events"][1]["min"] == 15           # 10 min nouvelles → arrondies à 15
    assert d["total_min"] == 45
    assert sum(e["min"] for e in d["events"]) == d["total_min"]
    assert d["categories"][0]["nom"] == "Journée"


def test_decompte_minutes_partagees_entre_interventions():
    """Deux interventions qui se chevauchent : les minutes réelles communes ne
    sont comptées qu'une fois (attribuées à la première) ; chaque ligne est
    arrondie au quart supérieur et les événements somment au total du jour."""
    d = decompte_astreinte("2026-07-13", [
        {"debut": "22:39", "fin": "23:05"},
        {"debut": "23:02", "fin": "23:49"},
    ])
    assert d["events"][0]["min"] == 30          # 26 min réelles → 30
    assert d["events"][1]["min"] == 45          # 44 min nouvelles → 45 (3 min communes)
    assert d["total_min"] == 75
    assert d["total_pondere_min"] == 113         # 75 × 1,5 (Nuit)


def test_decompte_event_incomplet_ignore():
    """Un événement sans debut ou sans fin est ignoré."""
    d = decompte_astreinte("2026-07-13", [{"debut": "22:00"}, {"fin": "23:00"}, {}])
    assert d["tranches"] == 0
    assert d["total_min"] == 0
    assert d["events"] == []
    assert d["categories"] == []


def test_decompte_regles_personnalisees():
    """Une config custom remplace les règles par défaut (fenêtre à cheval sur minuit)."""
    facteurs = [{"nom": "Garde", "jours": ["semaine"], "debut": "18:00", "fin": "09:00", "facteur": 2}]
    d = decompte_astreinte("2026-07-13", [{"debut": "20:00", "fin": "21:00"}], facteurs)
    assert d["total_min"] == 60
    assert d["categories"][0]["nom"] == "Garde"
    assert d["total_pondere_min"] == 120


# ── Nominaux ──────────────────────────────────────────────────────────────────

def test_nominaux_exclusion_totale_du_matin():
    m, a = nominaux_du_jour(set(), 360, 180, 0)
    assert (m, a) == (0, 180)


def test_nominaux_sans_exclusion_reste_la_moitié():
    m, a = nominaux_du_jour(set(), 468, 0, 0)
    assert (m, a) == (234, 234)


# ── compute_week ──────────────────────────────────────────────────────────────

def test_compute_week_decompte_absent_des_heures_de_semaine(freeze_today):
    """Lundi et jeudi complets, mardi astreinte avec event 23:00→01:00, mercredi
    vide : les heures d'astreinte n'entrent jamais dans total_travaille/total_du,
    seulement dans result["astreinte"] ; seules les 3h de présence obligatoire du
    matin couvertes par le repos (retour 12:00) sont créditées comme effectuées."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", astreinte_events=[{"debut": "23:00", "fin": "01:00"}]),
        _pointage("2026-07-15"),
        _pointage("2026-07-16", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-14"])

    # pointé (2 × 7h48) + 3h de présence couvertes créditées ; astreinte exclue
    assert result["total_travaille"] == "18h36"
    assert result["jours"][2]["couvert_min"] == 180

    ast = result["astreinte"]
    assert ast["actif"] is True
    assert ast["total_min"] == 120              # 23:00→01:00 = 8 tranches
    assert ast["total_h"] == "2h00"
    assert ast["total_pondere_min"] == 180      # Nuit ×1,5
    assert ast["total_pondere_h"] == "3h00"
    assert ast["categories"][0]["nom"] == "Nuit"
    assert any(j["date"] == "2026-07-14" for j in ast["jours"])

    mardi = result["jours"][1]
    assert mardi["astreinte_min"] == 120
    assert mardi["astreinte_h"] == "2h00"
    assert mardi["astreinte_pondere_min"] == 180


def test_compute_week_fin_nocturne_decale_le_decompte_et_les_cibles(freeze_today):
    """Mardi astreinte, event 01:00→02:00 saisi sur le mercredi (lendemain) :
    retour mercredi 13:00, présence du matin (3h) créditée comme effectuée,
    aucune cible matin, après-midi 13:30→18:18 (nominal 288 = 234 + report)."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-15", astreinte_events=[{"debut": "01:00", "fin": "02:00"}]),
        _pointage("2026-07-16"),
        _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-14"])
    mercredi = result["jours"][2]

    # dues complètes, présence matin 09:00→12:00 couverte créditée au travaillé
    assert mercredi["du_min"] == 468
    assert mercredi["couvert_min"] == 180
    assert mercredi["travaille_min"] == 180
    assert mercredi["couvert_detail"] == "matin 09:00→12:00"
    assert mercredi["retour"] == "13:00"        # 02:00 + 11h
    assert mercredi["cible_matin"] is None
    assert mercredi["cible_aprem"] == "18:18"
    assert result["total_du"] == "39h00"         # dues nominales complètes
    assert result["total_travaille"] == "18h36"  # 2 × 7h48 + 3h de présence créditée


def test_compute_week_nuit_finissant_au_matin(freeze_today):
    """Event 23:00→06:00 (à cheval sur minuit) saisi sur le mardi astreinte : le
    retour 17:00 s'applique au mercredi (matin et après-midi exclus jusqu'à 17:00)."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54",
                  astreinte_events=[{"debut": "23:00", "fin": "06:00"}]),
        _pointage("2026-07-15"),
        _pointage("2026-07-16"),
        _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-14"])
    mercredi = result["jours"][2]

    assert mercredi["retour"] == "17:00"
    # matin (180) + 14:00→17:00 (180) couverts → crédités 360, dues complètes 468
    assert mercredi["du_min"] == 468
    assert mercredi["couvert_min"] == 360
    assert mercredi["couvert_h"] == "6h00"
    assert mercredi["cible_matin"] is None
    # aprem démarre à 17:00, nominal 108 (54 matin + 54 aprem) → 18:48
    assert mercredi["cible_aprem_entree"] == "17:00"
    assert mercredi["cible_aprem"] == "18:48"
    # décompte : 23:00→06:00 = 28 tranches = 7h en Nuit ×1,5
    assert result["jours"][1]["astreinte_min"] == 420
    assert result["astreinte"]["total_pondere_min"] == 630


def test_compute_week_presence_couvertes_comptees_effectuees(freeze_today):
    """Retour décalé à 11:00 (event mardi 22:39→23:49) : les 2h de présence
    obligatoire du matin (09:00→11:00) sont comptées comme effectuées —
    créditées au travaillé, dues complètes, Δ inchangé par rapport à
    l'ancienne soustraction des dues."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54",
                  astreinte_events=[{"debut": "22:39", "fin": "23:49"}]),
        _pointage("2026-07-15", "11:00", "12:00", "14:00", "17:00"),
        _pointage("2026-07-16"),
        _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-14"])
    mercredi = result["jours"][2]

    assert mercredi["retour"] == "11:00"
    assert mercredi["couvert_min"] == 120          # présence 09:00→11:00
    assert mercredi["couvert_h"] == "2h00"
    assert mercredi["couvert_detail"] == "matin 09:00→11:00"
    assert mercredi["travaille_min"] == 240 + 120  # pointé (1h + 3h) + couvert
    assert mercredi["travaille"] == "6h00"
    assert mercredi["du_min"] == 468               # dues complètes
    assert mercredi["delta_min"] == 360 - 468


def test_compute_week_event_ignore_hors_jour_qualifie(freeze_today):
    """Un event saisi un jour non qualifié (pas d'astreinte) ne change rien au
    décompte ni au décompte d'astreinte."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54",
                  astreinte_events=[{"debut": "01:00", "fin": "02:00"}]),
        _pointage("2026-07-15"),
        _pointage("2026-07-16"),
        _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, [])
    mardi = result["jours"][1]
    assert mardi["du_min"] == HEURES_JOUR_MIN
    assert mardi["retour_min"] is None
    assert mardi["astreinte_min"] == 0
    assert result["astreinte"]["actif"] is False


def test_compute_week_arrivee_visee_ne_precede_jamais_le_retour(freeze_today):
    """Event mardi 21:00→23:30 → retour mercredi 10:30 : arrivée cible du matin
    10:30, sortie 12:00, et le nominal qui ne tient pas (234-90=144 → 54
    manquantes) bascule sur l'après-midi du même jour."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54",
                  astreinte_events=[{"debut": "21:00", "fin": "23:30"}]),
        _pointage("2026-07-15"),
        _pointage("2026-07-16"),
        _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-14"])
    mercredi = result["jours"][2]

    assert mercredi["retour"] == "10:30"
    assert mercredi["cible_matin_entree"] == "10:30"
    assert mercredi["cible_matin"] == "12:00"
    # aprem : nominal 234 + 54 reportées = 288 depuis 13:30 → 18:18
    assert mercredi["cible_aprem"] == "18:18"


def test_compute_week_demi_journee_entierement_en_repos_compte_complete(freeze_today):
    """Avec un quota de 6h/jour (180 par demi-journée), un retour 13:00 (event
    01:00→02:00 sur le mercredi, mardi astreinte) couvre toute la plage du matin :
    plus rien à y remplir, la demi-journée est complète d'office et l'absence de
    pointage matin ne casse pas le cumul."""
    heures_jour = 360
    pointages = [
        _pointage("2026-07-13", "09:00", "12:00", "13:30", "16:30"),
        _pointage("2026-07-14", "09:00", "12:00", "13:30", "16:30"),
        _pointage("2026-07-15", aprem_entree="13:30", aprem_sortie="16:30",
                  astreinte_events=[{"debut": "01:00", "fin": "02:00"}]),
        _pointage("2026-07-16", "09:00", "12:00", "13:30", "16:30"),
        _pointage("2026-07-17", "09:00", "12:00", "13:30", "16:30"),
    ]
    result = compute_week(pointages, [], heures_jour, PLAGES, ["2026-07-14"])
    mercredi = result["jours"][2]

    assert mercredi["matin_nominal_min"] == 0
    assert mercredi["is_complete"] is True
    assert mercredi["cumul_visible"] is True
    assert mercredi["du_min"] == 360          # dues complètes du jour (6h)
    assert mercredi["couvert_min"] == 180     # 3h de présence matin couvertes, créditées


# ── Stockage des astreintes ───────────────────────────────────────────────────

def test_toggle_astreinte_persiste():
    models.toggle_astreinte("2026-07-14", "u-astreinte")
    assert models.load_astreintes("u-astreinte") == ["2026-07-14"]
    models.toggle_astreinte("2026-07-14", "u-astreinte")
    assert models.load_astreintes("u-astreinte") == []


def test_load_facteurs_astreinte_defaut_si_absent():
    facteurs = models.load_facteurs_astreinte()
    assert any(f["nom"] == "Nuit" for f in facteurs)


# ── Fenêtre d'astreinte 18:00 → 18:00 ───────────────────────────────────────

def test_fenetre_astreinte_jour():
    """Le jour déclaré couvre 18:00 → 18:00 le lendemain ; le lendemain n'est
    couvert que jusqu'à 18:00 ; deux astreintes consécutives se recollent.
    Samedi, dimanche et férié : journée entière 0h00 → 0h00."""
    # jours ouvrés non fériés (mercredi 15 → vendredi 17 juillet 2026)
    assert fenetre_astreinte_jour("2026-07-15", ["2026-07-15"]) == (ASTREINTE_DEBUT_MIN, 24 * 60 + ASTREINTE_DEBUT_MIN)
    assert fenetre_astreinte_jour("2026-07-16", ["2026-07-15"]) == (0, ASTREINTE_DEBUT_MIN)
    assert fenetre_astreinte_jour("2026-07-16", ["2026-07-15", "2026-07-16"]) == (0, 24 * 60 + ASTREINTE_DEBUT_MIN)
    assert fenetre_astreinte_jour("2026-07-17", ["2026-07-15"]) is None
    # samedi et dimanche : journée entière dès 0h00, déclarés ou lendemain
    # d'astreinte (le jour AS déclaré garde sa borne du lendemain 18:00)
    assert fenetre_astreinte_jour("2026-07-18", ["2026-07-18"]) == (0, 24 * 60 + ASTREINTE_DEBUT_MIN)
    assert fenetre_astreinte_jour("2026-07-19", ["2026-07-18"]) == (0, 24 * 60)
    # férié légal (14 juillet) : journée entière même en milieu de semaine
    assert fenetre_astreinte_jour("2026-07-14", ["2026-07-13"]) == (0, 24 * 60)
    # férié marqué à la main : idem
    assert fenetre_astreinte_jour("2026-07-15", ["2026-07-14"], {"2026-07-15"}) == (0, 24 * 60)


def test_decompte_hors_fenetre_18h_18h_ignore():
    # Matin du jour AS déclaré : avant 18:00, hors astreinte
    d = decompte_astreinte("2026-07-14", [{"debut": "10:00", "fin": "12:00"}],
                           None, (ASTREINTE_DEBUT_MIN, 24 * 60 + ASTREINTE_DEBUT_MIN))
    assert d["total_min"] == 0
    # Lendemain après 18:00 : hors astreinte
    d = decompte_astreinte("2026-07-15", [{"debut": "19:00", "fin": "20:00"}],
                           None, (0, ASTREINTE_DEBUT_MIN))
    assert d["total_min"] == 0
    # Lendemain matin : dans la fenêtre
    d = decompte_astreinte("2026-07-15", [{"debut": "01:00", "fin": "02:00"}],
                           None, (0, ASTREINTE_DEBUT_MIN))
    assert d["total_min"] == 60
    # Événement à cheval sur la borne 18:00 du lendemain : seul le fragment
    # intérieur compte (17:00→18:00 = 4 tranches)
    d = decompte_astreinte("2026-07-15", [{"debut": "17:00", "fin": "19:00"}],
                           None, (0, ASTREINTE_DEBUT_MIN))
    assert d["total_min"] == 60


def test_compute_week_intervention_avant_18h_hors_astreinte(freeze_today):
    """Mercredi ouvré AS : l'event 16:00→17:00 (avant 18:00) ne compte pas ; le
    même créneau à 19:00→20:00 (dans la fenêtre) compte 1h (Journée ×1)."""
    pointages = [
        _pointage("2026-07-13"), _pointage("2026-07-14"), _pointage("2026-07-16"),
        _pointage("2026-07-17"),
        _pointage("2026-07-15", astreinte_events=[{"debut": "16:00", "fin": "17:00"}]),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-15"])
    assert result["astreinte"]["total_min"] == 0
    assert result["jours"][2]["astreinte_min"] == 0
    # le même créneau le soir, dans la fenêtre 18:00 → 18:00, compte (Journée ×1)
    pointages[4] = _pointage("2026-07-15", astreinte_events=[{"debut": "19:00", "fin": "20:00"}])
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-15"])
    assert result["astreinte"]["total_min"] == 60
    assert result["astreinte"]["total_pondere_min"] == 60


def test_compute_week_astreinte_weekend_journee_entiere(freeze_today):
    """Vendredi AS : le samedi compte de 0h00 à 0h00 — l'intervention 20:00→21:00
    du samedi (après la borne 18:00 des jours ouvrés) est de l'astreinte (Nuit ×1,5)."""
    pointages = [
        _pointage("2026-07-13"), _pointage("2026-07-14"), _pointage("2026-07-15"),
        _pointage("2026-07-16"),
        _pointage("2026-07-17", astreinte_events=[{"debut": "20:00", "fin": "21:00"}]),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-17"])
    # l'événement saisi sur le vendredi est dans sa fenêtre 18:00 → 18:00
    vendredi = result["jours"][4]
    assert vendredi["astreinte_min"] == 60


def test_decompte_fenetre_samedi_soir_apres_18h():
    """Samedi lendemain d'astreinte : 20:00→21:00 compte (journée entière),
    4 tranches en Nuit ×1,5 = 1h30 pondérées."""
    fen = fenetre_astreinte_jour("2026-07-18", ["2026-07-17"])
    d = decompte_astreinte("2026-07-18", [{"debut": "20:00", "fin": "21:00"}], None, fen)
    assert d["total_min"] == 60
    assert d["categories"][0]["nom"] == "Nuit"
    assert d["total_pondere_min"] == 90


def test_compute_week_ferie_journee_entiere_ratio_x2(freeze_today):
    """Lundi AS, intervention le mardi 14 juillet (férié légal) : journée entière
    0h00 → 0h00, ratio Dimanche / férié ×2 (10:00→12:00 = 2h → 4h pondérées)."""
    pointages = [
        _pointage("2026-07-13"),
        _pointage("2026-07-14", astreinte_events=[{"debut": "10:00", "fin": "12:00"}]),
        _pointage("2026-07-15"), _pointage("2026-07-16"), _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-13"])
    assert result["astreinte"]["total_min"] == 120
    assert result["astreinte"]["total_pondere_min"] == 240  # férié ×2


def test_compute_week_astreinte_samedi_dimanche(freeze_today):
    """Samedi AS avec intervention nocturne : dû 0 (week-end), décompte en
    compteur astreinte (Nuit vendredi ×1,5 puis Samedi ×1,5 sur 08:00→20:00)."""
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-15", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-16", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-17", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-18", astreinte_events=[{"debut": "23:00", "fin": "09:00"}]),
        _pointage("2026-07-19"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-18"])
    samedi = result["jours"][5]
    assert samedi["du_min"] == 0
    assert samedi["astreinte_min"] == 10 * 60              # 23:00→09:00 = 10h
    assert result["total_du"] == "39h00"                  # week-end hors dues


# ── Forfait par jour d'astreinte déclaré ───────────────────────────────────────

def test_compute_week_forfait_hors_heures_travaillees(freeze_today):
    """Forfait 1h00 réglé : attribué au jour AS déclaré uniquement (pas du
    lendemain), mais jamais compté dans les heures travaillées — seulement
    suivi dans le récapitulatif d'astreinte, pondéré par la bonification
    journée du jour (2026-07-14 est férié : ×2)."""
    plages = {**PLAGES, "astreinte_forfait": "01:00"}
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-15"), _pointage("2026-07-16"), _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, plages, ["2026-07-14"])
    mardi = result["jours"][1]
    assert mardi["forfait_min"] == 60
    assert mardi["travaille_min"] == HEURES_JOUR_MIN    # pointé seul, forfait exclu
    assert result["jours"][2]["forfait_min"] == 0       # lendemain : rien
    assert result["jours"][0]["forfait_min"] == 0       # jour sans astreinte
    assert result["total_travaille"] == "15h36"          # 2 × 7h48, forfait exclu
    # récapitulatif d'astreinte : le jour AS apparaît avec son forfait même sans
    # intervention ; le forfait est bonifié « journée » du jour (férié → ×2)
    ast = result["astreinte"]
    assert ast["actif"] is True
    assert ast["total_min"] == 0
    assert ast["total_forfait_min"] == 60
    assert ast["total_forfait_h"] == "1h00"
    assert ast["total_forfait_pondere_min"] == 120
    assert ast["total_forfait_pondere_h"] == "2h00"
    [(jour_as)] = ast["jours"]
    assert (jour_as["date"], jour_as["forfait_min"], jour_as["events"]) == ("2026-07-14", 60, [])
    assert (jour_as["forfait_pondere_min"], jour_as["forfait_regle"], jour_as["forfait_facteur_txt"]) == (120, "Dimanche / férié", "2")


def test_forfait_bonifie_selon_la_journee_du_jour(freeze_today):
    """Le forfait est considéré réalisé en journée : il bénéficie de la
    bonification « journée » du jour où il est attribué — ×1 en semaine, ×1,5
    le samedi, ×2 le dimanche ou un férié (règles par défaut)."""
    plages = {**PLAGES, "astreinte_forfait": "01:00"}
    pointages = [_pointage(d) for d in
                 ["2026-07-13", "2026-07-14", "2026-07-15", "2026-07-16", "2026-07-17",
                  "2026-07-18", "2026-07-19"]]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, plages,
                          ["2026-07-15", "2026-07-18", "2026-07-19"])
    ast = result["astreinte"]
    details = {j["date"]: (j["forfait_min"], j["forfait_pondere_min"], j["forfait_regle"])
               for j in ast["jours"]}
    assert details["2026-07-15"] == (60, 60, "Journée")        # mercredi : ×1
    assert details["2026-07-18"] == (60, 90, "Samedi")         # samedi : ×1,5
    assert details["2026-07-19"] == (60, 120, "Dimanche / férié")  # dimanche : ×2
    assert ast["total_forfait_min"] == 180
    assert ast["total_forfait_pondere_min"] == 270
    assert ast["total_forfait_pondere_h"] == "4h30"


def test_regle_journee_astreinte_suit_les_regles_configurees():
    """La bonification journée du forfait suit les règles configurées : première
    règle couvrant midi pour le type du jour."""
    regles = [{"nom": "Journée spéciale", "jours": ["semaine"], "debut": "06:00", "fin": "22:00", "facteur": 1.25}]
    r = regle_journee_astreinte("2026-07-15", regles)
    assert r is not None
    assert (r["nom"], r["facteur"], r["facteur_txt"]) == ("Journée spéciale", 1.25, "1,25")
    # Aucune règle ne couvre midi ce jour-là : pas de bonification
    assert regle_journee_astreinte("2026-07-15", [{"nom": "Nuit", "jours": ["semaine"], "debut": "22:00", "fin": "06:00", "facteur": 1.5}]) is None


def test_compute_week_sans_forfait_comportement_inchange(freeze_today):
    pointages = [
        _pointage("2026-07-13", "09:00", "12:24", "13:30", "17:54"),
        _pointage("2026-07-14", "09:00", "12:24", "13:30", "17:54",
                  astreinte_events=[{"debut": "21:00", "fin": "22:00"}]),
        _pointage("2026-07-15"), _pointage("2026-07-16"), _pointage("2026-07-17"),
    ]
    result = compute_week(pointages, [], HEURES_JOUR_MIN, PLAGES, ["2026-07-14"])
    assert result["jours"][1]["forfait_min"] == 0
    assert result["total_travaille"] == "15h36"