import test from "node:test";
import assert from "node:assert/strict";
import os from "node:os";
import path from "node:path";
import { mkdtemp, rm } from "node:fs/promises";
import { NextRequest } from "next/server";

let runtimeRoot = "";
let postMessageRoute: (typeof import("../src/app/api/v1/projects/[projectId]/messages/route"))["POST"];
let getDispatchPlansRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/route"))["GET"];
let confirmDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm/route"))["POST"];
let rejectDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/reject/route"))["POST"];
let retryDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/retry/route"))["POST"];
let updateDispatchReminderRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-reminder/route"))["PATCH"];
let createAuthSession: (typeof import("../src/lib/boss-data"))["createAuthSession"];
let createProjectGroupChat: (typeof import("../src/lib/boss-data"))["createProjectGroupChat"];
let isDispatchableThreadProject: (typeof import("../src/lib/boss-data"))["isDispatchableThreadProject"];
let readState: (typeof import("../src/lib/boss-data"))["readState"];
let writeState: (typeof import("../src/lib/boss-data"))["writeState"];
let AUTH_SESSION_COOKIE = "";
let baseState: Awaited<ReturnType<typeof import("../src/lib/boss-data")["readState"]>>;

async function setup() {
  if (runtimeRoot) {
    return;
  }

  runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-task4-"));
  process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
  process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");

  const [messageModule, plansModule, confirmModule, rejectModule, retryModule, reminderModule, data, auth] = await Promise.all([
    import("../src/app/api/v1/projects/[projectId]/messages/route.ts"),
    import("../src/app/api/v1/projects/[projectId]/dispatch-plans/route.ts"),
    import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm/route.ts"),
    import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/reject/route.ts"),
    import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/retry/route.ts"),
    import("../src/app/api/v1/projects/[projectId]/dispatch-reminder/route.ts"),
    import("../src/lib/boss-data.ts"),
    import("../src/lib/boss-auth.ts"),
  ]);

  postMessageRoute = messageModule.POST;
  getDispatchPlansRoute = plansModule.GET;
  confirmDispatchPlanRoute = confirmModule.POST;
  rejectDispatchPlanRoute = rejectModule.POST;
  retryDispatchPlanRoute = retryModule.POST;
  updateDispatchReminderRoute = reminderModule.PATCH;
  createAuthSession = data.createAuthSession;
  createProjectGroupChat = data.createProjectGroupChat;
  isDispatchableThreadProject = data.isDispatchableThreadProject;
  readState = data.readState;
  writeState = data.writeState;
  baseState = structuredClone(await readState());
  AUTH_SESSION_COOKIE = auth.AUTH_SESSION_COOKIE;
}

test.after(async () => {
  if (runtimeRoot) {
    await rm(runtimeRoot, { recursive: true, force: true });
  }
});

test.beforeEach(async () => {
  await setup();
  await writeState(structuredClone(baseState));
});

function buildDispatchableThreadProject({
  id,
  projectName,
  threadDisplayName,
  body,
}: {
  id: string;
  projectName: string;
  threadDisplayName: string;
  body: string;
}) {
  return {
    id,
    name: projectName,
    pinned: false,
    systemPinned: false,
    deviceIds: ["mac-studio"],
    preview: body,
    updatedAt: "2026-03-30T10:00:00+08:00",
    lastMessageAt: "2026-03-30T10:00:00+08:00",
    isGroup: false,
    threadMeta: {
      projectId: id,
      threadId: `thread-${id}`,
      threadDisplayName,
      folderName: "阻塞梳理",
      activityIconCount: 0,
      updatedAt: "2026-03-30T10:00:00+08:00",
      codexThreadRef: `thread-${id}`,
      codexFolderRef: id,
    },
    groupMembers: [],
    createdByAgent: true,
    collaborationMode: "development" as const,
    approvalState: "not_required" as const,
    unreadCount: 0,
    riskLevel: "low" as const,
    messages: [
      {
        id: `msg-${id}`,
        sender: "device" as const,
        senderLabel: "Win GPU / Codex",
        body,
        sentAt: "2026-03-30T10:00:00+08:00",
        kind: "text" as const,
      },
    ],
    goals: [],
    versions: [],
  };
}

