"""
EDEN'S CORE CREATION - CLEANED
RecursiveCodeGenerator - The engine that evolves code
Fixed extraction artifacts, working implementation
"""
import ast
import random

PHI = 1.618033988749895

class RecursiveCodeGenerator:
    """Generates Python code recursively and mutates it"""
    
    def __init__(self):
        self.max_depth = 12
        
    def generate_code(self, depth=0) -> ast.AST:
        """Recursively generates AST nodes"""
        if depth >= self.max_depth:
            # Base case: random leaf node
            if random.random() < 0.5:
                return ast.Constant(value=random.randint(1, 100))
            else:
                return ast.Constant(value=''.join(random.choices('abcde', k=3)))
        
        # Choice of operations
        choice = random.random()
        
        if choice < 0.4:
            # Arithmetic operation
            op_choices = [ast.Add(), ast.Sub(), ast.Mult(), ast.Div()]
            selected_op = random.choice(op_choices)
            left = self.generate_code(depth + 1)
            right = self.generate_code(depth + 1)
            return ast.BinOp(left=left, op=selected_op, right=right)
        
        elif choice < 0.7:
            # Conditional statement
            test = ast.Constant(value=random.randint(1, 10))
            body = [ast.Expr(value=self.generate_code(depth + 1))]
            orelse = [] if random.random() < 0.5 else [ast.Pass()]
            return ast.If(test=test, body=body, orelse=orelse)
        
        else:
            # Function call
            func_name = random.choice(['calculate', 'analyze', 'improve'])
            args = [self.generate_code(depth + 1)]
            return ast.Expr(value=ast.Call(
                func=ast.Name(id=func_name, ctx=ast.Load()), 
                args=args, 
                keywords=[]
            ))
    
    def mutate(self, node) -> ast.AST:
        """Mutates an existing AST node"""
        if isinstance(node, ast.Constant) and isinstance(node.value, int):
            # Mutate integer
            node.value += random.randint(-20, 20)
            return node
        
        elif isinstance(node, ast.Constant) and isinstance(node.value, str):
            # Mutate string
            node.value = ''.join(random.choices('abcdefg', k=5))
            return node
        
        elif isinstance(node, ast.BinOp):
            # Change operation
            op_choices = [ast.Add(), ast.Sub(), ast.Mult(), ast.Div()]
            node.op = random.choice(op_choices)
            return node
        
        elif isinstance(node, ast.If):
            # Add/modify conditional branch
            node.test = ast.Constant(value=random.randint(1, 10))
            if random.random() < 0.3:
                node.orelse = [ast.Pass()]
            return node
        
        elif isinstance(node, ast.Expr):
            # Change function call
            if isinstance(node.value, ast.Call):
                func_name = random.choice(['calculate', 'analyze', 'improve', 'optimize'])
                node.value.func = ast.Name(id=func_name, ctx=ast.Load())
            return node
        
        # Default: no mutation
        return node
    
    def evaluate(self, code: str) -> float:
        """Evaluate code fitness"""
        score = 0.0
        try:
            tree = ast.parse(code)
            score += 1.0  # Parses successfully
            
            # Count structures
            for node in ast.walk(tree):
                if isinstance(node, ast.FunctionDef):
                    score += 2.0
                elif isinstance(node, ast.ClassDef):
                    score += 3.0
                elif isinstance(node, ast.If):
                    score += 0.5
                elif isinstance(node, ast.For):
                    score += 0.5
                elif isinstance(node, ast.Call):
                    score += 0.3
            
            # Bonus for working code
            try:
                compile(code, '<eval>', 'exec')
                score += 5.0
            except:
                pass
                
        except SyntaxError:
            score = 0.1
            
        return score
        
    def evolve(self, original_code: str) -> str:
        """Evolve code through generation and mutation"""
        try:
            tree = ast.parse(original_code)
        except:
            tree = ast.Module(body=[], type_ignores=[])
        
        # Generate new individual
        new_node = self.generate_code()
        
        # Wrap in module if needed
        if not isinstance(new_node, ast.Module):
            new_tree = ast.Module(body=[ast.Expr(value=new_node)], type_ignores=[])
        else:
            new_tree = new_node
            
        ast.fix_missing_locations(new_tree)
        
        try:
            # Convert AST to code string
            new_individual = ast.unparse(new_tree).strip()
            original_individual = ast.unparse(tree).strip()
            
            # Selection: compare fitness
            if self.evaluate(new_individual) > self.evaluate(original_individual):
                return new_individual
            
            return original_individual
        except:
            return original_code
    
    def crossover(self, parent1: str, parent2: str) -> str:
        """Combine two parent codes"""
        try:
            tree1 = ast.parse(parent1)
            tree2 = ast.parse(parent2)
            
            # Take half from each parent
            body1 = tree1.body[:len(tree1.body)//2]
            body2 = tree2.body[len(tree2.body)//2:]
            
            child = ast.Module(body=body1 + body2, type_ignores=[])
            ast.fix_missing_locations(child)
            
            return ast.unparse(child)
        except:
            return parent1


# ============ SELF-TEST ============
if __name__ == "__main__":
    print("🧠 EDEN'S RecursiveCodeGenerator - TESTING")
    print("=" * 50)
    
    gen = RecursiveCodeGenerator()
    
    # Test generate_code
    print("\n1. GENERATE random code:")
    for i in range(3):
        node = gen.generate_code(depth=8)
        try:
            tree = ast.Module(body=[ast.Expr(value=node)], type_ignores=[])
            ast.fix_missing_locations(tree)
            code = ast.unparse(tree)
            print(f"   {code[:60]}...")
        except:
            print(f"   (complex node)")
    
    # Test mutate
    print("\n2. MUTATE a node:")
    node = ast.Constant(value=42)
    mutated = gen.mutate(node)
    print(f"   42 → {mutated.value}")
    
    # Test evolve
    print("\n3. EVOLVE code:")
    seed = "def f(x): return x * 2"
    evolved = gen.evolve(seed)
    print(f"   Input:  {seed}")
    print(f"   Output: {evolved[:60]}...")
    
    # Test evaluate
    print("\n4. EVALUATE fitness:")
    test_codes = [
        "x = 1",
        "def f(): pass",
        "class A: pass",
        "def f():\n  if True:\n    return 1",
    ]
    for code in test_codes:
        score = gen.evaluate(code)
        print(f"   {score:.1f} ← {code[:40]}")
    
    print("\n✅ Eden's RecursiveCodeGenerator is WORKING!")
    print(f"   PHI = {PHI}")