import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

// ★★ルート本体は**静的 import** すること★★ — `it()` の中で `await import()` すると、
//   最初の1本だけがモジュール読み込みを丸ごと抱え込み、フルスイート実行時に既定の
//   タイムアウトを踏んで不定期に落ちる（`app/api/clean-logs/__tests__/route.test.ts` の実測）。
import { GET as GET_CONTINUOUS } from "@/app/api/reports/continuous-problems/route";
import { GET as GET_BREAKDOWN } from "@/app/api/reports/error-breakdown/route";
import { GET as GET_PERFORMANCE } from "@/app/api/reports/facility-performance/route";
import { GET as GET_KPI } from "@/app/api/reports/kpi/route";
import { CLEAN_TIMETABLE_PRECHECK, PRECHECK_MINUTES_BEFORE } from "@/lib/config";
// ★データ層を直接呼ぶテストが1つだけある★（理由はそのテストの docstring）
import { db } from "@/lib/db";
import { FACILITY_SECTION_VISIBLE_WHERE } from "@/lib/db/visibility";
import { logEvent } from "@/lib/logger";
import { consecutiveLookbackCalendarDays } from "@/lib/db/consecutive-source";
import { guardNullRobotId } from "@/lib/db/__tests__/robot-error-null-guard";
import { loadConsecutiveDaysMax } from "@/lib/settings/display-limits";
import type {
  ApiError,
  ContinuousProblem,
  ErrorBreakdownItem,
  FacilityPerformance,
  ListResponse,
  ReportKpi,
} from "@/lib/types";

/**
 * 指示書AC ★段階5★ の期待値表（#1〜#9）。
 *
 * ------------------------------------------------------------------------
 * ★★何を守るためのテストか★★
 * ------------------------------------------------------------------------
 *  - ★確定期間（サマリ由来）の値を履歴から再計算しない★（★★禁止事項10 / D-102★★）—
 *    #1 は「詳細テーブルを引けば別の数字になる」データを置いて、
 *    ★サマリの値がそのまま出ること★ と ★詳細テーブルを1行も読まないこと★ を固定する
 *  - ★★連続日数は期間で絞らない★★（★★C-2 の地雷★★）— #6 は
 *    ★期間をまたぐ連続（4日）★ を置き、期間で絞ったら出てしまう値（2日）にならないことを見る
 *  - ★月跨ぎ週（08-30〜08-31 の2日）／月の第1週・最終週の境界★（#3 / #4）—
 *    ★範囲は `periodRange()` に作らせる★ので、SQL に降りた `start_at` の境界で固定する
 *
 * ------------------------------------------------------------------------
 * ★★DBには接続しません★★
 * ------------------------------------------------------------------------
 * `@/lib/db/prisma` の `getPrisma()` を ★スタブに差し替え★、
 * `@/lib/db/use-fixtures` の `USE_FIXTURES` を ★`false`★ に固定して
 * ★`prismaSource` の経路★ を走らせる（段階2 / 段階4 のテストと同じ作法）。
 *
 * ★★合成データを使う理由★★: ローカルDB（`dwatch_local`）では
 *   - ★`start_at` が深夜0〜3時にしか無く、`toDbJst()` の付け忘れを検出できない★（C-6）
 *   - ★月跨ぎ週（8月第6週）に清掃データが無い★
 *   - ★「サマリと詳細が食い違う」状態を作れない★（D-102 の検出ができない）
 *
 * ★ローカルDBとの突き合わせは別で実施済み★ — 段階0（引数なし）と段階5（引数あり）の
 * 出力を11期間ぶん採って ★完全一致★ を確認した（`consecutive_problem_days` 込み。
 * 指示書AC 段階5 期待値表 #1 / #2 / #6 / G-3）。
 */

/**
 * ★`include: { robots: { orderBy: { id: "asc" } } }` を再現する★（指示書BB D7・表2 R9）—
 *   ★`orderBy` があるときだけ並べ替える★。実装が付け忘れたら、スタブはデータの順のまま返す（R9 が赤くなる）。
 *   `app/api/clean-logs/__tests__/route.test.ts` の `sortIncludedRobots()`（R5）と同じ作法
 */
function sortIncludedFacilityRobots(
  row: Record<string, unknown>,
  args: Record<string, unknown> | undefined
): Record<string, unknown> {
  const include = args?.include as { robots?: { orderBy?: { id?: string } } } | undefined;
  if (include?.robots?.orderBy?.id !== "asc" || !Array.isArray(row.robots)) return row;
  const robots = [...(row.robots as StubFacility["robots"])].sort(
    (a, b) => Number(a.id ?? 0) - Number(b.id ?? 0)
  );
  return { ...row, robots };
}

// ---------------------------------------------------------------- スタブ（DBの代わり）

interface StubFacility {
  id: bigint;
  facility_name: string;
  deleted_at: Date | null;
  /** `id` は省略可（★2台以上のときの並び `orderBy: { id: "asc" }` を見るため。指示書BB D7・表2 R9★） */
  robots: { id?: bigint; serial_number: string; deleted_at: Date | null }[];
  /**
   * ★分類（ホールディングス／屋号）の解決に使う2列★（指示書AK 段階4b）。
   * `loadFacilityGroupIndex()` が `select: { id, customer_id, customer: { group_id } }` で読む。
   * ★`customers.group_id` は NOT NULL で 0 = ホールディングスなし★（D-011）。
   */
  customer_id: bigint;
  customer: { group_id: bigint };
}

interface StubTimetable {
  id: bigint;
  facility_id: bigint;
  parent_id: bigint;
  start_at: Date;
  /** ★予定の終了（結果待ちの判定用。D-173）★。既定は開始の1時間後 */
  end_at: Date;
  precheck: number;
}

/**
 * ★清掃結果の取得元は `clean_task_reports`★（指示書AQ 決定2/3。旧 `clean_status_histories`）。
 *   ★`clean_error` 列は無い★ — ★未実施は「行が無い」で表す★（指示書AQ §1-1）。
 *   `clean_timetable_id` / `ended_at` は nullable（指示書AQ 罠1 / 罠3）。
 */
interface StubReport {
  clean_timetable_id: bigint | null;
  /** ★予定外タスク（指示書BG）の施設はこの列で決まる★。予定のある行は予定の施設を使うので省略可 */
  facility_id?: bigint;
  clean_ratio: number;
  status: number;
  started_at: Date;
  ended_at: Date | null;
  task_area: number;
  clean_area: number;
}

interface StubErrorReport {
  clean_timetable_id: bigint | null;
  /** ★予定外のエラー（指示書BG）の施設はこの列で決まる★ */
  facility_id: bigint;
  error_type: string;
  errored_at: Date | null;
  created_at: Date;
  /** ★DDL では NULL 可（第11回 P-8 b）。読まないこと（指示書AU 段階0-4）★ */
  robot_id?: bigint | null;
}

interface StubSummary {
  id: bigint;
  facility_id: bigint;
  customer_id: bigint;
  year: number;
  month: number;
  week: number;
  operation_ratio: number;
  launch_ratio: number;
  clean_ratio: number;
  error_ratio: number;
}

interface StubErrorSummary {
  id: bigint;
  facility_id: bigint;
  year: number;
  month: number;
  week: number;
  error_type: string;
  /**
   * ★2026-10-29 の DDL 変更で `error_detail` の代わりに入った列（NOT NULL・error_lists への FK）★。
   *   ★アプリは読まない★（`select` に入れない。内訳は `error_type` で束ねる）
   */
  error_list_id: bigint;
  error_count: number;
}

/**
 * 顧客マスタ（`customers`）。★段階6 で `/reports/kpi` が読むようになった★ —
 * ★対象顧客を1社に決める材料★（`resolveTargetCustomer()`。指示書AK §2-1）。
 * ★既定は1社だけ★にしてある（＝P1の実データ相当）ので、
 * ★`customer_id` を付けない既存のテストは今までどおり 200★ になる。
 */
interface StubCustomer {
  id: bigint;
  customer_name: string;
  /** ★NOT NULL。0 = ホールディングスなしのセンチネル★（D-011） */
  group_id: bigint;
  deleted_at: Date | null;
}

interface StubData {
  facilities: StubFacility[];
  customers: StubCustomer[];
  timetables: StubTimetable[];
  /** ★`clean_timetable_histories` の行（指示書AU 段階3b）。無ければ空★ */
  historyTimetables?: StubTimetable[];
  reports: StubReport[];
  errorReports: StubErrorReport[];
  customerSummaries: StubSummary[];
  facilitySummaries: StubSummary[];
  facilityErrorSummaries: StubErrorSummary[];
}

/** `findMany()` に渡された引数の記録（★どんな `where` が発行されたかを検査する★） */
const calls: Record<string, Record<string, unknown>[]> = {
  facility: [],
  customer: [],
  cleanTimetable: [],
  cleanTimetableHistory: [],
  cleanTaskReport: [],
  robotErrorReport: [],
  customerSummary: [],
  facilitySummary: [],
  facilityErrorSummary: [],
};

let data: StubData;

/** BigInt / number / null をまたいで id を比較する（`===` では比較できない） */
function sameId(a: unknown, b: unknown): boolean {
  if (a === null || a === undefined || b === null || b === undefined) return false;
  return String(a) === String(b);
}

/**
 * Prisma の `where` のうち、★本作業が使う分だけ★ を再現する（段階4 のテストの形 + `OR`）。
 *
 * ★★`in: undefined` は Prisma では「条件が消えて全件」になる★★（★罠1★）。
 *   ★ここでは例外にして、書き間違いが静かに通り抜けないようにする★。
 */
function matchesWhere(row: Record<string, unknown>, where: unknown): boolean {
  if (!where) return true;
  for (const [field, cond] of Object.entries(where as Record<string, unknown>)) {
    if (field === "OR") {
      // ★確定期間 ＋ 前期の2期間を1クエリで引くための `OR`★
      if (!(cond as unknown[]).some((sub) => matchesWhere(row, sub))) return false;
      continue;
    }
    const value = row[field];
    if (cond !== null && typeof cond === "object" && !(cond instanceof Date)) {
      const c = cond as Record<string, unknown>;
      if ("in" in c) {
        if (c.in === undefined) {
          throw new Error(
            `[stub] where.${field}.in が undefined です。★罠1★: Prisma では条件が消えて全件になります`
          );
        }
        if (!(c.in as unknown[]).some((x) => sameId(x, value))) return false;
      }
      if (c.gte instanceof Date && (value as Date).getTime() < c.gte.getTime()) return false;
      if (c.lt instanceof Date && (value as Date).getTime() >= c.lt.getTime()) return false;
    } else if (typeof cond === "bigint" || typeof value === "bigint") {
      if (!sameId(value, cond)) return false;
    } else if (value !== cond) {
      return false;
    }
  }
  return true;
}

function project(row: Record<string, unknown>, select: unknown): Record<string, unknown> {
  if (!select) return row;
  const out: Record<string, unknown> = {};
  for (const key of Object.keys(select as Record<string, unknown>)) out[key] = row[key];
  return out;
}

function findMany(
  bucket: keyof typeof calls,
  rows: Record<string, unknown>[],
  args: Record<string, unknown> | undefined
) {
  calls[bucket].push(args ?? {});
  return rows
    .filter((row) => matchesWhere(row, args?.where))
    .map((row) => project(row, args?.select));
}

vi.mock("@/lib/db/use-fixtures", () => ({ USE_FIXTURES: false }));

// ★確定期間のサマリ0行の `data.anomaly`（指示書BB A11・表13）を見るため `logEvent` だけ差し替える（`withRequestId` はそのまま）★
vi.mock("@/lib/logger", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@/lib/logger")>();
  return { ...actual, logEvent: vi.fn() };
});

vi.mock("@/lib/db/prisma", () => ({
  getPrisma: async () => ({
    facility: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany("facility", data.facilities as unknown as Record<string, unknown>[], args).map(
          (row) => sortIncludedFacilityRobots(row, args)
        ),
    },
    customer: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany("customer", data.customers as unknown as Record<string, unknown>[], args),
    },
    cleanTimetable: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany("cleanTimetable", data.timetables as unknown as Record<string, unknown>[], args),
    },
    // ★`clean_timetable_histories`（指示書AU 段階3b）。既定は空★
    cleanTimetableHistory: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany(
          "cleanTimetableHistory",
          (data.historyTimetables ?? []) as unknown as Record<string, unknown>[],
          args
        ),
    },
    cleanTaskReport: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany(
          "cleanTaskReport",
          data.reports as unknown as Record<string, unknown>[],
          args
        ),
    },
    robotErrorReport: {
      findMany: async (args?: Record<string, unknown>) => {
        // ★`robot_id` が NULL の行を `robot_id` ごと読むと本物の Prisma は落ちる（指示書AU 段階0-4）★
        guardNullRobotId(data.errorReports as unknown as Record<string, unknown>[], args);
        return findMany(
          "robotErrorReport",
          data.errorReports as unknown as Record<string, unknown>[],
          args
        );
      },
    },
    customerSummary: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany(
          "customerSummary",
          data.customerSummaries as unknown as Record<string, unknown>[],
          args
        ),
    },
    facilitySummary: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany(
          "facilitySummary",
          data.facilitySummaries as unknown as Record<string, unknown>[],
          args
        ),
    },
    facilityErrorSummary: {
      findMany: async (args?: Record<string, unknown>) =>
        findMany(
          "facilityErrorSummary",
          data.facilityErrorSummaries as unknown as Record<string, unknown>[],
          args
        ),
    },
  }),
}));

// ---------------------------------------------------------------- 合成データ

/** DB に入っているのと同じ「壁時計値としての `Date`」（D-115。他のテストと同じヘルパー） */
function dbWallClock(jstIso: string): Date {
  return new Date(jstIso.replace("+09:00", "Z"));
}

/** ★実在の店名を使わない★（`CLAUDE.md` §7 / `docs/fixtures.md`） */
const FACILITY_1 = "バリューマート北町店";
const FACILITY_2 = "メガバリューマート緑野店";
/** ★中点入り★ — 記号を無視する照合（`includesFoldName`）の検証用（指示書AG） */
const FACILITY_3 = "バリュー・マート三つ角店";

