import { beforeEach } from 'node:test';
import { questionLog } from './question-log.js';
beforeEach(t => {
  if (!('mock' in t)) throw new Error('Expected test context');
  t.mock.method(questionLog, 'start', async () => 'synthetic-question');
  t.mock.method(questionLog, 'finish', async () => {});
});
import assert from "node:assert/strict";
import test, { type TestContext } from "node:test";
import { Hono } from "hono";
import router from "./index.js";
import { vehicleRepository } from "../vehicles/repository.js";
import { gapStore } from "./gaps.js";
import type { AuthUser } from "../../auth/types.js";
import type { Vehicle } from "../../types.js";
import type { AssistantRequest, AssistantResult, GapReason, QueryPlan } from "../../../shared/assets/assistant.js";

const company = "合成公司A";
const plan = (overrides: Partial<QueryPlan> = {}): QueryPlan => ({
  kind: "assets", category: "inventory", groupBy: "city", view: "table", filters: { region: ["华东"] }, analysis: "distribution", ...overrides,
});
const part = (id: string, title: string, queryPlan: QueryPlan, display = "table") => ({ id, title, question: title, plan: queryPlan, display });
let serial = 0;

function fixture(t: TestContext, permissionLevel: AuthUser["permissionLevel"] = "personal") {
  const user: AuthUser = { userId: `composition-${++serial}`, userName: "组合验收", loginName: "composition", depCode: "D", depName: "合成部门", permissionLevel, roles: [] };
  const vehicles = [
    { id: "jx-inventory", type: "4.5T", city: "嘉兴市", status: "Inventory", operationStatus: "3" },
    { id: "hz-inventory", type: "18T", city: "杭州市", status: "Inventory", operationStatus: "3" },
    { id: "jx-pending", type: "4.5T", city: "嘉兴市", status: "Pending", operationStatus: "4" },
    { id: "jx-operating", type: "18T", city: "嘉兴市", status: "Operating", operationStatus: "1" },
    { id: "south-inventory", type: "49T", city: "广州市", province: "广东省", status: "Inventory", operationStatus: "3" },
    { id: "other-company", type: "4.5T", city: "嘉兴市", subjectOrg: "合成公司B", status: "Inventory", operationStatus: "3" },
    { id: "other-owner", type: "4.5T", city: "嘉兴市", managerId: "another-user", departmentName: "其他部门", status: "Inventory", operationStatus: "3" },
  ].map((v) => ({ province: "浙江省", model: "合成车型", subjectOrg: company, departmentName: "合成部门", managerId: user.userId, plateNumber: `合成-${v.id}`, vin: `SYNTHETIC-${v.id}`, ...v }) as Vehicle);
  const getVehicles = t.mock.method(vehicleRepository, "getVehicles", async () => vehicles);
  let flowFailure = false;
  const getFlow = t.mock.method(vehicleRepository, "getFlowDetailRows", async (start: string) => {
    if (flowFailure) throw new Error("Synthetic internal database error; must not become user output");
    return [
      { id: "event-valid", truck_id: "jx-inventory", stat_date: start, type: "delivered", type_label: "交车" },
      { id: "event-other-company", truck_id: "other-company", stat_date: start, type: "delivered", type_label: "交车" },
      { id: "event-other-owner", truck_id: "other-owner", stat_date: start, type: "delivered", type_label: "交车" },
    ];
  });
  const gaps: { demand: string; reason: GapReason }[] = [];
  t.mock.method(gapStore, "record", async (_user: string, demand: string, reason: GapReason) => { gaps.push({ demand, reason }); });
  const oldKey = process.env.DEEPSEEK_API_KEY, oldEnabled = process.env.ASSET_AI_EXTERNAL_ENABLED;
  process.env.DEEPSEEK_API_KEY = "synthetic-model-key";
  process.env.ASSET_AI_EXTERNAL_ENABLED = "1";
  t.after(() => {
    if (oldKey === undefined) delete process.env.DEEPSEEK_API_KEY; else process.env.DEEPSEEK_API_KEY = oldKey;
    if (oldEnabled === undefined) delete process.env.ASSET_AI_EXTERNAL_ENABLED; else process.env.ASSET_AI_EXTERNAL_ENABLED = oldEnabled;
  });
  const proposals: Record<string, unknown>[] = [];
  const presentationRequests: string[] = [];
  // Existing assertions count planning calls; presentation is an independent stage.
  const requests: string[] = [];
  t.mock.method(globalThis, "fetch", async (_url: unknown, init?: RequestInit) => {
    const body = JSON.parse(String(init?.body));
    const context = JSON.parse(body.messages.find((message: { role: string }) => message.role === "user").content);
    if (context.stage === "presentation") {
      presentationRequests.push(String(init?.body));
      const presentation = { layout: "stack", results: context.results.map((result: { id: string }) => ({ id: result.id, blocks: [{ id: "summary", kind: "summary" }], interactions: [] })) };
      return new Response(JSON.stringify({ choices: [{ message: { content: JSON.stringify(presentation) }, finish_reason: "stop" }] }));
    }
    requests.push(String(init?.body));
    assert.ok(proposals.length, "Unexpected external request: every response is supplied by this test");
    return new Response(JSON.stringify({ choices: [{ message: { content: JSON.stringify(proposals.shift()) }, finish_reason: "stop" }] }), { headers: { "Content-Type": "application/json" } });
  });
  const app = new Hono<{ Variables: { user: AuthUser } }>();
  app.use("*", async (c, next) => { c.set("user", user); await next(); });
  app.route("/ai", router);
  async function ask(input: Partial<AssistantRequest>) {
    const response = await app.request("/ai/ask", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ subject: company, ...input }) });
    assert.equal(response.status, 200);
    const events = (await response.text()).split("\n").filter((line) => line.startsWith("data:")).map((line) => JSON.parse(line.slice(5)));
    const error = events.find((event) => event.type === "error");
    assert.equal(error, undefined, error?.message);
    const result = events.find((event) => event.type === "result")?.result as AssistantResult;
    assert.ok(result, "A composed response must produce a result even if one section fails");
    return result;
  }
  return { app, ask, proposals, requests, presentationRequests, gaps, getVehicles, getFlow, vehicles, failFlow: () => { flowFailure = true; } };
}
const based = (result: AssistantResult) => ({ sessionId: result.sessionId, baseResultId: result.resultId });
const ids = (result: AssistantResult) => result.rows.map((row) => row.id).sort();
const inventory = () => part("inventory", "华东库存按城市分布", plan(), "chart");
const flow = () => part("flow", "华东本期交退换趋势", plan({ kind: "flow", category: "all", groupBy: "none", start: "2026-09-17", end: "2026-09-23" }), "chart");

