import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import test from "node:test";

import {
  classifyCodeAgentBrowserJourney,
  classifyLiveDeploymentIdentity,
  classifyLiveWebAssetIdentity,
  parseSmokeArgs,
  runDevCloudWorkbenchStaticSmoke,
  sanitizeAgentChatBody
} from "./src/dev-cloud-workbench-smoke-lib.mjs";
import {
  classifyCodeAgentBrowserFailure,
  classifyCodeAgentChatReadiness
} from "./src/code-agent-response-contract.mjs";
import {
  decideSmokeReportWrite,
  smokeCliExitCode
} from "./dev-cloud-workbench-smoke.mjs";
import { checkProfiles } from "./src/check-plan.mjs";

const sourceIdentity = Object.freeze({
  status: "observed",
  commitId: "ff4b3f928f76a0b46cd7998a2a865f3e1caf02c8",
  shortCommitId: "ff4b3f928f76",
  reportCommitId: "ff4b3f928f76",
  worktreeState: "clean",
  dirty: false
});

const expectedRuntimeIdentity = Object.freeze({
  status: "observed",
  serviceId: "hwlab-cloud-api",
  source: "deploy/artifact-catalog.dev.json+deploy/deploy.json:runtime-config",
  commitId: "7de6edd",
  imageTag: "7de6edd",
  image: "127.0.0.1:5000/hwlab/hwlab-cloud-api:7de6edd"
});
const rootPackage = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
const cloudWebPackage = JSON.parse(readFileSync(new URL("../web/hwlab-cloud-web/package.json", import.meta.url), "utf8"));
const cloudWebCheckSource = readFileSync(new URL("../web/hwlab-cloud-web/scripts/check.ts", import.meta.url), "utf8");

test("workbench smoke defaults to SOURCE mode and requires live confirmation before DEV-LIVE provider calls", () => {
  const defaultArgs = parseSmokeArgs([]);
  assert.equal(defaultArgs.mode, "source");
  assert.equal(defaultArgs.url, "http://74.48.78.17:16666/");
  assert.equal(defaultArgs.confirmDevLive, false);

  const sourceArgs = parseSmokeArgs(["--source"]);
  assert.equal(sourceArgs.mode, "source");

  const staticAliasArgs = parseSmokeArgs(["--static"]);
  assert.equal(staticAliasArgs.mode, "source");

  const liveArgs = parseSmokeArgs(["--live", "--confirm-dev-live"]);
  assert.equal(liveArgs.mode, "live");
  assert.equal(liveArgs.confirmDevLive, true);
  assert.equal(liveArgs.url, "http://74.48.78.17:16666/");

  assert.throws(
    () => parseSmokeArgs(["--live"]),
    /requires explicit --live --confirm-dev-live/u
  );
});

test("source/default workbench report cannot claim DEV-LIVE and documents the confirmed live command", () => {
  const report = runDevCloudWorkbenchStaticSmoke();
  assert.equal(report.mode, "source");
  assert.equal(report.evidenceLevel, "SOURCE");
  assert.equal(report.devLive, false);
  assert.equal(report.safety.devLive, false);
  assert.equal(report.validationCommands.includes("node scripts/dev-cloud-workbench-smoke.mjs --source"), true);
  assert.equal(
    report.validationCommands.includes("node scripts/dev-cloud-workbench-smoke.mjs --live --confirm-dev-live --url http://74.48.78.17:16666/ --report /tmp/hwlab-dev-gate/dev-cloud-workbench-live.json"),
    true
  );
  assert.equal(
    report.validationCommands.includes("node scripts/dev-cloud-workbench-smoke.mjs --live --url http://74.48.78.17:16666/ --report /tmp/hwlab-dev-gate/dev-cloud-workbench-live.json"),
    false
  );
  assert.equal(report.checks.find((check) => check.id === "code-agent-long-timeout-contract")?.status, "pass");
  const traceDisclosure = report.checks.find((check) => check.id === "code-agent-trace-replay-disclosure");
  assert.equal(traceDisclosure?.status, "pass");
  assert.deepEqual(traceDisclosure?.evidence, ["显示全部可读事件 / 完整 trace 回放中", "复制 JSON", "下载 trace", "traceDetailsOpen", "traceScrollPositions", "traceScrollPinnedToBottom", "internal scroll for full trace"]);
});