const [FIRST_ROUND_MINUTES] = PRECHECK_MINUTES_BEFORE;

function timetable(
  id: number,
  facilityId: number,
  jstIso: string,
  precheck: number = CLEAN_TIMETABLE_PRECHECK.main,
  parentId = 0
): StubTimetable {
  return {
    id: BigInt(id),
    facility_id: BigInt(facilityId),
    parent_id: BigInt(parentId),
    start_at: dbWallClock(jstIso),
    end_at: new Date(dbWallClock(jstIso).getTime() + 60 * 60_000),
    precheck,
  };
}

/**
 * `clean_task_reports` の1行（＝その本清掃は実施された）。
 *
 * ★★「出発失敗（未実施）」はこの関数で作らない★★ — ★未実施 ＝ 対応するレポートの行が無い★
 *   （指示書AQ §1-1）。旧 `history(id, CLEAN_ERROR.notExecuted, …)` の行は ★行ごと置かない★ことで表す。
 */
function report(
  timetableId: number,
  cleanRatio: number,
  taskArea: number,
  cleanArea: number
): StubReport {
  return {
    clean_timetable_id: BigInt(timetableId),
    clean_ratio: cleanRatio,
    // ★稼働率の分子（正常終了）に使われる★（4 = 清掃正常終了。第11回 P-6=A。`isCompletedTask()`）。
    //   ★4 以外にすると当期の稼働率が変わる★（◎○△× と未実施の判定には使わない。D-155 項2）
    status: 4,
    started_at: dbWallClock("2026-09-29T23:00:00+09:00"),
    ended_at: dbWallClock("2026-09-30T00:00:00+09:00"),
    task_area: taskArea,
    clean_area: cleanArea,
  };
}

/** 顧客マスタ1行（`db.customers()` が `deleted_at IS NULL` で引く） */
function customer(id: number, name: string, groupId: number): StubCustomer {
  return {
    id: BigInt(id),
    customer_name: name,
    group_id: BigInt(groupId),
    deleted_at: null,
  };
}

function errorReport(timetableId: number | null, type: string, facilityId = 1): StubErrorReport {
  return {
    clean_timetable_id: timetableId === null ? null : BigInt(timetableId),
    facility_id: BigInt(facilityId),
    error_type: type,
    errored_at: dbWallClock("2026-09-13T02:30:00+09:00"),
    created_at: dbWallClock("2026-09-13T02:30:00+09:00"),
  };
}

/**
 * @param customerId ★既定は1社（＝P1の実データ相当）★。
 *   ★2社目を置きたいテストだけが明示的に渡す★（指示書AH 段階3 / D-5）
 */
function summary(
  id: number,
  facilityId: number,
  year: number,
  month: number,
  week: number,
  ratios: [number, number, number, number],
  customerId = 1
): StubSummary {
  return {
    id: BigInt(id),
    facility_id: BigInt(facilityId),
    customer_id: BigInt(customerId),
    year,
    month,
    week,
    operation_ratio: ratios[0],
    launch_ratio: ratios[1],
    clean_ratio: ratios[2],
    error_ratio: ratios[3],
  };
}

/**
 * ★2026年9月の週（`periodRange()` の実測）★:
 *   第1週 = 09-01〜09-05（★1日から。5日間★） / 第2週 = 09-06〜09-12 /
 *   ★第3週 = 09-13〜09-19（`NOW` の当期）★
 * ★2026年8月の週★: 第5週 = 08-23〜08-29 / ★第6週 = 08-30〜08-31（★月跨ぎ・2日★）
 */
function buildData(): StubData {
  return {
    // ★所属（指示書AK 段階4b）★: 施設1 = 屋号1（HD1）/ 施設2 = 屋号2（HD1）/
    //   施設3 = 屋号3（★ホールディングスなし。`group_id = 0` がセンチネル★。D-011）
    facilities: [
      { id: BigInt(1), facility_name: FACILITY_1, deleted_at: null, robots: [{ serial_number: "8111R56280600001", deleted_at: null }], customer_id: BigInt(1), customer: { group_id: BigInt(1) } },
      { id: BigInt(2), facility_name: FACILITY_2, deleted_at: null, robots: [{ serial_number: "8111R56280600002", deleted_at: null }], customer_id: BigInt(2), customer: { group_id: BigInt(1) } },
      { id: BigInt(3), facility_name: FACILITY_3, deleted_at: null, robots: [{ serial_number: "8111R56280600003", deleted_at: null }], customer_id: BigInt(3), customer: { group_id: BigInt(0) } },
    ],
    // ★★既定は屋号1の1社だけ★★（指示書AK 段階6）— ★P1 の実データ相当★。
    //   ★2社目を置きたいテスト（6-4 / 6-7）だけが `data.customers` を差し替える★。
    //   ★施設2・3 が指す屋号2・3 はマスタに置かない★ — 置くと「顧客が3社」になり、
    //   ★`customer_id` を付けていない既存のテストが全部 422 になる★。
    customers: [customer(1, "屋号1", 1)],
    timetables: [
      // --- 先週（第2週。★確定期間。サマリがある★）---
      //   ★詳細から集計すると稼働率 25% になるが、サマリは 90% と言っている★（D-102 の検出）
      timetable(201, 1, "2026-09-08T02:00:00+09:00"),
      timetable(202, 1, "2026-09-10T02:00:00+09:00"),
      // --- 当期（第3週）---
      timetable(301, 1, "2026-09-13T02:00:00+09:00"),
      timetable(302, 1, "2026-09-14T02:00:00+09:00"),
      // ★事前チェック行（301の子）★ — ★本清掃として数えてはいけない★
      timetable(3011, 1, "2026-09-13T01:00:00+09:00", FIRST_ROUND_MINUTES, 301),
      // ★★未来の予定★★（`isFutureSchedule()` を外すと分母に入る。禁止事項8）
      timetable(305, 1, "2026-09-18T02:00:00+09:00"),
      // --- 施設2: ★期間をまたぐ連続（09-10 / 09-12 / 09-14 / 09-15 の4日）★ ---
      timetable(311, 2, "2026-09-10T02:00:00+09:00"),
      timetable(312, 2, "2026-09-12T02:00:00+09:00"),
      timetable(313, 2, "2026-09-14T02:00:00+09:00"),
      // ★★壁時計 20:00 の清掃★★（C-6。★ローカルDBには1件も無い時間帯★）
      timetable(314, 2, "2026-09-15T20:00:00+09:00"),
      // --- 施設3（施設名の記号ゆれ検索用）---
      timetable(321, 3, "2026-09-16T02:00:00+09:00"),
      // --- 月境界（#3 / #4）---
      //   ★★施設3 に置いてある★★ — ★施設1・2 には第1週のサマリ行があり、
      //   確定期間の値が優先される（＝詳細の集計を観測できない）ため★。
      //   施設3 にはサマリが1行も無いので、★境界の行が入ったかどうかが数字に出る★。
      timetable(401, 3, "2026-08-29T02:00:00+09:00"), // 8月第5週
      timetable(402, 3, "2026-08-30T02:00:00+09:00"), // ★8月第6週の初日★
      timetable(403, 3, "2026-08-31T02:00:00+09:00"), // ★8月第6週の末日（＝月末）★
      timetable(404, 3, "2026-09-01T02:00:00+09:00"), // ★9月第1週の初日（＝1日）★
      timetable(405, 3, "2026-09-05T02:00:00+09:00"), // ★9月第1週の最終日★
      timetable(406, 3, "2026-09-06T02:00:00+09:00"), // 9月第2週
    ],
    // ★★未実施（202 / 302 / 311 / 312 / 313 / 403）はレポートの行を置かない★★（指示書AQ §1-1）—
    //   旧データでは `clean_error = notExecuted` の履歴行として置いていた。
    //   ★`clean_task_reports` には未実施を表す列が無いので「行が無い」で表す★
    reports: [
      report(201, 80, 100, 80),
      report(301, 95, 100, 95),
      // ★△（10以上70未満）＝ 問題日★
      report(314, 50, 100, 50),
      report(321, 100, 100, 100),
      report(401, 100, 100, 100),
      report(402, 90, 100, 90),
      report(404, 100, 100, 100),
      report(405, 60, 100, 60),
      report(406, 90, 100, 90),
    ],
    errorReports: [
      // ★★本清掃行（301）を指すエラー → 数える★★
      errorReport(301, "EmergencyStop"),
      // ★★事前チェック行（3011）を指すエラー → 数えない★★（D-118 / D-114 項2）
      errorReport(3011, "HandleUp"),
      // ★`clean_timetable_id` が null ＝ 予定外のエラー → ★当期の数に入る★（指示書BG §2-4・A案。旧: 数えない（決定3））。
      //   ★施設3（屋号3）に置く★ — 顧客1（施設1）の KPI の数字を変えないため。全社のエラー内訳（絞り込みなし）には出る
      errorReport(null, "LostLocation", 3),
      // ★dangling（存在しない本清掃を指す）→ 数えない★（決定3）
      errorReport(9999, "BrushError"),
      // ★先週の本清掃を指すエラー → 当期には入らない★
      errorReport(201, "EmergencyStop"),
    ],
    // ★全社サマリ: 第2週（確定）とその前期（第1週）★
    customerSummaries: [
      summary(1, 0, 2026, 9, 2, [90, 88, 77.7, 5.5]),
      summary(2, 0, 2026, 9, 1, [80, 70, 60, 10]),
      // ★年次（month=0 && week=0）の行★ — ★2026-09-30 に年次を解禁した（指示書AQ 決定1）★。
      //   旧コメントは「年次は読まない（D-072項4）」。★週次・月次の要求に混ざらないこと★は
      //   期間キーの完全一致と `periodOfSummaryRow()` が担う（年次のテストは末尾の describe）
      summary(3, 0, 2026, 0, 0, [11, 11, 11, 11]),
    ],
    facilitySummaries: [
      summary(11, 1, 2026, 9, 2, [95, 95, 88, 0]),
      summary(12, 2, 2026, 9, 2, [60, 60, 40, 20]),
      summary(13, 1, 2026, 9, 1, [85, 85, 80, 0]),
      summary(14, 2, 2026, 9, 1, [50, 50, 30, 25]),
    ],
    facilityErrorSummaries: [
      { id: BigInt(21), facility_id: BigInt(1), year: 2026, month: 9, week: 2, error_type: "HandleUp", error_list_id: BigInt(131), error_count: 2 },
      { id: BigInt(22), facility_id: BigInt(2), year: 2026, month: 9, week: 2, error_type: "HandleUp", error_list_id: BigInt(131), error_count: 1 },
      { id: BigInt(23), facility_id: BigInt(1), year: 2026, month: 9, week: 2, error_type: "EmergencyStop", error_list_id: BigInt(131), error_count: 1 },
      // ★別の期間の行は混ざらない★
      { id: BigInt(24), facility_id: BigInt(1), year: 2026, month: 9, week: 1, error_type: "BrushError", error_list_id: BigInt(131), error_count: 9 },
    ],
  };
}

/** ★当期 = 2026年9月第3週（09-13〜09-19）★。09-18 の予定はまだ未来 */
const NOW = new Date("2026-09-16T09:00:00+09:00");

/** 当期（第3週） */
const CURRENT = "period=weekly&year=2026&month=9&week=3";
/** 確定期間（第2週。サマリがある） */
const CONFIRMED = "period=weekly&year=2026&month=9&week=2";

async function kpi(search: string): Promise<ReportKpi> {
  const res = await GET_KPI(new Request(`http://localhost/api/reports/kpi?${search}`));
  return (await res.json()) as ReportKpi;
}

async function performance(search: string): Promise<ListResponse<FacilityPerformance>> {
  const res = await GET_PERFORMANCE(
    new Request(`http://localhost/api/reports/facility-performance?${search}`)
  );
  return (await res.json()) as ListResponse<FacilityPerformance>;
}

async function continuous(search: string): Promise<ListResponse<ContinuousProblem>> {
  const res = await GET_CONTINUOUS(
    new Request(`http://localhost/api/reports/continuous-problems?${search}`)
  );
  return (await res.json()) as ListResponse<ContinuousProblem>;
}

async function breakdown(search: string): Promise<{ items: ErrorBreakdownItem[] }> {
  const res = await GET_BREAKDOWN(
    new Request(`http://localhost/api/reports/error-breakdown?${search}`)
  );
  return (await res.json()) as { items: ErrorBreakdownItem[] };
}

/** 当期の集計で使われた `clean_timetables` の本体クエリ（＝ `where.precheck` を持つもの） */
function mainQueryWhere(): Record<string, unknown> {
  const call = calls.cleanTimetable.find((c) => !isConsecutiveQuery(c) && "where" in c);
  expect(call).toBeDefined();
  return (call as { where: Record<string, unknown> }).where;
}

/**
 * ★連続日数用のクエリか★（`loadConsecutiveInputs()` が発行する1本）。
 *
 * ★★`select` の中身で見分けること★★ — 段階6 でこのクエリにも
 *   `where: { precheck, start_at }` が付いたので、★「`where` を持たない」では
 *   当期の主クエリ（`select: { id, facility_id, start_at }`）と区別できない★。
 *   ★連続日数用だけが `precheck` を**読む**（本清掃の絞り込みをメモリ側でも行うため）★。
 */
function isConsecutiveQuery(call: Record<string, unknown>): boolean {
  const select = call.select as Record<string, unknown> | undefined;
  return select?.precheck === true && select.facility_id === true;
}

/** ★連続日数用のクエリの `where`★ */
function consecutiveQueryWhere(): Record<string, unknown> {
  const call = calls.cleanTimetable.find(isConsecutiveQuery);
  expect(call).toBeDefined();
  return (call as { where: Record<string, unknown> }).where;
}

beforeEach(() => {
  data = buildData();
  for (const key of Object.keys(calls)) calls[key] = [];
  // ★`new Date()` を固定する（Date だけを差し替え、タイマーは触らない）★
  vi.useFakeTimers({ toFake: ["Date"] });
  vi.setSystemTime(NOW);
});