test("one model decision executes four independent analyses in the same authorized company scope", async (t) => {
  const { ask, proposals, requests, presentationRequests, getVehicles } = fixture(t);
  const sections = [
    part("overview", "华东全部资产概况", plan({ category: "all" }), "metrics"),
    inventory(),
    part("pending", "华东待交车清单", plan({ category: "pending", view: "list" }), "list"),
    part("operating", "华东运营车辆按车型统计", plan({ category: "operating", groupBy: "type" }), "table"),
  ];
  proposals.push({ kind: "query", plan: sections[0].plan, queries: sections });
  const result = await ask({ message: "分别展示华东资产概况、库存分布、待交车清单和运营车型统计。" });
  assert.equal(result.sections?.length, 4);
  assert.ok(result.resultId);
  const counts = [5, 4, 1, 1];
  const childIds: string[] = [];
  for (const [index, section] of result.sections!.entries()) {
    assert.equal(section.id, sections[index].id);
    assert.equal(section.display, sections[index].display);
    assert.equal(section.error, undefined);
    assert.ok(section.result);
    assert.equal(section.result.rows.length, counts[index]);
    assert.equal(section.result.scope?.company, company);
    assert.deepEqual(section.result.plan.filters, { region: ["华东"] });
    assert.equal(section.result.sessionId, result.sessionId);
    assert.ok(section.result.resultId);
    childIds.push(section.result.resultId!);
    assert.ok(ids(section.result).every((id) => !["other-company", "south-inventory"].includes(id)));
  }
  assert.equal(new Set([result.resultId, ...childIds]).size, 5, "Root and each analysis need distinct result identities");
  assert.equal(result.outcome, "complete");
  assert.equal(requests.length, 1);
  assert.equal(presentationRequests.length, 1, "One display generation call serves all four analyses");
  assert.equal(getVehicles.mock.callCount(), 1, "All analyses must share a single authorized vehicle snapshot");
});

