from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Protocol
import functools

# --- Factory : Python n'a pas besoin d'une hierarchie complexe, une fonction suffit souvent ---
class Vehicule(ABC):
    @abstractmethod
    def rouler(self) -> str: ...

class Voiture(Vehicule):
    def rouler(self) -> str:
        return "Vroom"

class Velo(Vehicule):
    def rouler(self) -> str:
        return "Cling cling"

def creer_vehicule(type_vehicule: str) -> Vehicule:
    fabriques = {"voiture": Voiture, "velo": Velo}
    if type_vehicule not in fabriques:
        raise ValueError(f"Type inconnu : {type_vehicule}")
    return fabriques[type_vehicule]()

# --- Strategy : les fonctions de premiere classe remplacent souvent des classes ---
def strategie_tri_alphabetique(items):
    return sorted(items)

def strategie_tri_longueur(items):
    return sorted(items, key=len)

class Trieur:
    def __init__(self, strategie):
        self.strategie = strategie          # une fonction, pas une interface complexe

    def trier(self, items):
        return self.strategie(items)

trieur = Trieur(strategie_tri_longueur)
print(trieur.trier(["banane", "kiwi", "abricot"]))

# --- Observer : notifier des abonnes lors d'un evenement ---
class SujetObservable:
    def __init__(self):
        self._observateurs = []

    def s_abonner(self, callback):
        self._observateurs.append(callback)

    def notifier(self, *args, **kwargs):
        for callback in self._observateurs:
            callback(*args, **kwargs)

class GestionnaireCommandes(SujetObservable):
    def passer_commande(self, commande):
        print(f"Commande {commande} enregistree")
        self.notifier(commande)

def envoyer_email(commande):
    print(f"Email envoye pour {commande}")

def journaliser(commande):
    print(f"[LOG] Nouvelle commande : {commande}")

gestionnaire = GestionnaireCommandes()
gestionnaire.s_abonner(envoyer_email)
gestionnaire.s_abonner(journaliser)
gestionnaire.passer_commande("CMD-001")

# --- Builder : construire un objet complexe etape par etape ---
@dataclass
class Requete:
    url: str = ""
    methode: str = "GET"
    headers: dict = None
    corps: str = None

class RequeteBuilder:
    def __init__(self):
        self._requete = Requete(headers={})

    def url(self, url):
        self._requete.url = url
        return self          # chainage fluide (fluent interface)

    def methode(self, methode):
        self._requete.methode = methode
        return self

    def header(self, cle, valeur):
        self._requete.headers[cle] = valeur
        return self

    def corps(self, corps):
        self._requete.corps = corps
        return self

    def build(self):
        return self._requete

requete = (
    RequeteBuilder()
    .url("https://api.example.com")
    .methode("POST")
    .header("Content-Type", "application/json")
    .corps('{"cle": "valeur"}')
    .build()
)

# --- Decorator pattern : Python le fait nativement avec @ (voir lecon dediee) ---

# --- Singleton : le module lui-meme EST un singleton en Python (a preferer souvent) ---
# fichier config_singleton.py :
'''
_config = {}

def get_config():
    return _config
'''
# Importer ce module donne toujours la MEME instance de _config -- pas besoin de pattern complexe

# --- Adapter : uniformiser des interfaces incompatibles ---
class ServiceMeteoLegacy:
    def get_temp_fahrenheit(self, ville):
        return 75.0

class AdaptateurMeteoMetrique:
    def __init__(self, service_legacy):
        self._service = service_legacy

    def get_temperature_celsius(self, ville):
        fahrenheit = self._service.get_temp_fahrenheit(ville)
        return (fahrenheit - 32) * 5 / 9

adaptateur = AdaptateurMeteoMetrique(ServiceMeteoLegacy())
print(f"{adaptateur.get_temperature_celsius('Paris'):.1f} C")

# --- Null Object : eviter les verifications "if x is None" repetees ---
class UtilisateurNull:
    nom = "Invite"
    def a_permission(self, permission):
        return False

def obtenir_utilisateur(id_utilisateur):
    return None if id_utilisateur < 0 else UtilisateurNull()  # simplifie ici

utilisateur = obtenir_utilisateur(-1) or UtilisateurNull()
print(utilisateur.nom)     # pas de verification "is None" necessaire