afterEach(() => {
  vi.useRealTimers();
});

// ---------------------------------------------------------------- テスト

describe("#1 確定期間 — ★サマリの値をそのまま返す（履歴から再計算しない）★", () => {
  it("KPI はサマリの4率そのもの。前期比は1つ前の期間のサマリから", async () => {
    const body = await kpi(CONFIRMED);
    // ★★詳細から集計すると稼働率は 25%（4件中1件）になる★★ — サマリの 90 が出ること
    expect(body.operation_rate.value).toBe(90);
    expect(body.operation_rate.prev).toBe(80);
    expect(body.launch_rate.value).toBe(88);
    expect(body.completion_rate.value).toBe(77.7);
    expect(body.error_rate.value).toBe(5.5);
  });

  it("★★確定期間では詳細テーブルを1行も読まない★★（★禁止事項10 / D-102★）", async () => {
    await kpi(CONFIRMED);
    expect(calls.cleanTimetable).toEqual([]);
    expect(calls.cleanTaskReport).toEqual([]);
    expect(calls.robotErrorReport).toEqual([]);
  });

  it("★サマリは「要求された期間 ＋ 前期」の2期間だけ引く（全件読みに戻さない）★", async () => {
    await kpi(CONFIRMED);
    expect(calls.customerSummary).toHaveLength(1);
    const where = calls.customerSummary[0].where as { OR: Record<string, number>[] };
    expect(where.OR).toEqual([
      { year: 2026, month: 9, week: 2 },
      { year: 2026, month: 9, week: 1 },
    ]);
  });

  it("施設別パフォーマンスもサマリの値。前期比つき", async () => {
    const body = await performance(`${CONFIRMED}&limit=100`);
    const fac1 = body.items.find((item) => item.facility_id === 1);
    expect(fac1?.operation_rate.value).toBe(95);
    expect(fac1?.operation_rate.prev).toBe(85);
    expect(fac1?.completion_rate.value).toBe(88);
    // ★★確定期間では詳細テーブルを読まない（連続日数の1本を除く）★★
    expect(calls.cleanTimetable.filter((c) => !isConsecutiveQuery(c))).toEqual([]);
  });

  it("★R9: 施設にロボット2台（id 10 と id 7）→ id 7 のシリアルを採る。`robots` の並びは `id` 昇順を SQL に頼む。ログは出さない★", async () => {
    // 施設に複数台は正常（指示書BB 表2 R9）なので `data.anomaly` は出さない
    data.facilities = data.facilities.map((f) =>
      Number(f.id) === 1
        ? {
            ...f,
            robots: [
              { id: BigInt(10), serial_number: "SERIAL-ID10", deleted_at: null },
              { id: BigInt(7), serial_number: "SERIAL-ID7", deleted_at: null },
            ],
          }
        : f
    );
    vi.mocked(logEvent).mockClear();
    const body = await performance(`${CONFIRMED}&limit=100`);
    expect(body.items.find((item) => item.facility_id === 1)?.serial_number).toBe("SERIAL-ID7");
    const include = calls.facility.find((c) => "include" in c)?.include as {
      robots: { orderBy: unknown };
    };
    expect(include.robots.orderBy).toEqual({ id: "asc" });
    expect(
      vi.mocked(logEvent).mock.calls.filter(([, p]) => p.event === "data.anomaly")
    ).toEqual([]);
  });

  it("エラー種別内訳はサマリを施設ぶん足し上げる（件数の降順）", async () => {
    const body = await breakdown(CONFIRMED);
    expect(body.items.map((i) => [i.type, i.count])).toEqual([
      ["HandleUp", 3],
      ["EmergencyStop", 1],
    ]);
    // ★別の期間（第1週）の行が混ざっていない★
    expect(body.items.some((i) => i.type === "BrushError")).toBe(false);
    // ★削除済みの施設の行は数えない（指示書BB U1・表1 V14。清掃エリアの削除は外せない — D5）★
    expect(calls.facilityErrorSummary[0].where).toEqual({
      year: 2026,
      month: 9,
      week: 2,
      facility: { deleted_at: null },
    });
  });

  it("★同じ施設・同じ error_type で error_list_id が違う2行は1項目に足す★（2026-10-29 の DDL 変更）", async () => {
    // ★サマリの行は error_list_id ごとにも分かれるようになった★が、API の出力（種別ごとの件数）は変えない
    data.facilityErrorSummaries.push(
      { id: BigInt(25), facility_id: BigInt(1), year: 2026, month: 9, week: 2, error_type: "LostLocalization", error_list_id: BigInt(38), error_count: 4 },
      { id: BigInt(26), facility_id: BigInt(1), year: 2026, month: 9, week: 2, error_type: "LostLocalization", error_list_id: BigInt(131), error_count: 3 }
    );
    const body = await breakdown(CONFIRMED);
    expect(body.items.map((i) => [i.type, i.count])).toEqual([
      ["LostLocalization", 7],
      ["HandleUp", 3],
      ["EmergencyStop", 1],
    ]);
    // ★使う列だけ読む★ — ★`error_detail`（消えた列）も `error_list_id` も SELECT しない★
    //   （`select` 無しの全列読みで、列の削除が500になった。2026-10-29）
    expect(calls.facilityErrorSummary[0].select).toEqual({
      year: true,
      month: true,
      week: true,
      error_type: true,
      error_count: true,
    });
  });
});

describe("#2 当期（進行中の週）— ★詳細テーブルからその場集計する★", () => {
  /**
   * ★★2026-09-16（指示書AL ★段階1★）に期待値を作り直した★★。
   *
   * ★以前は「全施設（1・2・3）の合算」を固定していた★（planned=5 / executed=3 /
   * 完了率 49 / エラー率 33.333）。★当期KPIが顧客で絞られていなかったため★で、
   * ★★その数字は「確定期間は顧客1社・当期は全社」という食い違いそのもの★★だった。
   *
   * ★いまは `customer_id` 未指定でも顧客は1社に定まる★（`buildData()` の顧客マスタは
   * ★屋号1 の1社だけ＝P1の実データ相当★）ので、★その顧客の全施設＝施設1だけ★が母集団になる
   * （期待値表 ★1-5★）。★テストを消したのではなく、正しい母集団に直した★。
   */
  it("KPI は詳細からの集計。前期比は先週のサマリから（★対象顧客＝屋号1 の施設1だけ★）", async () => {
    const body = await kpi(CURRENT);
    // planned=2（301/302。★305 は未来なので入らない★）/ executed=1（301）
    expect(body.operation_rate.value).toBe(50);
    expect(body.launch_rate.value).toBe(50);
    // 47.5 → 95: 面積比 (95+0)/200 → 1回ごとの完了率（`runCompletionRate()`）の平均（指示書AS。95/100 → 95）。
    //   fixture は `clean_ratio` 列と clean_area÷task_area を揃えてあるので、列でも面積でも同じ値になる。
    //   ★未実施（302）はレポート行が無いので平均に入らない★（§1-1）。0% として混ぜたら 47.5 になる。
    //   ★全社合算なら (95+50+100)/3 ≒ 81.67 になる★
    expect(body.completion_rate.value).toBeCloseTo(95, 10);
    // ★分子は本清掃行を指すエラーだけ（301 の1件）/ 分母は清掃予定回数（2件。第11回 P-6=B）★
    expect(body.error_rate.value).toBe(50);
    expect(body.operation_rate.prev).toBe(90);
  });

  it("★★本清掃の絞り込みと期間の絞り込みが SQL に降りている★★（全件読みに戻さない）", async () => {
    await kpi(CURRENT);
    const where = mainQueryWhere();
    expect(where.precheck).toBe(CLEAN_TIMETABLE_PRECHECK.main);
    const startAt = where.start_at as { gte: Date; lt: Date };
    // ★★壁時計値であること★★（C-6。★生の `parseDate()`（真の瞬間）ではない★）
    expect(startAt.gte.toISOString()).toBe("2026-09-13T00:00:00.000Z");
    expect(startAt.lt.toISOString()).toBe("2026-09-20T00:00:00.000Z");
  });

  it("★清掃結果（clean_task_reports）・エラー報告は引いた本清掃の id でしか引かない★", async () => {
    await kpi(CURRENT);
    const historyWhere = calls.cleanTaskReport.find((c) => "where" in c) as {
      where: { clean_timetable_id: { in: bigint[] } };
    };
    // ★期間内の本清掃行すべて★（★305 は未来の予定だが、それを外すのは
    //   `isFutureSchedule()`（純粋関数）の仕事で SQL の仕事ではない★。
    //   ★SQL 側で未来を外さないこと★ — 「いま何時か」を `where` に混ぜると、
    //   同じクエリが実行時刻で別の結果を返すようになる）
    // ★★施設2・3 の行（313/314/321）は入らない★★ — ★当期も対象顧客の施設だけを読む★
    //   （指示書AL 段階1。★以前は全施設ぶん読んでいた★）。
    expect(historyWhere.where.clean_timetable_id.in.map(String).sort()).toEqual(
      ["301", "302", "305"].sort()
    );
  });

  it("★★事前チェック行が本清掃として数えられない★★（`precheck` を SQL から外さない）", async () => {
    const body = await performance(`${CURRENT}&limit=100`);
    const fac1 = body.items.find((item) => item.facility_id === 1);
    // 301（実施）/ 302（未実施）の2件だけ。3011 が混ざると分母が3になる
    expect(fac1?.operation_rate.value).toBe(50);
  });

  it("★壁時計 20:00 の清掃がその週に含まれる★（C-6。★ローカルDBでは検出できない★）", async () => {
    const body = await performance(`${CURRENT}&limit=100`);
    const fac2 = body.items.find((item) => item.facility_id === 2);
    // 313（未実施）/ 314（20:00・完了率50）の2件
    expect(fac2?.operation_rate.value).toBe(50);
    // 25 → 50: 面積比 50/200 → 1回ごとの完了率の平均（未実施 313 は入らない。50/100 → 50）。指示書AS
    //   ★314 が週から落ちていれば null になる★（C-6 の検出力は operation_rate と併せて保たれる）
    expect(fac2?.completion_rate.value).toBe(50);
  });
});

describe("#3 月跨ぎ週（2026年8月第6週 ＝ 08-30〜08-31 の2日）", () => {
  /** ★その週を「当期」にして、詳細テーブルの絞り込みを走らせる★ */
  beforeEach(() => {
    vi.setSystemTime(new Date("2026-08-31T23:00:00+09:00"));
  });

  it("★★`periodRange()` の返す範囲どおりに SQL が絞る★★（08-30 00:00 以上 / 09-01 00:00 未満）", async () => {
    await kpi("period=weekly&year=2026&month=8&week=6");
    const startAt = mainQueryWhere().start_at as { gte: Date; lt: Date };
    expect(startAt.gte.toISOString()).toBe("2026-08-30T00:00:00.000Z");
    expect(startAt.lt.toISOString()).toBe("2026-09-01T00:00:00.000Z");
  });

  it("★2日ぶんだけが集計される★（08-29 も 09-01 も入らない）", async () => {
    // ★★境界の行（401〜406）は施設3 に置いてある★★（`buildData()` の注記）ので、
    //   ★施設3 の屋号（＝3）を対象顧客にして引く★（指示書AL 段階1 で当期も顧客で
    //   絞るようになったため。★`customer_id` の存在確認はしない契約★なので、
    //   顧客マスタに無い 3 でもそのまま対象顧客になる＝期待値表 6-9 と同じ形）。
    const body = await kpi("period=weekly&year=2026&month=8&week=6&customer_id=3");
    // 402（実施・90/100）/ 403（未実施）の2件
    expect(body.operation_rate.value).toBe(50);
    // 45 → 90: 面積比 90/200 → 1回ごとの完了率の平均（未実施 403 は入らない。90/100 → 90）。指示書AS。
    //   ★08-29（401=100）や 09-01（404=100）が混ざれば 95 になる★
    expect(body.completion_rate.value).toBe(90);
  });
});

describe("#4 月の第1週（必ず1日から）／最終週（必ず末日で終わる）", () => {
  it("★第1週は 09-01 から 09-05★（前月の 08-31 も 第2週の 09-06 も入らない）", async () => {
    vi.setSystemTime(new Date("2026-09-05T23:00:00+09:00"));
    // ★施設3（サマリが1行も無い＝詳細の集計がそのまま出る）で見る★
    const body = await performance("period=weekly&year=2026&month=9&week=1&limit=100");
    const startAt = mainQueryWhere().start_at as { gte: Date; lt: Date };
    expect(startAt.gte.toISOString()).toBe("2026-09-01T00:00:00.000Z");
    expect(startAt.lt.toISOString()).toBe("2026-09-06T00:00:00.000Z");
    // 404（100/100）/ 405（60/100）の2件。★境界の行が落ちていない★
    //   （★完了率 80 は期間の面積比でも1回ごとの完了率の平均でも同じ値★なので期待値は据え置き）
    const fac3 = body.items.find((item) => item.facility_id === 3);
    expect(fac3?.operation_rate.value).toBe(100);
    expect(fac3?.completion_rate.value).toBe(80);
  });

  it("★最終週は月末で終わる★（8月第6週の `lt` が 09-01。#3 と同じ境界）", async () => {
    vi.setSystemTime(new Date("2026-08-31T23:00:00+09:00"));
    await kpi("period=weekly&year=2026&month=8&week=6");
    const startAt = mainQueryWhere().start_at as { gte: Date; lt: Date };
    expect(startAt.lt.toISOString()).toBe("2026-09-01T00:00:00.000Z");
  });

  it("★その月に存在しない週（9月の第6週）は 422★（指示書BB A8・表8 W2。旧: 200・空）", async () => {
    const q = "period=weekly&year=2026&month=9&week=6";
    const expected = {
      error: {
        code: "validation_failed",
        message: "weekの値が不正です",
        details: { week: ["2026年9月に第6週はありません"] },
      },
    };
    for (const res of [
      await GET_KPI(new Request(`http://localhost/api/reports/kpi?${q}`)),
      await GET_CONTINUOUS(new Request(`http://localhost/api/reports/continuous-problems?${q}`)),
      await GET_PERFORMANCE(new Request(`http://localhost/api/reports/facility-performance?${q}`)),
      await GET_BREAKDOWN(new Request(`http://localhost/api/reports/error-breakdown?${q}`)),
    ]) {
      expect(res.status).toBe(422);
      expect(await res.json()).toEqual(expected);
    }
    // ★データ層まで来ない★
    expect(calls.cleanTimetable).toHaveLength(0);
  });
});