for (const failedFirst of [true, false]) {
  test(`a ${failedFirst ? "primary" : "secondary"} flow failure preserves the successful asset analysis`, async (t) => {
    const { ask, proposals, gaps, failFlow, requests } = fixture(t);
    failFlow();
    const queries = failedFirst ? [flow(), inventory()] : [inventory(), flow()];
    proposals.push({ kind: "query", plan: queries[0].plan, queries });
    const result = await ask({ message: "华东库存和本期交退换分别展示，哪个暂不可用就保留其余结果。" });
    assert.equal(result.sections?.length, 2);
    const asset = result.sections!.find((section) => section.id === "inventory")!;
    const failed = result.sections!.find((section) => section.id === "flow")!;
    assert.equal(asset.result?.rows.length, 4);
    assert.ok(asset.result?.resultId);
    assert.ok(failed.error);
    assert.equal(failed.result, undefined);
    assert.equal(result.outcome, "partial");
    assert.ok(result.unanswered?.some((item) => /交退换|流转/.test(item.question)));
    assert.ok(gaps.some((gap) => /交退换|流转/.test(gap.demand)));
    assert.doesNotMatch(JSON.stringify(result), /Synthetic internal database/);
    assert.equal(requests.length, 1);
  });
}

test("drilling and following up a child preserves that child's category and filters", async (t) => {
  const { ask, proposals, requests, presentationRequests } = fixture(t);
  proposals.push({ kind: "query", plan: plan({ category: "all" }), queries: [part("overview", "华东全部资产", plan({ category: "all" }), "metrics"), inventory()] });
  const composition = await ask({ message: "华东资产概览和库存分布分开给我。" });
  const child = composition.sections!.find((section) => section.id === "inventory")!.result!;
  const drill = await ask({ ...based(child), action: { type: "drill", keys: { city: "嘉兴市" } } });
  assert.equal(drill.sections, undefined, "A local block action must return a normal result for in-place replacement");
  assert.equal(drill.plan.category, "inventory");
  assert.deepEqual(drill.plan.filters, { region: ["华东"], city: ["嘉兴市"] });
  assert.deepEqual(ids(drill), ["jx-inventory", "jx-pending", "other-owner"]);
  assert.equal(requests.length, 1, "Click-based drilling should not trigger another planning request");
  assert.equal(presentationRequests.length, 2, "The original result and clicked result each get one display generation pass");
  proposals.push({ kind: "query", plan: plan({ category: "pending", view: "list", filters: { region: ["华东"], city: ["嘉兴市"] } }) });
  const follow = await ask({ ...based(drill), message: "这里面待交车的单独列出来" });
  assert.equal(follow.sections, undefined);
  assert.deepEqual(ids(follow), ["jx-pending"]);
  assert.deepEqual(follow.plan.filters, drill.plan.filters);
  assert.equal(follow.breadcrumbs?.at(-2)?.resultId, drill.resultId);
});

