"""Spawn tool for creating background subagents."""

from typing import TYPE_CHECKING, Any
from collections.abc import Callable, Coroutine

from tinybot.agent.tools.base import Tool, tool_parameters
from tinybot.agent.tools.schema import StringSchema, tool_parameters_schema

if TYPE_CHECKING:
    from tinybot.agent.subagent import SubagentManager


@tool_parameters(
    tool_parameters_schema(
        task=StringSchema("The task for the subagent to complete"),
        label=StringSchema("Optional short label for the task (for display)"),
        required=["task"],
    )
)
class SpawnTool(Tool):
    """Tool to spawn a subagent for background task execution."""

    def __init__(self, manager: "SubagentManager"):
        self._manager = manager
        self._origin_channel = "cli"
        self._origin_chat_id = "direct"
        self._session_key = "cli:direct"

    def set_context(self, channel: str, chat_id: str) -> None:
        """Set the origin context for subagent announcements."""
        self._origin_channel = channel
        self._origin_chat_id = chat_id
        self._session_key = f"{channel}:{chat_id}"

    @property
    def name(self) -> str:
        return "spawn"

    @property
    def description(self) -> str:
        return (
            "Spawn a subagent to handle a task in the background. "
            "Use this for complex or time-consuming tasks that can run independently. "
            "The subagent will complete the task and report back when done. "
            "For deliverables or existing projects, inspect the workspace first "
            "and use a dedicated subdirectory when helpful."
        )

    async def execute(self, task: str, label: str | None = None, **kwargs: Any) -> str:
        """Spawn a subagent to execute the given task."""
        return await self._manager.spawn(
            task=task,
            label=label,
            origin_channel=self._origin_channel,
            origin_chat_id=self._origin_chat_id,
            session_key=self._session_key,
        )

    async def spawn_with_callback(
        self,
        task: str,
        label: str | None = None,
        metadata: dict[str, Any] | None = None,
        on_complete: Callable[[str, str, str, dict[str, Any] | None], Coroutine[Any, Any, None]] | None = None,
    ) -> str:
        """Spawn a subagent with completion callback (for TaskTool integration)."""
        return await self._manager.spawn(
            task=task,
            label=label,
            origin_channel=self._origin_channel,
            origin_chat_id=self._origin_chat_id,
            session_key=self._session_key,
            metadata=metadata,
            on_complete=on_complete,
        )