describe("#5 サマリに行が無い期間 — ★空のKPI（404 にしない）★", () => {
  it("KPI は4指標すべて null", async () => {
    const body = await kpi("period=weekly&year=2026&month=7&week=1");
    expect(body).toEqual({
      operation_rate: { value: null, prev: null, diff: null },
      launch_rate: { value: null, prev: null, diff: null },
      completion_rate: { value: null, prev: null, diff: null },
      error_rate: { value: null, prev: null, diff: null },
    });
  });

  it("一覧3本は空配列で 200", async () => {
    const q = "period=weekly&year=2026&month=7&week=1";
    expect((await performance(q)).items).toEqual([]);
    expect((await continuous(q)).items).toEqual([]);
    expect((await breakdown(q)).items).toEqual([]);
  });
});

describe("★★#6 連続日数 — 期間で絞らない（C-2 の地雷）★★", () => {
  it("★★期間をまたぐ連続が途切れない★★（09-10/09-12/09-14/09-15 → ★4日★）", async () => {
    const body = await performance(`${CURRENT}&limit=100`);
    const fac2 = body.items.find((item) => item.facility_id === 2);
    // ★★期間（09-13〜09-19）で絞ると 2 になる★★ — そうなっていたらここで落ちる
    expect(fac2?.consecutive_problem_days).toBe(4);
  });

  it("★連続問題施設も同じ数字・同じ判定★（L3。D-109 の再発防止）", async () => {
    const body = await continuous(`${CURRENT}&limit=100`);
    expect(body.items.map((i) => [i.facility_id, i.consecutive_problem_days, i.escalation_level])).toEqual([
      [2, 4, "L3"],
    ]);
  });

  it("★★連続日数の読み取りは期間の手前を「上限 +1日ぶん」余分に遡る★★（構造。指示書AC 段階6）", async () => {
    await performance(`${CURRENT}&limit=100`);
    const consecutiveCall = calls.cleanTimetable.find(isConsecutiveQuery);
    expect(consecutiveCall).toBeDefined();
    expect((consecutiveCall as { select: object }).select).toEqual({
      id: true,
      facility_id: true,
      start_at: true,
      // ★結果待ちの判定用（D-173）★
      end_at: true,
      precheck: true,
    });

    // ★★要求された期間の開始日をそのまま下限にしたら連続が途切れる（C-2 の地雷）★★ —
    //   遡り幅は ★保存された表示上限★ から導く（★定数に写し取らないこと★。申し送り⑪）
    const main = mainQueryWhere().start_at as { gte: Date; lt: Date };
    const consecutive = consecutiveQueryWhere().start_at as { gte: Date; lt: Date };
    expect(consecutive.lt.getTime()).toBe(main.lt.getTime());
    expect((main.gte.getTime() - consecutive.gte.getTime()) / 86_400_000).toBe(
      consecutiveLookbackCalendarDays(await loadConsecutiveDaysMax())
    );
  });

  it("★禁止事項8: 未来の予定は連続日数にも分母にも入らない★（`isFutureSchedule()`）", async () => {
    const body = await performance(`${CURRENT}&limit=100`);
    const fac1 = body.items.find((item) => item.facility_id === 1);
    // 09-14（未実施）だけが問題日。09-18 の未来の予定を数えると 2 になる
    expect(fac1?.consecutive_problem_days).toBe(1);
  });
});

describe("#7 `period=weekly` かつ `week=0` → ★422★（`week=0` は月次の予約値）", () => {
  it("4本とも 422 を返し、DB を1本も引かない", async () => {
    for (const get of [GET_KPI, GET_PERFORMANCE, GET_CONTINUOUS, GET_BREAKDOWN]) {
      const res = await get(
        new Request("http://localhost/api/reports/x?period=weekly&year=2026&month=9&week=0")
      );
      expect(res.status).toBe(422);
      const body = (await res.json()) as ApiError;
      expect(body.error.code).toBe("validation_failed");
    }
    for (const key of Object.keys(calls)) expect(calls[key]).toEqual([]);
  });
});

/**
 * ★`year` の範囲外 → 422★（`d-watch-api.yaml` の `Year` / `lib/config` の `REPORT_YEAR`）
 *
 * ★直す前の実測（2026-09-14 / develop `3e48d30`。ローカルDB接続の dev サーバ）★:
 *   - `period=monthly&year=-1&month=9` → ★200★（空のKPI。紀元前が有効な期間になっていた）
 *   - `period=weekly&year=-1` / `year=0` / `year=1000000` → ★500★
 *     （`lib/format/period.ts` の `addDays` が `00-1-09-05` 等で RangeError）
 *   - `year=99999999999999999999` → ★500★（Prisma: Unable to fit value into a
 *     64-bit signed integer for field `year`。SQLは出ないが、
 *     ★攻撃者が選んだ値が `logApiError` 経由でサーバログに載る★）
 *   いずれも入力の誤りなので、DBに触る前に422で弾く。
 */
describe("★`year` が範囲外 → 422★（month / week と同じ作法。DBに降ろさない）", () => {
  it("4本とも 422 を返し、DB を1本も引かない", async () => {
    const outOfRange = ["-1", "0", "1999", "2101", "1000000", "99999999999999999999"];
    for (const year of outOfRange) {
      for (const get of [GET_KPI, GET_PERFORMANCE, GET_CONTINUOUS, GET_BREAKDOWN]) {
        const res = await get(
          new Request(
            `http://localhost/api/reports/x?period=weekly&year=${year}&month=9&week=2`
          )
        );
        expect(res.status).toBe(422);
        const body = (await res.json()) as ApiError;
        expect(body.error.code).toBe("validation_failed");
        expect(body.error.details).toEqual({
          year: ["2000〜2100で指定してください"],
        });
      }
    }
    for (const key of Object.keys(calls)) expect(calls[key]).toEqual([]);
  });

  it("★period=monthly でも422★（旧実装ではここだけ200で通っていた）", async () => {
    const res = await GET_KPI(
      new Request("http://localhost/api/reports/kpi?period=monthly&year=-1&month=9")
    );
    expect(res.status).toBe(422);
    for (const key of Object.keys(calls)) expect(calls[key]).toEqual([]);
  });

  it("境界ちょうど（2000 / 2100）は422にならない（データが無いだけ）", async () => {
    for (const year of ["2000", "2100"]) {
      const res = await GET_KPI(
        new Request(
          `http://localhost/api/reports/kpi?period=weekly&year=${year}&month=9&week=2`
        )
      );
      expect(res.status).toBe(200);
    }
  });
});

describe("★★#8 エラー種別内訳の分子は「本清掃行を指す」エラーだけ★★（D-118 / D-114 項2）", () => {
  it("事前チェック行・dangling・別期間は数えない。★予定外（null）は数える（指示書BG §2-4）★", async () => {
    const body = await breakdown(CURRENT);
    expect(body.items).toEqual([
      { type: "EmergencyStop", label: "EmergencyStop", count: 1, rate: 50 },
      // ★施設3 の予定外のエラー（`clean_timetable_id` が null。errored_at 09-13 02:30 は当期）★
      { type: "LostLocation", label: "LostLocation", count: 1, rate: 50 },
    ]);
  });

  it("★エラー行は本清掃の id でしか引かない（全件読みに戻さない）★", async () => {
    await breakdown(CURRENT);
    const where = calls.robotErrorReport[0].where as {
      clean_timetable_id: { in: bigint[] };
    };
    // ★期間内の本清掃行すべて（事前チェック行 3011 は入らない）★
    expect(where.clean_timetable_id.in.map(String).sort()).toEqual(
      ["301", "302", "305", "313", "314", "321"].sort()
    );
  });
});

/**
 * ★当期のエラー内訳は、未来・結果待ちの予定を指すエラーを数えない★（ユーザー指示 2026-10-29
 * 「結果待ちなので、まだエラーかどうか確定してない」）— ★エラー発生率の分子と同じ集合★。
 *
 * 今 = 09-16 09:00（`NOW`）・結果待ち 120分・予定の終了は開始の1時間後。施設1（屋号1。KPI の母集団）に足す:
 *
 * | 予定 | 開始 | レポート | エラー | 内訳 |
 * |---|---|---|---|---|
 * | 301（既存） | 09-13 02:00 | あり | EmergencyStop | ★数える★ |
 * | 302（既存） | 09-14 02:00 | 無し（未実施） | ★HandleUp を足す★ | ★数える★ |
 * | 305（既存） | 09-18 02:00（未来） | 無し | ★BrushError を足す★ | 数えない |
 * | 306 | 09-16 06:00（終了＋120分 ＝ 09:00 ちょうど） | 無し | ★LostLocation★ | ★数える★（境界は確定） |
 * | 307 | 09-16 06:01（終了＋120分 ＝ 09:01） | 無し | ★Pending★ | 数えない（結果待ち） |
 */
describe("★当期のエラー内訳 — 未来・結果待ちの予定を数えない（ユーザー指示 2026-10-29）★", () => {
  beforeEach(() => {
    data.timetables.push(
      timetable(306, 1, "2026-09-16T06:00:00+09:00"),
      timetable(307, 1, "2026-09-16T06:01:00+09:00")
    );
    data.errorReports.push(
      errorReport(302, "HandleUp"),
      errorReport(305, "BrushError"),
      errorReport(306, "LostLocation"),
      errorReport(307, "Pending")
    );
  });

  it("未実施・境界ちょうどは数え、未来・結果待ちは数えない", async () => {
    const body = await breakdown(CURRENT);
    expect(body.items.map((i) => [i.type, i.count]).sort()).toEqual(
      [
        ["EmergencyStop", 1],
        ["HandleUp", 1],
        // ★306 の1件 ＋ 施設3 の予定外のエラー（null）1件★（絞り込みなし。指示書BG §2-4）
        ["LostLocation", 2],
      ].sort()
    );
  });

  it("★★内訳の件数の合計 ＝ KPI のエラー発生率の分子★★（同じ母集団・同じ now）", async () => {
    const items = (await breakdown(`${CURRENT}&customer_id=1`)).items;
    const total = items.reduce((sum, i) => sum + i.count, 0);
    const body = await kpi(`${CURRENT}&customer_id=1`);
    // ★予定回数は 301 / 302 / 306 の3件（305 は未来・307 は結果待ちで入らない）★。
    //   出発成功率 ＝ 開始1件（301）÷ 予定 なので、予定回数は 100 ÷ 出発成功率 × 1
    expect(body.launch_rate.value).toBeCloseTo(100 / 3, 10);
    expect(total).toBe(3);
    expect(body.error_rate.value).toBeCloseTo((total / 3) * 100, 10);
  });

  it("★レポートは引いた本清掃の id でだけ、有無の判定に要る列だけ読む★", async () => {
    await breakdown(CURRENT);
    const call = calls.cleanTaskReport[0] as {
      where: { clean_timetable_id: { in: bigint[] } };
      select: Record<string, boolean>;
    };
    expect(call.where.clean_timetable_id.in.map(String).sort()).toEqual(
      ["301", "302", "305", "306", "307", "313", "314", "321"].sort()
    );
    expect(call.select).toEqual({ clean_timetable_id: true, started_at: true, ended_at: true });
  });
});

describe("#9 読み込み行数 — ★期間で絞ったぶんしか読まない★", () => {
  it("当期でも `clean_timetables` は本清掃かつ期間内の行だけ", async () => {
    await kpi(CURRENT);
    // ★`where` 付きのクエリはすべて `start_at` を持つ（＝全期間を読むクエリが無い）★
    //   ★例外は連続日数の1本だけ（`where` を持たない `select` 専用クエリ。C-2）★
    for (const call of calls.cleanTimetable) {
      if (!("where" in call)) continue;
      expect(call.where).toHaveProperty("start_at");
    }
  });

  it("確定期間なら詳細テーブルのクエリは0本（`kpi` / `error-breakdown`）", async () => {
    await kpi(CONFIRMED);
    await breakdown(CONFIRMED);
    expect(calls.cleanTimetable).toEqual([]);
    expect(calls.robotErrorReport).toEqual([]);
  });
});

