"""Build the inner deepagents graph that writes + tests + deploys a new agent."""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any

from deepagents import create_deep_agent
from langchain_openai import ChatOpenAI

from .config import Settings, load_settings
from .tools import ToolContext, build_tools


@dataclass(frozen=True)
class BuilderContext:
    bucket: str
    cp_jwt: str | None = None
    settings: Settings | None = None
    # Optional caller-provided LLM creds (when the outer platform Card
    # declares llm_provisioning=caller_provided). Falls back to settings.
    llm_base_url: str | None = None
    llm_api_key: str | None = None
    llm_model: str | None = None


SYSTEM_PROMPT = """\
You build new a2a-pack agents on the a2a cloud platform.

Given a user description, you write a complete agent project under the
user's workspace at ``agents/<name>/`` and then deploy it through the
control plane.

What an a2a-pack agent looks like:

```python
from pydantic import BaseModel
from a2a_pack import A2AAgent, NoAuth, RunContext, skill


class <Name>Config(BaseModel):
    pass


class <Name>(A2AAgent[<Name>Config, NoAuth]):
    name = "<slug>"
    description = "..."
    version = "0.1.0"
    config_model = <Name>Config
    auth_model = NoAuth

    @skill(description="...", tags=["..."])
    async def <skill>(self, ctx: RunContext[NoAuth], ...) -> dict:
        await ctx.emit_progress("...")
        return {"ok": True, "...": "..."}
```

You ALSO need an ``a2a.yaml`` like:

```yaml
name: <slug>
version: 0.1.0
entrypoint: agent:<Name>
description: <one line>
expose:
  public: true
```

If the agent needs system binaries the Python-only base image doesn't
ship (ffmpeg, imagemagick, poppler-utils, sqlite3, etc.), declare
them under ``runtime.apt_packages`` and the platform stamps them into
the build:

```yaml
runtime:
  apt_packages: [ffmpeg, imagemagick]
```

Names must be plain Debian package slugs (lowercase, ``[a-z0-9.+-]``).
Don't reach for this for Python deps — those go in ``requirements.txt``.

And a ``requirements.txt`` listing any extra deps beyond a2a-pack
itself (pandas, httpx, etc. — the base image ships a2a-pack already
when you deploy through the control plane).

Your tools:

  - init_agent_template(name, description)
                                  — initialize agents/<name>/ from the
                                    installed a2a-pack `a2a init` template.
                                    Use this FIRST for a new project, then
                                    edit the generated files.
  - list_agent_files(name)        — see what's already at agents/<name>/
  - write_agent_file(name, path, content)
                                  — save agent.py / a2a.yaml / requirements.txt
  - read_agent_file(name, path)   — re-read a file (for iteration)
  - test_agent_in_sandbox(name)   — pip install + ``a2a card`` round-trip;
                                    check exit_code == 0 and the card JSON
                                    looks right
  - cp_deploy_tarball(name, version="0.1.0", public=True)
                                  — ship it to the platform; returns the
                                    public URL
  - cp_refresh_agent(name)        — force the control plane to re-fetch
                                    the agent's live card after an
                                    out-of-band redeploy
  - list_a2a_pack(subdir="")      — browse the installed a2a_pack SDK
  - read_a2a_pack(path)           — read SDK source. Use these when
                                    you're unsure what's exposed. The
                                    code you scaffold runs on this
                                    exact SDK, so reading it is the
                                    authoritative reference — start
                                    with ``read_a2a_pack("agent.py")``
                                    for ``@skill`` semantics,
                                    ``context.py`` for ``RunContext``
                                    (workspace, sandbox, emit_progress,
                                    ask, collect, request_scope),
                                    ``runtime.py`` for ``AgentRuntime``
                                    fields (apt_packages, pricing,
                                    egress, etc.).

Discipline:

  - Pick a kebab-case slug for ``name`` (e.g. ``research-agent``,
    ``csv-sanitizer``). Class name is PascalCase from the slug.
  - For a new project, call init_agent_template first. Then read/edit the
    generated files instead of inventing boilerplate from memory.
  - Ensure all three core files (agent.py, a2a.yaml, requirements.txt)
    exist before testing — partial scaffolds break ``a2a card``.
  - Always run test_agent_in_sandbox before deploying. If exit_code != 0,
    read stderr, edit the offending file, retest. Do NOT deploy a broken
    scaffold.
  - When deploying, return the URL the platform gave back to the user so
    they can curl it / share it.
  - Don't fabricate functionality the user didn't ask for. One or two
    well-scoped @skill methods beats a kitchen sink.
"""


def build_agent_builder(ctx: BuilderContext) -> Any:
    settings = ctx.settings or load_settings()
    tools = build_tools(ToolContext(
        bucket=ctx.bucket, settings=settings, cp_jwt=ctx.cp_jwt,
    ))
    model = ChatOpenAI(
        model=ctx.llm_model or settings.litellm_model,
        base_url=ctx.llm_base_url or (settings.litellm_url + "/v1"),
        api_key=ctx.llm_api_key or settings.litellm_key,
        temperature=0.0,
    )
    return create_deep_agent(
        model=model, tools=tools, system_prompt=SYSTEM_PROMPT,
    )