#!/usr/bin/env python3
"""
META-LEARNER: Eden learns from her own successful solutions
Extracts patterns from working code to improve future generations
"""
import sqlite3
import re
from collections import Counter

DB = "/Eden/DATA/asi_memory.db"

def extract_patterns(code):
    """Extract reusable patterns from working code"""
    patterns = []
    
    # DP pattern
    if "dp[" in code and "for" in code:
        patterns.append("dynamic_programming")
    
    # Recursion
    if re.search(r'def (\w+)\(.*\).*\1\(', code, re.DOTALL):
        patterns.append("recursion")
    
    # List comprehension
    if re.search(r'\[.+for.+in.+\]', code):
        patterns.append("list_comprehension")
    
    # Two pointers
    if "low" in code and "high" in code:
        patterns.append("two_pointers")
    
    # Hash map
    if "dict()" in code or "{}" in code:
        patterns.append("hashmap")
    
    # Sorting
    if "sorted(" in code or ".sort()" in code:
        patterns.append("sorting")
    
    return patterns

def analyze_successes():
    """Analyze all successful capabilities"""
    conn = sqlite3.connect(DB)
    
    # Get high-scoring caps
    caps = conn.execute(
        "SELECT id, code, score FROM caps WHERE score > 1000 ORDER BY score DESC LIMIT 100"
    ).fetchall()
    
    all_patterns = []
    for cap_id, code, score in caps:
        patterns = extract_patterns(code)
        all_patterns.extend(patterns)
    
    # Count patterns
    pattern_counts = Counter(all_patterns)
    
    print("🧠 META-LEARNING ANALYSIS")
    print("="*50)
    print(f"Analyzed: {len(caps)} successful capabilities")
    print("\nPattern frequency:")
    for pattern, count in pattern_counts.most_common():
        print(f"  {pattern}: {count}")
    
    conn.close()
    return pattern_counts

if __name__ == "__main__":
    analyze_successes()

# ============ STRATEGY SELECTION FOR NEW PROBLEMS ============

STRATEGY_MAP = {
    "recursion": {
        "keywords": ["recursive", "self-similar", "tree", "nested", "depth", "factorial", "fibonacci"],
        "solved": ["fibonacci", "factorial", "tree_depth", "tree_sum"]
    },
    "dynamic_programming": {
        "keywords": ["optimal", "minimum", "maximum", "subsequence", "knapsack", "coins", "path"],
        "solved": ["lcs", "knapsack", "coin_change"]
    },
    "divide_conquer": {
        "keywords": ["sort", "merge", "split", "binary", "search", "half"],
        "solved": ["merge_sort", "quick_sort", "binary_search"]
    },
    "iteration": {
        "keywords": ["each", "transform", "reverse", "even", "odd", "prime", "gcd"],
        "solved": ["is_even", "reverse_string", "gcd", "prime_factors", "nth_prime"]
    },
    "stack_queue": {
        "keywords": ["balanced", "parentheses", "matching", "nested", "flatten"],
        "solved": ["valid_parentheses", "flatten_list"]
    },
    "hash_lookup": {
        "keywords": ["count", "frequency", "anagram", "two sum", "duplicate", "unique"],
        "solved": ["word_frequency", "anagram_check", "two_sum"]
    }
}

def suggest_strategy(problem_description):
    """Given a NEW problem, suggest which strategy to use"""
    desc_lower = problem_description.lower()
    
    scores = {}
    for strategy, info in STRATEGY_MAP.items():
        score = sum(1 for kw in info["keywords"] if kw in desc_lower)
        scores[strategy] = score
    
    best_strategy = max(scores, key=scores.get)
    
    if scores[best_strategy] == 0:
        return {"strategy": "unknown", "confidence": 0, "similar": []}
    
    return {
        "strategy": best_strategy,
        "confidence": scores[best_strategy],
        "similar_solved": STRATEGY_MAP[best_strategy]["solved"],
        "hint": f"Try {best_strategy}. You solved {STRATEGY_MAP[best_strategy]['solved'][:2]} the same way."
    }

def get_template_from_solved(strategy):
    """Get working code template from a solved problem"""
    conn = sqlite3.connect(DB)
    
    if strategy in STRATEGY_MAP:
        similar = STRATEGY_MAP[strategy]["solved"][0]
        row = conn.execute(
            "SELECT code FROM caps WHERE id LIKE ? AND score > 1000 ORDER BY score DESC LIMIT 1",
            (f"%{similar}%",)
        ).fetchone()
        conn.close()
        
        if row:
            return {"template": row[0][:800], "from_problem": similar}
    
    conn.close()
    return None

def transfer_solve(new_problem_desc):
    """Full transfer learning: identify strategy + get template"""
    suggestion = suggest_strategy(new_problem_desc)
    
    if suggestion["strategy"] == "unknown":
        return {"success": False, "reason": "No matching strategy found"}
    
    template = get_template_from_solved(suggestion["strategy"])
    
    return {
        "success": True,
        "strategy": suggestion["strategy"],
        "similar_problems": suggestion["similar_solved"],
        "hint": suggestion["hint"],
        "template": template
    }

# Demo
if __name__ == "__main__":
    analyze_successes()
    
    print("\n" + "="*50)
    print("🎯 STRATEGY SELECTION TEST")
    print("="*50)
    
    test_problems = [
        "Find the longest increasing subsequence",
        "Check if string has balanced brackets",
        "Count frequency of each word",
        "Calculate nth term where each = sum of previous two"
    ]
    
    for prob in test_problems:
        result = suggest_strategy(prob)
        print(f"\n  Problem: {prob}")
        print(f"  Strategy: {result['strategy']} (confidence: {result.get('confidence', 0)})")
        if result.get('similar_solved'):
            print(f"  Similar: {result['similar_solved'][:2]}")