describe("★施設名の絞り込みを持つのは facility-performance だけ★（段階2 と同じ作法）", () => {
  it("★記号ゆれを無視して施設IDに解決し、`facility_id: { in: [...] }` で降ろす★", async () => {
    // ★`バリュー・マート三つ角店` を中点なしで検索する（`includesFoldName`。指示書AG）★
    const body = await performance(`${CURRENT}&facility_name=バリューマート三つ角&limit=100`);
    expect(body.items.map((i) => i.facility_id)).toEqual([3]);
    const facilityCall = calls.facility.find(
      (c) => "where" in c && "id" in (c.where as object)
    );
    expect(facilityCall).toBeDefined();
    expect(
      ((facilityCall as { where: { id: { in: number[] } } }).where.id.in).map(Number)
    ).toEqual([3]);
  });

  it("★★1件も当たらない施設名 → `in: []` で0件★★（★罠1。「全件表示」に化けていないか★）", async () => {
    const body = await performance(`${CURRENT}&facility_name=存在しない店&limit=100`);
    expect(body.items).toEqual([]);
    expect(body.meta.total).toBe(0);
  });

  it("★施設名が未指定なら施設で絞らない★（`null`。`[]` と混同しない）", async () => {
    const body = await performance(`${CURRENT}&limit=100`);
    expect(body.items.map((i) => i.facility_id).sort()).toEqual([1, 2, 3]);
    const facilityCall = calls.facility.find(
      (c) => "where" in c && "id" in (c.where as object)
    );
    expect(facilityCall).toBeUndefined();
  });

  /**
   * ★★ここだけデータ層（`db.facilityPerformance()`）を直接呼ぶ★★。
   *
   * ★理由: ルート層の `filterFacilityPerformanceByName()`（C-5 の「保険」）が
   *   ★罠1 の壊れ方を隠してしまう★★ — `facility_ids: []` が `in: undefined` に化けて
   *   SQL が全施設を返しても、★施設名で再度メモリ絞り込みされるので画面は0件のまま★。
   *   ★★つまりルート経由のテストでは「0件ヒットが全件読みに化けた」ことを検出できない★★
   *   （実測: `!== null` を `?.length` に書き換えてもルートのテストは全部緑のままだった）。
   *   ★読み込み行数を減らすのが本作業の目的★なので、ここはデータ層で固定する。
   */
  it("★★`facility_ids: []` はデータ層で0件★★（★罠1。`in: undefined` に化けていないか★）", async () => {
    const rows = await db.facilityPerformance({
      period: "weekly",
      year: 2026,
      month: 9,
      week: 3,
      facility_ids: [],
    });
    expect(rows).toEqual([]);
    // ★`in: []` がそのまま SQL に渡っていること（条件が消えていない）★
    const facilityCall = calls.facility.find(
      (c) => "where" in c && "id" in (c.where as object)
    );
    expect((facilityCall as { where: { id: { in: number[] } } }).where.id.in).toEqual([]);
  });

  it("★`facility_ids: null` はデータ層で全施設★（`[]` と混同しない）", async () => {
    const rows = await db.facilityPerformance({
      period: "weekly",
      year: 2026,
      month: 9,
      week: 3,
      facility_ids: null,
    });
    expect(rows.map((row) => row.item.facility_id).sort()).toEqual([1, 2, 3]);
  });

  it("★`serial` は据え置き＝メモリ絞り込みのまま★（SQL には降ろさない）", async () => {
    const body = await performance(`${CURRENT}&serial=600003&limit=100`);
    expect(body.items.map((i) => i.facility_id)).toEqual([3]);
    // ★シリアルを SQL に降ろしていないこと（施設の `where` に `id` が現れない）★
    const facilityCall = calls.facility.find(
      (c) => "where" in c && "id" in (c.where as object)
    );
    expect(facilityCall).toBeUndefined();
  });
});

/**
 * 指示書AH ★段階3★ の期待値表 #9〜#13（ルート側）を、
 * ★★指示書AK ★段階6★ の決定（§2-1）に合わせて置き換えたもの★★。
 *
 * ------------------------------------------------------------------------
 * ★★何が変わったか★★
 * ------------------------------------------------------------------------
 * ★以前は「複数顧客の行が混ざったら 500」★だった（D-133 の安全弁）。
 * ★分類が復活して「どの顧客か」を決める根拠ができた★ので、
 * ★★`where` で対象顧客を絞る → そもそも混ざらない★★ に変わった（＝ ★2社目のデータが
 * 入っても画面が常時500にならない★。§2-1 の却下案「500 のまま」の理由）。
 *
 * ★★何を守るためのテストか★★
 *  - ★★`customer_id` の絞り込みが本当に効いていること★★（#10 ＝ 期待値表 ★6-2★。
 *    ★2社ぶんの `customer_summaries` を置いて、片方の数字だけが出ることを見る★）
 *  - ★前期比が別会社の行で汚染されないこと★（#11。★罠5 の形をそのまま流用★）
 *  - ★★同じ期間キーの重複は今も 500★★（#14 ＝ 期待値表 ★6-8★。
 *    ★一意制約が無いので同一顧客でも起こりうる★）。
 *    ★body に `customer_id` が1バイトも漏れないこと★も併せて固定する
 *    （ルートは★定数の固定文言★を返す契約。`d-watch-api.yaml` は変更しない。D-7）
 *  - ★0行は 200 のまま（404 にしない）★（#12。既存挙動を変えない）
 *
 * ★ローカルDBでは絶対に再現しない★ — ★顧客は1件しか無い★ので合成データでしか作れない。
 */
describe("★★指示書AK 段階6 — 確定期間KPIを対象顧客で絞る★★（D-5 / D-133 の置き換え）", () => {
  /** ★2社目★（1社目は `summary()` の既定 = 1） */
  const OTHER_CUSTOMER = 777;

  /** ルートの生レスポンス（body を★文字列のまま★検査するため JSON.parse しない） */
  async function rawKpi(search: string): Promise<{ status: number; text: string }> {
    const res = await GET_KPI(new Request(`http://localhost/api/reports/kpi?${search}`));
    return { status: res.status, text: await res.text() };
  }

  it("#9 1顧客・当期＋前期 → 200", async () => {
    // buildData() の既定（どちらも customer_id=1）
    const res = await rawKpi(CONFIRMED);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate.value).toBe(90);
  });

  it("★★#10（＝6-2）DBに2社ぶんある・customer_id=1 → 200。顧客1だけの数字★★", async () => {
    data.customerSummaries = [
      summary(1, 0, 2026, 9, 2, [90, 88, 77.7, 5.5]),
      summary(2, 0, 2026, 9, 1, [80, 70, 60, 10]),
      // ★★2社目（絞れていなければ 500 になるか、別会社の数字が混ざる）★★
      summary(3, 0, 2026, 9, 2, [10, 10, 10, 10], OTHER_CUSTOMER),
      summary(4, 0, 2026, 9, 1, [11, 11, 11, 11], OTHER_CUSTOMER),
    ];
    const res = await rawKpi(`${CONFIRMED}&customer_id=1`);
    expect(res.status).toBe(200);
    const body = JSON.parse(res.text) as ReportKpi;
    // ★顧客1の値そのもの★（★合算も平均もしない★）
    expect(body.operation_rate.value).toBe(90);
    expect(body.operation_rate.prev).toBe(80);
    // ★2社目の値（10 / 11）が1つも出ていないこと★
    expect(body.completion_rate.value).toBe(77.7);
    expect(body.error_rate.value).toBe(5.5);
    // ★★`where` に `customer_id` が降りていること★★（★`OR` と同じ階層 ＝ AND★）
    const where = calls.customerSummary[0].where as Record<string, unknown>;
    expect(String(where.customer_id)).toBe("1");
    expect(where.OR).toEqual([
      { year: 2026, month: 9, week: 2 },
      { year: 2026, month: 9, week: 1 },
    ]);
  });

  it("★★#11 当期はA社・前期はB社（キーは衝突しない）→ 前期比が汚染されない★★（★罠5★）", async () => {
    data.customerSummaries = [
      summary(1, 0, 2026, 9, 2, [90, 88, 77.7, 5.5]),
      summary(2, 0, 2026, 9, 1, [10, 10, 10, 10], OTHER_CUSTOMER),
    ];
    // ★以前は 500 で止めていた★（どちらの顧客か決められなかったため）。
    //   ★いまは B社の行が `where` で落ちるので、前期比は「前期の行が無い」＝ null★。
    //   ★★両社の差という無意味な数字が出ないこと★★が要。
    const res = await rawKpi(`${CONFIRMED}&customer_id=1`);
    expect(res.status).toBe(200);
    const body = JSON.parse(res.text) as ReportKpi;
    expect(body.operation_rate.value).toBe(90);
    expect(body.operation_rate.prev).toBeNull();
    expect(body.operation_rate.diff).toBeNull();
  });

  it("#12 0行（確定期間）→ 200（★404 にしない★。既存挙動）", async () => {
    data.customerSummaries = [];
    const res = await rawKpi(CONFIRMED);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate).toEqual({
      value: null,
      prev: null,
      diff: null,
    });
  });

  it("#13 当期0行 + 前期が2顧客 → 200・空のKPI（★B社の行を拾わない★）", async () => {
    data.customerSummaries = [
      summary(2, 0, 2026, 9, 1, [80, 70, 60, 10]),
      summary(3, 0, 2026, 9, 1, [10, 10, 10, 10], OTHER_CUSTOMER),
    ];
    // ★当期（要求された期間）の行が1つも無いので空のKPI★。
    //   ★前期の行が2顧客ぶんあっても、絞り込みで A社だけが残る★ので 500 にはならない。
    const res = await rawKpi(`${CONFIRMED}&customer_id=1`);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate).toEqual({
      value: null,
      prev: null,
      diff: null,
    });
  });

  it("★★#14（＝6-8）同じ期間キーが重複したら例外のまま（500）／body に `customer_id` が漏れない★★", async () => {
    // ★★同一顧客でも起こりうる★★ — `customer_summaries` に一意制約が無い（指示書AK §9-2）。
    //   ★後勝ちで不定になるので、絞り込みが入った後もこの検知は残す★。
    data.customerSummaries = [
      summary(1, 0, 2026, 9, 2, [90, 88, 77.7, 5.5]),
      summary(2, 0, 2026, 9, 2, [10, 10, 10, 10]),
    ];
    const res = await rawKpi(`${CONFIRMED}&customer_id=1`);
    expect(res.status).toBe(500);
    // ★body は定数（`app/api/reports/kpi/route.ts`）★ — 例外メッセージを混ぜない
    expect(JSON.parse(res.text)).toEqual({
      error: { code: "internal_error", message: "データの取得に失敗しました", details: null },
    });
    // ★★文字列としても顧客IDが出ていないこと★★（`details` に例外を詰め始めたら落ちる）
    expect(res.text).not.toContain("customer_id");
  });

  /**
   * ★★罠6（2026-09-30 に書き直し。指示書AQ 決定1 / §3 罠2・罠6）★★
   *
   * ★旧テスト★は「★P1では年次サマリを読まない契約（D-072項4）★なので、年次の行が同じ期間キーで
   * 2行あっても 500 にしてはいけない（`resolves.toEqual([])`）」を固定していた。
   * ★★年次を解禁した（指示書AQ 決定1）ので、その前提が消えた★★ — 年次の行は ★読む行★ になり、
   * ★読む行の重複は #14（週次）と同じく検知して止めるのが正しい★（後勝ちで不定になるため）。
   * そこで次の2本に分けた:
   *   - 罠6-1: ★年次の行は `yearly` として返る★（`periodOfSummaryRow()` が `month` を見ていること。
   *     `monthly` と取り違えると `selectKpiRow()` で弾かれて空のKPIになる＝罠2）
   *   - 罠6-2: ★同じ年次キーの重複は例外★（旧テストと期待値が逆になる。理由は上のとおり決定1）
   *
   * ★データ層を直接呼ぶ★（`facility_ids: []` のテストと同じ作法。ルート経由の年次は末尾の describe）。
   * ★年は 2025（確定期間）にする★ — 2026 は `NOW` の当年（＝当期）なので詳細テーブルの集計に入る。
   */
  it("★★罠6-1: 年次（month=0 && week=0）の行は `yearly` として返り、前年が前期比になる★★", async () => {
    data.customerSummaries = [
      summary(1, 0, 2025, 0, 0, [11, 12, 13, 14]),
      // ★前期（前年）★ — `shiftPeriod("yearly", 2025, 0, 0, -1)` = 2024/0/0
      summary(2, 0, 2024, 0, 0, [22, 22, 22, 22]),
    ];
    const rows = await db.reportKpis({
      period: "yearly",
      year: 2025,
      month: 0,
      week: 0,
      // ★`facility_ids: null` = 施設で絞らない★（`reportKpis()` の確定期間はこの値を見ない。
      //   絞り込みの軸は `customer_id`）
      facility_ids: null,
      customer_id: 1,
    });
    expect(rows).toHaveLength(1);
    // ★`monthly` になっていたら罠2（年次が月次として混入）★
    expect(rows[0]).toMatchObject({ period: "yearly", year: 2025, month: 0, week: 0 });
    expect(rows[0].kpi.operation_rate).toEqual({ value: 11, prev: 22, diff: -11 });
    expect(rows[0].kpi.completion_rate.value).toBe(13);
    // ★確定期間なので詳細テーブルは読まない★（D-102）
    expect(calls.cleanTimetable).toEqual([]);
    expect(calls.cleanTaskReport).toEqual([]);
  });

  it("★★罠6-2: 同じ年次キーの行が2行あれば例外（#14 と同じ検知）★★", async () => {
    // ★旧テストは resolves.toEqual([]) だった★ — 年次を読まない前提（D-072項4）が
    //   指示書AQ 決定1 で消えたため、★読む行の重複として検知するのが正しい★（期待値が逆転）
    data.customerSummaries = [
      summary(1, 0, 2025, 0, 0, [11, 11, 11, 11]),
      summary(2, 0, 2025, 0, 0, [22, 22, 22, 22]),
    ];
    await expect(
      db.reportKpis({
        period: "yearly",
        year: 2025,
        month: 0,
        week: 0,
        facility_ids: null,
        customer_id: 1,
      })
    ).rejects.toThrow("yearly/2025/0/0");
  });
});

/**
 * 指示書AK ★段階6★ の期待値表 ★6-1 / 6-3 〜 6-7 / 6-9★（ルート側）。
 * （★6-2 は上の #10★、★6-8 は上の #14★ で固定している）
 *
 * ------------------------------------------------------------------------
 * ★★何を守るためのテストか★★
 * ------------------------------------------------------------------------
 *  - ★★候補が2つ以上のときに「静かに1社を選ぶ」ことをしない★★（★落とし穴6★。D-133）—
 *    ★6-4 / 6-7 が 200 で通ってしまったら、誰かが暗黙の選択を入れたということ★
 *  - ★★500 ではなく 422★★（6-4）— ★サーバの不具合ではなく「指定が足りない」★（§2-1）
 *  - ★候補を `details.customer_ids` で返す★（6-5）— ★画面が文言を読まずに選択肢を出せる★
 *  - ★存在しない `customer_id` は 200・空★（6-9）— ★「該当なし」は正常★（404/422 にしない）
 */
