# -*- coding: utf-8 -*-
"""
Corrigé Python - Bac NSI 2026 - Épreuve pratique - Sujet 6
Thème : smoothies et alternatives

Ce fichier propose une correction concise de la classe Boutique_smoothie.
"""

from __future__ import annotations


class Boutique_smoothie:
    """
    Représente une boutique de smoothies avec une liste de fruits disponibles.
    """

    def __init__(self, liste_fruits_disponibles: list[str]) -> None:
        self.liste_fruits_disponibles = liste_fruits_disponibles
        self.db_smoothies = {
            "Tropical": ["Mangue", "Ananas", "Banane"],
            "Rouge": ["Fraise", "Framboise", "Cerise"],
            "Vert": ["Kiwi", "Pomme verte", "Menthe"],
            "Agrume": ["Orange", "Citron", "Pamplemousse"],
            "Exotique": ["Papaye", "Fruit de la passion", "Noix de coco"],
            "Tropical citron": ["Mangue", "Ananas", "Citron"],
            "Rouge kiwi": ["Fraise", "Framboise", "Kiwi"],
            "Exotique rouge": ["Papaye", "Fraise", "Fruit de la passion"],
            "Vert citron": ["Kiwi", "Pomme verte", "Citron"],
            "Soleil couchant": ["Mangue", "Fraise", "Pamplemousse"],
        }

    # -------------------------------------------------------------------------
    # Question 1
    # -------------------------------------------------------------------------

    def smoothie_possible(self, nom_smoothie: str) -> bool:
        """
        Renvoie True si tous les fruits du smoothie demandé sont disponibles.
        """
        if nom_smoothie not in self.db_smoothies:
            return False

        for fruit in self.db_smoothies[nom_smoothie]:
            if fruit not in self.liste_fruits_disponibles:
                return False
        return True

    # -------------------------------------------------------------------------
    # Question 2
    # -------------------------------------------------------------------------

    def liste_smoothies_possibles(self) -> list[str]:
        """
        Renvoie la liste des smoothies réalisables avec les fruits disponibles.
        """
        smoothies_possibles = []
        for nom_smoothie in self.db_smoothies:
            if self.smoothie_possible(nom_smoothie):
                smoothies_possibles.append(nom_smoothie)
        return smoothies_possibles

    # -------------------------------------------------------------------------
    # Question 3
    # -------------------------------------------------------------------------

    def score_proximité(self, nom1: str, nom2: str) -> int:
        """
        Renvoie le nombre de fruits communs entre deux smoothies.
        """
        nb = 0
        fruits1 = self.db_smoothies[nom1]
        fruits2 = self.db_smoothies[nom2]
        for fruit in fruits1:
            if fruit in fruits2:
                nb += 1
        return nb

    # -------------------------------------------------------------------------
    # Question 4
    # -------------------------------------------------------------------------

    def plus_proche_possible(self, nom_smoothie_ref: str) -> str | None:
        """
        Renvoie le smoothie réalisable le plus proche du smoothie demandé.

        Correction importante : on ne compare qu'avec les smoothies possibles,
        et on exclut le smoothie de référence lui-même.
        Si aucun smoothie possible ne partage au moins un fruit, on renvoie None.
        """
        max_communs = 0
        smoothie_proche = None

        for nom_smoothie in self.liste_smoothies_possibles():
            if nom_smoothie != nom_smoothie_ref:
                nb_communs = self.score_proximité(nom_smoothie_ref, nom_smoothie)
                if nb_communs > max_communs:
                    max_communs = nb_communs
                    smoothie_proche = nom_smoothie

        return smoothie_proche

    # -------------------------------------------------------------------------
    # Question 5
    # -------------------------------------------------------------------------

    def affichage_possibles(self) -> None:
        """
        Affiche les smoothies possibles et les alternatives proposées.
        """
        smoothies = self.liste_smoothies_possibles()
        print("Smoothies possibles avec les fruits disponibles :")
        for smoothie in smoothies:
            print("-", smoothie)

        print("Alternative aux autres smoothies :")
        for smoothie in self.db_smoothies:
            if smoothie not in smoothies:
                proche = self.plus_proche_possible(smoothie)
                if proche is not None:
                    print(f"Pour le smoothie {smoothie}, essayez {proche}.")
                else:
                    print(f"Pour le smoothie {smoothie}, aucun smoothie proche disponible.")


# -----------------------------------------------------------------------------
# Tests
# -----------------------------------------------------------------------------


def test_smoothie_possible() -> None:
    boutique = Boutique_smoothie(["Mangue", "Ananas", "Banane", "Fraise", "Citron"])
    assert boutique.smoothie_possible("Tropical") is True
    assert boutique.smoothie_possible("Rouge") is False
    assert boutique.smoothie_possible("Recette inconnue") is False


def test_liste_smoothies_possibles() -> None:
    boutique1 = Boutique_smoothie(["Mangue", "Ananas", "Banane", "Fraise", "Citron"])
    boutique2 = Boutique_smoothie(
        ["Fraise", "Framboise", "Cerise", "Kiwi", "Orange", "Citron", "Pamplemousse"]
    )
    boutique3 = Boutique_smoothie(["Orange", "Mangue", "Papaye"])

    assert boutique1.liste_smoothies_possibles() == ["Tropical", "Tropical citron"]
    assert boutique2.liste_smoothies_possibles() == ["Rouge", "Agrume", "Rouge kiwi"]
    assert boutique3.liste_smoothies_possibles() == []


def test_score_proximité() -> None:
    boutique = Boutique_smoothie([])
    assert boutique.score_proximité("Tropical", "Tropical citron") == 2
    assert boutique.score_proximité("Tropical", "Rouge") == 0
    assert boutique.score_proximité("Rouge", "Rouge kiwi") == 2
    assert boutique.score_proximité("Rouge kiwi", "Vert") == 1


def test_plus_proche_possible() -> None:
    boutique = Boutique_smoothie(
        ["Mangue", "Ananas", "Banane", "Fraise", "Citron", "Kiwi", "Pomme verte"]
    )
    assert boutique.plus_proche_possible("Tropical") == "Tropical citron"
    assert boutique.plus_proche_possible("Exotique") is None


if __name__ == "__main__":
    test_smoothie_possible()
    test_liste_smoothies_possibles()
    test_score_proximité()
    test_plus_proche_possible()
    print("Tous les tests du sujet 6 sont réussis.\n")

    boutique = Boutique_smoothie(
        ["Mangue", "Ananas", "Banane", "Fraise", "Citron", "Kiwi", "Pomme verte"]
    )
    boutique.affichage_possibles()