"""Astreinte : événements, décompte par tranches de 15 min, 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,
    retour_apres_repos, DEFAULT_PLAGES, PAS_ASTREINTE_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_jour_meme():
    """Event 05:00→06:00 sur le jour d'astreinte : l'activité s'est réellement
    terminée à 06:00 ce jour-là → repos jusqu'à 17:00 le même jour."""
    p_by_date = {"2026-07-14": _pointage("2026-07-14",
                                         astreinte_events=[{"debut": "05:00", "fin": "06:00"}])}
    assert retour_apres_repos("2026-07-14", p_by_date, PLAGES, ["2026-07-14"]) == 17 * 60


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_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 : tranches de 15 min entamées, par règle ───────────────

def test_decompte_tranche_entamee_comptee_entiere():
    """22:07→22:20 touche les tranches alignées 22:00 et 22:15 : comptées entières."""
    d = decompte_astreinte("2026-07-13", [{"debut": "22:07", "fin": "22:20"}])
    assert d["tranches"] == 2                    # tranches 22:00 + 22:15 entamées
    assert d["total_min"] == 2 * PAS_ASTREINTE_MIN   # 30
    assert d["total_h"] == "0h30"
    assert d["categories"][0]["nom"] == "Nuit"   # lundi 22:xx → Nuit ×1,5
    assert d["total_pondere_min"] == 45          # 30 × 1,5


def test_decompte_arrondi_des_bornes():
    """09:50→10:05 touche les tranches 09:45 et 10:00 : 2 tranches en Journée ×1."""
    d = decompte_astreinte("2026-07-13", [{"debut": "09:50", "fin": "10:05"}])
    assert d["tranches"] == 2                    # tranches 09:45 + 10:00
    assert d["total_min"] == 30
    assert d["categories"][0]["nom"] == "Journée"  # lundi en journée ×1
    assert d["total_pondere_min"] == 30


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 tranches communes ne comptent
    qu'une fois dans le total du jour, chaque event garde son propre détail."""
    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]["tranches"] == 2       # tranches 10:00 + 10:15
    assert d["events"][0]["min"] == 30
    assert d["events"][1]["tranches"] == 2       # 10:10 aligné sur la tranche 10:00
    assert d["events"][1]["min"] == 30
    assert d["tranches"] == 2                    # union dédoublonnée
    assert d["total_min"] == 30
    assert d["categories"][0]["nom"] == "Journée"


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"]."""
    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"])

    # seul le pointé compte : 2 × 468 = 15h36, astreinte exclue
    assert result["total_travaille"] == "15h36"

    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 retirée de la semaine, 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]

    assert mercredi["du_min"] == 468 - 180      # matin 09:00→12:00 exclu par le retour 13: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"] == "36h00"        # 39h - 3h de présence retirées


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) exclus → dû = 108
    assert mercredi["du_min"] == 468 - 360
    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_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"] == 180  # 6h dues - 3h de présence matin retiré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)