describe("★★指示書AK 段階6 — 対象顧客の決定（期待値表 6-1 / 6-3〜6-7 / 6-9）★★", () => {
  async function rawKpi(search: string): Promise<{ status: number; text: string }> {
    const res = await GET_KPI(new Request(`http://localhost/api/reports/kpi?${search}`));
    return { status: res.status, text: await res.text() };
  }

  it("★6-1★ customer_id=1 指定・顧客1社のデータ → 200。その顧客の数字", async () => {
    const res = await rawKpi(`${CONFIRMED}&customer_id=1`);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate.value).toBe(90);
  });

  it("★6-3★ 指定なし・顧客が1社だけ → 200（★P1 はここ★）", async () => {
    // `buildData()` の既定（顧客マスタは屋号1 の1社だけ）
    const res = await rawKpi(CONFIRMED);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate.value).toBe(90);
    // ★暗黙に決まった1社が `where` に降りていること★
    expect(String((calls.customerSummary[0].where as Record<string, unknown>).customer_id)).toBe("1");
  });

  it("★★6-4 / 6-5★★ 指定なし・顧客が2社 → 422（★500 ではない★）。details に候補が入る", async () => {
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 2)];
    const res = await rawKpi(CONFIRMED);
    expect(res.status).toBe(422);
    expect(JSON.parse(res.text)).toEqual({
      error: {
        code: "validation_failed",
        message:
          "顧客またはグループを指定してください。複数の顧客のデータを合算した数値は出せません。",
        details: { customer_ids: [1, 2] },
      },
    });
    // ★★422 のときはサマリを1行も読まない★★（★どの顧客か決まっていないのだから読めない★）
    expect(calls.customerSummary).toHaveLength(0);
  });

  it("★6-6★ group_id 指定・傘下1社 → 200（その顧客の数字）", async () => {
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 2)];
    data.customerSummaries = [summary(10, 0, 2026, 9, 2, [55, 55, 55, 55], 2)];
    const res = await rawKpi(`${CONFIRMED}&group_id=2`);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate.value).toBe(55);
    expect(String((calls.customerSummary[0].where as Record<string, unknown>).customer_id)).toBe("2");
  });

  it("★★6-7★★ group_id 指定・傘下2社 → 422（★傘下の候補だけを返す★）", async () => {
    data.customers = [
      customer(1, "屋号1", 1),
      customer(2, "屋号2", 1),
      // ★別ホールディングスの顧客は候補に入らない★
      customer(3, "屋号3", 2),
    ];
    const res = await rawKpi(`${CONFIRMED}&group_id=1`);
    expect(res.status).toBe(422);
    expect((JSON.parse(res.text) as ApiError).error.details).toEqual({
      customer_ids: [1, 2],
    });
  });

  it("★6-9★ 存在しない customer_id → 200・空のKPI（★422 にしない★。「該当なし」は正常）", async () => {
    const res = await rawKpi(`${CONFIRMED}&customer_id=999`);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate).toEqual({
      value: null,
      prev: null,
      diff: null,
    });
    // ★存在確認をしない＝顧客マスタに無くても `where` に降りる★
    expect(String((calls.customerSummary[0].where as Record<string, unknown>).customer_id)).toBe(
      "999"
    );
  });

  it("★group_id 指定・傘下0社 → 422（候補は空配列）★（★指示書に明記が無く、起草者が決めた★）", async () => {
    data.customers = [customer(1, "屋号1", 1)];
    const res = await rawKpi(`${CONFIRMED}&group_id=9`);
    expect(res.status).toBe(422);
    expect((JSON.parse(res.text) as ApiError).error.details).toEqual({ customer_ids: [] });
    expect(calls.customerSummary).toHaveLength(0);
  });

  it("★K7: customer_id と group_id の同時指定・傘下2社のうちの1社 → その顧客（422 にしない）★（指示書BB 表9。AND）", async () => {
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 1)];
    // ★傘下2社のホールディングスでも、顧客が名指しされていれば 422 にならない★
    const res = await rawKpi(`${CONFIRMED}&group_id=1&customer_id=1`);
    expect(res.status).toBe(200);
    expect((JSON.parse(res.text) as ReportKpi).operation_rate.value).toBe(90);
  });

  it("★★K3: customer_id=2・group_id=1（顧客2は傘下でない）→ 200・空のKPI。サマリも詳細も読まない★★（指示書BB A17・表9）", async () => {
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 2), customer(3, "屋号3", 1)];
    const res = await rawKpi(`${CONFIRMED}&group_id=1&customer_id=2`);
    expect(res.status).toBe(200);
    expect(JSON.parse(res.text)).toEqual({
      operation_rate: { value: null, prev: null, diff: null },
      launch_rate: { value: null, prev: null, diff: null },
      completion_rate: { value: null, prev: null, diff: null },
      error_rate: { value: null, prev: null, diff: null },
    });
    expect(calls.customerSummary).toHaveLength(0);
    expect(calls.cleanTimetable).toHaveLength(0);
  });
});

/**
 * 指示書AL ★段階1★ の期待値表 ★1-1 〜 1-5★ — ★★当期（進行中の週）のKPIを顧客で絞る★★。
 * （★1-6（指定なし・顧客2社 → 422）は段階6 の「6-4 / 6-5」で固定済み★）
 *
 * ------------------------------------------------------------------------
 * ★★何を守るためのテストか★★
 * ------------------------------------------------------------------------
 *  - ★★存在しない顧客を指定したら当期が空になること★★（★1-3。今回の要★）—
 *    ★数字が出たら絞れていない★。★★`facility_ids: []` が `null`（＝全社合算）に
 *    化けていないか★★を見る（★罠1 / 落とし穴3★）
 *  - ★確定期間（`customer_summaries` を `customer_id` で絞る）と当期
 *    （`clean_timetables` を `facility_id` で絞る）が★★同じ顧客を指すこと★★（★1-7★）
 *  - ★★施設IDを `target.customerId` から解決していること★★（★落とし穴1★）—
 *    ★リクエストの `group_id` から直接引くと母集団がずれる★
 *
 * ★★D-138 の残課題★★（「確定期間は選んだ顧客の数字・当期は全社合算」）がここで解消する。
 * ★fixtures 経路（`USE_FIXTURES=true`）は元から顧客単位で正しかった★
 *   （`filterFixtureReportKpis()` の注記）。★このファイルは Prisma 経路★。
 */
describe("★★指示書AL 段階1 — 当期KPIを顧客で絞る（期待値表 1-1〜1-5）★★", () => {
  /** 当期の集計に降りた `facility_id` の条件（★無ければ `undefined`＝絞っていない★） */
  function currentFacilityIdIn(): number[] | undefined {
    const cond = mainQueryWhere().facility_id as { in: unknown[] } | undefined;
    return cond?.in.map(Number);
  }

  it("★1-1★ 当期・customer_id=1 → ★顧客1（施設1）だけの数字★（★全社の数字にならない★）", async () => {
    const body = await kpi(`${CURRENT}&customer_id=1`);
    // 301（実施・95）/ 302（未実施）。
    // 47.5 → 95: 面積比 → 1回ごとの完了率の平均（指示書AS）。★全社合算なら 49 → ≒81.67★
    expect(body.completion_rate.value).toBeCloseTo(95, 10);
    // ★エラー1件 ÷ 予定2件（第11回 P-6=B。旧: ÷ 実施1件で 100）★
    expect(body.error_rate.value).toBe(50);
    expect(currentFacilityIdIn()).toEqual([1]);
  });

  it("★1-2★ 当期・customer_id=2 → ★1-1 と違う数字★（施設2 だけ）", async () => {
    const body = await kpi(`${CURRENT}&customer_id=2`);
    // 313（未実施）/ 314（20:00・50）。★1-1 の 95 とも全社の ≒81.67 とも違う★
    // 25 → 50: 面積比 50/200 → 1回ごとの完了率の平均（指示書AS）
    expect(body.completion_rate.value).toBe(50);
    // ★施設2 はエラー報告を1件も持たない★（施設1 の EmergencyStop が混ざれば 100 になる）
    expect(body.error_rate.value).toBe(0);
    expect(currentFacilityIdIn()).toEqual([2]);
  });

  it("★★1-3★★ 当期・customer_id=9999 → ★★空（value が null）★★（★数字が出たら不具合★）", async () => {
    const body = await kpi(`${CURRENT}&customer_id=9999`);
    expect(body).toEqual({
      operation_rate: { value: null, prev: null, diff: null },
      launch_rate: { value: null, prev: null, diff: null },
      completion_rate: { value: null, prev: null, diff: null },
      error_rate: { value: null, prev: null, diff: null },
    });
    // ★★`in: []` がそのまま降りていること★★ — ★`null` に化けると全社の数字が出る★（罠1）
    expect(currentFacilityIdIn()).toEqual([]);
  });

  it("★1-4★ 当期・group_id 指定（傘下1社）→ ★その顧客の数字★", async () => {
    // `buildData()` の顧客マスタは屋号1（ホールディングス1）の1社だけ
    const body = await kpi(`${CURRENT}&group_id=1`);
    // 47.5 → 95: 面積比 → 1回ごとの完了率の平均（指示書AS。1-1 と同じ母集団）
    expect(body.completion_rate.value).toBeCloseTo(95, 10);
    expect(currentFacilityIdIn()).toEqual([1]);
  });

  it("★1-5★ 当期・指定なし・顧客1社 → ★その顧客の全施設★（★P1 はここ★）", async () => {
    const body = await kpi(CURRENT);
    // 47.5 → 95: 面積比 → 1回ごとの完了率の平均（指示書AS。1-1 と同じ母集団）
    expect(body.completion_rate.value).toBeCloseTo(95, 10);
    expect(currentFacilityIdIn()).toEqual([1]);
  });

  it("★★落とし穴1: 施設IDは `target.customerId` から解決する（リクエストの group_id からではない）★★", async () => {
    // ★屋号1・屋号2 はどちらもホールディングス1★（指示書BB A17 で customer_id と group_id は AND になったので、
    //   傘下の顧客を名指しする形で確かめる。旧: group_id=2&customer_id=1 — いまは食い違いで 200・空になる）。
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 1)];
    // ★`customer_id` が名指しされているので対象顧客は屋号1★。
    //   ★★リクエストの `group_id`（=1。傘下は屋号1・2）から施設を引くと施設2 まで入り★★、
    //   ★確定期間（屋号1の数字）とずれる★。
    const body = await kpi(`${CURRENT}&group_id=1&customer_id=1`);
    expect(currentFacilityIdIn()).toEqual([1]);
    // 47.5 → 95: 面積比 → 1回ごとの完了率の平均（指示書AS。1-1 と同じ母集団）
    expect(body.completion_rate.value).toBeCloseTo(95, 10);
  });

  it("★★1-7 / 1-8 確定期間と当期・前期比が、どれも同じ顧客の数字★★", async () => {
    // ★確定期間（第2週）は `customer_summaries` を `customer_id` で絞る★
    const confirmed = await kpi(`${CONFIRMED}&customer_id=1`);
    expect(confirmed.operation_rate.value).toBe(90);
    // ★当期（第3週）は `clean_timetables` を `facility_id` で絞る★。
    //   ★★`prev` は同じ顧客の確定期間サマリ（第2週）から来る★★ので、
    //   ★当期＝顧客1の詳細 / 前期＝顧客1のサマリ★ で前期比が計算されている。
    const current = await kpi(`${CURRENT}&customer_id=1`);
    expect(current.operation_rate.value).toBe(50);
    expect(current.operation_rate.prev).toBe(90);
    expect(current.operation_rate.diff).toBe(-40);

    // ★別の顧客を指定すると、当期も前期も**その顧客**の数字に揃って入れ替わる★
    data.customerSummaries = [
      ...data.customerSummaries,
      summary(5, 0, 2026, 9, 2, [30, 30, 30, 30], 2),
    ];
    const other = await kpi(`${CURRENT}&customer_id=2`);
    expect(other.operation_rate.value).toBe(50); // 施設2: 313/314 の2件中1件
    // ★★前期に顧客1の 90 が混ざらないこと★★（混ざれば diff が -40 になる）
    expect(other.operation_rate.prev).toBe(30);
    expect(other.operation_rate.diff).toBe(20);
  });
});

/**
 * 指示書AL ★段階3★ §4-3 — ★`customer_id` が明示されているときは顧客マスタを読まない★。
 *
 * `resolveTargetCustomer()` は ★`customerId !== null` なら顧客リストを一切見ない★
 * （★存在確認をしない★契約。段階6 期待値表 6-9）ので、読んでも捨てるだけの1クエリになる。
 *
 * ★★挙動は1ミリも変わらない直し★★なので、★発行されたクエリを数えないと固定できない★
 * （レスポンスだけを見るテストでは、読んでも読まなくても同じ結果になる）。
 */
describe("★★指示書AL 段階3 §4-3 — 不要な顧客マスタの読み込みをやめる★★", () => {
  // 段階6 の describe 内と同じ形（`kpi()` は 200 を前提にしているので 422 を見られない）
  async function rawKpi(search: string): Promise<{ status: number; text: string }> {
    const res = await GET_KPI(new Request(`http://localhost/api/reports/kpi?${search}`));
    return { status: res.status, text: await res.text() };
  }

  it("★customer_id 明示 → `customer.findMany` を1回も呼ばない★", async () => {
    const res = await rawKpi(`${CONFIRMED}&customer_id=1`);
    expect(res.status).toBe(200);
    expect(calls.customer).toHaveLength(0);
  });

  it("★customer_id と group_id の同時指定では読む★（AND の傘下判定に要る。指示書BB A17・D15）", async () => {
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 1)];
    const res = await rawKpi(`${CONFIRMED}&group_id=1&customer_id=1`);
    expect(res.status).toBe(200);
    expect(calls.customer).toHaveLength(1);
  });

  it("★★customer_id 未指定のときは読む★★（★読まなくしすぎると 422 の候補が出せなくなる★）", async () => {
    data.customers = [customer(1, "屋号1", 1), customer(2, "屋号2", 2)];
    const res = await rawKpi(CONFIRMED);
    expect(res.status).toBe(422);
    expect(calls.customer).toHaveLength(1);
    expect((JSON.parse(res.text) as ApiError).error.details).toEqual({
      customer_ids: [1, 2],
    });
  });

  it("★group_id だけの指定でも読む★（傘下の候補を数えるのに要る）", async () => {
    const res = await rawKpi(`${CONFIRMED}&group_id=1`);
    expect(res.status).toBe(200);
    expect(calls.customer).toHaveLength(1);
  });
});

