import importlib
import importlib.util
import pkgutil
import sys
from pathlib import Path

# --- importlib.import_module : importer un module dont le NOM est une chaine dynamique ---
nom_module = "json"
module = importlib.import_module(nom_module)
print(module.dumps({"cle": "valeur"}))

# Import dynamique conditionnel : selectionner une implementation selon la configuration
def charger_backend(nom: str):
    module = importlib.import_module(f"mon_app.backends.{nom}")
    return module.Backend()

# --- Recharger un module modifie sans redemarrer le processus (dev uniquement) ---
importlib.reload(module)

# --- importlib.util.spec_from_file_location : charger un fichier .py par CHEMIN ---
def charger_module_depuis_chemin(chemin: Path, nom_module: str):
    spec = importlib.util.spec_from_file_location(nom_module, chemin)
    if spec is None or spec.loader is None:
        raise ImportError(f"Impossible de charger {chemin}")
    module = importlib.util.module_from_spec(spec)
    sys.modules[nom_module] = module      # necessaire pour un import relatif eventuel dans le plugin
    spec.loader.exec_module(module)
    return module

# --- pkgutil.iter_modules : decouvrir tous les plugins d'un package a l'execution ---
# Structure supposee :
# mon_app/plugins/
#   __init__.py
#   plugin_export_csv.py
#   plugin_export_json.py
def decouvrir_plugins(package_plugins):
    plugins = {}
    for _, nom_module, _ in pkgutil.iter_modules(package_plugins.__path__):
        module = importlib.import_module(f"{package_plugins.__name__}.{nom_module}")
        if hasattr(module, "register"):
            plugins[nom_module] = module.register()
    return plugins

# --- Pattern registre : chaque plugin s'auto-enregistre via un decorateur ---
REGISTRE_EXPORTATEURS = {}

def exportateur(nom: str):
    def decorateur(classe):
        REGISTRE_EXPORTATEURS[nom] = classe
        return classe
    return decorateur

@exportateur("csv")
class ExportateurCSV:
    def exporter(self, donnees):
        return "\n".join(",".join(map(str, ligne)) for ligne in donnees)

@exportateur("json")
class ExportateurJSON:
    def exporter(self, donnees):
        import json
        return json.dumps(donnees)

def exporter(nom_format: str, donnees):
    if nom_format not in REGISTRE_EXPORTATEURS:
        raise ValueError(f"Format inconnu : {nom_format}. Disponibles : {list(REGISTRE_EXPORTATEURS)}")
    return REGISTRE_EXPORTATEURS[nom_format]().exporter(donnees)

print(exporter("csv", [[1, 2], [3, 4]]))

# --- Entry points : LE mecanisme standard pour des plugins DISTRIBUES en packages separes ---
# Dans le pyproject.toml du package "mon-plugin-slack" (installe separement via pip) :
'''
[project.entry-points."mon_app.exportateurs"]
slack = "mon_plugin_slack:ExportateurSlack"
'''
# Le package central peut alors decouvrir TOUS les plugins installes, sans les connaitre a l'avance :
from importlib.metadata import entry_points

def charger_plugins_installes():
    plugins = {}
    for point in entry_points(group="mon_app.exportateurs"):
        classe_plugin = point.load()          # importe dynamiquement le module cible
        plugins[point.name] = classe_plugin
    return plugins

# plugins_disponibles = charger_plugins_installes()
# -> {"slack": <class ExportateurSlack>, "csv": <class ExportateurCSV>, ...}
# N'importe qui peut publier "mon-plugin-teams" sur PyPI et l'application le decouvre
# automatiquement des qu'il est installe, SANS modifier une seule ligne du code central.

# --- Chargement paresseux (lazy loading) d'un plugin lourd, seulement si utilise ---
class GestionnaireExportateursParesseux:
    def __init__(self):
        self._points = {p.name: p for p in entry_points(group="mon_app.exportateurs")}
        self._instances = {}

    def obtenir(self, nom: str):
        if nom not in self._instances:
            if nom not in self._points:
                raise KeyError(f"Plugin '{nom}' non installe")
            classe = self._points[nom].load()      # import reel seulement au premier usage
            self._instances[nom] = classe()
        return self._instances[nom]

# --- Isolation : verifier l'interface d'un plugin avant de l'activer (contrat via Protocol) ---
from typing import Protocol, runtime_checkable

@runtime_checkable
class Exportateur(Protocol):
    def exporter(self, donnees: list) -> str: ...

def valider_plugin(classe) -> bool:
    instance = classe()
    return isinstance(instance, Exportateur)

print(valider_plugin(ExportateurCSV))     # True