import { CLOUD_API_SERVICE_ID } from "../audit/index.mjs";
import { describeCodeAgentAvailability } from "./code-agent-chat.ts";
import {
  applyRuntimeDbReadinessLayers,
  buildDbRuntimeReadiness
} from "./db-contract.ts";
import { buildCloudApiReadiness } from "./health-contract.ts";
import {
  M3_IO_CONTROL_ROUTE,
  describeM3IoControlLive
} from "./m3-io-control.ts";

const STATUS = Object.freeze({
  pass: "通过",
  blocked: "阻塞",
  failed: "失败",
  pending: "待验证",
  info: "信息"
});

export async function buildGateDiagnosticsRows(options = {}) {
  const observedAt = new Date().toISOString();
  const rows = [];
  const health = await observeHealth(options, observedAt);
  const m3 = await observeM3(options, observedAt);
  const audit = await observeAudit(options, observedAt);
  const evidence = await observeEvidence(options, observedAt);

  rows.push(...health.rows, m3.row, audit.row, evidence.row);

  const status = rows.some((row) => row.statusKey === "failed")
    ? "failed"
    : rows.some((row) => row.statusKey === "blocked")
      ? "blocked"
      : rows.some((row) => row.statusKey === "pending")
        ? "pending"
      : "pass";

  return {
    serviceId: CLOUD_API_SERVICE_ID,
    route: "/v1/diagnostics/gate",
    contractVersion: "gate-diagnostics-table-v1",
    status,
    sourceKind: "LIVE-BACKEND",
    liveBackend: true,
    observedAt,
    rowCount: rows.length,
    columns: ["类别", "检查项", "状态", "归因对象", "关键细节", "证据/trace", "更新时间", "下一步"],
    rows,
    safety: {
      frontendHardcodedRows: false,
      sourceFixturePromoted: false,
      localStorageUsed: false,
      blockedIsGreen: false,
      hardwareControlSurface: false,
      codeAgentConversationSurface: false
    }
  };
}

async function observeHealth(options, observedAt) {
  try {
    const env = options.env ?? process.env;
    const dbProbe = await buildDbRuntimeReadiness(env, options.dbProbe);
    const runtime = await runtimeReadiness(options.runtimeStore);
    const db = applyRuntimeDbReadinessLayers(dbProbe, runtime);
    const codeAgent = await describeCodeAgentAvailability(env, options);
    const readiness = buildCloudApiReadiness({ db, codeAgent, runtime });
    const commitId = env.HWLAB_COMMIT_ID || env.HWLAB_GIT_SHA || "unknown";
    const imageTag = env.HWLAB_IMAGE_TAG || shortHash(commitId);
    return {
      rows: [
        row({
          category: "部署",
          check: "Cloud API 实况身份",
          statusKey: commitId === "unknown" ? "info" : "pass",
          owner: CLOUD_API_SERVICE_ID,
          detail: `service=${CLOUD_API_SERVICE_ID}; env=dev; status=${readiness.status}; imageTag=${imageTag}`,
          evidence: [`commit=${commitId}`, "GET /health/live"],
          updatedAt: observedAt,
          next: readiness.ready ? "继续保持与 DEV desired state 对齐。" : "先处理下方阻塞行，再重新执行 DEV live 复核。"
        }),
        row({
          category: "健康检查",
          check: "/health/live readiness",
          statusKey: readiness.ready ? "pass" : "blocked",
          owner: CLOUD_API_SERVICE_ID,
          detail: `ready=${readiness.ready}; status=${readiness.status}; blockers=${readiness.blockerCodes.join(",") || "无"}`,
          evidence: readiness.blockerCodes.length > 0 ? readiness.blockerCodes.map((code) => `blocker=${code}`) : ["GET /health/live"],
          updatedAt: observedAt,
          next: readiness.ready ? "无额外动作。" : "按 blocker code 分别处理 DB、runtime、Code Agent 或 M3 依赖。"
        }),
        row({
          category: "DB",
          check: "DB live readiness",
          statusKey: db?.ready && db?.connected && db?.liveDbEvidence ? "pass" : "blocked",
          owner: "hwlab-cloud-api / DEV Postgres",
          detail: `ready=${Boolean(db?.ready)}; connected=${Boolean(db?.connected)}; liveDbEvidence=${Boolean(db?.liveDbEvidence)}; endpointSource=${db?.endpointSource ?? "unknown"}`,
          evidence: db?.blocker ? [`blocker=${db.blocker}`] : ["db.liveDbEvidence=true"],
          updatedAt: observedAt,
          next: db?.ready && db?.connected && db?.liveDbEvidence
            ? "继续保持 Secret URL host 与 live DB 证据分层。"
            : "修复 DEV DB env/连接/auth，且不打印 Secret 值。"
        }),
        row({
          category: "运行态",
          check: "runtime durable adapter",
          statusKey: runtime?.durable === true && runtime?.ready === true && runtime?.liveRuntimeEvidence === true ? "pass" : "blocked",
          owner: "hwlab-cloud-api runtime-store",
          detail: `adapter=${runtime?.adapter ?? "unknown"}; durable=${Boolean(runtime?.durable)}; ready=${Boolean(runtime?.ready)}; liveRuntimeEvidence=${Boolean(runtime?.liveRuntimeEvidence)}`,
          evidence: [
            runtime?.blocker ? `blocker=${runtime.blocker}` : null,
            runtime?.durabilityContract?.blockedLayer ? `blockedLayer=${runtime.durabilityContract.blockedLayer}` : null,
            runtime?.connection?.queryResult ? `queryResult=${runtime.connection.queryResult}` : null
          ].filter(Boolean),
          updatedAt: observedAt,
          next: runtime?.durable === true && runtime?.ready === true && runtime?.liveRuntimeEvidence === true
            ? "可作为可信记录持久化前置。"
            : "修复 runtime durable auth/schema/migration/readiness 后再升级可信闭环。"
        }),
        row({
          category: "Code Agent",
          check: "provider readiness",
          statusKey: codeAgent?.ready && codeAgent?.status !== "blocked" ? "pass" : "blocked",
          owner: "hwlab-cloud-api / Code Agent provider",
          detail: `status=${codeAgent?.status ?? "unknown"}; provider=${codeAgent?.provider ?? "unknown"}; model=${codeAgent?.model ?? "unknown"}; backend=${codeAgent?.backend ?? "unknown"}`,
          evidence: [
            codeAgent?.reason ? `reason=${codeAgent.reason}` : null,
            ...(Array.isArray(codeAgent?.missingEnv) ? codeAgent.missingEnv.map((name) => `missingEnv=${name}`) : []),
            "Secret 值未读取/未展示"
          ].filter(Boolean),
          updatedAt: observedAt,
          next: codeAgent?.ready && codeAgent?.status !== "blocked"
            ? "继续用受控 /v1/agent/chat 验证真实 runner 能力。"
            : "补齐 provider env/Secret/egress 后复测，不用 mock 回复冒充。"
        })
      ]
    };
  } catch (error) {
    return {
      rows: [
        row({
          category: "健康检查",
          check: "后端聚合读取",
          statusKey: "failed",
          owner: CLOUD_API_SERVICE_ID,
          detail: `live 聚合失败：${oneLine(error.message)}`,
          evidence: "GET /v1/diagnostics/gate",
          updatedAt: observedAt,
          next: "先修复 cloud-api 聚合接口，再重新刷新内部复核表。"
        })
      ]
    };
  }
}

