#!/usr/bin/env python3
"""
Eden Mirror Orchestration Engine
Intelligent capability selection and resource optimization
"""
import os
import sys
import json
import random
from pathlib import Path
from datetime import datetime

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

class OrchestrationEngine:
    """Intelligent capability selection and orchestration"""
    
    def __init__(self):
        self.capabilities_dir = Path('/Eden/CORE/phi_fractal')
        self.cache_file = Path('/Eden/MEMORY/orchestration_cache.json')
        self.usage_stats = self.load_usage_stats()
        
    def load_usage_stats(self):
        """Load capability usage statistics"""
        if self.cache_file.exists():
            with open(self.cache_file) as f:
                return json.load(f)
        return {
            'capability_scores': {},
            'last_used': {},
            'success_rates': {}
        }
    
    def save_usage_stats(self):
        """Save usage statistics"""
        with open(self.cache_file, 'w') as f:
            json.dump(self.usage_stats, f, indent=2)
    
    def get_all_capabilities(self):
        """Get list of all available capabilities"""
        capabilities = []
        for f in self.capabilities_dir.glob('eden_capability_*.py'):
            # Extract capability name
            name = f.stem.replace('eden_capability_', '')
            
            # Check if working
            try:
                with open(f, 'r', errors='ignore') as file:
                    compile(file.read(), f.name, 'exec')
                status = 'working'
            except:
                status = 'broken'
            
            capabilities.append({
                'name': name,
                'file': f.name,
                'path': str(f),
                'status': status
            })
        
        return capabilities
    
    def score_capability(self, capability, task_context=None):
        """Score capability relevance for a task"""
        name = capability['name']
        
        # Base score
        score = 50
        
        # Bonus for working status
        if capability['status'] == 'working':
            score += 30
        else:
            score -= 40
        
        # Historical success rate
        if name in self.usage_stats['success_rates']:
            success_rate = self.usage_stats['success_rates'][name]
            score += success_rate * 20
        
        # Recency bonus (recently used = likely useful)
        if name in self.usage_stats['last_used']:
            # Simple recency heuristic
            score += 5
        
        # Task context matching (if provided)
        if task_context:
            # Simple keyword matching
            context_lower = task_context.lower()
            name_lower = name.lower()
            
            # Check for keyword overlap
            context_words = set(context_lower.split('_'))
            name_words = set(name_lower.split('_'))
            overlap = len(context_words & name_words)
            
            score += overlap * 15
        
        return max(0, min(100, score))
    
    def select_capabilities(self, task_context=None, max_capabilities=7):
        """Select optimal capabilities for a task"""
        all_caps = self.get_all_capabilities()
        
        # Score each capability
        scored = []
        for cap in all_caps:
            score = self.score_capability(cap, task_context)
            scored.append({
                'capability': cap,
                'score': score
            })
        
        # Sort by score
        scored.sort(key=lambda x: x['score'], reverse=True)
        
        # Select top N
        selected = scored[:max_capabilities]
        
        return [s['capability'] for s in selected]
    
    def record_usage(self, capability_name, success=True):
        """Record capability usage"""
        # Update success rate
        if capability_name not in self.usage_stats['success_rates']:
            self.usage_stats['success_rates'][capability_name] = 0.5
        
        current = self.usage_stats['success_rates'][capability_name]
        # Simple exponential moving average
        new_rate = current * 0.9 + (1.0 if success else 0.0) * 0.1
        self.usage_stats['success_rates'][capability_name] = new_rate
        
        # Update last used
        self.usage_stats['last_used'][capability_name] = str(datetime.now())
        
        self.save_usage_stats()
    
    def optimize(self):
        """Optimize orchestration based on usage patterns"""
        print("Analyzing usage patterns...")
        
        # Find underperforming capabilities
        underperforming = []
        for name, rate in self.usage_stats['success_rates'].items():
            if rate < 0.3:
                underperforming.append(name)
        
        return {
            'underperforming': underperforming,
            'total_tracked': len(self.usage_stats['success_rates']),
            'optimization_needed': len(underperforming) > 0
        }
    
    def get_stats(self):
        """Get orchestration statistics"""
        all_caps = self.get_all_capabilities()
        working = sum(1 for c in all_caps if c['status'] == 'working')
        
        return {
            'total_capabilities': len(all_caps),
            'working': working,
            'broken': len(all_caps) - working,
            'tracked_usage': len(self.usage_stats['success_rates']),
            'health': working / len(all_caps) if all_caps else 0
        }

def main():
    """Test orchestration"""
    print("="*70)
    print("EDEN MIRROR ORCHESTRATION ENGINE")
    print("="*70)
    print()
    
    engine = OrchestrationEngine()
    
    # Get stats
    stats = engine.get_stats()
    print("System Statistics:")
    print(f"  Total capabilities: {stats['total_capabilities']}")
    print(f"  Working: {stats['working']}")
    print(f"  Broken: {stats['broken']}")
    print(f"  Health: {stats['health']:.1%}")
    print()
    
    # Test capability selection
    print("Testing capability selection...")
    selected = engine.select_capabilities(task_context="data analysis", max_capabilities=5)
    print(f"Selected {len(selected)} capabilities:")
    for cap in selected[:5]:
        print(f"  • {cap['name']}")
    print()
    
    print("Orchestration engine operational ✅")

if __name__ == "__main__":
    main()