test("the parent conversation includes all successful analyses for cross-section references", async (t) => {
  const { ask, proposals, requests } = fixture(t);
  proposals.push({ kind: "query", plan: plan(), queries: [inventory(), part("pending", "华东待交车清单", plan({ category: "pending", view: "list" }), "list")] });
  const root = await ask({ message: "华东库存分布和待交车清单分开显示。" });
  const pending = root.sections!.find((section) => section.id === "pending")!.result!;
  proposals.push({ kind: "query", plan: plan({ category: "pending", groupBy: "type" }), baseResultId: pending.resultId });
  const next = await ask({ ...based(root), message: "继续第二项的待交车，按车型拆开" });
  const request = JSON.parse(requests.at(-1)!);
  const context = JSON.parse([...request.messages].reverse().find((message: { role: string }) => message.role === "user").content);
  const analyses = context.analyses || context.resultContext?.analyses;
  assert.ok(Array.isArray(analyses), "The model needs every analysis, not only the root's first plan");
  assert.equal(analyses.length, 2);
  assert.ok(analyses.some((analysis: { plan: QueryPlan; metrics: { value: number }[] }) => analysis.plan.category === "inventory" && analysis.metrics[0].value === 4));
  assert.ok(analyses.some((analysis: { id: string; plan: QueryPlan; metrics: { value: number }[] }) => analysis.id === pending.resultId && analysis.plan.category === "pending" && analysis.metrics[0].value === 1));
  assert.equal(next.plan.category, "pending");
  assert.deepEqual(ids(next), ["jx-pending"]);
  assert.equal(next.breadcrumbs?.at(-2)?.resultId, pending.resultId);
});

test("an unknown display or invalid child plan cannot discard the healthy sibling", async (t) => {
  const { ask, proposals, requests, gaps } = fixture(t);
  proposals.push({ kind: "query", plan: plan(), queries: [
    inventory(),
    part("unknown-display", "待交车清单", plan({ category: "pending", view: "list" }), "javascript:unsupported-renderer"),
    { ...part("invalid-plan", "未能识别的业务查询", plan()), plan: { ...plan(), category: "does-not-exist" } },
  ] });
  const result = await ask({ message: "库存分布、待交清单和另外一项查询分别显示。" });
  const healthy = result.sections?.find((section) => section.id === "inventory")?.result || result;
  assert.equal(healthy.rows.length, 4);
  assert.equal(healthy.plan.category, "inventory");
  const display = result.sections?.find((section) => section.id === "unknown-display");
  if (display) {
    assert.ok(["metrics", "chart", "table", "list"].includes(display.display));
    assert.ok(display.error || display.result?.plan.category === "pending");
  } else {
    assert.ok(result.unanswered?.some((item) => item.question === "待交车清单"), "Discarded presentation must have an explicit unanswered item");
  }
  const invalid = result.sections?.find((section) => section.id === "invalid-plan");
  assert.ok(invalid?.error || result.unanswered?.some((item) => item.question === "未能识别的业务查询"), "Invalid query must be individually explained, either as a failed section or an unanswered item");
  assert.equal(result.outcome, "partial");
  assert.ok(result.unanswered?.length);
  assert.ok(gaps.some((gap) => /未能识别的业务查询/.test(gap.demand)));
  assert.equal(requests.length, 1, "An invalid section must not cause a blanket second planning pass");
});

test("a simple query keeps the legacy result shape and uses one planning call", async (t) => {
  const { ask, proposals, requests, presentationRequests, getVehicles, getFlow } = fixture(t);
  proposals.push({ kind: "query", plan: plan() });
  const result = await ask({ message: "华东库存按城市统计" });
  assert.equal(result.sections, undefined);
  assert.equal(result.rows.length, 4);
  assert.equal(result.metrics[0].value, 4);
  assert.ok(result.resultId);
  assert.equal(requests.length, 1);
  assert.equal(presentationRequests.length, 1);
  assert.equal(getVehicles.mock.callCount(), 1);
  assert.equal(getFlow.mock.callCount(), 0);
});

test("inventory subset percentages use the full inventory denominator even when the chart shows Top 1", async (t) => {
  const { ask, proposals, vehicles } = fixture(t);
  vehicles.find((vehicle) => vehicle.id === "hz-inventory")!.status = "Abnormal";
  const stock = plan({ topN: 1 });
  proposals.push({ kind: "query", plan: stock, queries: [part("stock-share", "华东库存分布与子集占比", stock, "chart"), part("pending", "华东待交车清单", plan({ category: "pending", view: "list" }), "list")] });
  const result = await ask({ message: "华东库存最多的城市和待交车清单分别展示，同时给待交车与异动占库存比例。" });
  const stockResult = result.sections!.find((section) => section.id === "stock-share")!.result!;
  assert.equal(stockResult.rows.length, 4);
  assert.equal(stockResult.groups.length, 1);
  assert.equal(stockResult.groups[0].count, 3);
  assert.equal(stockResult.metrics.find((metric) => metric.label === "待交车占库存")?.value, 25);
  assert.equal(stockResult.metrics.find((metric) => metric.label === "异动占库存")?.value, 25);
  assert.equal(stockResult.metrics.find((metric) => metric.label === "待交车占库存")?.unit, "%");
});

