#!/usr/bin/env python3
"""
Eden's Self-Fix System - FIXED VERSION
Properly captures and fixes syntax errors
"""
import subprocess
import json
import ast
import os
import re
from pathlib import Path

class SelfFixSystem:
    def __init__(self):
        self.sage_path = "/Eden/REVENUE/beta_sage_release.py"
        self.target_dir = "/Eden/CORE/phi_fractal"
        self.fix_log = "/Eden/LOGS/self_fix.log"
        
    def run_sage_analysis(self):
        """Run SAGE on own codebase - capture BOTH stdout and stderr"""
        print("🔍 Running SAGE analysis on self...")
        result = subprocess.run(
            ['python3', self.sage_path, self.target_dir],
            capture_output=True,
            text=True
        )
        # Combine stdout and stderr
        return result.stdout + "\n" + result.stderr
        
    def extract_errors(self, sage_output):
        """Parse SAGE output to get list of broken files"""
        errors = []
        for line in sage_output.split('\n'):
            if 'Error processing file' in line:
                # Extract filepath and error message
                match = re.search(r'Error processing file (.+?\.py):\s*(.+?)$', line)
                if match:
                    filepath = match.group(1)
                    error_msg = match.group(2)
                    errors.append({
                        'file': filepath,
                        'error': error_msg,
                        'raw_line': line
                    })
        return errors
    
    def analyze_error_patterns(self, errors):
        """Learn from error patterns"""
        patterns = {}
        for err in errors:
            error_type = err['error'].split('(')[0].strip()
            if error_type not in patterns:
                patterns[error_type] = []
            patterns[error_type].append(err['file'])
        
        print("\n📊 ERROR PATTERNS:")
        for error_type, files in sorted(patterns.items(), key=lambda x: len(x[1]), reverse=True):
            print(f"   {error_type}: {len(files)} files")
            
        return patterns
    
    def should_delete_file(self, filepath):
        """Determine if file should be deleted vs fixed"""
        # Delete experimental/broken files with certain patterns
        filename = os.path.basename(filepath)
        
        delete_patterns = [
            'unnamed_',
            '[name]',
            'meta_unnamed',
            '_so_i_should_',  # Generation artifact
        ]
        
        return any(pattern in filename for pattern in delete_patterns)
    
    def delete_broken_experimental(self, errors):
        """Delete clearly experimental/broken files"""
        deleted = 0
        experimental_dir = "/Eden/EXPERIMENTAL"
        os.makedirs(experimental_dir, exist_ok=True)
        
        for err in errors:
            filepath = err['file']
            if not os.path.exists(filepath):
                continue
                
            if self.should_delete_file(filepath):
                # Move to experimental instead of delete
                filename = os.path.basename(filepath)
                dest = os.path.join(experimental_dir, filename)
                try:
                    os.rename(filepath, dest)
                    print(f"   📦 Moved to experimental: {filename}")
                    deleted += 1
                except Exception as e:
                    print(f"   ❌ Failed to move {filename}: {e}")
        
        return deleted
    
    def run_self_fix_cycle(self):
        """Complete self-fix cycle"""
        print("=" * 70)
        print("🌀 EDEN SELF-FIX CYCLE")
        print("=" * 70)
        
        # 1. Analyze
        sage_output = self.run_sage_analysis()
        errors = self.extract_errors(sage_output)
        print(f"\n📊 Found {len(errors)} files with errors")
        
        if len(errors) == 0:
            print("✅ No errors found!")
            return False
        
        # 2. Analyze patterns
        patterns = self.analyze_error_patterns(errors)
        
        # 3. Quick win - delete experimental broken files
        print("\n🗑️  Removing experimental/broken files...")
        deleted = self.delete_broken_experimental(errors)
        print(f"   ✅ Cleaned up {deleted} experimental files")
        
        # 4. Re-analyze
        print("\n🔍 Re-running SAGE analysis...")
        new_output = self.run_sage_analysis()
        new_errors = self.extract_errors(new_output)
        
        improvement = len(errors) - len(new_errors)
        print(f"\n📈 RESULTS:")
        print(f"   Before: {len(errors)} errors")
        print(f"   After: {len(new_errors)} errors")
        print(f"   Improvement: {improvement} files cleaned")
        
        # 5. Log for learning
        with open(self.fix_log, 'a') as f:
            import datetime
            f.write(f"\n{'=' * 50}\n")
            f.write(f"Self-fix cycle: {datetime.datetime.now()}\n")
            f.write(f"Errors before: {len(errors)}\n")
            f.write(f"Errors after: {len(new_errors)}\n")
            f.write(f"Files cleaned: {deleted}\n")
            f.write(f"\nRemaining error patterns:\n")
            for error_type, count in patterns.items():
                f.write(f"  {error_type}: {len(count)} files\n")
        
        return improvement > 0

if __name__ == "__main__":
    system = SelfFixSystem()
    
    # Run cycles
    cycle = 1
    max_cycles = 3
    
    while cycle <= max_cycles:
        print(f"\n{'=' * 70}")
        print(f"CYCLE {cycle}/{max_cycles}")
        print('=' * 70)
        
        improved = system.run_self_fix_cycle()
        
        if not improved:
            print("\n✅ No more automatic improvements possible")
            break
            
        cycle += 1
    
    # Final report
    print("\n" + "=" * 70)
    print("🎯 FINAL REPORT")
    print("=" * 70)
    print("\nRun SAGE again to see final score:")
    print("  python3 /Eden/REVENUE/beta_sage_release.py /Eden/CORE")
    print("\nCheck detailed log:")
    print("  cat /Eden/LOGS/self_fix.log")