from datetime import datetime, timedelta, timezone
from uuid import uuid4

import pytest

from app.domain.domain_errors import DomainError
from app.domain.schemas.operational_task import AgentArtifactsCommand
from app.domain.schemas.operational_task import InvestigationDiagram, InvestigationGraphUpdate
from app.domain.schemas.operational_data import TaskDataSnapshot
from app.services.investigation_graph import update_investigation_graph
from app.services.operational_tasks import OperationalTaskService
from tests.support.operational_task_repository import (
    TaskRepository, _active_run, _context, _task_document,
)


@pytest.fixture
def anyio_backend():
    return "asyncio"


def setup_service():
    now = datetime(2026, 11, 10, tzinfo=timezone.utc)
    context = _context()
    task = _task_document(context, now, lease=now + timedelta(minutes=1))
    repo = TaskRepository(task, _active_run(task, now))
    return task, repo, OperationalTaskService(repo, context, set(), clock=lambda: now)


async def publish(service, repo, task_id, *, nodes=(), edges=(), **progress):
    command = AgentArtifactsCommand.model_validate({
        "request_id": str(uuid4()), "source_session_id": repo.run["agent_session_id"],
        "run_id": repo.run["run_id"],
        "progress": {"summary": "更新调查路线", "graph_update": {
            "nodes": list(nodes), "edges": list(edges),
        }, **progress},
    })
    return await service.publish_artifacts(task_id, command)


@pytest.mark.anyio
async def test_failed_path_is_retained_when_a_new_route_is_added():
    task, repo, service = setup_service()
    await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "read", "label": "读取全量 SCADA", "status": "recorded"},
        {"node_id": "locate_1", "label": "第一次候选定位", "status": "reference"},
    ], edges=[{"source": "read", "target": "locate_1"}])
    await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "locate_1", "label": "第一次候选定位", "status": "failed", "detail": "计算超时"},
        {"node_id": "locate_2", "label": "调整窗口后重试", "status": "reference"},
    ], edges=[{"source": "locate_1", "target": "locate_2", "label": "调整后重试"}])
    result = await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "locate_2", "label": "调整窗口后重试", "status": "recorded"},
    ])
    diagram = result.task.latest_progress.progress.diagram
    assert [(n.node_id, n.status) for n in diagram.node_refs] == [
        ("read", "recorded"), ("locate_1", "failed"), ("locate_2", "recorded"),
    ]
    assert diagram.node_refs[1].detail == "计算超时"
    assert len(diagram.edges) == 2
    assert "第一次候选定位（失败）" in diagram.mermaid
    assert 'locate_1 -->|"调整后重试"| locate_2' in diagram.mermaid
    # A text-only update cannot clear the accumulated graph.
    summary = AgentArtifactsCommand.model_validate({
        "request_id": str(uuid4()), "source_session_id": repo.run["agent_session_id"],
        "run_id": repo.run["run_id"], "progress": {"summary": "等待人工", "diagram": None},
    })
    assert (await service.publish_artifacts(task["task_id"], summary)).task.latest_progress.progress.diagram == diagram


@pytest.mark.anyio
async def test_failed_attempt_cannot_be_relabelled_as_a_success():
    task, repo, service = setup_service()
    await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "attempt_1", "label": "候选定位", "status": "failed", "detail": "超时"},
    ])
    with pytest.raises(DomainError, match="new node"):
        await publish(service, repo, task["task_id"], nodes=[
            {"node_id": "attempt_1", "label": "候选定位", "status": "recorded"},
        ])