test("Code Agent browser failure classifier emits Chinese timeout/provider/browser categories with traceId", () => {
  const timeout = classifyCodeAgentBrowserFailure(new Error("request timed out after 180000ms"), { traceId: "trc_timeout" });
  assert.equal(timeout.category, "timeout");
  assert.match(timeout.chineseSummary, /超时/u);
  assert.match(timeout.chineseSummary, /trc_timeout/u);

  const provider = classifyCodeAgentBrowserFailure(new Error("OpenAI provider returned HTTP 502"), { traceId: "trc_provider" });
  assert.equal(provider.category, "provider");
  assert.match(provider.chineseSummary, /Provider 故障/u);
  assert.match(provider.chineseSummary, /trc_provider/u);

  const runnerBusy = classifyCodeAgentBrowserFailure(new Error("session_busy: runner already busy"), { traceId: "trc_busy" });
  assert.equal(runnerBusy.category, "runner_busy");
  assert.equal(runnerBusy.blocker, "runner-busy");
  assert.match(runnerBusy.chineseSummary, /Runner 忙碌/u);
  assert.match(runnerBusy.chineseSummary, /trc_busy/u);

  const sessionBlocked = classifyCodeAgentBrowserFailure(new Error("session_expired: session blocked"), { traceId: "trc_session" });
  assert.equal(sessionBlocked.category, "session_blocked");
  assert.equal(sessionBlocked.blocker, "session-blocked");
  assert.match(sessionBlocked.chineseSummary, /Session 受阻/u);
  assert.match(sessionBlocked.chineseSummary, /trc_session/u);

  const apiError = classifyCodeAgentBrowserFailure(new Error("API HTTP 500 request_failed"), { traceId: "trc_api" });
  assert.equal(apiError.category, "api_error");
  assert.equal(apiError.blocker, "api-error");
  assert.match(apiError.chineseSummary, /API 错误/u);
  assert.match(apiError.chineseSummary, /trc_api/u);

  const browser = classifyCodeAgentBrowserFailure(new Error("locator #command-input not found"), { traceId: "trc_browser" });
  assert.equal(browser.category, "browser");
  assert.match(browser.chineseSummary, /浏览器故障/u);
  assert.match(browser.chineseSummary, /trc_browser/u);
});

test("workbench smoke CLI treats skipped browser evidence as blocked and refuses to write reports", () => {
  const report = {
    status: "skip",
    mode: "static-mobile-browser",
    summary: "Mobile browser smoke skipped because Playwright is unavailable."
  };
  const decision = decideSmokeReportWrite(
    { reportPath: "/tmp/hwlab-dev-gate/dev-cloud-workbench-mobile.json" },
    report,
    { repoRoot: "/repo", cwd: "/repo" }
  );

  assert.equal(decision.status, "blocked");
  assert.equal(decision.write, false);
  assert.match(decision.summary, /skipped and does not contain required browser evidence/u);
  assert.equal(smokeCliExitCode(report, decision), 2);
});

test("workbench smoke CLI refuses to overwrite live report with non-live fixture evidence", () => {
  const report = {
    status: "pass",
    mode: "local-agent-fixture-browser"
  };
  const decision = decideSmokeReportWrite(
    { reportPath: "/tmp/hwlab-dev-gate/dev-cloud-workbench-live.json" },
    report,
    { repoRoot: "/repo", cwd: "/repo" }
  );

  assert.equal(decision.status, "blocked");
  assert.equal(decision.write, false);
  assert.match(decision.summary, /Refusing to overwrite \/tmp\/hwlab-dev-gate\/dev-cloud-workbench-live\.json/u);
  assert.equal(smokeCliExitCode(report, decision), 2);
});

test("workbench smoke CLI allows live evidence to write the live report", () => {
  const report = {
    status: "pass",
    mode: "live"
  };
  const decision = decideSmokeReportWrite(
    { reportPath: "/tmp/hwlab-dev-gate/dev-cloud-workbench-live.json" },
    report,
    { repoRoot: "/repo", cwd: "/repo" }
  );

  assert.equal(decision.status, "pass");
  assert.equal(decision.write, true);
  assert.equal(decision.reportPath, "/tmp/hwlab-dev-gate/dev-cloud-workbench-live.json");
  assert.equal(smokeCliExitCode(report, decision), 0);
});

