# -*- coding: utf-8 -*-
"""
Corrigé Python - Bac NSI 2026 - Épreuve pratique - Sujet 21
Thème : cartes mémoire, POO, dates et algorithme de Leitner
"""

from __future__ import annotations

import datetime


def date_future(nb_jours: int) -> datetime.date:
    return datetime.date.today() + datetime.timedelta(days=nb_jours)


DELAIS = [1, 3, 7, 15, 30]


class Carte:
    def __init__(self, question: str, reponse: str) -> None:
        self.question = question
        self.reponse = reponse
        self.niveau = 0
        self.date_prochaine = datetime.date.today()

    def __repr__(self) -> str:
        return f"<Carte: {self.question} (Niveau {self.niveau})>"
    
#############################################################################
# Question 1 : Écrire la méthode traiter_reponse(self, succes)        
#############################################################################
    def traiter_reponse(self, succes: bool) -> None:
        """Met à jour le niveau et la prochaine date de révision."""
        if succes:
            self.niveau = min(self.niveau + 1, 4)
        else:
            self.niveau = 0
        self.date_prochaine = date_future(DELAIS[self.niveau])

#############################################################################
# Question 2 :Écrire la fonction extraire_cartes_du_jour         
#############################################################################

# Solution 1
def extraire_cartes_du_jour(paquet: list[Carte], date_jour: datetime.date) -> list[Carte]:
    """Renvoie les cartes à réviser à la date donnée."""
    return [carte for carte in paquet if carte.date_prochaine <= date_jour]

# Solution 2
def extraire_cartes_du_jour2(paquet, date_jour):
    # On crée une liste vide qui contiendra les cartes à revoir
    cartes_a_revoir = []   
    # On parcourt chaque carte du paquet
    for carte in paquet:
        # On compare la date de prochaine révision avec la date ciblée
        if carte.date_prochaine <= date_jour:
            # Si le jour de révision est arrivé ou passé, on ajoute la carte
            cartes_a_revoir.append(carte)
            
    # On renvoie la liste finale
    return cartes_a_revoir

#############################################################################
# Question 3 : Exécuter la fonction test_renforcement() fournie. Observer le résultat affiché dans la
# console et constater l’incohérence.
# Analyser le code de la fonction extraire_cartes_a_renforcer(paquet), identifier
# la source de cette erreur logique, puis corriger le code afin qu’il ne renvoie que les cartes
# possédant rigoureusement le niveau minimum.
#############################################################################

#############################################################################
# Fonction défaillante à analyser et corriger pour la question 3            #
#############################################################################

def extraire_cartes_a_renforcer_defaillant(paquet):
    """
    Parcourt le paquet et renvoie la liste des cartes ayant le 
    niveau d'avancement le plus faible.
    """
    if len(paquet) == 0:
        return []
        
    niveau_min = paquet[0].niveau
    a_renforcer = []
    
    for carte in paquet:
        if carte.niveau < niveau_min:
            niveau_min = carte.niveau
            a_renforcer.append(carte)
        elif carte.niveau == niveau_min:
            a_renforcer.append(carte)
            
    return a_renforcer


# L'erreur réside dans le fait d'ajouter des cartes à la liste a_renforcer lorsqu'on trouve une nouvelle valeur minimale:
# on conserve donc les cartes de l'ancienne valeur minimale.*
# Pour rectifier, il faut réinitialiser cette liste avec seulement la carte correspondante.

def extraire_cartes_a_renforcer(paquet: list[Carte]) -> list[Carte]:
    """Renvoie uniquement les cartes dont le niveau est minimal."""
    if len(paquet) == 0:
        return []

    niveau_min = paquet[0].niveau
    a_renforcer = []
    for carte in paquet:
        if carte.niveau < niveau_min:
            niveau_min = carte.niveau
            # CORRECTION : si on trouve un niveau strictement plus petit, on doit
            # vider la liste des anciennes cartes mémorisées (qui avaient un niveau supérieur)
            # et initialiser la liste avec cette nouvelle carte.
            a_renforcer = [carte]
        elif carte.niveau == niveau_min:
            a_renforcer.append(carte)
    return a_renforcer


 ###############################################




def tests() -> None:
    c = Carte("Capitale de l'Italie ?", "Rome")
    c.traiter_reponse(True)
    assert c.niveau == 1
    assert c.date_prochaine == date_future(3)
    c.traiter_reponse(False)
    assert c.niveau == 0
    assert c.date_prochaine == date_future(1)

    c1 = Carte("A", "a")
    c1.niveau = 2
    c2 = Carte("B", "b")
    c2.niveau = 1
    c3 = Carte("C", "c")
    c3.niveau = 2
    assert extraire_cartes_a_renforcer([c1, c2, c3]) == [c2]
    assert extraire_cartes_du_jour([c1], datetime.date.today()) == [c1]
    print("Tous les tests du sujet 21 sont passés.")


if __name__ == "__main__":
    tests()