async function createAuthedRequest(url: string, method: "GET" | "POST" | "PATCH", body?: unknown) {
  const session = await createAuthSession({
    account: "17600003315",
    role: "highest_admin",
    displayName: "Boss 超级管理员",
    loginMethod: "password",
  });

  return new NextRequest(url, {
    method,
    headers: {
      "content-type": "application/json",
      cookie: `${AUTH_SESSION_COOKIE}=${session.sessionToken}`,
    },
    body: body ? JSON.stringify(body) : undefined,
  });
}

async function ensureTwoSingleThreadProjects() {
  const state = await readState();
  const singles = state.projects.filter((project) => isDispatchableThreadProject(project));
  if (singles.length >= 2) {
    return singles;
  }

  const freshProjects = [
    buildDispatchableThreadProject({
      id: "dispatch-confirm-a",
      projectName: "北区试产线主线程",
      threadDisplayName: "北区试产线回归",
      body: "这里还在等待主 Agent 汇总阻塞点。",
    }),
    buildDispatchableThreadProject({
      id: "dispatch-confirm-b",
      projectName: "南区试产线主线程",
      threadDisplayName: "南区试产线回归",
      body: "这里还在等待视觉链路复核。",
    }),
  ];

  await writeState({
    ...state,
    projects: state.projects.concat(freshProjects),
  });

  const nextState = await readState();
  return nextState.projects.filter((project) => isDispatchableThreadProject(project));
}

async function createDispatchPlanForTest() {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  const groupProject = await createProjectGroupChat({
    sourceProjectId: memberProjects[0].id,
    memberProjectIds: [memberProjects[1].id],
    createdBy: "17600003315",
  });

  const response = await postMessageRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/messages`,
      "POST",
      { body: "请主 Agent 推荐要先同步的线程" },
    ),
    { params: Promise.resolve({ projectId: groupProject.id }) },
  );
  assert.equal(response.status, 200);
  const payload = (await response.json()) as {
    dispatchPlan:
      | {
          planId: string;
          targets: Array<{ projectId: string }>;
          orchestrationBackendId?: string;
          orchestrationBackendLabel?: string;
        }
      | null;
  };
  assert.ok(payload.dispatchPlan, "expected seeded dispatch plan");
  assert.equal(payload.dispatchPlan?.orchestrationBackendId, "boss-native-orchestrator");
  assert.equal(payload.dispatchPlan?.orchestrationBackendLabel, "Boss Native Orchestrator");
  return { groupProject, dispatchPlan: payload.dispatchPlan };
}

async function createMasterAgentDispatchPlanForTest() {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected dispatchable single-thread projects");

  const response = await postMessageRoute(
    await createAuthedRequest(
      "http://127.0.0.1:3000/api/v1/projects/master-agent/messages",
      "POST",
      { body: "请操作真实线程，先让南区试产线回归只回复：主Agent确认链路正常" },
    ),
    { params: Promise.resolve({ projectId: "master-agent" }) },
  );
  assert.equal(response.status, 200);
  const payload = (await response.json()) as {
    dispatchPlan:
      | {
          planId: string;
          targets: Array<{ projectId: string }>;
          orchestrationBackendId?: string;
          orchestrationBackendLabel?: string;
        }
      | null;
  };
  assert.ok(payload.dispatchPlan, "expected master-agent dispatch plan");
  return { dispatchPlan: payload.dispatchPlan };
}

test("GET /api/v1/projects/[projectId]/dispatch-plans lists the latest group dispatch plans", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();

  const response = await getDispatchPlansRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans`,
      "GET",
    ),
    { params: Promise.resolve({ projectId: groupProject.id }) },
  );
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    plans: Array<{ planId: string; requestMessageId: string; status: string }>;
  };
  assert.equal(payload.ok, true);
  assert.equal(payload.plans[0]?.planId, dispatchPlan.planId);
  assert.equal(payload.plans[0]?.status, "pending_user_confirmation");
});

