import { describe, expect, it } from "bun:test";
import { createExecutionPlanSnapshot, executionPlanNeedsTaskPublish, executionPlanSchema, 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("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);
  });
});