from django.contrib.auth import get_user_model
from django.core.management import call_command

from apps.agents.models import AgentRun
from apps.agents.services import build_config_snapshot
from apps.modelhub.services import CompletionResult

from .helpers import create_agent, create_deployment


def login_admin(client):
    call_command("bootstrap_governance")
    user = get_user_model().objects.get(username="admin")
    client.force_login(user)
    return user


def test_admin_publishes_and_runs_agent(client, db, monkeypatch):
    login_admin(client)
    definition, version = create_agent()
    monkeypatch.setattr(
        "apps.modelhub.services._request_completion",
        lambda *args, **kwargs: CompletionResult('{"summary":"ok","reply":"ok"}', 3, 2),
    )

    published = client.post(f"/api/agents/{definition.id}/publish")
    assert published.status_code == 200
    assert published.json()["status"] == "published"

    run = client.post(
        f"/api/agents/{definition.id}/runs",
        data={"version": 1, "input": {"problem": "无法登录"}},
        content_type="application/json",
    )
    assert run.status_code == 200
    assert run.json()["status"] == "succeeded"
    public_id = run.json()["public_id"]
    detail = client.get(f"/api/agent-runs/{public_id}")
    assert detail.status_code == 200
    assert detail.json()["config_snapshot"]["agent"]["version"] == 1
    assert all(
        step["model_deployment_id"] == version.model_deployment_id
        for step in detail.json()["steps"]
    )


def test_publishing_rejects_draft_skill(client, db):
    login_admin(client)
    definition, version = create_agent()
    binding = version.steps.first()
    binding.skill_version.status = "draft"
    binding.skill_version.save(update_fields=["status"])

    response = client.post(f"/api/agents/{definition.id}/publish")

    assert response.status_code == 400
    assert "已发布 Skill" in response.json()["detail"]


def test_draft_steps_can_override_model_and_clone_binding(client, db):
    login_admin(client)
    definition, version = create_agent()
    override = create_deployment(
        capability="vision_chat",
        provider=version.model_deployment.provider,
        suffix="-vision",
    )
    steps = [
        {
            "code": step.code,
            "skill_version_id": step.skill_version_id,
            "model_deployment_id": override.id if index == 0 else None,
            "input_mapping": step.input_mapping,
        }
        for index, step in enumerate(version.steps.all())
    ]

    response = client.patch(
        f"/api/agents/{definition.id}/draft",
        data={"steps": steps},
        content_type="application/json",
    )

    assert response.status_code == 200
    response_steps = response.json()["steps"]
    assert response_steps[0]["model_deployment_id"] == override.id
    assert response_steps[0]["model_display_name"] == override.display_name
    assert response_steps[0]["model_capability"] == "vision_chat"
    assert response_steps[1]["model_deployment_id"] is None
    assert response_steps[1]["model_display_name"] == version.model_deployment.display_name

    assert client.post(f"/api/agents/{definition.id}/publish").status_code == 200
    clone = client.post(f"/api/agents/{definition.id}/draft")

    assert clone.status_code == 200
    assert clone.json()["steps"][0]["model_deployment_id"] == override.id
    assert clone.json()["steps"][1]["model_deployment_id"] is None


def test_publishing_rejects_non_chat_step_model(client, db):
    login_admin(client)
    definition, version = create_agent()
    embedding = create_deployment(
        capability="embedding",
        provider=version.model_deployment.provider,
        suffix="-embedding",
    )
    binding = version.steps.first()
    binding.model_deployment = embedding
    binding.save(update_fields=["model_deployment"])

    response = client.post(f"/api/agents/{definition.id}/publish")

    assert response.status_code == 400
    assert "必须绑定文本或视觉模型" in response.json()["detail"]


def test_agent_run_permission_is_required(client, db):
    definition, _ = create_agent(published=True)
    user = get_user_model().objects.create_user(username="requester", password="password")
    client.force_login(user)

    response = client.post(
        f"/api/agents/{definition.id}/runs",
        data={"version": 1, "input": {"problem": "无法登录"}},
        content_type="application/json",
    )

    assert response.status_code == 403


def test_agent_run_creator_can_view_own_detail_without_global_run_permission(client, db):
    definition, version = create_agent(published=True)
    owner = get_user_model().objects.create_user(username="run-owner")
    outsider = get_user_model().objects.create_user(username="run-outsider")
    run = AgentRun.objects.create(
        definition=definition,
        agent_version=version,
        input_payload={"problem": "无法登录"},
        config_snapshot=build_config_snapshot(version),
        created_by=owner,
        total_steps=version.steps.count(),
    )

    client.force_login(owner)
    owner_response = client.get(f"/api/agent-runs/{run.public_id}")

    client.force_login(outsider)
    outsider_response = client.get(f"/api/agent-runs/{run.public_id}")

    assert owner_response.status_code == 200
    assert outsider_response.status_code == 403


def test_queued_run_can_be_cancelled(client, db, monkeypatch):
    login_admin(client)
    definition, version = create_agent(published=True)
    run = AgentRun.objects.create(
        definition=definition,
        agent_version=version,
        input_payload={"problem": "无法登录"},
        config_snapshot=build_config_snapshot(version),
        total_steps=version.steps.count(),
    )
    revoked = []
    monkeypatch.setattr(
        "apps.agents.api.AsyncResult.revoke",
        lambda self, **kwargs: revoked.append(kwargs),
    )
    run.task_id = "queued-task-id"
    run.save(update_fields=["task_id"])

    response = client.post(f"/api/agent-runs/{run.public_id}/cancel")

    assert response.status_code == 200
    assert response.json()["status"] == "cancelled"
    assert response.json()["cancellation_requested_at"] is not None
    assert revoked == [{"terminate": False}]


def test_seed_command_creates_support_agent(client, db):
    deployment = create_deployment()

    call_command("seed_ai_demo", deployment_id=deployment.id)

    from apps.agents.models import AgentDefinition

    agent = AgentDefinition.objects.get(code="support-analysis")
    assert agent.versions.get(status="draft").steps.count() == 3