import tracemalloc
import gc
import sys
import weakref

# --- tracemalloc : suivi precis des allocations, ligne par ligne ---
tracemalloc.start(nframes=10)     # conserve jusqu'a 10 niveaux de call stack par allocation

def creer_gros_objets():
    return [bytearray(10_000) for _ in range(1000)]

avant = tracemalloc.take_snapshot()
gros_objets = creer_gros_objets()
apres = tracemalloc.take_snapshot()

# compare_to : LE outil le plus utile pour localiser une fuite entre deux points dans le temps
differences = apres.compare_to(avant, "lineno")
for stat in differences[:5]:
    print(stat)                     # fichier:ligne, delta memoire, delta nombre de blocs

# --- Snapshot filtre : ignorer le bruit des librairies standard/tierces ---
filtres = [
    tracemalloc.Filter(inclure=True, filename_pattern="*mon_projet*"),
]
snapshot_filtre = apres.filter_traces(filtres)

# --- Traquer l'origine exacte d'un objet precis ---
def tracer_allocation(objet):
    for trace in tracemalloc.get_object_traceback(objet) or []:
        print(trace)

# --- Detection de croissance continue : pattern pour un test de non-regression memoire ---
def detecter_fuite(fonction_suspecte, iterations=1000, seuil_octets=1_000_000):
    gc.collect()
    debut = tracemalloc.take_snapshot()
    for _ in range(iterations):
        fonction_suspecte()
    gc.collect()
    fin = tracemalloc.take_snapshot()

    stats = fin.compare_to(debut, "filename")
    croissance_totale = sum(s.size_diff for s in stats)
    if croissance_totale > seuil_octets:
        raise AssertionError(
            f"Fuite suspectee : +{croissance_totale / 1_000_000:.2f} Mo apres {iterations} iterations"
        )

# --- gc : trouver ce qui empeche precisement un objet d'etre collecte ---
class Ressource:
    def __init__(self, nom):
        self.nom = nom

    def __del__(self):
        print(f"Ressource {self.nom} liberee")

def diagnostiquer_retenue(objet):
    referents = gc.get_referrers(objet)     # QUI reference cet objet ?
    for ref in referents:
        if ref is not sys._getframe():        # exclut la frame courante elle-meme
            print(f"Retenu par : {type(ref)} -> {repr(ref)[:80]}")

r = Ressource("cache-principal")
conteneurs = {"actif": r}
diagnostiquer_retenue(r)      # revele que "conteneurs" retient r

# --- Cycles de references : le GC generationnel les detecte, mais __del__ complique tout ---
class Noeud:
    def __init__(self, nom):
        self.nom = nom
        self.suivant = None

    def __del__(self):
        print(f"Noeud {self.nom} collecte")

n1, n2 = Noeud("A"), Noeud("B")
n1.suivant = n2
n2.suivant = n1          # cycle

del n1, n2
gc.collect()      # necessaire pour casser le cycle : le comptage de refs seul ne suffit pas

# --- gc.get_stats() : suivre la pression memoire par generation ---
print(gc.get_stats())
print(f"Objets actuellement traques par le GC : {len(gc.get_objects())}")

# --- Cache mal borne : la fuite la plus frequente en production ---
class ServiceAvecFuite:
    def __init__(self):
        self._cache = {}      # grandit indefiniment, aucune eviction

    def traiter(self, cle, valeur):
        self._cache[cle] = valeur     # jamais purge -- fuite garantie sur une longue duree de vie

class ServiceCorrige:
    def __init__(self, taille_max=10_000):
        self._cache = {}
        self._taille_max = taille_max

    def traiter(self, cle, valeur):
        if len(self._cache) >= self._taille_max:
            # evincer le plus ancien (ordre d'insertion garanti depuis 3.7)
            plus_ancien = next(iter(self._cache))
            del self._cache[plus_ancien]
        self._cache[cle] = valeur

# --- weakref.finalize : nettoyage garanti, plus fiable que __del__ ---
class GestionnaireFichier:
    def __init__(self, chemin):
        self.chemin = chemin
        self._descripteur = open(chemin, "w")
        # finalize s'execute quand l'objet est collecte, MEME si le programme plante avant __del__
        self._finalizer = weakref.finalize(self, self._descripteur.close)

    def fermer_maintenant(self):
        self._finalizer()     # peut aussi etre declenche manuellement

# --- objgraph (librairie tierce) : visualiser les chaines de references (tres utile en debug) ---
# pip install objgraph
'''
import objgraph

objgraph.show_most_common_types(limit=10)       # types d'objets les plus nombreux en memoire
objgraph.show_growth()                            # objets crees depuis le dernier appel (delta)
objgraph.show_backrefs([mon_objet_suspect], max_depth=5, filename="chaine.png")
# genere un graphe visuel des references qui retiennent mon_objet_suspect en vie
'''

tracemalloc.stop()