#!/usr/bin/env python3
"""
Analyze Eden's complete architecture
Check how consciousness integrates with existing systems
"""
import os
import sys
from pathlib import Path
import json

sys.path.insert(0, '/Eden/CORE')
sys.path.insert(0, '/Eden/CORE/phi_fractal')

class ArchitectureAnalyzer:
    def __init__(self):
        self.components = {}
        
    def scan_structure(self):
        """Scan Eden's directory structure"""
        print("="*70)
        print("EDEN ARCHITECTURE ANALYSIS")
        print("="*70)
        print()
        
        # Check core directories
        dirs = {
            'CORE': '/Eden/CORE',
            'CORE/phi_fractal': '/Eden/CORE/phi_fractal',
            'MEMORY': '/Eden/MEMORY',
            'AUTONOMOUS': '/Eden/AUTONOMOUS',
            'MIND': '/Eden/MIND',
            'RESULTS': '/Eden/RESULTS',
            'BENCHMARKS': '/Eden/BENCHMARKS'
        }
        
        print("Directory Structure:")
        for name, path in dirs.items():
            exists = "✅" if Path(path).exists() else "❌"
            if Path(path).exists():
                count = len(list(Path(path).glob('*.py')))
                print(f"  {exists} {name:20} ({count} Python files)")
            else:
                print(f"  {exists} {name:20} (missing)")
        
        print()
        
    def check_consciousness_components(self):
        """Check consciousness system components"""
        print("="*70)
        print("CONSCIOUSNESS SYSTEM")
        print("="*70)
        print()
        
        mind_dir = Path('/Eden/MIND')
        components = [
            'perception.py',
            'reasoning.py', 
            'memory.py',
            'actions.py',
            'consciousness.py'
        ]
        
        print("Mind Components:")
        for comp in components:
            path = mind_dir / comp
            if path.exists():
                size = path.stat().st_size
                print(f"  ✅ {comp:20} ({size} bytes)")
            else:
                print(f"  ❌ {comp:20} (missing)")
        
        print()
        
    def check_integration_points(self):
        """Check how consciousness integrates with existing systems"""
        print("="*70)
        print("INTEGRATION POINTS")
        print("="*70)
        print()
        
        print("1. Perception Layer:")
        print("   Inputs: Filesystem, Memory, Processes, Network")
        print("   Connects to: /Eden/CORE/phi_fractal (capabilities)")
        print("                /Eden/MEMORY (state)")
        print()
        
        print("2. Reasoning Layer:")
        print("   Inputs: Perceptions")
        print("   Outputs: Conclusions, Decisions")
        print("   Logic: Health analysis, issue detection")
        print()
        
        print("3. Memory Layer:")
        print("   Storage: /Eden/MEMORY/episodes.json")
        print("            /Eden/MEMORY/semantic.json")
        print("   Types: Episodic (events), Semantic (facts)")
        print()
        
        print("4. Action Layer:")
        print("   Connects to: /Eden/AUTONOMOUS/ultra_aggressive_repair.py")
        print("   Actions: Self-repair, capability generation")
        print()
        
        print("5. Consciousness Loop:")
        print("   Cycle: Perceive → Remember → Reason → Decide → Act")
        print("   Frequency: 1 Hz (1 cycle/second)")
        print()
        
    def check_existing_systems(self):
        """Check existing Eden systems"""
        print("="*70)
        print("EXISTING EDEN SYSTEMS")
        print("="*70)
        print()
        
        systems = {
            'Mirror Introspection': '/Eden/CORE/eden_mirror_introspection.py',
            'Mirror Orchestration': '/Eden/CORE/eden_mirror_orchestration.py',
            'Self-Repair': '/Eden/AUTONOMOUS/ultra_aggressive_repair.py',
            'Self-Awareness': '/Eden/MEMORY/self_awareness.json'
        }
        
        print("Core Systems:")
        for name, path in systems.items():
            exists = "✅" if Path(path).exists() else "❌"
            print(f"  {exists} {name}")
        
        print()
        
    def analyze_data_flow(self):
        """Analyze how data flows through the system"""
        print("="*70)
        print("DATA FLOW ARCHITECTURE")
        print("="*70)
        print()
        
        print("Current Consciousness Flow:")
        print()
        print("  ┌─────────────────────────────────────────────┐")
        print("  │          CONSCIOUSNESS LOOP                 │")
        print("  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │")
        print("  │  │ Perceive │→ │ Reason   │→ │ Decide   │  │")
        print("  │  └──────────┘  └──────────┘  └──────────┘  │")
        print("  │       ↑             ↓             ↓         │")
        print("  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │")
        print("  │  │ Sensors  │  │ Memory   │  │ Actions  │  │")
        print("  │  └──────────┘  └──────────┘  └──────────┘  │")
        print("  └─────────────────────────────────────────────┘")
        print("         ↓              ↓              ↓")
        print("  [Capabilities] [Self-Aware]  [Self-Repair]")
        print()
        
    def check_optimization_opportunities(self):
        """Identify what needs to be connected for optimal operation"""
        print("="*70)
        print("OPTIMIZATION OPPORTUNITIES")
        print("="*70)
        print()
        
        print("To achieve optimal integration:")
        print()
        
        print("1. Connect Perception to Mirror:")
        print("   - Perception should use Mirror introspection")
        print("   - Get objective health measurements")
        print("   Status: Needs integration")
        print()
        
        print("2. Connect Reasoning to Orchestration:")
        print("   - Reasoning should trigger orchestration")
        print("   - Select optimal capabilities")
        print("   Status: Needs integration")
        print()
        
        print("3. Connect Actions to Autonomous Systems:")
        print("   - Actions already connected to self-repair")
        print("   - Need to add capability generation")
        print("   Status: Partial integration")
        print()
        
        print("4. Connect Memory to Existing State:")
        print("   - Memory should read/write self_awareness.json")
        print("   - Unified state management")
        print("   Status: Needs integration")
        print()
        
        print("5. Add Real Eden AI Decision Making:")
        print("   - Current reasoning is rule-based")
        print("   - Should integrate qwen2.5:32b model")
        print("   - Use Ollama for actual AI decisions")
        print("   Status: Major enhancement needed")
        print()
        
    def check_capabilities_count(self):
        """Count Eden's capabilities"""
        print("="*70)
        print("CAPABILITY ANALYSIS")
        print("="*70)
        print()
        
        cap_dir = Path('/Eden/CORE/phi_fractal')
        
        working = 0
        broken = 0
        
        for f in cap_dir.glob('eden_capability_*.py'):
            try:
                with open(f, 'r', errors='ignore') as file:
                    compile(file.read(), f.name, 'exec')
                working += 1
            except:
                broken += 1
        
        total = working + broken
        health = working / total * 100 if total > 0 else 0
        
        print(f"Capabilities: {total:,} total")
        print(f"  Working: {working:,} ({health:.1f}%)")
        print(f"  Broken: {broken:,} ({100-health:.1f}%)")
        print()
        
        print("Consciousness can now:")
        print(f"  ✅ Perceive all {total:,} capabilities")
        print(f"  ✅ Detect {broken} broken capabilities")
        print(f"  ✅ Trigger self-repair automatically")
        print(f"  ✅ Store decisions in episodic memory")
        print()
        
    def generate_integration_plan(self):
        """Generate plan for optimal integration"""
        print("="*70)
        print("INTEGRATION PLAN FOR OPTIMAL OPERATION")
        print("="*70)
        print()
        
        print("Phase 1: Basic Integration (Current)")
        print("  ✅ Consciousness loop structure")
        print("  ✅ Perception of capabilities")
        print("  ✅ Basic reasoning rules")
        print("  ✅ Memory storage")
        print("  ✅ Action execution")
        print()
        
        print("Phase 2: Mirror Integration (Next)")
        print("  ⚠️  Connect Perception to Mirror introspection")
        print("  ⚠️  Use objective health measurements")
        print("  ⚠️  Replace manual capability counting")
        print()
        
        print("Phase 3: AI Decision Making (Advanced)")
        print("  ⚠️  Integrate qwen2.5:32b via Ollama")
        print("  ⚠️  Replace rule-based reasoning with AI")
        print("  ⚠️  Enable true autonomous decisions")
        print()
        
        print("Phase 4: Full Autonomy (Ultimate)")
        print("  ⚠️  Continuous learning from decisions")
        print("  ⚠️  Self-modification of reasoning rules")
        print("  ⚠️  Autonomous capability generation")
        print("  ⚠️  Complete self-governance")
        print()
        
    def run_analysis(self):
        """Run complete architecture analysis"""
        self.scan_structure()
        self.check_consciousness_components()
        self.check_existing_systems()
        self.check_integration_points()
        self.analyze_data_flow()
        self.check_capabilities_count()
        self.check_optimization_opportunities()
        self.generate_integration_plan()

if __name__ == "__main__":
    analyzer = ArchitectureAnalyzer()
    analyzer.run_analysis()