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";

let runtimeRoot = "";
let data: typeof import("../src/lib/boss-data");

async function setup() {
  if (runtimeRoot) return;
  runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-master-task-reliability-"));
  process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
  process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");
  data = await import("../src/lib/boss-data.ts");
}

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

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

async function queueDesktopTask(taskId: string) {
  return data.queueMasterAgentTask({
    taskId,
    projectId: "master-agent",
    taskType: "desktop_control",
    requestMessageId: `${taskId}-message`,
    requestText: "打开 Chrome",
    executionPrompt: "打开 Chrome",
    requestedBy: "krisolo",
    requestedByAccount: "krisolo",
    deviceId: "mac-studio",
    runtimeKind: "computer-use-runtime",
    controlPlatform: "macos",
  });
}

test("claiming a desktop control task records attempt count and a server lease", async () => {
  await queueDesktopTask("lease-task");

  const claimed = await data.claimNextMasterAgentTask("mac-studio");

  assert.equal(claimed?.taskId, "lease-task");
  assert.equal(claimed?.status, "running");
  assert.equal(claimed?.attemptCount, 1);
  assert.ok(claimed?.leaseExpiresAt);
  assert.ok(Date.parse(claimed.leaseExpiresAt) > Date.parse(claimed.claimedAt ?? ""));
});

test("an expired running desktop control task can be reclaimed with a new attempt", async () => {
  await queueDesktopTask("reclaim-task");
  const firstClaim = await data.claimNextMasterAgentTask("mac-studio");
  assert.equal(firstClaim?.attemptCount, 1);

  const state = await data.readState();
  const task = state.masterAgentTasks.find((item) => item.taskId === "reclaim-task");
  assert.ok(task);
  task.claimedAt = "2000-01-01T00:00:00.000Z";
  task.leaseExpiresAt = "2000-01-01T00:01:00.000Z";
  await data.writeState(state);

  const reclaimed = await data.claimNextMasterAgentTask("mac-studio");

  assert.equal(reclaimed?.taskId, "reclaim-task");
  assert.equal(reclaimed?.status, "running");
  assert.equal(reclaimed?.attemptCount, 2);
  assert.notEqual(reclaimed?.claimedAt, firstClaim?.claimedAt);
});

test("an expired running task is timed out after max attempts instead of being claimed forever", async () => {
  await queueDesktopTask("timeout-task");
  await data.claimNextMasterAgentTask("mac-studio");

  const state = await data.readState();
  const task = state.masterAgentTasks.find((item) => item.taskId === "timeout-task");
  assert.ok(task);
  task.status = "running";
  task.attemptCount = 3;
  task.maxAttempts = 3;
  task.leaseExpiresAt = "2000-01-01T00:01:00.000Z";
  await data.writeState(state);

  const claimed = await data.claimNextMasterAgentTask("mac-studio");

  assert.equal(claimed, null);
  const nextTask = (await data.readState()).masterAgentTasks.find((item) => item.taskId === "timeout-task");
  assert.equal(nextTask?.status, "timed_out");
  assert.match(nextTask?.errorMessage ?? "", /timed out/i);
});

test("canceling a running task prevents late success completion from overwriting the terminal state", async () => {
  await queueDesktopTask("cancel-task");
  const claimed = await data.claimNextMasterAgentTask("mac-studio");
  assert.equal(claimed?.status, "running");

  const canceled = await data.cancelMasterAgentTask({
    taskId: "cancel-task",
    actorAccount: "krisolo",
    reason: "用户取消演示任务",
  });
  assert.equal(canceled.status, "canceled");
  assert.ok(canceled.canceledAt);

  const late = await data.completeMasterAgentTask({
    taskId: "cancel-task",
    deviceId: "mac-studio",
    status: "completed",
    replyBody: "迟到的成功结果",
  });

  assert.equal(late.status, "canceled");
  assert.equal(late.replyBody, undefined);
  const finalTask = (await data.readState()).masterAgentTasks.find((item) => item.taskId === "cancel-task");
  assert.equal(finalTask?.status, "canceled");
  assert.equal(finalTask?.replyBody, undefined);
});