@pytest.mark.anyio
async def test_existing_waiting_node_accepts_a_status_only_update_without_extending_the_graph():
    task, repo, service = setup_service()
    first = await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "read", "label": "读取监测", "status": "recorded"},
        {"node_id": "review", "label": "核对补充资料", "status": "needs_input", "detail": "等待现场记录"},
    ], edges=[{"source": "read", "target": "review"}])
    original = first.task.latest_progress.progress.diagram
    await service.publish_artifacts(task["task_id"], AgentArtifactsCommand.model_validate({
        "request_id": str(uuid4()), "source_session_id": repo.run["agent_session_id"],
        "run_id": repo.run["run_id"], "report": {
            "title": "阶段报告", "current_conclusion": "仍需核对现场资料", "conclusion_boundary": "现有资料范围",
            "stage": "interim", "outcome": "concluded", "data_gaps": [],
        },
    }))
    result = await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "review", "status": "recorded", "detail": "已核对收到的现场记录"},
    ])
    updated = result.task.latest_progress.progress.diagram
    assert [node.node_id for node in updated.node_refs] == ["read", "review"]
    assert updated.node_refs[1].label == "核对补充资料"
    assert updated.node_refs[1].status == "recorded"
    assert updated.node_refs[1].detail == "已核对收到的现场记录"
    assert updated.edges == original.edges
    assert updated.mermaid == original.mermaid
    assert original.node_refs[1].status == "needs_input"
    archived = (await service.report(task["task_id"], 1)).report.diagram
    assert archived.node_refs[1].status == "needs_input"
    assert archived.node_refs[1].detail == "等待现场记录"


@pytest.mark.parametrize("label_patch", [{}, {"label": None}])
def test_partial_updates_keep_labels_and_accumulated_references_including_legacy_nodes(label_patch):
    evidence_id = "saved-reading"
    action_id = uuid4()
    original = InvestigationDiagram.model_validate({
        "title": "旧调查图", "mermaid": "flowchart LR\nold{核对资料} --> next[继续调查]",
        "node_refs": [{"node_id": "old", "label": "核对资料", "status": "waiting_human",
                       "detail": "等待资料", "evidence_refs": [evidence_id], "action_refs": [action_id],
                       "map_targets": [{"source_id": "scada", "feature_id": "P1"}]}],
    })
    updated = update_investigation_graph(original, InvestigationGraphUpdate.model_validate({
        "nodes": [{"node_id": "old", "status": "recorded", **label_patch}],
    }))
    assert updated.mermaid == updated.source_mermaid == original.mermaid
    assert updated.node_refs[0] == original.node_refs[0].model_copy(update={"status": "recorded"})
    assert original.node_refs[0].status == "needs_input"


def test_status_only_updates_cannot_create_an_unlabelled_node_or_rewrite_a_failed_attempt():
    with pytest.raises(DomainError) as error:
        update_investigation_graph(None, InvestigationGraphUpdate.model_validate({
            "nodes": [{"node_id": "missing", "status": "recorded"}],
        }))
    assert error.value.code == "GRAPH_NODE_LABEL_REQUIRED"
    failed = update_investigation_graph(None, InvestigationGraphUpdate.model_validate({
        "nodes": [{"node_id": "attempt", "label": "失败尝试", "status": "failed", "detail": "接口超时"}],
    }))
    enriched = update_investigation_graph(failed, InvestigationGraphUpdate.model_validate({
        "nodes": [{"node_id": "attempt", "evidence_refs": ["timeout-record"]}],
    }))
    assert enriched.node_refs[0].label == "失败尝试"
    assert enriched.node_refs[0].detail == "接口超时"
    assert enriched.node_refs[0].status == "failed"
    assert enriched.node_refs[0].evidence_refs == ["timeout-record"]
    with pytest.raises(DomainError) as error:
        update_investigation_graph(enriched, InvestigationGraphUpdate.model_validate({
            "nodes": [{"node_id": "attempt", "status": "recorded"}],
        }))
    assert error.value.code == "GRAPH_FAILED_ATTEMPT_IMMUTABLE"