test("an empty inventory denominator has no invented percentage and does not become a query failure", async (t) => {
  const { ask, proposals, gaps } = fixture(t);
  const noMatch = plan({ filters: { city: ["北京市"] } });
  proposals.push({ kind: "query", plan: noMatch, queries: [part("empty-inventory", "北京库存子集占比", noMatch, "metrics"), part("empty-pending", "北京待交车清单", { ...noMatch, category: "pending", view: "list" }, "list")] });
  const result = await ask({ message: "北京库存占比和待交车列表分别展示。" });
  const stockResult = result.sections!.find((section) => section.id === "empty-inventory")!.result!;
  assert.equal(stockResult.metrics[0].value, 0);
  assert.ok(stockResult.metrics.every((metric) => !/占库存/.test(metric.label)));
  assert.match(stockResult.summary, /分母.*0|没有|未找到/);
  assert.equal(result.outcome, "empty");
  assert.equal(result.gap, undefined);
  assert.equal(gaps.length, 0);
});

test("explicitly changing the parent region for composed analyses does not restore an obsolete city filter", async (t) => {
  const { ask, proposals } = fixture(t);
  proposals.push({ kind: "query", plan: plan({ filters: { region: ["华东"], city: ["嘉兴市"] } }) });
  const previous = await ask({ message: "只看华东嘉兴库存" });
  assert.equal(previous.rows.length, 3);
  const southernInventory = plan({ filters: { region: ["华南"] } });
  const southernOperating = plan({ category: "operating", filters: { region: ["华南"] } });
  proposals.push({ kind: "query", plan: southernInventory, queries: [
    part("southern-inventory", "改看华南库存分布", southernInventory, "chart"),
    part("southern-operating", "改看华南运营概况", southernOperating, "metrics"),
  ] });
  const changed = await ask({ ...based(previous), message: "改看华南，库存分布和运营概况分开展示。" });
  const inventoryResult = changed.sections!.find((section) => section.id === "southern-inventory")!.result!;
  assert.deepEqual(inventoryResult.plan.filters, { region: ["华南"] });
  assert.deepEqual(ids(inventoryResult), ["south-inventory"]);
  assert.ok(changed.sections!.every((section) => !section.result?.plan.filters.city));
});

for (const permissionLevel of ["personal", "department"] as const) {
  test(`${permissionLevel} can analyze public stock but flow, comparisons, actions and exports retain original scope`, async (t) => {
    const { app, ask, proposals } = fixture(t, permissionLevel);
    const compared = { ...flow(), plan: { ...flow().plan, comparePrevious: true } };
    proposals.push({ kind: "query", plan: plan(), queries: [inventory(), compared] });
    const result = await ask({ message: "库存和交退换趋势分别展示，并对比上期" });
    const stock = result.sections!.find(section => section.id === "inventory")!.result!;
    const business = result.sections!.find(section => section.id === "flow")!.result!;
    assert.ok(ids(stock).includes("other-owner"), "Other departments' stock is public");
    assert.deepEqual(ids(business), ["event-valid"], "Public stock does not expose other owners' historical events");
    assert.equal(business.comparison![0].current, 1);
    assert.equal(business.comparison![0].previous, 1);
    const day = await ask({ ...based(business), action: { type: "day", date: business.plan.start! } });
    assert.deepEqual(ids(day), ["event-valid"]);
    const exported = await app.request("/ai/export", {
      method: "POST", headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ sessionId: business.sessionId, resultId: business.resultId, subject: company }),
    });
    assert.equal(exported.status, 200);
    const csv = await exported.text();
    assert.match(csv, /合成-jx-inventory/);
    assert.doesNotMatch(csv, /合成-other-owner|合成-other-company/);
  });
}