async function observeM3(options, observedAt) {
  try {
    const payload = await describeM3IoControlLive(options);
    const ready = payload?.readiness?.status === "ready" && payload?.readiness?.controlReady === true;
    return {
      row: row({
        category: "M3",
        check: "DO1 经 hwlab-patch-panel 同步到 DI1",
        statusKey: ready ? "pass" : payload?.readiness?.status === "pending" ? "pending" : "blocked",
        owner: "hwlab-cloud-api / hwlab-patch-panel",
        detail: payload?.readiness?.summary ?? payload?.blockedReason ?? "M3 IO readiness 未返回摘要。",
        evidence: [
          `route=${M3_IO_CONTROL_ROUTE}`,
          payload?.readiness?.sourceKind ? `sourceKind=${payload.readiness.sourceKind}` : null,
          payload?.readiness?.blocker?.code ? `blocker=${payload.readiness.blocker.code}` : null,
          payload?.readiness?.blocker?.layer ? `layer=${payload.readiness.blocker.layer}` : null
        ].filter(Boolean),
        updatedAt: payload?.readiness?.observedAt ?? observedAt,
        next: ready
          ? "只表示控制路径可执行；M3 验收仍需 operation/trace/audit/evidence 闭环。"
          : payload?.readiness?.blocker?.zh ?? "修复 gateway-simu、box-simu 或 patch-panel 只读 readiness 后再复核。"
      })
    };
  } catch (error) {
    return {
      row: row({
        category: "M3",
        check: "DO1 经 hwlab-patch-panel 同步到 DI1",
        statusKey: "failed",
        owner: "hwlab-cloud-api / hwlab-patch-panel",
        detail: `M3 live readiness 读取失败：${oneLine(error.message)}`,
        evidence: `GET ${M3_IO_CONTROL_ROUTE}`,
        updatedAt: observedAt,
        next: "先恢复 M3 IO readiness 接口，再验证 patch-panel 目标链路。"
      })
    };
  }
}