@pytest.mark.anyio
async def test_new_execution_round_continues_the_same_task_graph():
    task, repo, service = setup_service()
    first = await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "first", "label": "首次查询", "status": "failed"},
    ])
    archived = first.task.latest_progress.progress.diagram.model_dump(mode="json")
    repo.task["execution_generation"] = 2
    repo.task["execution_request_id"] = str(uuid4())
    repo.run["status"] = "succeeded"
    repo.run = _active_run(repo.task, datetime(2026, 11, 10, tzinfo=timezone.utc))
    repo.runs[repo.run["run_id"]] = repo.run
    assert (await service.detail(task["task_id"])).latest_progress.progress.diagram.node_refs[0].status == "failed"
    result = await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "second", "label": "补充信息后查询", "status": "recorded"},
    ], edges=[{"source": "first", "target": "second"}])
    assert result.progress_revision == 1
    assert result.task.latest_progress.execution_generation == 2
    assert len(result.task.latest_progress.progress.diagram.node_refs) == 2
    assert repo.progress[(task["task_id"], 1)]["progress"]["diagram"] == archived


@pytest.mark.anyio
async def test_reports_archive_the_host_graph_and_keep_older_versions_unchanged():
    task, repo, service = setup_service()
    await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "failed", "label": "数据读取", "status": "failed", "detail": "接口超时"},
    ])
    command = AgentArtifactsCommand.model_validate({
        "request_id": str(uuid4()), "source_session_id": repo.run["agent_session_id"],
        "run_id": repo.run["run_id"], "report": {
            "title": "调查", "current_conclusion": "已有阶段判断", "conclusion_boundary": "限于现有资料",
            "stage": "final", "outcome": "concluded", "data_gaps": [],
            "diagram": {"title": "重新生成的图", "mermaid": "flowchart TD\nNEW[新图]"},
        },
    })
    first = await service.publish_artifacts(task["task_id"], command)
    assert first.task.latest_report.report.diagram.node_refs[0].status == "failed"
    await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "retry", "label": "重新读取", "status": "recorded"},
    ], edges=[{"source": "failed", "target": "retry"}])
    assert len((await service.report(task["task_id"], 1)).report.diagram.node_refs) == 1
    assert len((await service.detail(task["task_id"])).latest_progress.progress.diagram.node_refs) == 2
    # Idempotent replays do not append nodes or change the archived report.
    assert (await service.publish_artifacts(task["task_id"], command)).report_revision == 1


@pytest.mark.anyio
async def test_graph_updates_validate_references_and_cannot_replace_a_managed_graph():
    task, repo, service = setup_service()
    with pytest.raises(DomainError, match="unknown evidence"):
        await publish(service, repo, task["task_id"], nodes=[
            {"node_id": "unknown", "label": "未知依据", "evidence_refs": ["forged"]},
        ])
    await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "kept", "label": "实际步骤", "status": "recorded"},
    ])
    with pytest.raises(DomainError, match="graph_update"):
        await service.publish_artifacts(task["task_id"], AgentArtifactsCommand.model_validate({
            "request_id": str(uuid4()), "source_session_id": repo.run["agent_session_id"],
            "run_id": repo.run["run_id"], "progress": {
                "summary": "重画", "diagram": {"title": "替换", "mermaid": "flowchart TD\nNEW[新图]"},
            },
        }))


def test_graph_renderer_escapes_labels_and_keeps_explicit_parallel_and_failed_paths():
    graph = update_investigation_graph(None, InvestigationGraphUpdate.model_validate({
        "nodes": [
            {"node_id": "start", "label": '核查 "地点" <script> ``` %%{init: {}}'},
            {"node_id": "left", "label": "监测", "status": "failed"},
            {"node_id": "right", "label": "工单", "status": "reference"},
        ], "edges": [{"source": "start", "target": target} for target in ["left", "right"]],
    }))
    assert "<script>" not in graph.mermaid
    assert "#lt;script#gt;" in graph.mermaid
    assert "#quot;地点#quot;" in graph.mermaid
    assert "```" not in graph.mermaid and "%%{" not in graph.mermaid
    assert "监测（失败）" in graph.mermaid
    updated = update_investigation_graph(graph, InvestigationGraphUpdate.model_validate({
        "nodes": [{"node_id": "right", "label": "工单", "status": "recorded"}],
        "edges": [{"source": "start", "target": "right"}],
    }))
    assert len(updated.edges) == 2
    assert graph.node_refs[2].status == "reference"