test("POST /api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm confirms targets, creates executions, and writes a master-agent notice", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
  const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
  assert.ok(approvedTargetProjectId, "expected a recommended target project");

  const response = await confirmDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/confirm`,
      "POST",
      { approvedTargetProjectIds: [approvedTargetProjectId] },
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    plan: {
      planId: string;
      status: string;
      confirmedTargetProjectIds: string[];
      orchestrationBackendId?: string;
      orchestrationBackendLabel?: string;
    };
    executions: Array<{
      planId: string;
      targetProjectId: string;
      status: string;
      orchestrationBackendId?: string;
      orchestrationBackendLabel?: string;
    }>;
    notice: { kind: string; body: string } | null;
    collaborationGate: {
      isGroup: boolean;
      collaborationMode: string;
      requiresMasterAgentApproval: boolean;
      approvalState: string;
    };
  };
  assert.equal(payload.ok, true);
  assert.equal(payload.plan.planId, dispatchPlan.planId);
  assert.equal(payload.plan.status, "dispatched");
  assert.deepEqual(payload.plan.confirmedTargetProjectIds, [approvedTargetProjectId]);
  assert.equal(payload.executions.length, 1);
  assert.equal(payload.executions[0]?.planId, dispatchPlan.planId);
  assert.equal(payload.executions[0]?.targetProjectId, approvedTargetProjectId);
  assert.equal(payload.executions[0]?.status, "queued");
  assert.ok(payload.notice, "expected a confirmation notice in the response");
  assert.equal(payload.notice?.kind, "system_notice");
  assert.equal(payload.notice?.body, "已确认下发到 1 个线程：《北区试产线回归》。");
  assert.equal(payload.collaborationGate.isGroup, true);
  assert.equal(payload.collaborationGate.collaborationMode, "development");
  assert.equal(payload.collaborationGate.requiresMasterAgentApproval, false);
  assert.equal(payload.collaborationGate.approvalState, "not_required");

  const nextState = await readState();
  const notice = nextState.projects
    .find((project) => project.id === groupProject.id)
    ?.messages.find(
      (message) =>
        message.sender === "master" &&
        message.kind === "system_notice" &&
        message.body.includes("已确认下发到 1 个线程"),
    );
  assert.ok(notice, "expected a master-agent notice in the group chat after confirmation");
  const confirmedPlan = nextState.dispatchPlans.find((plan) => plan.planId === dispatchPlan.planId);
  assert.ok(confirmedPlan, "expected confirmed dispatch plan in state");
  assert.equal(confirmedPlan?.orchestrationBackendId, "boss-native-orchestrator");
  assert.equal(confirmedPlan?.orchestrationBackendLabel, "Boss Native Orchestrator");
  const createdExecution = nextState.dispatchExecutions.find((item) => item.planId === dispatchPlan.planId);
  assert.ok(createdExecution, "expected dispatch execution in state");
  assert.equal(createdExecution?.orchestrationBackendId, "boss-native-orchestrator");
  assert.equal(createdExecution?.orchestrationBackendLabel, "Boss Native Orchestrator");
  const executionTask = nextState.masterAgentTasks.find(
    (task) =>
      task.taskType === "dispatch_execution" &&
      task.projectId === groupProject.id &&
      task.targetProjectId === approvedTargetProjectId,
  );
  assert.ok(executionTask, "expected queued dispatch execution task");
  assert.equal(executionTask?.orchestrationBackendId, "boss-native-orchestrator");
  assert.equal(executionTask?.orchestrationBackendLabel, "Boss Native Orchestrator");
});

test("confirming a dispatch plan with rememberLightReminder persists the group reminder preference", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
  const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
  assert.ok(approvedTargetProjectId, "expected a recommended target project");

  const response = await confirmDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/confirm`,
      "POST",
      {
        approvedTargetProjectIds: [approvedTargetProjectId],
        rememberLightReminder: true,
      },
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    collaborationGate: {
      lightDispatchReminderEnabled?: boolean;
    };
  };
  assert.equal(payload.ok, true);
  assert.equal(payload.collaborationGate.lightDispatchReminderEnabled, true);

  const nextState = await readState();
  const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
  assert.ok(nextGroupProject, "expected group project to remain present");
  assert.equal(nextGroupProject?.lightDispatchReminderEnabled, true);
});

