#!/usr/bin/env python3
"""Teach Eden the functions she couldn't figure out"""
import sqlite3

DB = "/mnt/eden_ram/asi_memory.db"
PHI = 1.618033988749895

# Correct implementations for Eden to learn
LESSONS = [
    {
        "name": "bubble_sort",
        "code": """def bubble_sort(arr):
    arr = arr.copy()
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr""",
        "tests": [([3,1,2], [1,2,3]), ([5,4,3,2,1], [1,2,3,4,5]), ([], [])]
    },
    {
        "name": "gcd",
        "code": """def gcd(a, b):
    while b:
        a, b = b, a % b
    return a""",
        "tests": [(12, 8, 4), (17, 5, 1), (100, 25, 25)]
    },
    {
        "name": "flatten_list",
        "code": """def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result""",
        "tests": [([[1,2],[3]], [1,2,3]), ([[1],[2],[3]], [1,2,3]), ([], [])]
    },
    {
        "name": "merge_sort",
        "code": """def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result""",
        "tests": [([3,1,2], [1,2,3]), ([5,4,3,2,1], [1,2,3,4,5])]
    },
    {
        "name": "quick_sort",
        "code": """def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)""",
        "tests": [([3,1,2], [1,2,3]), ([5,4,3,2,1], [1,2,3,4,5])]
    },
    {
        "name": "prime_factors",
        "code": """def prime_factors(n):
    factors = []
    d = 2
    while d * d <= n:
        while n % d == 0:
            factors.append(d)
            n //= d
        d += 1
    if n > 1:
        factors.append(n)
    return factors""",
        "tests": [(12, [2,2,3]), (17, [17]), (100, [2,2,5,5])]
    },
]

def verify(code, tests):
    """Test if code works"""
    try:
        namespace = {}
        exec(code, namespace)
        func = [v for v in namespace.values() if callable(v) and not str(v).startswith('<built')][0]
        
        for test in tests:
            if len(test) == 3:
                if func(test[0], test[1]) != test[2]:
                    return False
            elif len(test) == 2:
                if func(test[0]) != test[1]:
                    return False
        return True
    except Exception as e:
        print(f"Error: {e}")
        return False

print("🎓 TEACHING EDEN NEW FUNCTIONS")
print("=" * 50)

conn = sqlite3.connect(DB)
learned = 0

for lesson in LESSONS:
    name = lesson["name"]
    code = lesson["code"]
    tests = lesson["tests"]
    
    print(f"\n📚 {name}:")
    
    if verify(code, tests):
        conn.execute(
            "INSERT OR REPLACE INTO caps VALUES (?,?,?,?)",
            (f"verified_{name}", code, 1618.0, 100)
        )
        print(f"   ✅ Verified and saved!")
        learned += 1
    else:
        print(f"   ❌ Test failed")

conn.commit()
conn.close()

print(f"\n{'='*50}")
print(f"🎓 Eden learned {learned}/{len(LESSONS)} new functions!")

# Count total verified
conn = sqlite3.connect(DB)
total = conn.execute("SELECT COUNT(*) FROM caps WHERE id LIKE 'verified_%'").fetchone()[0]
conn.close()
print(f"📊 Total verified capabilities: {total}")