def test_first_structured_update_preserves_an_existing_mermaid_without_reinterpreting_it():
    original = InvestigationDiagram.model_validate({
        "title": "原调查路线", "mermaid": 'flowchart LR\nA{核查条件} -->|具备| B[原路径]\nA --> C[另一分支]',
        "node_refs": [{"node_id": "B", "label": "原路径", "status": "failed", "detail": "查询超时"}],
    })
    updated = update_investigation_graph(original, InvestigationGraphUpdate.model_validate({
        "nodes": [{"node_id": "retry", "label": "改用其他数据", "status": "reference"}],
        "edges": [{"source": "B", "target": "retry"}],
    }))
    assert updated.mermaid.startswith(original.mermaid + "\n")
    assert updated.source_mermaid == original.mermaid
    assert updated.node_refs[0].status == "failed"
    final = update_investigation_graph(updated, InvestigationGraphUpdate.model_validate({
        "nodes": [{"node_id": "retry", "label": "改用其他数据", "status": "recorded"}],
    }))
    assert final.mermaid.count("A{核查条件}") == 1
    assert "B --> retry" in final.mermaid
    with pytest.raises(DomainError, match="original Mermaid"):
        update_investigation_graph(updated, InvestigationGraphUpdate.model_validate({
            "nodes": [{"node_id": "C", "label": "与旧图冲突的新步骤"}],
        }))


@pytest.mark.anyio
async def test_first_update_uses_the_last_saved_legacy_report_graph():
    task, repo, service = setup_service()
    repo.reports.append({
        "revision": 1, "execution_generation": 1, "source_session_id": "session-1",
        "published_at": "2026-11-09T00:00:00Z", "published_by": "agent", "report": {
            "title": "旧报告", "current_conclusion": "已有判断", "conclusion_boundary": "已有证据",
            "diagram": {"title": "旧路线", "mermaid": "flowchart TD\nold[此前查询]",
                        "node_refs": [{"node_id": "old", "label": "此前查询", "status": "failed"}]},
        },
    })
    result = await publish(service, repo, task["task_id"], nodes=[
        {"node_id": "retry", "label": "接续查询", "status": "reference"},
    ], edges=[{"source": "old", "target": "retry"}])
    diagram = result.task.latest_progress.progress.diagram
    assert diagram.source_mermaid == "flowchart TD\nold[此前查询]"
    assert [n.node_id for n in diagram.node_refs] == ["old", "retry"]


@pytest.mark.parametrize("update,code", [
    ({"nodes": []}, "GRAPH_NODE_REQUIRED"),
    ({"nodes": [{"node_id": "end", "label": "保留字"}]}, "GRAPH_NODE_ID_INVALID"),
    ({"nodes": [{"node_id": "n", "label": "一"}, {"node_id": "n", "label": "二"}]}, "GRAPH_NODE_DUPLICATE"),
    ({"nodes": [{"node_id": "n", "label": "一"}], "edges": [{"source": "n", "target": "missing"}]}, "GRAPH_EDGE_NODE_NOT_FOUND"),
])
def test_graph_updates_reject_invalid_structure_without_erasing_history(update, code):
    with pytest.raises(DomainError) as error:
        update_investigation_graph(None, InvestigationGraphUpdate.model_validate(update))
    assert error.value.code == code


