from typing import List, Dict, Any, Optional
from sqlalchemy.orm import Session
from app.db import models
from app.core.skills.base import BaseSkill
import logging

logger = logging.getLogger(__name__)

class ToolService:
    """
    Orchestrates AI tools (Skills) available to users.
    Handles discovery, permission checks, and execution routing.
    """
    
    def __init__(self, services: Any = None, local_skills: List[BaseSkill] = []):
        self._services = services
        self._local_skills = {s.name: s for s in local_skills}

    def get_available_tools(self, db: Session, user_id: str, feature: str = None) -> List[Dict[str, Any]]:
        """
        Retrieves all tools the user is authorized to use, optionally filtered by feature.
        """
        # 1. Fetch system/local skills and filter by feature if requested
        local_skills = self._local_skills.values()
        if feature:
            local_skills = [s for s in local_skills if feature in getattr(s, "features", ["chat"])]
        
        tools = [s.to_tool_definition() for s in local_skills]
        
        # 2. Add DB-defined skills (System skills or user-owned)
        query = db.query(models.Skill).filter(
            (models.Skill.is_system == True) | 
            (models.Skill.owner_id == user_id)
        ).filter(models.Skill.is_enabled == True)
        
        if feature:
            # SQLAlchemy JSON containment check (SQLite specific or generic enough)
            # For simplicity, we filter in Python if the DB driver is tricky
            db_skills = query.all()
            db_skills = [ds for ds in db_skills if feature in (ds.features or [])]
        else:
            db_skills = query.all()
        
        for ds in db_skills:
            # Prevent duplicates if name overlaps with local
            if any(t["function"]["name"] == ds.name for t in tools):
                continue
            
            tools.append({
                "type": "function",
                "function": {
                    "name": ds.name,
                    "description": ds.description,
                    "parameters": ds.config.get("parameters", {})
                }
            })
            
        return tools

    async def call_tool(self, tool_name: str, arguments: Dict[str, Any], db: Session = None, user_id: str = None) -> Any:
        """
        Executes a registered skill.
        """
        # 1. Try local/native skill first
        if tool_name in self._local_skills:
            skill = self._local_skills[tool_name]
            result = await skill.execute(**arguments)
            return result.dict()
        
        # 2. Handle System / DB Skills
        if db:
            db_skill = db.query(models.Skill).filter(models.Skill.name == tool_name).first()
            if db_skill and db_skill.is_system:
                return await self._execute_system_skill(db_skill, arguments)
        
        logger.error(f"Tool '{tool_name}' not found or handled yet.")
        return {"success": False, "error": "Tool not found"}

    async def _execute_system_skill(self, skill: models.Skill, args: Dict[str, Any]) -> Any:
        """Routes system skill execution to a stateful SubAgent."""
        from app.core.services.sub_agent import SubAgent
        
        orchestrator = getattr(self._services, "orchestrator", None)
        if not orchestrator:
            return {"success": False, "error": "Orchestrator not available"}
        
        assistant = orchestrator.assistant
        node_id = args.get("node_id")

        if not node_id:
            return {"success": False, "error": "node_id is required"}

        # Define the task function and arguments for the SubAgent
        task_fn = None
        task_args = {}

        try:
            if skill.name == "mesh_terminal_control":
                # Maps to TaskAssistant.dispatch_single
                cmd = args.get("command")
                timeout = int(args.get("timeout", 30))
                task_fn = assistant.dispatch_single
                task_args = {"node_id": node_id, "cmd": cmd, "timeout": timeout}

            elif skill.name == "browser_automation_agent":
                # Maps to TaskAssistant.dispatch_browser
                from app.protos import agent_pb2
                action_str = args.get("action", "navigate").upper()
                action_type = getattr(agent_pb2.BrowserAction, action_str, agent_pb2.BrowserAction.NAVIGATE)
                
                browser_action = agent_pb2.BrowserAction(
                    action=action_type,
                    url=args.get("url", ""),
                )
                task_fn = assistant.dispatch_browser
                task_args = {"node_id": node_id, "action": browser_action}

            elif skill.name == "mesh_file_explorer":
                # Maps to TaskAssistant.ls, cat, write, rm
                action = args.get("action")
                path = args.get("path")
                
                if action == "list":
                    task_fn = assistant.ls
                    task_args = {"node_id": node_id, "path": path}
                elif action == "read":
                    task_fn = assistant.cat
                    task_args = {"node_id": node_id, "path": path}
                elif action == "write":
                    content = args.get("content", "").encode('utf-8')
                    task_fn = assistant.write
                    task_args = {"node_id": node_id, "path": path, "content": content}
                elif action == "delete":
                    task_fn = assistant.rm
                    task_args = {"node_id": node_id, "path": path}
                else:
                    return {"success": False, "error": f"Unsupported action: {action}"}

            if task_fn:
                # Create and run the SubAgent
                sub_agent = SubAgent(
                    name=f"{skill.name}_{node_id}",
                    task_fn=task_fn,
                    args=task_args,
                    retries=2 # Allow 2 retries for transient node issues
                )
                res = await sub_agent.run()
                
                # Post-process specific results to be more AI-friendly
                if skill.name == "mesh_file_explorer" and args.get("action") == "list":
                    if isinstance(res, dict) and "files" in res:
                        res = self._format_ls_result(res, node_id, path)

                # Standardize output for AI
                if isinstance(res, dict) and "error" in res:
                    return {"success": False, "error": res["error"], "sub_agent_status": sub_agent.status}
                
                return {"success": True, "output": res, "sub_agent_status": sub_agent.status}

        except Exception as e:
            logger.exception(f"System skill execution failed: {e}")
            return {"success": False, "error": str(e)}

        return {"success": False, "error": "Skill execution logic not found"}

    def _format_ls_result(self, res: dict, node_id: str, path: str) -> str:
        """Formats raw directory listing for LLM consumption."""
        formatted = f"Directory listing for '{res.get('path', path)}' on node {node_id}:\n"
        files = res.get("files")
        if not files:
            formatted += "(Empty directory or failed to list files)"
        else:
            files.sort(key=lambda x: (not x.get("is_dir"), x.get("name", "").lower()))
            limit = 100
            for f in files[:limit]:
                icon = "📁" if f.get("is_dir") else "📄"
                size_str = f" ({f.get('size')} bytes)" if not f.get("is_dir") else ""
                formatted += f"{icon} {f.get('name')}{size_str}\n"
            if len(files) > limit:
                formatted += f"... and {len(files) - limit} more items."
        return formatted