import importlib
from types import SimpleNamespace

import pytest

from agent.core.runner import RunConfig
from agent.trace.project_environment import ProjectEnvironment
from examples.legacy_adapters import LegacyExampleResolver


@pytest.mark.asyncio
async def test_legacy_example_resolver_success_missing_and_internal_error(monkeypatch):
    resolver = LegacyExampleResolver()
    received = []

    async def initializer(messages=None):
        received.append(messages)
        return "project-runner", messages or [{"role": "user", "content": "default"}], RunConfig()

    module = SimpleNamespace(init_project_env=initializer)
    monkeypatch.setattr(importlib, "import_module", lambda name: module)
    resolved = await resolver.resolve("demo", [{"role": "user", "content": "input"}])
    assert resolved.runner == "project-runner"
    assert received[-1][0]["content"] == "input"

    def missing(name):
        error = ImportError("missing project")
        error.name = "examples.missing.run"
        raise error

    monkeypatch.setattr(importlib, "import_module", missing)
    assert await resolver.resolve("missing") is None

    def internal_error(name):
        error = ImportError("missing dependency")
        error.name = "business_dependency"
        raise error

    monkeypatch.setattr(importlib, "import_module", internal_error)
    with pytest.raises(ImportError, match="dependency"):
        await resolver.resolve("broken")


@pytest.mark.asyncio
async def test_run_api_uses_injected_project_environment(monkeypatch):
    from agent.trace import run_api

    selected = {}
    project_runner = object()

    class Resolver:
        async def resolve(self, project_name, messages=None):
            selected["project_name"] = project_name
            return ProjectEnvironment(
                runner=project_runner,
                messages=[{"role": "user", "content": "resolved"}],
                default_config=RunConfig(),
            )

    async def fake_run(messages, config, trace_id_future, runner_instance=None):
        selected["runner"] = runner_instance
        selected["messages"] = messages
        trace_id_future.set_result("project-trace")

    monkeypatch.setattr(run_api, "_project_environment_resolver", Resolver())
    monkeypatch.setattr(run_api, "_runner", object())
    monkeypatch.setattr(run_api, "_run_with_trace_signal", fake_run)
    response = await run_api.create_and_run(
        run_api.CreateRequest(
            messages=[{"role": "user", "content": "original"}],
            project_name="demo",
        )
    )
    assert response.trace_id == "project-trace"
    assert selected["project_name"] == "demo"
    assert selected["runner"] is project_runner
    assert selected["messages"][0]["content"] == "resolved"