test("smoke args include a DOM-only live read-only mode", () => {
  const args = parseSmokeArgs(["--dom-only", "--url", "http://74.48.78.17:16666/"]);
  assert.equal(args.confirmDevLive, false);
  assert.equal(args.mode, "dom-only");
  assert.equal(args.url, "http://74.48.78.17:16666/");
  assert.equal(args.urlExplicit, true);
});

test("source/default smoke covers #352 resource explorer removal contract", () => {
  const report = runDevCloudWorkbenchStaticSmoke();
  const check = report.checks.find((item) => item.id === "feedback-352-resource-explorer-removed");
  assert.equal(check?.status, "pass");
  assert.equal(check.evidence.includes("aside#resource-explorer absent"), true);
  assert.equal(check.evidence.includes("#explorer-resize absent"), true);
});

test("source/default smoke covers Device Pod right-sidebar contract", () => {
  const report = runDevCloudWorkbenchStaticSmoke();
  const summary = report.checks.find((item) => item.id === "device-pod-summary-sidebar");
  const events = report.checks.find((item) => item.id === "device-pod-event-stream");
  const service = report.checks.find((item) => item.id === "device-pod-executor-authority");
  assert.equal(summary?.status, "pass");
  assert.equal(events?.status, "pass");
  assert.equal(service?.status, "pass");
  assert.equal(summary.evidence.includes("summary-tile"), true);
  assert.equal(summary.evidence.includes("device-detail-dialog"), true);
  assert.equal(events.evidence.includes("device-event-text"), true);
});

test("source/default smoke covers #288 gate single-table contract", () => {
  const report = runDevCloudWorkbenchStaticSmoke();
  const check = report.checks.find((item) => item.id === "feedback-288-gate-single-table");
  assert.equal(check?.status, "pass");
  assert.equal(report.checks.some((item) => item.id === "feedback-119-gate-retains-diagnostics"), false);
});

test("live workbench identity passes only when runtime commit or image tag matches current source", () => {
  assert.equal(
    classifyLiveDeploymentIdentity(sourceIdentity, {
      status: "observed",
      commitId: "7de6edd2c41f",
      imageTag: "c7de474"
    }, expectedRuntimeIdentity).status,
    "pass"
  );

  assert.equal(
    classifyLiveDeploymentIdentity(sourceIdentity, {
      status: "observed",
      commitId: "unknown",
      imageTag: "7de6edd"
    }, expectedRuntimeIdentity).status,
    "pass"
  );

  const stale = classifyLiveDeploymentIdentity(sourceIdentity, {
    status: "observed",
    commitId: "c7de474",
    imageTag: "c7de474"
  }, expectedRuntimeIdentity);
  assert.equal(stale.status, "blocked");
  assert.match(stale.summary, /Deployment drift/u);
  assert.match(stale.reason, /does not match current source desired runtime identity/u);
});

test("live workbench identity blocks when source identity is dirty or runtime identity is absent", () => {
  const dirty = classifyLiveDeploymentIdentity(
    { ...sourceIdentity, worktreeState: "dirty", dirty: true, reportCommitId: "unknown" },
    { status: "observed", commitId: "7de6edd", imageTag: "7de6edd" },
    expectedRuntimeIdentity
  );
  assert.equal(dirty.status, "blocked");
  assert.match(dirty.reason, /not cleanly attributable/u);

  const missingRuntime = classifyLiveDeploymentIdentity(sourceIdentity, {
    status: "not_observed",
    commitId: "not_observed",
    imageTag: "not_observed"
  }, expectedRuntimeIdentity);
  assert.equal(missingRuntime.status, "blocked");
  assert.match(missingRuntime.reason, /not observed/u);
});

test("live workbench identity uses deploy desired runtime identity instead of git HEAD", () => {
  const deployed = classifyLiveDeploymentIdentity(sourceIdentity, {
    status: "observed",
    commitId: "7de6edd",
    imageTag: "7de6edd"
  }, expectedRuntimeIdentity);
  assert.equal(deployed.status, "pass");
  assert.equal(deployed.expectedCommit, "7de6edd");
  assert.equal(deployed.expectedReportCommitId, "ff4b3f928f76");
  assert.equal(deployed.expectedSource, "deploy/artifact-catalog.dev.json+deploy/deploy.json:runtime-config");
});