test("master-agent dispatch plans can also be confirmed and create queued executions", async () => {
  const { dispatchPlan } = await createMasterAgentDispatchPlanForTest();
  const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
  assert.ok(approvedTargetProjectId, "expected a recommended target project");

  const response = await confirmDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/master-agent/dispatch-plans/${dispatchPlan.planId}/confirm`,
      "POST",
      { approvedTargetProjectIds: [approvedTargetProjectId] },
    ),
    { params: Promise.resolve({ projectId: "master-agent", planId: dispatchPlan.planId }) },
  );
  assert.equal(response.status, 200);
  const payload = (await response.json()) as {
    ok: boolean;
    plan: { status: string; confirmedTargetProjectIds: string[] };
    executions: Array<{ targetProjectId: string; status: string }>;
    notice: { body: string } | null;
  };
  assert.equal(payload.ok, true);
  assert.equal(payload.plan.status, "dispatched");
  assert.deepEqual(payload.plan.confirmedTargetProjectIds, [approvedTargetProjectId]);
  assert.equal(payload.executions.length, 1);
  assert.equal(payload.executions[0]?.targetProjectId, approvedTargetProjectId);
  assert.equal(payload.executions[0]?.status, "queued");
  assert.match(payload.notice?.body ?? "", /已确认下发到 1 个线程/);
});

test("confirm rejects targets whose device is offline before creating queued executions", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
  const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
  const targetDeviceId = dispatchPlan.targets[0]?.deviceId;
  assert.ok(approvedTargetProjectId, "expected a recommended target project");
  assert.ok(targetDeviceId, "expected a target device");

  const state = await readState();
  await writeState({
    ...state,
    devices: state.devices.map((device) =>
      device.id === targetDeviceId
        ? {
            ...device,
            status: "offline" as const,
          }
        : device,
    ),
  });

  const response = await confirmDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/confirm`,
      "POST",
      { approvedTargetProjectIds: [approvedTargetProjectId] },
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(response.status, 400);
  const payload = (await response.json()) as { ok: boolean; code: string; message: string };
  assert.equal(payload.ok, false);
  assert.equal(payload.code, "DISPATCH_TARGET_DEVICE_OFFLINE");
  assert.equal(payload.message, "目标线程所在设备当前不在线，请先让设备上线后再确认下发。");

  const nextState = await readState();
  const createdExecution = nextState.dispatchExecutions.find((item) => item.planId === dispatchPlan.planId);
  assert.equal(createdExecution, undefined);
});

test("confirming a dispatch plan marks approval_required groups as approved", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
  const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
  assert.ok(approvedTargetProjectId, "expected a recommended target project");

  const state = await readState();
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            collaborationMode: "approval_required" as const,
            approvalState: "pending_user" as const,
          }
        : project,
    ),
  });

  const response = await confirmDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/confirm`,
      "POST",
      { approvedTargetProjectIds: [approvedTargetProjectId] },
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(response.status, 200);

  const nextState = await readState();
  const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
  assert.ok(nextGroupProject, "expected group project to remain present");
  assert.equal(nextGroupProject?.approvalState, "approved");
});

test("rejecting a dispatch plan marks approval_required groups as rejected and writes a system notice", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();

  const state = await readState();
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            collaborationMode: "approval_required" as const,
            approvalState: "pending_user" as const,
          }
        : project,
    ),
  });

  const response = await rejectDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/reject`,
      "POST",
      {},
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    plan: { planId: string; status: string };
    notice: { kind: string; body: string };
    collaborationGate: {
      isGroup: boolean;
      collaborationMode: string;
      requiresMasterAgentApproval: boolean;
      approvalState: string;
    };
  };
  assert.equal(payload.ok, true);
  assert.equal(payload.plan.planId, dispatchPlan.planId);
  assert.equal(payload.plan.status, "rejected");
  assert.equal(payload.notice.kind, "system_notice");
  assert.equal(payload.notice.body, "已拒绝主 Agent 推荐，本次不会下发到任何线程。");
  assert.equal(payload.collaborationGate.isGroup, true);
  assert.equal(payload.collaborationGate.collaborationMode, "approval_required");
  assert.equal(payload.collaborationGate.requiresMasterAgentApproval, true);
  assert.equal(payload.collaborationGate.approvalState, "rejected");

  const nextState = await readState();
  const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
  assert.ok(nextGroupProject, "expected group project to remain present");
  assert.equal(nextGroupProject?.approvalState, "rejected");
  const notice = nextGroupProject?.messages.find(
    (message) =>
      message.kind === "system_notice" &&
      message.body.includes("已拒绝主 Agent 推荐"),
  );
  assert.ok(notice, "expected rejection notice in group chat");
});