/**
 * 指示書AK ★段階4b★ — 分類（`group_id` / `customer_id`）を `where` に降ろす。
 *
 * ------------------------------------------------------------------------
 * ★★なぜ fixtures ではなくここ（Prisma 版）で固定するのか★★
 * ------------------------------------------------------------------------
 * ★`/reports/error-breakdown` は fixtures では確かめられません★ —
 * fixtures のエラー種別内訳は ★施設をまたいで足し上げたあとの集計値★で、
 * ★どの施設のエラーかという情報を持っていない★ためです
 * （`fixtureSource.errorBreakdown()` の docstring が正）。
 * ★★`facility_error_summaries` を `facility_id` で絞る（＝D-133 申し送り③の解消）★★ かどうかは、
 * ★このスタブで発行された `where` と、足し上げた件数の両方で見ます★。
 *
 * ルート経由の絞り込み（fixtures 側）は
 * `app/api/__tests__/master-filter-dashboard-reports.test.ts` にあります。
 */
describe("★★指示書AK 段階4b — 分類で `facility_id` を絞る★★", () => {
  /** 施設の `where` に降りた `id: { in: [...] }`（無ければ `undefined`） */
  function facilityIdIn(): number[] | undefined {
    const call = calls.facility.find((c) => "where" in c && "id" in (c.where as object));
    if (!call) return undefined;
    return (call as { where: { id: { in: unknown[] } } }).where.id.in.map(Number);
  }

  it("★`customer_id=1` → `facility_error_summaries` を施設1だけで引く★（D-133 申し送り③の解消）", async () => {
    const body = await breakdown(`${CONFIRMED}&customer_id=1`);
    // ★施設2 の HandleUp(1件) が混ざらない★ — 絞れていなければ 3 になる
    expect(body.items.map((i) => [i.type, i.count])).toEqual([
      ["HandleUp", 2],
      ["EmergencyStop", 1],
    ]);
    expect(calls.facilityErrorSummary[0].where).toEqual({
      year: 2026,
      month: 9,
      week: 2,
      // ★施設IDは `Number`（`loadFacilityGroupIndex()` が BigInt を落としている）★
      facility_id: { in: [1] },
      facility: { deleted_at: null },
    });
  });

  it("★`group_id=1` → 傘下2社（施設1・2）ぶんを足し上げる★", async () => {
    const body = await breakdown(`${CONFIRMED}&group_id=1`);
    expect(body.items.map((i) => [i.type, i.count])).toEqual([
      ["HandleUp", 3],
      ["EmergencyStop", 1],
    ]);
  });

  it("★分類を指定しなければ `facility_id` の条件を付けない★（`in: undefined` にもしない。罠1）", async () => {
    await breakdown(CONFIRMED);
    expect(calls.facilityErrorSummary[0].where).toEqual({
      year: 2026,
      month: 9,
      week: 2,
      facility: { deleted_at: null },
    });
  });

  it("★★積集合が空（`group_id=2&customer_id=1`）→ `in: []` で0件★★（全件に化けないこと）", async () => {
    const body = await breakdown(`${CONFIRMED}&customer_id=1&group_id=2`);
    expect(body.items).toEqual([]);
    expect(
      (calls.facilityErrorSummary[0].where as { facility_id: { in: unknown[] } })
        .facility_id.in
    ).toEqual([]);
  });

  it("★当期（詳細テーブル経由）でも `clean_timetables` を施設で絞る★", async () => {
    // 施設2 は当期に本清掃があるが、★エラー行を1つも持たない★
    const body = await breakdown(`${CURRENT}&customer_id=2`);
    expect(body.items).toEqual([]);
    expect((mainQueryWhere().facility_id as { in: unknown[] }).in.map(Number)).toEqual([2]);
    // ★絞らなければ施設1 の EmergencyStop（と施設3 の予定外の LostLocation。指示書BG）が出る★（＝この0件は「絞れた結果」）
    expect((await breakdown(CURRENT)).items.map((i) => i.type)).toEqual([
      "EmergencyStop",
      "LostLocation",
    ]);
  });

  it("★`/reports/continuous-problems` も施設で絞る★（連続4日の施設2だけが残る）", async () => {
    const scoped = await continuous(`${CURRENT}&customer_id=2&limit=100`);
    expect(scoped.items.map((i) => i.facility_id)).toEqual([2]);
    expect(facilityIdIn()).toEqual([2]);

    // ★屋号1（施設1）には2日以上の連続が無い★ — 絞れていなければ施設2 が出てしまう
    const other = await continuous(`${CURRENT}&customer_id=1&limit=100`);
    expect(other.items).toEqual([]);
    expect(other.meta.total).toBe(0);
  });

  it("★`/reports/facility-performance` も分類で絞る★（屋号3 = 施設3 だけ）", async () => {
    const scoped = await performance(`${CURRENT}&customer_id=3&limit=100`);
    expect(scoped.items.map((i) => i.facility_id)).toEqual([3]);
    expect(facilityIdIn()).toEqual([3]);
  });
});

/**
 * ★★申し送り（テストの制約。実装の制約ではない）★★
 *
 * ★施設名 × 分類の積集合★（`/reports/facility-performance` に両方を同時指定するケース）は
 * ★このファイルでは固定できません★ — ルートが
 * `Promise.all([resolveFacilityIdsByName(), resolveFacilityIdsByMasters()])` で
 * ★2本のデータ取得を**同時に**走らせる★ため、★`prismaSource` の `await import("./prisma")`
 * が同時に2回走り、`vi.mock()` の差し替え前の実体を掴んで 500 になります★（実測。
 * ★同じ現象の記録が `app/api/dashboard/__tests__/route.test.ts` の冒頭にあります★）。
 * ★★本番では起きません★★（`getPrisma()` はシングルトンで、差し替えも無いため）。
 *
 * ★積集合そのものは fixtures 側で固定してあります★ —
 * `app/api/__tests__/master-filter-dashboard-reports.test.ts` の
 * 「★施設名 × 分類 の積集合★」。
 */

/**
 * ★★年次（`period=yearly`）★★（指示書AQ 決定1 / §3 罠2・罠6。2026-09-30 解禁）
 *
 * ------------------------------------------------------------------------
 * ★★何を守るためのテストか★★
 * ------------------------------------------------------------------------
 *  - ★`period=yearly&year=…&month=0` がルートを通って 200 を返す★（旧: `month >= 1` で 422）
 *  - ★★年次サマリ行を月次と取り違えない★★（罠2）— `periodOfSummaryRow()` が年次行を
 *    `monthly` と判定すると、`selectKpiRow()` の `row.period === query.period` で弾かれ
 *    ★例外もなく空のKPIになる★（fail-silent）。★値が出ること★で固定する
 *  - ★当年（`NOW` = 2026-09-16 の 2026年）は詳細テーブルからその場集計★し、
 *    ★範囲は `periodRange()` の 1月1日〜12月31日★。★前期比は前年の年次サマリ★から
 *  - ★`period=yearly` で `month` が 0 以外なら 422★（落とし穴6。「yearly なら何でも通す」にしない）
 */
describe("★★年次（period=yearly）— 指示書AQ 決定1★★", () => {
  it("★Y-1★ 当年 `period=yearly&year=2026&month=0` → 200。詳細から集計し、前期比は前年の年次サマリ", async () => {
    // ★2026年の年次サマリ行は置かない★（置くと「確定期間の行が先」の規則でそちらが採られ、
    //   詳細の集計を観測できない。`reportKpis()` の末尾）
    data.customerSummaries = [summary(60, 0, 2025, 0, 0, [70, 71, 72, 73])];
    const res = await GET_KPI(
      new Request("http://localhost/api/reports/kpi?period=yearly&year=2026&month=0")
    );
    expect(res.status).toBe(200);
    const body = (await res.json()) as ReportKpi;

    // 施設1（対象顧客＝屋号1）の 2026年の本清掃: 201（80）/ 202（未実施）/ 301（95）/ 302（未実施）。
    //   ★305 は未来の予定なので入らない★。★3011 は事前チェック行なので入らない★
    expect(body.operation_rate).toEqual({ value: 50, prev: 70, diff: -20 });
    expect(body.launch_rate.value).toBe(50);
    // ★1回ごとの完了率の平均 (80+95)/2★（指示書AS。未実施はレポート行が無いので入らない）
    expect(body.completion_rate.value).toBeCloseTo(87.5, 10);
    expect(body.completion_rate.prev).toBe(72);
    // 本清掃を指すエラー 201 / 301 の2件 ÷ ★予定4件★（第11回 P-6=B。旧: ÷ 実施2件で 100）
    expect(body.error_rate.value).toBe(50);

    // ★範囲は `periodRange("yearly", 2026)` = 2026-01-01 〜 2026-12-31（壁時計値。C-6）★
    const startAt = mainQueryWhere().start_at as { gte: Date; lt: Date };
    expect(startAt.gte.toISOString()).toBe("2026-01-01T00:00:00.000Z");
    expect(startAt.lt.toISOString()).toBe("2027-01-01T00:00:00.000Z");
    // ★サマリは当年 ＋ 前年の年次キーだけを引く★（月次・週次のキーを混ぜない）
    expect((calls.customerSummary[0].where as { OR: unknown[] }).OR).toEqual([
      { year: 2026, month: 0, week: 0 },
      { year: 2025, month: 0, week: 0 },
    ]);
  });

  it("★★Y-2★★ 確定した年 `period=yearly&year=2025&month=0` → ★年次サマリ行の値そのもの★（月次と取り違えない）", async () => {
    data.customerSummaries = [
      summary(61, 0, 2025, 0, 0, [70, 71, 72, 73]),
      summary(62, 0, 2024, 0, 0, [60, 61, 62, 63]),
      // ★同じ年の月次行（12月）★ — `where` が期間キー3つの一致なので届かないはず。
      //   ★届いたら 500（重複）か別の値になる★
      summary(63, 0, 2025, 12, 0, [1, 1, 1, 1]),
    ];
    const res = await GET_KPI(
      new Request("http://localhost/api/reports/kpi?period=yearly&year=2025&month=0")
    );
    expect(res.status).toBe(200);
    const body = (await res.json()) as ReportKpi;
    // ★★年次行が `monthly` と判定されていたら、ここは null（空のKPI）になる★★（罠2）
    expect(body.operation_rate).toEqual({ value: 70, prev: 60, diff: 10 });
    expect(body.launch_rate.value).toBe(71);
    expect(body.completion_rate.value).toBe(72);
    expect(body.error_rate.value).toBe(73);
    // ★確定期間では詳細テーブルを1行も読まない★（D-102）
    expect(calls.cleanTimetable).toEqual([]);
    expect(calls.cleanTaskReport).toEqual([]);
  });

  it("★Y-3★ 施設別パフォーマンスも年次サマリを `yearly` として読む（前期比は前年）", async () => {
    data.facilitySummaries = [
      ...data.facilitySummaries,
      summary(71, 1, 2025, 0, 0, [66, 66, 66, 0]),
      summary(72, 1, 2024, 0, 0, [55, 55, 55, 0]),
    ];
    const body = await performance("period=yearly&year=2025&month=0&limit=100");
    const fac1 = body.items.find((item) => item.facility_id === 1);
    // ★年次行が `monthly` のキーで Map に入っていたら、ここは見つからないか値が null になる★
    expect(fac1?.operation_rate).toEqual({ value: 66, prev: 55, diff: 11 });
    expect(fac1?.completion_rate.value).toBe(66);
  });

  it("★Y-4★ `period=yearly` で `month` が 0 以外 → 422（DB を1本も引かない）", async () => {
    for (const get of [GET_KPI, GET_PERFORMANCE, GET_CONTINUOUS, GET_BREAKDOWN]) {
      const res = await get(
        new Request("http://localhost/api/reports/x?period=yearly&year=2026&month=9")
      );
      expect(res.status).toBe(422);
      expect(((await res.json()) as ApiError).error.code).toBe("validation_failed");
    }
    for (const key of Object.keys(calls)) expect(calls[key]).toEqual([]);
  });
});

describe("当期 — robot_id が NULL のエラー行（指示書AU 段階0-4。第11回 P-8 b）", () => {
  it("★robot_id が NULL の行を混ぜても KPI・施設別成績・エラー内訳が落ちず、値も変わらない★", async () => {
    const before = [
      await kpi(CURRENT),
      await performance(`${CURRENT}&limit=100`),
      await breakdown(CURRENT),
    ];
    data.errorReports = data.errorReports.map((r) => ({ ...r, robot_id: null }));
    for (const [handler, path] of [
      [GET_KPI, "kpi"],
      [GET_PERFORMANCE, "facility-performance"],
      [GET_BREAKDOWN, "error-breakdown"],
    ] as const) {
      const res = await handler(new Request(`http://localhost/api/reports/${path}?${CURRENT}&limit=100`));
      expect(res.status).toBe(200);
    }
    const after = [
      await kpi(CURRENT),
      await performance(`${CURRENT}&limit=100`),
      await breakdown(CURRENT),
    ];
    expect(after).toEqual(before);
  });
});