test("live web asset identity blocks stale deployed primary assets", () => {
  const pass = classifyLiveWebAssetIdentity([
    { path: "index.html", status: "match" },
    { path: "styles.css", status: "match" },
    { path: "app.js", status: "match" }
  ]);
  assert.equal(pass.status, "pass");

  const stale = classifyLiveWebAssetIdentity([
    { path: "index.html", status: "match" },
    { path: "styles.css", status: "mismatch" },
    { path: "app.js", status: "mismatch" }
  ]);
  assert.equal(stale.status, "blocked");
  assert.deepEqual(stale.mismatches, ["styles.css", "app.js"]);
  assert.match(stale.summary, /Deployment drift/u);
});

test("Code Agent browser classifier blocks provider 502 response shapes", () => {
  const summary = sanitizeAgentChatBody({
    status: "completed",
    provider: "openai-responses",
    model: "gpt-5.5",
    backend: "hwlab-cloud-api/openai-responses",
    traceId: "trc_provider_502",
    reply: {
      content: "must not count"
    },
    error: {
      code: "provider_unavailable",
      message: "OpenAI Responses returned HTTP 502: request rejected",
      providerStatus: 502,
      missingEnv: []
    }
  }, { httpStatus: 502 });

  assert.equal(summary.status, "failed");
  assert.equal(summary.hasReply, false);
  assert.equal(summary.error.code, "provider_unavailable");
  assert.equal(summary.error.providerStatus, 502);

  const classification = classifyCodeAgentBrowserJourney({
    responseSummary: summary,
    httpOk: false,
    httpStatus: 502,
    ui: {
      agentChatStatus: "DEV-LIVE 回复",
      completedMessageVisible: true,
      failedMessageVisible: false
    }
  });
  assert.equal(classification.status, "blocked");
  assert.equal(classification.blocker, "provider-upstream");
});

test("Code Agent browser classifier treats sanitized 服务受阻 UI as blocked provider evidence", () => {
  const summary = sanitizeAgentChatBody({
    status: "failed",
    provider: "openai-responses",
    model: "gpt-5.5",
    backend: "hwlab-cloud-api/openai-responses",
    traceId: "trc_provider_502",
    error: {
      code: "provider_unavailable",
      message: "OpenAI Responses returned HTTP 502: request rejected",
      providerStatus: 502,
      missingEnv: []
    }
  }, { httpStatus: 200 });

  const classification = classifyCodeAgentBrowserJourney({
    responseSummary: summary,
    httpOk: true,
    httpStatus: 200,
    ui: {
      agentChatStatus: "服务受阻",
      completedMessageVisible: false,
      failedMessageVisible: true
    }
  });

  assert.equal(classification.status, "blocked");
  assert.equal(classification.blocker, "provider-upstream");
});

test("Code Agent browser classifier distinguishes runner busy, session blocked, and API error payloads", () => {
  const base = {
    status: "failed",
    provider: "codex-readonly-runner",
    model: "read-only-tools",
    backend: "hwlab-cloud-api/codex-readonly-runner",
    traceId: "trc_runtime_block"
  };

  const runnerBusy = classifyCodeAgentBrowserJourney({
    responseSummary: sanitizeAgentChatBody({
      ...base,
      error: {
        code: "session_busy",
        message: "Code Agent runner session is already busy"
      }
    }, { httpStatus: 200 }),
    httpOk: true,
    httpStatus: 200,
    ui: {
      agentChatStatus: "服务受阻",
      completedMessageVisible: false,
      failedMessageVisible: true
    }
  });
  assert.equal(runnerBusy.blocker, "runner-busy");
  assert.equal(runnerBusy.category, "runner_busy");

  const sessionBlocked = classifyCodeAgentBrowserJourney({
    responseSummary: sanitizeAgentChatBody({
      ...base,
      error: {
        code: "session_expired",
        message: "Code Agent runner session expired"
      }
    }, { httpStatus: 200 }),
    httpOk: true,
    httpStatus: 200,
    ui: {
      agentChatStatus: "服务受阻",
      completedMessageVisible: false,
      failedMessageVisible: true
    }
  });
  assert.equal(sessionBlocked.blocker, "session-blocked");
  assert.equal(sessionBlocked.category, "session_blocked");

  const codexRuntimeBlocked = classifyCodeAgentBrowserJourney({
    responseSummary: sanitizeAgentChatBody({
      ...base,
      error: {
        code: "codex_stdio_failed",
        message: "Codex app-server turn finished with status=failed"
      }
    }, { httpStatus: 200 }),
    httpOk: true,
    httpStatus: 200,
    ui: {
      agentChatStatus: "Runner 受阻",
      completedMessageVisible: false,
      failedMessageVisible: true
    }
  });
  assert.equal(codexRuntimeBlocked.blocker, "runner-blocked");
  assert.equal(codexRuntimeBlocked.category, "runner_blocked");

  const apiError = classifyCodeAgentBrowserJourney({
    responseSummary: sanitizeAgentChatBody({
      status: "failed",
      traceId: "trc_proxy_timeout",
      error: {
        code: "cloud_api_proxy_failed",
        message: "cloud web proxy failed"
      }
    }, { httpStatus: 502 }),
    httpOk: false,
    httpStatus: 502,
    ui: {
      agentChatStatus: "后端失败",
      completedMessageVisible: false,
      failedMessageVisible: true
    }
  });
  assert.equal(apiError.blocker, "api-error");
  assert.equal(apiError.category, "api_error");
});