test("retrying a rejected dispatch plan creates a fresh pending recommendation and resets approval gate", async () => {
  const { groupProject, dispatchPlan } = await createDispatchPlanForTest();

  const state = await readState();
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            collaborationMode: "approval_required" as const,
            approvalState: "pending_user" as const,
          }
        : project,
    ),
  });

  const rejectResponse = await rejectDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/reject`,
      "POST",
      {},
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(rejectResponse.status, 200);

  const retryResponse = await retryDispatchPlanRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/retry`,
      "POST",
      {},
    ),
    { params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
  );
  assert.equal(retryResponse.status, 200);

  const retryPayload = (await retryResponse.json()) as {
    ok: boolean;
    dispatchPlan: { planId: string; status: string; requestMessageId: string } | null;
    collaborationGate: {
      approvalState: string;
      requiresMasterAgentApproval: boolean;
      collaborationMode: string;
    };
  };
  assert.equal(retryPayload.ok, true);
  assert.ok(retryPayload.dispatchPlan, "expected a fresh dispatch recommendation");
  assert.notEqual(retryPayload.dispatchPlan?.planId, dispatchPlan.planId);
  assert.equal(retryPayload.dispatchPlan?.status, "pending_user_confirmation");
  assert.match(retryPayload.dispatchPlan?.requestMessageId ?? "", /:retry:/);
  assert.equal(retryPayload.collaborationGate.collaborationMode, "approval_required");
  assert.equal(retryPayload.collaborationGate.requiresMasterAgentApproval, true);
  assert.equal(retryPayload.collaborationGate.approvalState, "pending_user");

  const nextState = await readState();
  const refreshedPlan = nextState.dispatchPlans.find((plan) => plan.planId === retryPayload.dispatchPlan?.planId);
  assert.ok(refreshedPlan, "expected retried dispatch plan in state");
  const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
  assert.equal(nextGroupProject?.approvalState, "pending_user");
});

test("PATCH /api/v1/projects/[projectId]/dispatch-reminder updates the per-group light reminder preference", async () => {
  const { groupProject } = await createDispatchPlanForTest();

  const enableResponse = await updateDispatchReminderRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-reminder`,
      "PATCH",
      { lightDispatchReminderEnabled: true },
    ),
    { params: Promise.resolve({ projectId: groupProject.id }) },
  );
  assert.equal(enableResponse.status, 200);
  const enablePayload = (await enableResponse.json()) as {
    ok: boolean;
    project: {
      id: string;
      lightDispatchReminderEnabled?: boolean;
    };
  };
  assert.equal(enablePayload.ok, true);
  assert.equal(enablePayload.project.id, groupProject.id);
  assert.equal(enablePayload.project.lightDispatchReminderEnabled, true);

  const disableResponse = await updateDispatchReminderRoute(
    await createAuthedRequest(
      `http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-reminder`,
      "PATCH",
      { lightDispatchReminderEnabled: false },
    ),
    { params: Promise.resolve({ projectId: groupProject.id }) },
  );
  assert.equal(disableResponse.status, 200);
  const disablePayload = (await disableResponse.json()) as {
    ok: boolean;
    project: {
      id: string;
      lightDispatchReminderEnabled?: boolean;
    };
    collaborationGate: {
      lightDispatchReminderEnabled?: boolean;
    };
  };
  assert.equal(disablePayload.ok, true);
  assert.equal(disablePayload.project.id, groupProject.id);
  assert.equal(disablePayload.project.lightDispatchReminderEnabled, false);
  assert.equal(disablePayload.collaborationGate.lightDispatchReminderEnabled, false);

  const nextState = await readState();
  const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
  assert.ok(nextGroupProject, "expected group project to remain present");
  assert.equal(nextGroupProject?.lightDispatchReminderEnabled, false);
});