"""
GENESIS SKILLS ENGINE
Advanced skill execution, discovery, and management
"""
import json
import importlib.util
from typing import Dict, Any, Callable, List
from pathlib import Path
from datetime import datetime

class SkillEngine:
    """Manages and executes Genesis skills"""
    
    def __init__(self, skills_dir: str = "E:/genesis-system/skills"):
        self.skills_dir = Path(skills_dir)
        self.skills_dir.mkdir(exist_ok=True)
        self.registry: Dict[str, Dict] = {}
        self.metrics: Dict[str, Dict] = {}
        
    def register_skill(self, name: str, skill_def: Dict) -> bool:
        """Register a new skill"""
        skill_id = f"{name}:v{skill_def.get('version', '1.0')}"
        
        # Validate skill definition
        required = ['type', 'description']
        if not all(k in skill_def for k in required):
            raise ValueError(f"Missing required fields: {required}")
        
        self.registry[skill_id] = {
            **skill_def,
            'name': name,
            'registered_at': datetime.now().isoformat(),
            'execution_count': 0
        }
        
        # Save to disk
        skill_file = self.skills_dir / f"{name}_v{skill_def.get('version', '1.0')}.json"
        with open(skill_file, 'w') as f:
            json.dump(self.registry[skill_id], f, indent=2)
        
        return True
    
    def execute(self, skill_name: str, params: Dict[str, Any]) -> Any:
        """Execute a skill with parameters"""
        # Find latest version
        matching = [k for k in self.registry if k.startswith(f"{skill_name}:")]
        if not matching:
            raise ValueError(f"Skill not found: {skill_name}")
        
        skill_id = sorted(matching)[-1]  # Latest version
        skill = self.registry[skill_id]
        
        # Track execution
        self.metrics.setdefault(skill_id, {
            'total_executions': 0,
            'successful': 0,
            'failed': 0,
            'avg_duration_ms': 0
        })
        
        start = datetime.now()
        
        try:
            # Execute based on skill type
            if skill['type'] == 'python':
                result = self._execute_python(skill, params)
            elif skill['type'] == 'prompt':
                result = self._execute_prompt(skill, params)
            elif skill['type'] == 'workflow':
                result = self._execute_workflow(skill, params)
            else:
                raise ValueError(f"Unknown skill type: {skill['type']}")
            
            # Update metrics
            duration = (datetime.now() - start).total_seconds() * 1000
            metrics = self.metrics[skill_id]
            metrics['total_executions'] += 1
            metrics['successful'] += 1
            metrics['avg_duration_ms'] = (
                (metrics['avg_duration_ms'] * (metrics['total_executions'] - 1) + duration)
                / metrics['total_executions']
            )
            
            self.registry[skill_id]['execution_count'] += 1
            
            return result
            
        except Exception as e:
            self.metrics[skill_id]['failed'] += 1
            raise
    
    def _execute_python(self, skill: Dict, params: Dict) -> Any:
        """Execute Python code skill"""
        code = skill.get('code', '')
        if not code:
            raise ValueError("Python skill has no code")
        
        # Create isolated namespace
        namespace = {'params': params}
        exec(code, namespace)
        
        return namespace.get('result')
    
    def _execute_prompt(self, skill: Dict, params: Dict) -> str:
        """Execute prompt template skill"""
        template = skill.get('template', '')
        return template.format(**params)
    
    def _execute_workflow(self, skill: Dict, params: Dict) -> Dict:
        """Execute n8n workflow skill"""
        # Placeholder for workflow integration
        return {
            'workflow': skill.get('workflow_name'),
            'status': 'triggered',
            'params': params
        }
    
    def discover(self, query: str = None, category: str = None) -> List[Dict]:
        """Discover skills by query or category"""
        results = []
        
        for skill_id, skill in self.registry.items():
            match = True
            
            if query:
                match = match and (
                    query.lower() in skill['name'].lower() or
                    query.lower() in skill.get('description', '').lower()
                )
            
            if category:
                match = match and skill.get('category') == category
            
            if match:
                results.append({
                    'id': skill_id,
                    'name': skill['name'],
                    'version': skill.get('version', '1.0'),
                    'category': skill.get('category', 'general'),
                    'description': skill.get('description', ''),
                    'executions': skill.get('execution_count', 0)
                })
        
        return results
    
    def get_metrics(self, skill_name: str = None) -> Dict:
        """Get execution metrics"""
        if skill_name:
            matching = [k for k in self.metrics if k.startswith(f"{skill_name}:")]
            return {k: self.metrics[k] for k in matching}
        return self.metrics


# Initialize global engine
engine = SkillEngine()


# Starter Skills
STARTER_SKILLS = {
    "csv-analyzer": {
        "version": "1.0",
        "type": "python",
        "category": "data-processing",
        "description": "Analyze CSV files for statistical insights",
        "parameters": {"file_path": "string"},
        "code": """
import pandas as pd
df = pd.read_csv(params['file_path'])
result = {
    'rows': len(df),
    'columns': list(df.columns),
    'summary': df.describe().to_dict()
}
"""
    },
    
    "api-caller": {
        "version": "1.0",
        "type": "python",
        "category": "integration",
        "description": "Make HTTP API calls with authentication",
        "parameters": {"url": "string", "method": "string", "data": "dict"},
        "code": """
import requests
result = requests.request(
    params['method'],
    params['url'],
    json=params.get('data')
).json()
"""
    },
    
    "text-transformer": {
        "version": "1.0",
        "type": "python",
        "category": "data-processing",
        "description": "Transform text with regex and templates",
        "parameters": {"text": "string", "operation": "string"},
        "code": """
import re
text = params['text']
op = params['operation']

if op == 'uppercase':
    result = text.upper()
elif op == 'extract_emails':
    result = re.findall(r'[\\w.+-]+@[\\w-]+\\.[\\w.-]+', text)
elif op == 'extract_urls':
    result = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)
else:
    result = text
"""
    }
}


if __name__ == "__main__":
    # Register starter skills
    for name, skill_def in STARTER_SKILLS.items():
        engine.register_skill(name, skill_def)
        print(f"[OK] Registered: {name}")
    
    print(f"\n[READY] Skills Engine - {len(engine.registry)} skills loaded")