# memory_tracker.py — track Python memory allocation by location
import tracemalloc
import linecache
import time
import anthropic


def display_top(snapshot, key_type='lineno', limit=10):
    """Format tracemalloc snapshot for AI analysis."""
    stats = snapshot.statistics(key_type)
    lines = [f"Top {limit} memory allocations:"]

    for idx, stat in enumerate(stats[:limit], 1):
        frame = stat.traceback[0]
        lines.append(
            f"#{idx}: {frame.filename}:{frame.lineno} "
            f"size={stat.size / 1024:.1f}KB count={stat.count}"
        )
        line = linecache.getline(frame.filename, frame.lineno).strip()
        if line:
            lines.append(f"     {line}")

    return "\n".join(lines)


def analyze_leak_with_claude(trace_output: str, context: str) -> str:
    """Use Claude to analyze tracemalloc output."""
    client = anthropic.Anthropic()

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Analyze this Python memory allocation trace for potential memory leaks.

Context: {context}

Allocation trace (tracemalloc snapshot diff):
{trace_output}

Identify:
1. Which allocations are growing abnormally
2. The most likely leak location and cause
3. Code pattern to fix the leak
4. How to verify the fix"""
        }]
    )

    return message.content[0].text


def monitor_process(func, iterations=100, context="Unknown process"):
    """Run a function repeatedly and track memory growth."""
    tracemalloc.start(25)  # Capture 25 frames of traceback
    baseline = tracemalloc.take_snapshot()

    for i in range(iterations):
        func()
        if i % 10 == 9:
            print(f"Iteration {i+1}: {tracemalloc.get_traced_memory()[0] / 1024:.1f} KB")

    current = tracemalloc.take_snapshot()

    # Compare snapshots
    top_stats = current.compare_to(baseline, 'lineno')
    formatted = "\n".join(
        str(stat) for stat in top_stats[:15] if stat.size_diff > 0
    )

    if formatted:
        print("\nMemory growth detected. Analyzing with Claude...")
        analysis = analyze_leak_with_claude(formatted, context)
        print(analysis)
    else:
        print("No significant memory growth detected.")

    tracemalloc.stop()

# valgrind_analyzer.py
import anthropic
import xml.etree.ElementTree as ET

def parse_valgrind_xml(xml_file: str) -> str:
    """Extract key information from Valgrind XML output."""
    tree = ET.parse(xml_file)
    root = tree.getroot()

    errors = []
    for error in root.findall('error'):
        kind = error.findtext('kind', 'Unknown')
        what = error.findtext('what', '')
        leak_bytes = error.findtext('.//leakedbytes', '0')

        frames = []
        for frame in error.findall('.//frame')[:5]:  # Top 5 frames
            fn = frame.findtext('fn', '???')
            file = frame.findtext('file', '')
            line = frame.findtext('line', '')
            frames.append(f"  {fn} ({file}:{line})" if file else f"  {fn}")

        errors.append(f"[{kind}] {what} ({leak_bytes} bytes)\n" + "\n".join(frames))

    return "\n\n".join(errors[:20])  # Top 20 errors


def analyze_valgrind(xml_file: str) -> str:
    client = anthropic.Anthropic()
    errors = parse_valgrind_xml(xml_file)

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Analyze these Valgrind memory errors and prioritize fixes:

{errors}

For each error type:
1. Explain the root cause
2. Show the likely code pattern that causes it
3. Provide the fix
4. Priority: CRITICAL / HIGH / MEDIUM"""
        }]
    )

    return message.content[0].text