import logging
import json
import sys
import time
import uuid
from contextvars import ContextVar

# --- Configuration de base : niveaux, handlers, formatters ---
logger = logging.getLogger("mon_application")
logger.setLevel(logging.DEBUG)

# Un handler decide OU les logs partent (console, fichier, reseau...)
handler_console = logging.StreamHandler(sys.stdout)
handler_console.setLevel(logging.INFO)          # ce handler ignore DEBUG, meme si le logger l'accepte

handler_fichier = logging.FileHandler("app.log", encoding="utf-8")
handler_fichier.setLevel(logging.DEBUG)

formatter_texte = logging.Formatter(
    "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
handler_console.setFormatter(formatter_texte)
handler_fichier.setFormatter(formatter_texte)

logger.addHandler(handler_console)
logger.addHandler(handler_fichier)

logger.debug("Detail technique, invisible en console (niveau INFO)")
logger.info("Application demarree")
logger.warning("Cache proche de la saturation")
logger.error("Echec de connexion a la base de donnees")
logger.critical("Service indisponible")

# --- Les 5 niveaux standards, du plus au moins verbeux ---
# CRITICAL(50) > ERROR(40) > WARNING(30) > INFO(20) > DEBUG(10)

# --- Logger un traceback complet ---
try:
    1 / 0
except ZeroDivisionError:
    logger.exception("Erreur lors du calcul")     # inclut automatiquement le traceback

# --- Logging structure : sortir du JSON exploitable par ELK/Datadog/Loki ---
class FormatterJSON(logging.Formatter):
    def format(self, record: logging.LogRecord) -> str:
        payload = {
            "timestamp": self.formatTime(record, "%Y-%m-%dT%H:%M:%S"),
            "niveau": record.levelname,
            "logger": record.name,
            "message": record.getMessage(),
            "module": record.module,
            "ligne": record.lineno,
        }
        # Champs additionnels attaches via logger.info(msg, extra={...})
        for cle, valeur in getattr(record, "champs_extra", {}).items():
            payload[cle] = valeur
        if record.exc_info:
            payload["exception"] = self.formatException(record.exc_info)
        return json.dumps(payload, ensure_ascii=False)

class AdaptateurExtra(logging.LoggerAdapter):
    """Permet de passer des champs structures sans repeter extra={...} partout."""
    def process(self, msg, kwargs):
        kwargs.setdefault("extra", {})["champs_extra"] = self.extra
        return msg, kwargs

logger_json = logging.getLogger("api")
logger_json.setLevel(logging.INFO)
handler_json = logging.StreamHandler(sys.stdout)
handler_json.setFormatter(FormatterJSON())
logger_json.addHandler(handler_json)
logger_json.propagate = False        # evite la duplication vers le root logger

log_requete = AdaptateurExtra(logger_json, {"service": "api-utilisateurs"})
log_requete.info("Requete traitee", extra={"champs_extra": {"duree_ms": 42, "statut": 200}})

# --- Correlation de requetes avec contextvars : tracer une requete a travers plusieurs couches ---
id_correlation: ContextVar[str] = ContextVar("id_correlation", default="-")

class FiltreCorrelation(logging.Filter):
    def filter(self, record: logging.LogRecord) -> bool:
        record.correlation_id = id_correlation.get()
        return True

logger_correle = logging.getLogger("service.commandes")
logger_correle.addFilter(FiltreCorrelation())
formatter_correle = logging.Formatter(
    "[%(correlation_id)s] %(asctime)s %(levelname)s %(message)s"
)
handler_correle = logging.StreamHandler(sys.stdout)
handler_correle.setFormatter(formatter_correle)
logger_correle.addHandler(handler_correle)

def traiter_requete_http(id_requete: str | None = None):
    jeton = id_correlation.set(id_requete or str(uuid.uuid4())[:8])
    try:
        logger_correle.info("Debut du traitement")
        valider_commande()
        logger_correle.info("Fin du traitement")
    finally:
        id_correlation.reset(jeton)        # nettoie le contexte, meme en cas d'exception

def valider_commande():
    # tout log ici herite AUTOMATIQUEMENT du meme correlation_id, sans le repasser en parametre
    logger_correle.info("Validation de la commande en cours")

traiter_requete_http()

# --- RotatingFileHandler / TimedRotatingFileHandler : eviter des logs illimites en taille ---
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler

handler_rotatif = RotatingFileHandler(
    "app_rotatif.log", maxBytes=10_000_000, backupCount=5      # 10 Mo x 5 fichiers max
)
handler_quotidien = TimedRotatingFileHandler(
    "app_quotidien.log", when="midnight", backupCount=14        # 14 jours d'historique
)

# --- structlog : librairie tierce qui structure TOUT nativement (context binding) ---
# pip install structlog
'''
import structlog

structlog.configure(
    processors=[
        structlog.contextvars.merge_contextvars,
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.JSONRenderer(),
    ],
)
log = structlog.get_logger()

structlog.contextvars.bind_contextvars(correlation_id="abc-123", utilisateur_id=42)
log.info("commande_creee", montant=99.90, devise="EUR")
# Sortie JSON : {"event": "commande_creee", "montant": 99.9, "correlation_id": "abc-123", ...}
'''

# --- Anti-patterns a eviter ---
# 1. logger.info(f"Utilisateur {nom} connecte")   -- f-string TOUJOURS evaluee, meme si niveau filtre
# 2. logger.info("Utilisateur %s connecte", nom)   -- BON : le formatage est LAZY (evalue seulement si loggue)
# 3. Ne jamais logger de secrets (mots de passe, tokens) meme en DEBUG