"""
Genesis V2 Ultrathink Bridge
============================
Unified session persistence and cross-tool dispatch system.
Connects Google Antigravity ↔ Gemini CLI ↔ Claude Code.
"""

import os
import json
import time
import logging
from pathlib import Path
from dataclasses import dataclass, asdict
from typing import Dict, List, Optional, Any

# Configure logging
logger = logging.getLogger("genesis_v2.core.ultrathink")

# Paths
GENESIS_ROOT = Path("E:/genesis-system")
STATE_DIR = GENESIS_ROOT / ".genesis_state"
SESSION_FILE = STATE_DIR / "ultrathink_session.json"

@dataclass
class BridgeSession:
    """Represents the unified Ultrathink session state."""
    session_id: str
    mission: str
    started_at: float
    last_sync: float
    active_tools: Dict[str, bool]  # e.g. {"gemini_cli": True, "antigravity": False}
    context_summary: str
    dispatch_queue: List[Dict[str, Any]]
    learnings: List[str]

    def to_dict(self) -> dict:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: dict) -> "BridgeSession":
        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})


class UltrathinkBridge:
    """
    Bridge controller for cross-tool synergy.
    """

    def __init__(self):
        self.session: Optional[BridgeSession] = None
        self._ensure_state_dir()
        self.load_session()

    def _ensure_state_dir(self):
        """Ensure state directory exists."""
        if not STATE_DIR.exists():
            STATE_DIR.mkdir(parents=True, exist_ok=True)

    def start_session(self, mission: str) -> BridgeSession:
        """Initialize a new Ultrathink session."""
        session_id = f"ultrathink_{int(time.time())}"
        self.session = BridgeSession(
            session_id=session_id,
            mission=mission,
            started_at=time.time(),
            last_sync=time.time(),
            active_tools={"gemini_cli": False, "antigravity": True, "claude_code": False},
            context_summary="Session started.",
            dispatch_queue=[],
            learnings=[]
        )
        self.save_session()
        logger.info(f"Ultrathink session started: {session_id}")
        return self.session

    def load_session(self) -> Optional[BridgeSession]:
        """Load session state from disk."""
        if SESSION_FILE.exists():
            try:
                data = json.loads(SESSION_FILE.read_text(encoding='utf-8'))
                self.session = BridgeSession.from_dict(data)
                return self.session
            except Exception as e:
                logger.error(f"Failed to load session: {e}")
        return None

    def save_session(self):
        """Persist session state to disk."""
        if self.session:
            self.session.last_sync = time.time()
            SESSION_FILE.write_text(json.dumps(self.session.to_dict(), indent=2), encoding='utf-8')

    def register_tool(self, tool_name: str, status: bool = True):
        """Register a tool as active in the current session."""
        if not self.session:
            self.start_session("Auto-started session")
        
        if self.session:
            self.session.active_tools[tool_name] = status
            self.save_session()

    def dispatch(self, task: str, priority: str = "medium") -> Dict[str, Any]:
        """
        Route a task to the optimal tool based on capability and cost.
        Returns the routing decision.
        """
        tool = self._determine_optimal_tool(task)
        
        task_packet = {
            "id": f"task_{int(time.time())}",
            "content": task,
            "priority": priority,
            "assigned_tool": tool,
            "status": "pending",
            "created_at": time.time()
        }
        
        if self.session:
            self.session.dispatch_queue.append(task_packet)
            self.save_session()
            
        return task_packet

    def _determine_optimal_tool(self, task: str) -> str:
        """Heuristic dispatch logic."""
        task_lower = task.lower()
        
        # Rule 1: Content generation -> Gemini CLI (Free/Fast)
        if any(w in task_lower for w in ["write", "blog", "post", "email", "marketing", "content"]):
            return "gemini-cli"
            
        # Rule 2: Multi-file refactoring -> Jules (Specialist)
        if any(w in task_lower for w in ["refactor", "rewrite", "migrate", "files"]):
            return "jules-pro"
            
        # Rule 3: Complex architecture -> Claude Opus (Planning)
        if any(w in task_lower for w in ["architect", "design", "plan", "strategy"]):
            return "claude-code"
            
        # Rule 4: Research/Browser -> Antigravity (Native Tools)
        if any(w in task_lower for w in ["research", "browse", "find", "search", "investigate"]):
            return "antigravity"
            
        # Default fallback
        return "gemini-cli"

    def get_bridge_status(self) -> Dict[str, Any]:
        """Return comprehensive bridge status."""
        self.load_session() # Refresh from disk
        
        return {
            "status": "active" if self.session else "inactive",
            "session": self.session.to_dict() if self.session else None,
            "state_file": str(SESSION_FILE),
            "bridge_version": "1.0.0"
        }

    def persist_learning(self, insight: str):
        """Save a key learning to the session."""
        if self.session:
            if insight not in self.session.learnings:
                self.session.learnings.append(insight)
                self.save_session()

# Global instance
bridge = UltrathinkBridge()