async function observeAudit(options, observedAt) {
  try {
    const result = await options.runtimeStore?.queryAuditEvents?.({ limit: 6 });
    const events = Array.isArray(result?.events) ? result.events : [];
    return {
      row: row({
        category: "证据",
        check: "audit.event.query",
        statusKey: events.length > 0 ? "info" : "pending",
        owner: "runtime-store / audit",
        detail: `只读查询返回 ${events.length} 条 audit；该行不单独证明 M3 通过。`,
        evidence: events.slice(0, 3).map((event) => [
          event.auditId ? `audit=${event.auditId}` : null,
          event.traceId ? `trace=${event.traceId}` : null
        ].filter(Boolean).join(" / ")).filter(Boolean),
        updatedAt: observedAt,
        next: events.length > 0 ? "将 audit 与 operation/evidence 绑定后再判断可信闭环。" : "等待 live audit 记录，或先修复 runtime durable blocker。"
      })
    };
  } catch (error) {
    return {
      row: row({
        category: "证据",
        check: "audit.event.query",
        statusKey: "blocked",
        owner: "runtime-store / audit",
        detail: `只读 audit 查询受阻：${oneLine(error.message)}`,
        evidence: "POST /json-rpc audit.event.query",
        updatedAt: observedAt,
        next: "修复 runtime durable/readiness 后再查询 audit，不用 SOURCE 回退冒充。"
      })
    };
  }
}

async function observeEvidence(options, observedAt) {
  try {
    const result = await options.runtimeStore?.queryEvidenceRecords?.({ limit: 6 });
    const records = Array.isArray(result?.records) ? result.records : [];
    return {
      row: row({
        category: "证据",
        check: "evidence.record.query",
        statusKey: records.length > 0 ? "info" : "pending",
        owner: "runtime-store / evidence",
        detail: `只读查询返回 ${records.length} 条 evidence；该行不单独证明 M3 通过。`,
        evidence: records.slice(0, 3).map((record) => [
          record.evidenceId ? `evidence=${record.evidenceId}` : null,
          record.traceId ?? record.metadata?.traceId ? `trace=${record.traceId ?? record.metadata?.traceId}` : null
        ].filter(Boolean).join(" / ")).filter(Boolean),
        updatedAt: observedAt,
        next: records.length > 0 ? "将 evidence 与 operation/audit/patch-panel live report 绑定后再判断。" : "等待 live evidence 记录，或先修复 runtime durable blocker。"
      })
    };
  } catch (error) {
    return {
      row: row({
        category: "证据",
        check: "evidence.record.query",
        statusKey: "blocked",
        owner: "runtime-store / evidence",
        detail: `只读 evidence 查询受阻：${oneLine(error.message)}`,
        evidence: "POST /json-rpc evidence.record.query",
        updatedAt: observedAt,
        next: "修复 runtime durable/readiness 后再查询 evidence，不用 SOURCE 回退冒充。"
      })
    };
  }
}

async function runtimeReadiness(runtimeStore) {
  if (typeof runtimeStore?.readiness === "function") {
    return runtimeStore.readiness();
  }
  if (typeof runtimeStore?.summary === "function") {
    return runtimeStore.summary();
  }
  return {
    adapter: "unknown",
    durable: false,
    ready: false,
    liveRuntimeEvidence: false,
    blocker: "runtime_store_unavailable"
  };
}

function row({ category, check, statusKey, owner, detail, evidence, updatedAt, next }) {
  const normalizedStatusKey = normalizeStatusKey(statusKey);
  return {
    category,
    check,
    status: STATUS[normalizedStatusKey],
    statusKey: normalizedStatusKey,
    owner,
    detail: oneLine(detail),
    evidence: normalizeEvidence(evidence),
    updatedAt,
    next: oneLine(next),
    sourceKind: "LIVE-BACKEND"
  };
}

function normalizeStatusKey(statusKey) {
  const normalized = String(statusKey ?? "").trim().toLowerCase();
  if (normalized === "pass" || normalized === "passed" || normalized === "ok" || normalized === "ready") return "pass";
  if (normalized === "failed" || normalized === "failure" || normalized === "error") return "failed";
  if (normalized === "pending" || normalized === "unknown" || normalized === "loading") return "pending";
  if (normalized === "info" || normalized === "information") return "info";
  return "blocked";
}

function normalizeEvidence(value) {
  const items = Array.isArray(value) ? value : [value];
  const normalized = items.map(oneLine).filter(Boolean);
  return normalized.length > 0 ? normalized : ["live 后端未返回可用 evidence 字段"];
}

function oneLine(value) {
  return String(value ?? "").replace(/\s+/gu, " ").trim().slice(0, 360);
}

function shortHash(value) {
  const text = String(value ?? "unknown");
  return text === "unknown" ? "unknown" : text.slice(0, 7);
}