describe("当期 — 予定を2表から読む（指示書AU 段階3b。第11回 P-7）", () => {
  /** 当期の4本（KPI・施設別成績・連続問題・エラー内訳）をまとめて取る */
  async function all() {
    return [
      await kpi(CURRENT),
      await performance(`${CURRENT}&limit=100`),
      await continuous(`${CURRENT}&limit=100`),
      await breakdown(CURRENT),
    ];
  }

  it("★予定が履歴にだけあっても、本表にあるときと同じ値になる★（レポート・エラー・出発失敗とも）", async () => {
    const baseline = await all();
    // ★301（レポートとエラーあり）と 302（出発失敗）を履歴へ移す★ — 事前チェック行 3011 は本表に残す
    const moved = new Set(["301", "302"]);
    data.historyTimetables = data.timetables.filter((t) => moved.has(t.id.toString()));
    data.timetables = data.timetables.filter((t) => !moved.has(t.id.toString()));
    expect(await all()).toEqual(baseline);
  });

  it("★両方にある同じ予定は1件として数える★（本表のまま）", async () => {
    const baseline = await all();
    data.historyTimetables = data.timetables.map((t) => ({ ...t }));
    expect(await all()).toEqual(baseline);
  });

  it("★2表に同じ引数が渡る★（`where` を2回書かない）", async () => {
    await kpi(CURRENT);
    await breakdown(CURRENT);
    expect(calls.cleanTimetableHistory).toEqual(calls.cleanTimetable);
  });
});

/**
 * ★表1 V11 / V13 / V15 / V16（指示書BB U1・D-182）★ — 当期の詳細テーブルの予定（2表とも）と、
 * 連続日数の入力（`loadConsecutiveInputs()`）の `where` に、削除済みの施設・清掃エリアの条件が入ること。
 * ★確定期間のサマリは外せる範囲だけ★（V14 は上の `facilityErrorSummary` の where。V10・V12 は変えない — D5）
 */
describe("削除済みの施設・清掃エリア — 当期の予定と連続日数の入力（指示書BB U1・表1）", () => {
  function expectAllTimetableWheresVisible() {
    const all = [...calls.cleanTimetable, ...calls.cleanTimetableHistory].filter((c) => "where" in c);
    expect(all.length).toBeGreaterThan(0);
    for (const c of all) {
      const where = (c as { where: Record<string, unknown> }).where;
      // ★影チェック（`id IN` だけの引き直し）は対象外★（`findTimetables()` の内部）
      if (!("precheck" in where)) continue;
      expect(where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
    }
  }

  it("V11: `/reports/kpi` の当期", async () => {
    await kpi(`${CURRENT}&customer_id=1`);
    expectAllTimetableWheresVisible();
  });

  it("V13・V15: `/reports/facility-performance` の当期（連続日数の入力を含む）", async () => {
    await performance(`${CURRENT}&limit=100`);
    expectAllTimetableWheresVisible();
    expect(calls.cleanTimetable.some((c) => isConsecutiveQuery(c))).toBe(true);
  });

  it("V16: `/reports/error-breakdown` の当期", async () => {
    await breakdown(CURRENT);
    expectAllTimetableWheresVisible();
  });

  it("V15: `/reports/continuous-problems`（連続日数の入力）", async () => {
    await continuous(`${CURRENT}&limit=100`);
    expectAllTimetableWheresVisible();
    expect(calls.cleanTimetable.some((c) => isConsecutiveQuery(c))).toBe(true);
  });
});

/**
 * ★表13（指示書BB A11・D-182）★ — 確定期間の `customer_summaries` が0行なら `data.anomaly` を1回（KPI は今どおり空）。
 *   当期にサマリが無いのは正常なのでログを出さない。★未来の期間（最終日が今日以降）も出さない★。
 *   どの顧客・期間か追えるよう、顧客と期間キー（粒度を含む）を載せる。
 */
describe("確定期間のサマリが0行（指示書BB 表13）", () => {
  function summaryAnomalies() {
    return vi
      .mocked(logEvent)
      .mock.calls.filter(([, p]) => p.event === "data.anomaly" && p.metric === "customer_summary_rows")
      .map(([, p]) => p);
  }

  it("★L1: 確定期間・サマリ0行 → KPI は空のまま。data.anomaly を1回★", async () => {
    vi.mocked(logEvent).mockClear();
    const body = await kpi("period=weekly&year=2026&month=7&week=1&customer_id=1");
    expect(body.operation_rate.value).toBeNull();
    expect(summaryAnomalies()).toEqual([
      {
        event: "data.anomaly",
        metric: "customer_summary_rows",
        expected: 1,
        actual: 0,
        period_mode: "summary_table",
        customer_id: 1,
        period: "weekly",
        year: 2026,
        month: 7,
        week: 1,
      },
    ]);
  });

  it("L1（月次・年次）: 期間キーは粒度のまま載る（月次は week 0・年次は month も 0）", async () => {
    vi.mocked(logEvent).mockClear();
    await kpi("period=monthly&year=2026&month=7&customer_id=1");
    await kpi("period=yearly&year=2024&month=0&customer_id=1");
    expect(summaryAnomalies()).toEqual([
      expect.objectContaining({ customer_id: 1, period: "monthly", year: 2026, month: 7, week: 0 }),
      expect.objectContaining({ customer_id: 1, period: "yearly", year: 2024, month: 0, week: 0 }),
    ]);
  });

  it("★L4: 未来の期間・サマリ0行 → ログを出さない（KPI は空のまま）★", async () => {
    vi.mocked(logEvent).mockClear();
    // NOW = 2026-09-16（9月第3週）。第4週・10月・2027年はまだ来ていない
    const body = await kpi("period=weekly&year=2026&month=9&week=4&customer_id=1");
    expect(body.operation_rate.value).toBeNull();
    expect((await kpi("period=monthly&year=2026&month=10&customer_id=1")).operation_rate.value).toBeNull();
    expect((await kpi("period=yearly&year=2027&month=0&customer_id=1")).operation_rate.value).toBeNull();
    expect(summaryAnomalies()).toHaveLength(0);
  });

  it("L2: 当期・サマリ0行 → ログを出さない", async () => {
    vi.mocked(logEvent).mockClear();
    await kpi(`${CURRENT}&customer_id=1`);
    expect(summaryAnomalies()).toHaveLength(0);
  });

  it("L3: 確定期間・1行 → ログを出さない", async () => {
    vi.mocked(logEvent).mockClear();
    const body = await kpi(`${CONFIRMED}&customer_id=1`);
    expect(body.operation_rate.value).toBe(90);
    expect(summaryAnomalies()).toHaveLength(0);
  });
});

/**
 * ★★表U2 — レポート（今の期間・A案）★★（指示書BG §3。監督が書いた期待値表をそのまま使う。数字を変えない）。
 *
 * 今 = 2026-10-29 10:00 JST、`RESULT_WAIT_MINUTES` = 120。施設 F1（＝施設1・屋号1）。期間 10-28 の1日
 * （API は週次: 2026年10月第5週 ＝ 10-25〜10-31。材料は 10-28 にしか置かない）。
 *
 * | 材料 | 内容 |
 * |---|---|
 * | 予定のある清掃 | 3回: 正常終了で完了率 80 ／ 正常終了で完了率 60 ／ 未実施 |
 * | 予定外 | 2回: `status` 4・完了率 100（`clean_timetable_id` = 0）／ `status` 6・完了率 20（NULL）|
 * | エラー | 予定の id に紐づく2件 ＋ 予定外（id 0）に紐づく1件（`errored_at` 10-28 22:00）＋ 事前チェックの回に紐づく1件 |
 *
 * | 指標 | 期待 |
 * |---|---|
 * | 予定回数 | 3 ＋ 2 ＝ 5 |
 * | 開始できた回数 | 2 ＋ 2 ＝ 4 → 出発成功率 80 |
 * | 正常終了 | 2 ＋ 1 ＝ 3 → 稼働率 60 |
 * | 清掃完了率 | (80 ＋ 60 ＋ 100 ＋ 20) ÷ 4 ＝ 65 |
 * | エラー発生回数 | 2 ＋ 1 ＝ 3（事前チェックの1件は入れない）→ エラー発生率 60 |
 * | エラー内訳の合計 | 3（エラー発生回数と同じ） |
 */
describe("★★表U2 — 予定外タスクを今の期間のレポートに含める（A案。指示書BG §2-4）★★", () => {
  const U2_NOW = new Date("2026-10-29T10:00:00+09:00");
  /** 10-28 を含む週（2026年10月第5週 ＝ 10-25〜10-31）。★当期★ */
  const U2_PERIOD = "period=weekly&year=2026&month=10&week=5&customer_id=1";

  /** 予定外タスク（`clean_task_reports` の行。予定の行は無い） */
  function unscheduledReport(
    timetableId: bigint | null,
    status: number,
    cleanArea: number,
    startedJst: string
  ): StubReport {
    return {
      clean_timetable_id: timetableId,
      facility_id: BigInt(1),
      clean_ratio: cleanArea,
      status,
      started_at: dbWallClock(startedJst),
      ended_at: new Date(dbWallClock(startedJst).getTime() + 30 * 60_000),
      task_area: 100,
      clean_area: cleanArea,
    };
  }

  beforeEach(() => {
    vi.setSystemTime(U2_NOW);
    data.timetables = [
      timetable(501, 1, "2026-10-28T21:00:00+09:00"),
      timetable(502, 1, "2026-10-28T22:00:00+09:00"),
      // ★未実施★（レポートの行を置かない。終了 10-29 00:00 ＋ 120分 ＜ 今 なので結果待ちではない）
      timetable(503, 1, "2026-10-28T23:00:00+09:00"),
      // ★事前チェックの回（501 の子）★ — どの集計にも入れない
      timetable(5011, 1, "2026-10-28T20:00:00+09:00", FIRST_ROUND_MINUTES, 501),
    ];
    data.reports = [
      { ...report(501, 80, 100, 80), facility_id: BigInt(1) },
      { ...report(502, 60, 100, 60), facility_id: BigInt(1) },
      // ★`clean_timetable_id` = 0 と NULL はどちらも予定外（表U1 U1-3）★
      unscheduledReport(BigInt(0), 4, 100, "2026-10-28T20:00:00+09:00"),
      unscheduledReport(null, 6, 20, "2026-10-28T23:30:00+09:00"),
    ];
    data.errorReports = [
      errorReport(501, "EmergencyStop"),
      errorReport(502, "HandleUp"),
      {
        clean_timetable_id: BigInt(0),
        facility_id: BigInt(1),
        // ★種類では絞らない★（予定のある清掃と同じ。指示書BG §1）
        error_type: "SECURITY_ON",
        errored_at: dbWallClock("2026-10-28T22:00:00+09:00"),
        created_at: dbWallClock("2026-10-28T22:00:05+09:00"),
      },
      // ★事前チェックの回に紐づくエラー → 入れない★
      errorReport(5011, "LostLocation"),
    ];
    data.customerSummaries = [];
    data.facilitySummaries = [];
    data.facilityErrorSummaries = [];
  });

  it("KPI: 出発成功率 80・稼働率 60・清掃完了率 65・エラー発生率 60", async () => {
    const body = await kpi(U2_PERIOD);
    expect(body.launch_rate.value).toBe(80);
    expect(body.operation_rate.value).toBe(60);
    expect(body.completion_rate.value).toBe(65);
    expect(body.error_rate.value).toBe(60);
  });

  it("施設別の成績も同じ集計（施設1 の行が同じ4率）", async () => {
    const body = await performance(`${U2_PERIOD}&limit=100`);
    const fac1 = body.items.find((item) => item.facility_id === 1);
    expect(fac1?.launch_rate.value).toBe(80);
    expect(fac1?.operation_rate.value).toBe(60);
    expect(fac1?.completion_rate.value).toBe(65);
    expect(fac1?.error_rate.value).toBe(60);
  });

  it("★★エラー内訳の合計 3 ＝ エラー発生率の分子★★（事前チェックの1件は入れない。`aa4292d` の不変条件）", async () => {
    const items = (await breakdown(U2_PERIOD)).items;
    expect(items.map((i) => [i.type, i.count]).sort()).toEqual(
      [
        ["EmergencyStop", 1],
        ["HandleUp", 1],
        ["SECURITY_ON", 1],
      ].sort()
    );
    const total = items.reduce((sum, i) => sum + i.count, 0);
    expect(total).toBe(3);
    // 分子 ＝ エラー発生率 × 予定回数（5）÷ 100
    const body = await kpi(U2_PERIOD);
    expect(((body.error_rate.value ?? Number.NaN) * 5) / 100).toBeCloseTo(total, 10);
  });

  it("★予定外の読み取りは期間・施設・可視性（削除済みを除く）を SQL に降ろし、`robot_id` を読まない★", async () => {
    await kpi(U2_PERIOD);
    const reportCall = calls.cleanTaskReport.find((c) => "OR" in (c.where as object)) as {
      where: Record<string, unknown>;
      select: Record<string, boolean>;
    };
    expect(reportCall).toBeDefined();
    expect(reportCall.where.OR).toEqual([
      { clean_timetable_id: null },
      { clean_timetable_id: BigInt(0) },
    ]);
    const startedAt = reportCall.where.started_at as { gte: Date; lt: Date };
    // ★壁時計値（10-25 00:00 以上 / 11-01 00:00 未満）★
    expect(startedAt.gte.toISOString()).toBe("2026-10-25T00:00:00.000Z");
    expect(startedAt.lt.toISOString()).toBe("2026-11-01T00:00:00.000Z");
    expect((reportCall.where.facility_id as { in: unknown[] }).in.map(Number)).toEqual([1]);
    expect(reportCall.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
    expect(reportCall.select.robot_id).toBeUndefined();

    const errorCall = calls.robotErrorReport.find((c) => "AND" in (c.where as object)) as {
      where: Record<string, unknown>;
      select: Record<string, boolean>;
    };
    expect(errorCall).toBeDefined();
    expect(errorCall.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
    expect((errorCall.where.facility_id as { in: unknown[] }).in.map(Number)).toEqual([1]);
    expect(errorCall.select.robot_id).toBeUndefined();
    expect(errorCall.select.robot).toBeUndefined();
  });

  it("★確定期間（先週）では予定外の行も読まない★（サマリのまま。ユーザー「サマリは変えて貰う予定」）", async () => {
    await kpi("period=weekly&year=2026&month=10&week=4&customer_id=1");
    await breakdown("period=weekly&year=2026&month=10&week=4&customer_id=1");
    expect(calls.cleanTaskReport).toEqual([]);
    expect(calls.robotErrorReport).toEqual([]);
  });
});