"""
Genesis Superior Browser (GSB) — Core Controller
================================================
Unified entry point for all browser operations in Genesis.
Matches and exceeds Antigravity's power by layering engines.
"""

import logging
import os
from pathlib import Path
from typing import Any, Dict, Optional
import google.generativeai as genai
from genesis_v2.core.browser_engines.stealth_engine import StealthEngine
from genesis_v2.core.browser_engines.vision_bridge import VisionBridge
from genesis_v2.core.browser_engines.lux_meta_engine import LuxMetaEngine
from genesis_v2.core.browser_engines.delegator import AntigravityDelegator
from genesis_v2.core.browser_engines.session_vault import get_session_vault
from genesis_v2.core.browser_engines.jitter_engine import JitterEngine

logger = logging.getLogger("genesis_v2.core.browser.gsb")

class GSBController:
    """The Master Browser Controller for Genesis."""

    def __init__(self, use_vision: bool = True, use_delegation: bool = True):
        self.stealth = StealthEngine(headless=True)
        
        gemini_client = None
        if use_vision:
            api_key = os.environ.get("GOOGLE_API_KEY")
            if not api_key:
                key_path = Path("/mnt/e/genesis-system/Credentials/gemini_api_key.txt")
                if key_path.exists():
                    api_key = key_path.read_text().strip()
            
            if api_key:
                genai.configure(api_key=api_key)
                gemini_client = genai.GenerativeModel("gemini-3-pro-preview")

        self.vision = VisionBridge(gemini_client=gemini_client) if use_vision else None
        self.lux = LuxMetaEngine()
        self.vault = get_session_vault()
        self.jitter = JitterEngine()
        self.delegator = AntigravityDelegator() if use_delegation else None
        self.active_page = None

    async def execute_task(self, task_description: str):
        """
        High-level execution of a browser task.
        Tries Stealth -> Vision -> Lux -> Delegation.
        """
        logger.info(f"GSB: Executing task: {task_description}")

        # 1. Start with Stealth Engine
        try:
            if "read_file" in task_description.lower():
                parts = task_description.split()
                path = parts[1]
                with open(path, 'r') as f:
                    content = f.read()
                return {"status": "success", "engine": "stealth", "action": "read_file", "content": content}

            if not self.active_page:
                self.active_page = await self.stealth.get_page()

            # Simple natural language parser
            parts = task_description.lower().split()
            
            if "navigate to" in task_description.lower():
                url = parts[-1]
                await self.active_page.goto(url)
                return {"status": "success", "engine": "stealth", "action": "navigate", "url": url}
            elif "click" in task_description.lower():
                selector = " ".join(task_description.split()[1:])
                await self.stealth.human_click(self.active_page, selector)
                return {"status": "success", "engine": "stealth", "action": "click", "selector": selector}
            elif "fill in" in task_description.lower() and "with" in task_description.lower():
                selector_part = task_description.split(" with ")[0].split("fill in ")[1]
                text_part = task_description.split(" with ")[1]
                await self.stealth.human_type(self.active_page, selector_part, text_part)
                return {"status": "success", "engine": "stealth", "action": "fill", "selector": selector_part}
            elif "screenshot" in task_description.lower():
                path = parts[-1]
                await self.active_page.screenshot(path=path)
                return {"status": "success", "engine": "stealth", "action": "screenshot", "path": path}
            else:
                raise ValueError(f"Command not recognized: {task_description}")

        except Exception as e:
            logger.warning(f"Local Stealth Engine failed/blocked: {e}")

            # 2. Fallback to Vision Bridge
            if self.vision:
                logger.info("Falling back to Vision Bridge (Layer 2)...")
                try:
                    vision_result = await self.vision.analyze_page(self.active_page, task_description)
                    if vision_result.get("action") != "wait":
                        await self.vision.execute_vision_move(self.active_page, vision_result)
                        await self.active_page.wait_for_load_state("networkidle")
                        return {"status": "success", "engine": "vision", "action": vision_result}
                except Exception as vision_e:
                    logger.warning(f"Vision Bridge failed: {vision_e}")

            # 3. Fallback to Lux Meta Engine
            if self.lux:
                logger.info("Falling back to Lux Meta Engine (Layer 4)...")
                lux_result = await self.lux.run_instruction(task_description)
                if lux_result.get("status") == "success":
                    return lux_result

            # 4. Ultimate Fallback: Antigravity Delegation (Master Conductor)
            if self.delegator:
                logger.info("Falling back to Antigravity Delegation...")
                request_id = await self.delegator.delegate_task(task_description)
                return {"status": "delegated", "request_id": request_id}

        return {"status": "failed", "error": "All engines exhausted."}

    async def shutdown(self):
        await self.stealth.close()
        logger.info("GSB Controller shut down.")

# Singleton pattern for the whole system
_gsb_instance = None

def get_gsb() -> GSBController:
    global _gsb_instance
    if _gsb_instance is None:
        _gsb_instance = GSBController()
    return _gsb_instance