import { describe, expect, it } from "bun:test";
import { createExecutionPlanSnapshot, executionPlanNeedsTaskPublish, executionPlanSchema, newExecutionPlanSchema, readExecutionPlans } from "../../src/routes/executionPlan.js";
import { streamPromptResponse } from "../../src/routes/chatStream.js";
import type { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";

const plan = {
  title: "水质调查", reason: "收到投诉",
  nodes: [
    { id: "upstream", title: "上游监测", status: "completed", owner: "agent", detail: "合成数据", evidence: ["场景输入：上游指标正常"] },
    { id: "sample", title: "现场采样", status: "waiting", owner: "human", detail: "等待现场记录", evidence: [] },
  ],
  edges: [{ from: "upstream", to: "sample", label: "上游正常" }],
};

describe("execution plans", () => {
  it("requires v2 for newly published task plans while retaining legacy reads", () => {
    const legacy = {
      title: "Legacy plan",
      reason: "Stored before graph plans",
      nodes: [{ id: "inspect", title: "Inspect", status: "pending", owner: "agent", detail: "", evidence: [] }],
      edges: [],
    };

    expect(executionPlanSchema.parse(legacy).schema).toBe("execution-plan@1");
    expect(newExecutionPlanSchema.safeParse(legacy).success).toBe(false);
  });

  it("accepts explicit v2 branches and structural joins without invented evidence", () => {
    const v2 = {
      schema: "execution-plan@2", title: "动态调查", reason: "工单请求现场及数据并行核验",
      nodes: [
        { id: "split", title: "并行启动", status: "completed", owner: "agent", detail: "同时核查", evidence: [], kind: "parallel_split" },
        { id: "field", title: "现场采样", status: "waiting", owner: "human", detail: "等待采样", evidence: [], kind: "activity" },
        { id: "data", title: "监测数据", status: "completed", owner: "agent", detail: "已核对", evidence: ["e-1"], kind: "activity" },
        { id: "join", title: "证据汇合", status: "waiting", owner: "agent", detail: "等待现场", evidence: [], kind: "parallel_join" },
      ],
      edges: [
        { id: "field-route", from: "split", to: "field", label: "现场" },
        { id: "data-route", from: "split", to: "data", label: "数据" },
        { id: "field-join", from: "field", to: "join", label: "" },
        { id: "data-join", from: "data", to: "join", label: "" },
      ],
    };
    const parsed = executionPlanSchema.parse(v2);
    expect(createExecutionPlanSnapshot(parsed, [], "session-1").schema_version).toBe("execution-plan@2");
    expect(executionPlanSchema.safeParse({ ...v2, edges: [{ ...v2.edges[0], id: "data-route" }, ...v2.edges.slice(1)] }).success).toBe(false);
  });
  it("rejects missing dependencies, cycles, duplicate IDs and unsupported completion", () => {
    for (const invalid of [
      { ...plan, edges: [{ from: "unknown", to: "sample", label: "" }] },
      { ...plan, edges: [...plan.edges, { from: "sample", to: "upstream", label: "" }] },
      { ...plan, nodes: [plan.nodes[0], plan.nodes[0]] },
      { ...plan, nodes: [{ ...plan.nodes[0], evidence: [] }, plan.nodes[1]] },
      {
        ...plan,
        nodes: [
          { ...plan.nodes[0], status: "waiting", detail: "等待数据", evidence: [] },
          { ...plan.nodes[1], status: "completed", evidence: ["evidence-2"] },
        ],
      },
    ]) expect(executionPlanSchema.safeParse(invalid).success).toBe(false);
  });

  it("preserves completed evidence and versions across persisted UI messages and active snapshots", () => {
    const first = createExecutionPlanSnapshot(plan, [], "session-1");
    const messages = [{ parts: [{ type: "data-execution_plan", data: first }] }, { executionPlans: [first] }];
    expect(readExecutionPlans(messages)).toHaveLength(1);
    const next = createExecutionPlanSnapshot({ ...plan, reason: "等待人工补充" }, messages, "session-1");
    expect(next.revision).toBe(2);
    expect(next.nodes[1].status).toBe("waiting");
    expect(() => createExecutionPlanSnapshot({ ...plan, nodes: [plan.nodes[1]], edges: [] }, messages, "session-1")).toThrow("Keep previous nodes");
    expect(() => createExecutionPlanSnapshot({ ...plan, nodes: [{ ...plan.nodes[0], status: "running" }, plan.nodes[1]] }, messages, "session-1")).toThrow("Keep completed evidence");
  });

  it("publishes only successful validated tool completions, once per call", async () => {
    const part = (status: string) => ({ type: "message.part.updated", properties: { sessionID: "runtime", part: {
      id: "plan-call", messageID: "assistant", sessionID: "runtime", type: "tool", tool: "publish_execution_plan",
      callID: "call-1", state: { status, input: plan, output: JSON.stringify({ plan_revision: 1, report_revision: null }), title: "plan", time: { start: 1, end: 2 } }
    } } });
    const events = [part("running"), part("completed"), part("completed"), { type: "session.idle", properties: { sessionID: "runtime" } }];
    const runtime = {
      subscribeEvents: async () => ({ async *[Symbol.asyncIterator]() { for (const event of events) yield event; } }),
      prompt: async () => undefined, messages: async () => []
    } as unknown as OpencodeRuntimeAdapter;
    const published: unknown[] = [];
    await streamPromptResponse({ runtime, sessionId: "runtime", clientSessionId: "session-1", message: "investigate", write(event, data) { if (event === "execution_plan") published.push(data); } });
    expect(published).toHaveLength(1);
    expect(published[0]).toMatchObject({ session_id: "session-1", server_published: true, nodes: plan.nodes });
  });

  it("falls back to route publication for a completed legacy local-only plan tool", async () => {
    const completed = { type: "message.part.updated", properties: { sessionID: "runtime", part: {
      id: "plan-call", messageID: "assistant", sessionID: "runtime", type: "tool", tool: "publish_execution_plan",
      callID: "call-1", state: { status: "completed", input: plan, output: JSON.stringify(plan), title: "plan", time: { start: 1, end: 2 } }
    } } };
    const runtime = {
      subscribeEvents: async () => ({ async *[Symbol.asyncIterator]() { yield completed; yield { type: "session.idle", properties: { sessionID: "runtime" } }; } }),
      prompt: async () => undefined, messages: async () => []
    } as unknown as OpencodeRuntimeAdapter;
    const published: Record<string, unknown>[] = [];

    await streamPromptResponse({ runtime, sessionId: "runtime", clientSessionId: "session-1", message: "investigate", write(event, data) { if (event === "execution_plan") published.push(data); } });

    expect(published).toHaveLength(1);
    expect(published[0]?.server_published).toBeUndefined();
    expect(executionPlanNeedsTaskPublish(published[0])).toBe(true);
  });

  it("does not publish a failed tool plan or duplicate an already persisted plan", async () => {
    const failed = { type: "message.part.updated", properties: { sessionID: "runtime", part: {
      id: "plan-call", messageID: "assistant", sessionID: "runtime", type: "tool", tool: "publish_execution_plan",
      callID: "call-1", state: { status: "error", input: plan, error: "server rejected plan", time: { start: 1, end: 2 } }
    } } };
    const runtime = {
      subscribeEvents: async () => ({ async *[Symbol.asyncIterator]() { yield failed; yield { type: "session.idle", properties: { sessionID: "runtime" } }; } }),
      prompt: async () => undefined, messages: async () => []
    } as unknown as OpencodeRuntimeAdapter;
    const published: unknown[] = [];

    await streamPromptResponse({ runtime, sessionId: "runtime", clientSessionId: "session-1", message: "investigate", write(event, data) { if (event === "execution_plan") published.push(data); } });

    expect(published).toEqual([]);
    expect(executionPlanNeedsTaskPublish({ server_published: true })).toBe(false);
    expect(executionPlanNeedsTaskPublish(plan)).toBe(true);
  });
});