@pytest.mark.anyio
@pytest.mark.parametrize("node_refs", [[], [{"node_id": "old", "label": "旧尝试", "status": "failed", "detail": "查询超时"}]])
async def test_summary_only_adopts_legacy_graph_before_the_first_incremental_update(node_refs):
    task, repo, service = setup_service()
    original = {"title": "旧路线", "mermaid": "flowchart LR\nold{旧尝试} --> other[另一分支]", "node_refs": node_refs}
    for progress in [{"summary": "此前调查", "diagram": original}, {"summary": "继续调查"}]:
        result = await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
            request_id=uuid4(), source_session_id="session-1", run_id=repo.run["run_id"], progress=progress,
        ))
    diagram = result.task.latest_progress.progress.diagram
    assert diagram is not None
    assert diagram.mermaid == diagram.source_mermaid == original["mermaid"]
    assert diagram.edges == []
    assert diagram.node_refs == InvestigationDiagram.model_validate(original).node_refs


@pytest.mark.anyio
async def test_identical_effective_reports_do_not_repeat_notifications_for_inherited_graph_evidence():
    task, repo, service = setup_service()
    evidence, _ = await service.record_data_snapshot(task["task_id"], TaskDataSnapshot(
        source="query_scada_readings", source_ref="probe", queried_at=service._now(),
        origin="system_data", truncated=False, data={"data": []},
    ))
    await publish(service, repo, task["task_id"], nodes=[{
        "node_id": "finding", "label": "已有结果", "status": "recorded", "evidence_refs": [evidence.evidence_id],
    }])
    saved = []
    for _ in range(2):
        result = await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
            request_id=uuid4(), source_session_id="session-1", report={
                "title": "调查", "current_conclusion": "已有判断", "conclusion_boundary": "当前资料",
                "stage": "final", "outcome": "concluded", "data_gaps": [],
            },
        ))
        saved.append(result.task.latest_report.report)
    assert saved[0] == saved[1]
    assert saved[0].evidence_refs == [evidence.evidence_id]
    assert len([notice for notice in repo.notifications if notice["kind"] == "report_updated"]) == 1


@pytest.mark.anyio
async def test_final_scada_report_validates_the_effective_inherited_evidence():
    task, repo, service = setup_service()
    task["workflow"] = "scada_anomaly"
    now = service._now()
    evidence, _ = await service.record_data_snapshot(task["task_id"], TaskDataSnapshot(
        source="query_scada_readings", source_ref="complete-scada", queried_at=now,
        origin="system_data", truncated=False, data={
            "data": {"coverage": {"mode": "all_scada", "query_complete": True}},
            "window": {"start": (now - timedelta(hours=1)).isoformat(), "end": now.isoformat()},
        },
    ))
    await publish(service, repo, task["task_id"], nodes=[{
        "node_id": "all_scada", "label": "全量读取", "evidence_refs": [evidence.evidence_id],
    }])
    result = await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
        request_id=uuid4(), source_session_id="session-1", report={
            "title": "调查", "current_conclusion": "已有判断", "conclusion_boundary": "当前资料",
            "stage": "final", "outcome": "concluded", "data_gaps": [],
        },
    ))
    assert result.task.latest_report.report.evidence_refs == [evidence.evidence_id]


@pytest.mark.anyio
async def test_evidence_only_publication_does_not_load_the_graph_baseline(monkeypatch):
    task, repo, service = setup_service()
    calls = []
    original = repo.get_latest_graph_progress

    async def load_graph(task_id):
        calls.append(task_id)
        return await original(task_id)

    # The returned task detail can read progress; count separately from publication.
    original_detail = service.detail

    async def detail(task_id):
        before_detail = len(calls)
        result = await original_detail(task_id)
        del calls[before_detail:]
        return result

    monkeypatch.setattr(repo, "get_latest_graph_progress", load_graph)
    monkeypatch.setattr(service, "detail", detail)
    await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
        request_id=uuid4(), source_session_id="session-1", evidence=[{
            "evidence_id": "demo", "kind": "synthetic", "summary": "演练依据",
            "source_label": "fixture", "observed_at": service._now(),
        }],
    ))
    assert calls == []