test("Code Agent readiness classifier blocks completed payloads over any non-2xx HTTP status", () => {
  const completedPayload = {
    conversationId: "cnv_completed_non_2xx",
    sessionId: "cnv_completed_non_2xx",
    messageId: "msg_completed_non_2xx",
    status: "completed",
    provider: "openai-responses",
    model: "gpt-5.5",
    backend: "hwlab-cloud-api/openai-responses",
    traceId: "trc_completed_non_2xx",
    reply: {
      content: "must only count over HTTP 2xx"
    }
  };

  const accepted = classifyCodeAgentChatReadiness(completedPayload, { realDevLive: true, httpStatus: 200 });
  assert.equal(accepted.status, "blocked");
  assert.equal(accepted.devLiveReplyPass, false);
  assert.equal(accepted.blocker, "untrusted-completion");

  for (const httpStatus of [400, 401, 403, 429, 500, 502, 503, 504]) {
    const blocked = classifyCodeAgentChatReadiness(completedPayload, { realDevLive: true, httpStatus });
    assert.equal(blocked.status, "blocked", `HTTP ${httpStatus} must block`);
    assert.equal(blocked.blocker, "provider-upstream", `HTTP ${httpStatus} blocker`);
    assert.equal(blocked.devLiveReplyPass, false, `HTTP ${httpStatus} must not pass DEV-LIVE`);
    assert.equal(blocked.providerStatus, httpStatus, `HTTP ${httpStatus} providerStatus`);
    assert.match(blocked.reason, /HTTP non-2xx|upstream response/u, `HTTP ${httpStatus} reason`);
  }
});

test("Code Agent browser classifier blocks completed payloads without backend evidence", () => {
  const summary = sanitizeAgentChatBody({
    status: "completed",
    provider: "openai-responses",
    model: "gpt-5.5",
    traceId: "trc_missing_backend",
    reply: {
      content: "must not count"
    }
  }, { httpStatus: 200 });

  const classification = classifyCodeAgentBrowserJourney({
    responseSummary: summary,
    httpOk: true,
    httpStatus: 200,
    ui: {
      agentChatStatus: "DEV-LIVE 回复",
      completedMessageVisible: true,
      failedMessageVisible: false
    }
  });

  assert.equal(classification.status, "blocked");
  assert.equal(classification.blocker, "untrusted-completion");
});

test("repo-owned web checks keep cloud-web semantic checks out of old browser gates", () => {
  const checkCommands = checkProfiles.check.map((task) => task.command.join(" "));
  assert.match(rootPackage.scripts["web:check"], /cd web\/hwlab-cloud-web && bun run check/u);
  assert.match(cloudWebPackage.scripts.check, /bun test && bun run scripts\/check\.ts/u);
  assert.ok(checkProfiles.check.some((task) => task.cwd === "web/hwlab-cloud-web" && task.command.join(" ") === "bun run check"));
  assert.doesNotMatch(checkCommands.join("\n"), /dev-cloud-workbench-layout-smoke|gate-summary\.mjs|export-web-gate-summary/u);
  assert.match(cloudWebCheckSource, /assertTraceHelpersBound/u);
  assert.match(cloudWebCheckSource, /Device Pod summary sidebar/u);
  assert.match(cloudWebCheckSource, /device-detail-dialog/u);
  assert.match(cloudWebCheckSource, /device-event-text/u);
  assert.match(cloudWebCheckSource, /isCodeAgentTimeoutError/u);
  assert.doesNotMatch(cloudWebCheckSource, /m3-readonly-contract|workbench-hardware-panel-contract|gate-summary\.mjs/u);
});