"""
GENESIS SKILLS LIBRARY
======================
Executable logic for Genesis Skills.
The Coordinator calls these functions to perform real work.
"""

import time
import subprocess
import os

class GenesisSkills:
    def __init__(self):
        self.root = os.path.dirname(os.path.abspath(__file__))
        
        # Lazy imports to avoid circular dependencies or heavy init
        self._notebook = None
        self._vids = None
        self._workspace = None
        self._imagen = None
        self._veo = None
        self._tts = None
        self._grounding = None
        self._ghl = None # Added for GHL MCP integration

    def _get_notebook(self):
        if not self._notebook:
            from notebook_lm_skill import NotebookLMAgent
            self._notebook = NotebookLMAgent()
        return self._notebook

    def _get_vids(self):
        if not self._vids:
            from vids_automator import VidsAutomator
            self._vids = VidsAutomator()
        return self._vids

    def _get_workspace(self):
        if not self._workspace:
            from workspace_skill import WorkspaceAgent
            self._workspace = WorkspaceAgent()
        return self._workspace

    def _get_imagen(self):
        if not self._imagen:
            from imagen_generator import ImagenAgent
            self._imagen = ImagenAgent()
        return self._imagen

    def _get_veo(self):
        if not self._veo:
            from veo_generator import VeoAgent
            self._veo = VeoAgent()
        return self._veo

    def _get_tts(self):
        if not self._tts:
            from tts_generator import TTSAgent
            self._tts = TTSAgent()
        return self._tts

    def execute(self, skill_name: str, task_context: str) -> bool:
        """Execute a skill by name."""
        method_name = f"run_{skill_name}"
        if hasattr(self, method_name):
            try:
                return getattr(self, method_name)(task_context)
            except Exception as e:
                print(f"[ERR] Skill execution failed: {skill_name} | {e}")
                return False
        else:
            print(f"!! Skill execution logic not found for: {skill_name}")
            return False

    # --- Specialized Skills ---

    def run_browser_mastery(self, task):
        from browser_mastery_skill import BrowserMasteryAgent
        import asyncio
        agent = BrowserMasteryAgent()
        asyncio.run(agent.execute_mission(task))
        print(f"[SKILL] Gemini 3 Browser Mastery complete for: {task}")
        return True

    def run_notebook_lm_skill(self, task):
        result = self._get_notebook().deep_research(task)
        print(f"[SKILL] NotebookLM complete: {len(result['report'])} chars produced.")
        return True

    def run_vids_automator(self, task):
        result = self._get_vids().create_presentation(task)
        print(f"[SKILL] Vids automation queued: {result['video_operation_id']}")
        return True

    def run_workspace_skill(self, task):
        if "email" in task.lower():
            self._get_workspace().compose_email("target@example.com", "Swarm Update", task)
        else:
            self._get_workspace().draft_summary("Swarm Findings", task)
        return True

    def run_imagen_generator(self, task):
        result = self._get_imagen().generate(task)
        print(f"[SKILL] Image generated: {result['path']}")
        return True

    def run_veo_generator(self, task):
        result = self._get_veo().generate(task)
        print(f"[SKILL] Video operation started: {result['operation_id']}")
        return True

    def run_tts_generator(self, task):
        result = self._get_tts().generate(task)
        print(f"[SKILL] Audio generated: {result['path']}")
        return True

    def run_ghl_automation(self, task):
        from ghl_mcp_bridge import GHLMCPBridge
        import os
        
        server_dir = os.path.join(self.root, "mcp-servers", "ghl")
        bridge = GHLMCPBridge(server_dir)
        
        try:
            print(f"[SKILL] GHL MCP Bridge active. Task: {task}")
            tools = bridge.list_tools()
            print(f"[SKILL] {len(tools)} GHL tools available for autonomous execution.")
            
            # For now, we list the tools to prove capability. 
            # In a full mission, we would call Gemini to select and execute.
            return True
        except Exception as e:
            print(f"[ERR] GHL Automation failed: {e}")
            return False
        finally:
            bridge.stop()

    # --- Legacy/Placeholder Skills ---