"""Tool manager for loading and managing tools."""

import logging
from pathlib import Path
from typing import Any

from nanobot.agent.tools.registry import ToolRegistry

from agents.tools.builtin import get_builtin_tools

logger = logging.getLogger(__name__)


class ToolManager:
    """Manages tools for the agent."""

    def __init__(self, workspace: Path | None = None):
        """Initialize tool manager.

        Args:
            workspace: Optional workspace path
        """
        self.workspace = workspace
        self.registry = ToolRegistry()
        self._load_builtin_tools()

    def _load_builtin_tools(self) -> None:
        """Load all built-in tools."""
        tools = get_builtin_tools(self.workspace)
        for tool in tools:
            self.registry.register(tool)
        logger.info(f"Loaded {len(tools)} built-in tools")

    def register_tool(self, tool: Any) -> None:
        """Register a custom tool.

        Args:
            tool: Tool instance to register
        """
        self.registry.register(tool)
        logger.info(f"Registered tool: {tool.name}")

    def unregister_tool(self, name: str) -> None:
        """Unregister a tool.

        Args:
            name: Tool name to unregister
        """
        self.registry.unregister(name)
        logger.info(f"Unregistered tool: {name}")

    def get_tool(self, name: str) -> Any:
        """Get a tool by name.

        Args:
            name: Tool name

        Returns:
            Tool instance or None
        """
        return self.registry.get(name)

    def has_tool(self, name: str) -> bool:
        """Check if a tool is registered.

        Args:
            name: Tool name

        Returns:
            True if tool exists
        """
        return self.registry.has(name)

    def list_tools(self) -> list[str]:
        """List all registered tool names.

        Returns:
            List of tool names
        """
        return self.registry.tool_names

    def get_tool_definitions(self) -> list[dict[str, Any]]:
        """Get all tool definitions in OpenAI format.

        Returns:
            List of tool schemas
        """
        return self.registry.get_definitions()

    async def execute_tool(self, name: str, params: dict[str, Any]) -> str:
        """Execute a tool by name.

        Args:
            name: Tool name
            params: Tool parameters

        Returns:
            Tool execution result
        """
        return await self.registry.execute(name, params)

    def __len__(self) -> int:
        """Get number of registered tools."""
        return len(self.registry)

    def __contains__(self, name: str) -> bool:
        """Check if tool is registered."""
        return name in self.registry