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

// --- PocketBase mock ---------------------------------------------------------
// The mock state has to be hoisted to the top of the file because Vitest
// hoists `vi.mock` factories above all imports. The state lives in a
// `vi.hoisted` block so the factory can close over it.

const { store, pbMock, clearStore } = vi.hoisted(() => {
  type StoreMap = Map<string, Record<string, unknown>>;
  const store: Record<string, StoreMap> = {};
  let seq = 0;
  const nextId = () => `mock-${++seq}`;

  // Relation name → collection name. PB stores every relation as the
  // singular id and the related records in the pluralised collection
  // (e.g. `order.customer` → `customers` collection). The mock's
  // getFullList uses this to resolve expand joins. Most words are
  // `+s`, but a few are irregular — `company` → `companies`, etc.
  const IRREGULAR_PLURALS: Record<string, string> = {
    company: "companies",
  };
  const pluralize = (rel: string): string => {
    if (IRREGULAR_PLURALS[rel]) return IRREGULAR_PLURALS[rel];
    return rel.endsWith("s") ? rel : `${rel}s`;
  };

  const getOrCreateMap = (name: string): StoreMap => {
    if (!store[name]) store[name] = new Map();
    return store[name];
  };

  // The mock `where` is intentionally minimal — supports the patterns the
  // production service actually issues: `field = "value"` (with or without
  // quotes), `field != "value"`, `&&` (AND), `||` (OR), and `id` lookups by
  // PB record id. Anything unrecognised passes through (returns all items
  // for the AND group), so unknown filters don't false-negative tests.
  const matchesClause = (item: Record<string, unknown>, clause: string): boolean => {
    const m = clause.match(/^(\w+)\s*(=~|!~|=|!=|>=|<=|<|>)\s*"?([^"]+?)"?$/);
    if (!m) return true;
    const [, field, op, raw] = m;
    const expected = raw.replace(/^"|"$/g, "");
    const actual = item[field];
    if (field === "year" || field === "month") {
      const num = Number(actual);
      const want = Number(expected);
      switch (op) {
        case "=": return num === want;
        case "!=": return num !== want;
        default: return true;
      }
    }
    const actualStr = String(actual ?? "");
    // Date / numeric comparisons go through `actual` (not the stringified
    // version) so PB-style `>=`/`<=`/`>`/`<` against ISO timestamps or
    // numbers behaves the way the service layer expects. The mock only
    // implements the subset the production code actually emits; if a
    // caller adds a new operator the match falls through to `true` so
    // tests don't false-negative.
    if (op === ">=" || op === "<=" || op === ">" || op === "<") {
      const a = actual as string | number | undefined | null;
      if (a === undefined || a === null) return false;
      switch (op) {
        case ">=": return a > expected || a === expected;
        case "<=": return a < expected || a === expected;
        case ">": return a > expected;
        case "<": return a < expected;
        default: return true;
      }
    }
    switch (op) {
      case "=": return actualStr === expected;
      case "!=": return actualStr !== expected;
      case "=~": return actualStr.includes(expected);
      case "!~": return !actualStr.includes(expected);
      default: return true;
    }
  };

  const where = (name: string, filter: string): Record<string, unknown>[] => {
    const items = Array.from(getOrCreateMap(name).values());
    if (!filter || !filter.trim()) return items;
    // Strip outer parens around the whole expression so the splitter
    // below doesn't see `(` / `)` as clause-leading characters. PB
    // filters are parenthesised when they mix `&&` / `||` — see
    // `completedTabFilter` in orders-service.ts for the canonical
    // example.
    const stripped = filter.replace(/^\s*\(/, "").replace(/\)\s*$/, "");
    // Split on `||` first (outer OR), then each alternative is a group of
    // `&&`-joined AND clauses. An item passes if it satisfies ANY
    // alternative group. We also strip wrapping parens around each
    // alternative so individual clauses don't start with `(`.
    const alternatives = stripped
      .split("||")
      .map((a) => a.trim().replace(/^\(/, "").replace(/\)$/, ""))
      .filter(Boolean);
    return items.filter((item) =>
      alternatives.some((alt) => {
        const clauses = alt
          .split("&&")
          .map((c) => c.trim().replace(/^\(/, "").replace(/\)$/, "").trim())
          .filter(Boolean);
        return clauses.every((clause) => matchesClause(item, clause));
      }),
    );
  };

  const applyExpand = (
    rows: Record<string, unknown>[],
    expand: string | undefined,
  ): Record<string, unknown>[] => {
    if (!expand) return rows;
    const relations = expand.split(",").map((s) => s.trim()).filter(Boolean);
    return rows.map((it) => {
      const exp: Record<string, unknown> = {};
      for (const rel of relations) {
        const relId = it[rel];
        if (typeof relId === "string" && getOrCreateMap(pluralize(rel)).has(relId)) {
          exp[rel] = getOrCreateMap(pluralize(rel)).get(relId);
        }
      }
      return { ...it, expand: exp };
    });
  };

  const pbMock = {
    autoCancellation: () => undefined,
    collection: (name: string) => ({
      async getList(
        page = 1,
        perPage = 25,
        opts: { filter?: string; sort?: string; expand?: string } = {},
      ) {
        const all = where(name, opts.filter || "");
        if (opts.sort) {
          const sign = opts.sort.startsWith("-") ? -1 : 1;
          const field = opts.sort.replace(/^-/, "");
          all.sort((a, b) => {
            const av = a[field] as string | number | undefined;
            const bv = b[field] as string | number | undefined;
            if (av === bv) return 0;
            if (av === undefined) return 1;
            if (bv === undefined) return -1;
            return (av > bv ? 1 : -1) * sign;
          });
        }
        // Real pagination — mirror PB's getList semantics so the
        // service code (which relies on totalPages) exercises the same
        // branches under test as in production.
        const totalItems = all.length;
        const totalPages = Math.max(1, Math.ceil(totalItems / perPage));
        const start = (page - 1) * perPage;
        const items = applyExpand(all.slice(start, start + perPage), opts.expand);
        return { items, totalItems, totalPages, page, perPage };
      },
async getFullList(opts: { filter?: string; fields?: string; expand?: string } = {}) {
        // Mirror production: respect the filter. The fields projection
        // is a wire-payload optimisation in PB; for tests we just
        // return the matched records as-is. Expand ("customer,company"
        // etc.) is honoured by attaching the related records from the
        // store under `expand.<relation>` so tests asserting on names
        // pulled through the expand join pass.
        const items = where(name, opts.filter || "");
        return applyExpand(items, opts.expand);
      },
      async getFirstListItem(filter: string) {
        const items = where(name, filter);
        if (items.length === 0) {
          const err = new Error("not found") as Error & { status: number };
          err.status = 404;
          throw err;
        }
        return items[0];
      },
      async getOne(id: string) {
        const item = getOrCreateMap(name).get(id);
        if (!item) {
          const err = new Error("not found") as Error & { status: number };
          err.status = 404;
          throw err;
        }
        return item;
      },
      async create(data: Record<string, unknown>) {
        if (name === "order_counters") {
          const map = getOrCreateMap(name);
          for (const item of map.values()) {
            if (item.year === data.year && item.month === data.month) {
              const err = new Error("unique constraint") as Error & { status: number };
              err.status = 409;
              throw err;
            }
          }
        }
        // Respect an explicit `id` when the test provides one — PB does
        // the same, and several tests (expand joins, split continuations)
        // rely on the predictable id to wire related records together.
        const item = {
          id: typeof data.id === "string" ? data.id : nextId(),
          created: new Date().toISOString(),
          updated: new Date().toISOString(),
          ...data,
        };
        getOrCreateMap(name).set(item.id, item);
        return item;
      },
      async update(id: string, data: Record<string, unknown>) {
        const map = getOrCreateMap(name);
        const existing = map.get(id);
        if (!existing) {
          const err = new Error("not found") as Error & { status: number };
          err.status = 404;
          throw err;
        }
        for (const [key, value] of Object.entries(data)) {
          if (key.endsWith("+")) {
            const real = key.slice(0, -1);
            existing[real] = Number(existing[real] ?? 0) + Number(value);
          } else {
            existing[key] = value;
          }
        }
        existing.updated = new Date().toISOString();
        return { ...existing };
      },
    }),
  };

  const clearStore = () => {
    for (const key of Object.keys(store)) delete store[key];
    seq = 0;
  };

  return { store, pbMock, clearStore };
});

vi.mock("pocketbase", () => {
  return {
    default: vi.fn().mockImplementation(() => pbMock),
  };
});

vi.mock("./pocketbase-admin", () => ({
  getAdminPocketBase: vi.fn().mockResolvedValue(pbMock),
}));

vi.mock("./order-quote-link-service", () => ({
  pairOrderLines: vi.fn().mockResolvedValue({
    confident: [], possible: [], unmatchedOrderItemIds: [],
  }),
  suggestQuoteForOrder: vi.fn().mockResolvedValue({ best: null }),
}));

vi.mock("./order-delivery-note-link-service", () => ({
  suggestDeliveryNoteForOrder: vi.fn().mockResolvedValue({
    best: null,
    method: "no_match",
  }),
}));

// `after()` normally defers its callback until the response has been
// sent — outside a real Next.js request, nothing ever flushes that
// queue. Stub it to run the callback inline so `createOrder` tests can
// assert on the scheduled quote-match synchronously.
vi.mock("next/server", async (importOriginal) => {
  const actual = await importOriginal<typeof import("next/server")>();
  return {
    ...actual,
    after: vi.fn((cb: () => unknown) => { void cb(); }),
  };
});

import {
  createOrder,
  createOrderFromQuote,
  clearOrderItemStatusTabCountsCache,
  getOrderItemStatusTabCounts,
  getOrderIdsForTabGroup,
  getOrderItemsCollectionName,
  getOrdersArchiveData,
  getOrdersDashboardData,
  listOrdersWithItems,
  splitOrderForContinuation,
  cancelOrder,
  cancelOrdersBulk,
  findDuplicateOrders,
  // Hermes unblock (PR 1, 2026-08-21):
  setOrderQuote,
  findOrderByOrderNumber,
  findOrderByEmailMessageId,
} from "./orders-service";

beforeEach(() => {
  clearStore();
});

// --- Tests -------------------------------------------------------------------

describe("getOrderItemsCollectionName", () => {
  it("defaults to 'order_items' when env var is unset", () => {
    const original = process.env.ORDER_ITEMS_COLLECTION;
    delete process.env.ORDER_ITEMS_COLLECTION;
    try {
      expect(getOrderItemsCollectionName()).toBe("order_items");
    } finally {
      if (original !== undefined) process.env.ORDER_ITEMS_COLLECTION = original;
    }
  });

  it("returns the env var when set (e.g. order_items_v2)", () => {
    process.env.ORDER_ITEMS_COLLECTION = "order_items_v2";
    try {
      expect(getOrderItemsCollectionName()).toBe("order_items_v2");
    } finally {
      delete process.env.ORDER_ITEMS_COLLECTION;
    }
  });
});

describe("createOrderFromQuote", () => {
  it("returns the existing order when one already references the quote", async () => {
    // Pre-seed an existing order in the store; dedupe check should find it
    // and short-circuit before the rest of the pipeline runs.
    await pbMock.collection("orders").create({
      id: "order-1",
      quote: "quote-abc",
      order_number: "ORD-2025-01-001",
    });

    const result = await createOrderFromQuote("quote-abc");
    expect(result.already_exists).toBe(true);
    expect(result.order.id).toBe("order-1");
    expect(result.created_items).toBe(0);
  });

  it("throws when the quote has no items", async () => {
    await pbMock.collection("quotes").create({
      id: "quote-empty",
      company: "comp-1",
      customer: "cust-1",
      notes: "",
    });
    // No quote_items rows → service must throw.
    await expect(createOrderFromQuote("quote-empty")).rejects.toThrow(
      /no items to convert/,
    );
  });

  it("creates an order, copies every quote_item, and sets the right defaults", async () => {
    // Seed the dependencies in the mock store.
    await pbMock.collection("quotes").create({
      id: "quote-99",
      company: "comp-7",
      customer: "cust-3",
      notes: "Rush",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-1",
      quote: "quote-99",
      description: "Widget",
      quantity: 3,
      selling_price: 100,
      supplier: "sup-1",
      cost_price: 50,
      markup: 10,
      notes: "front",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-2",
      quote: "quote-99",
      description: "Sprocket",
      quantity: 2,
      selling_price: 75,
      supplier: "sup-2",
      cost_price: 30,
      markup: 0,
      notes: "",
    });

    const result = await createOrderFromQuote("quote-99");

    expect(result.already_exists).toBe(false);
    expect(result.created_items).toBe(2);

    // Pull the created order directly out of the store.
    const orders = await pbMock.collection("orders").getFullList();
    const created = orders.find((o) => o.quote === "quote-99") as
      | Record<string, unknown>
      | undefined;
    expect(created).toBeDefined();
    expect(created?.quote).toBe("quote-99");
    expect(created?.company).toBe("comp-7");
    expect(created?.customer).toBe("cust-3");
    expect(created?.quote_matching_attempted).toBe(true);
    expect(created?.is_repair_order).toBe(false);
    expect(created?.invoiced).toBe(false);
    // Starts at ORD-{now-year}-{now-month}-001 because the orders table
    // is empty for this test (no prior order to extend from).
    const now = new Date();
    const expectedPrefix = `ORD-${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-`;
    expect(String(created?.order_number)).toBe(`${expectedPrefix}001`);

    // Order-item payload assertions: the two quote_items should each
    // have produced one order_item row.
    const orderItems = await pbMock.collection("order_items").getFullList();
    const ourItems = orderItems.filter((o) => o.order === created?.id);
    expect(ourItems.length).toBe(2);

    const widget = ourItems.find((o) => o.description === "Widget");
    expect(widget).toMatchObject({
      po_description: "Widget",
      quantity: 3,
      order_qty: 3,
      qty_ordered: "3",
      selling_price: 100,
      supplier: "sup-1",
      cost_price: 50,
      markup: 10,
      markup_percent: 10,
      item_status: "pending",
      status: "active",
      drv_status: "unassigned",
      notes: "front",
      quote_item: "qi-1",
    });

    const sprocket = ourItems.find((o) => o.description === "Sprocket");
    expect(sprocket?.quote_item).toBe("qi-2");
    expect(sprocket?.supplier).toBe("sup-2");
    expect(sprocket?.drv_status).toBe("unassigned");
  });

  it("extends the latest order's sequence (no month-boundary reset)", async () => {
    // The most recent order is in June; we're now in July. The contract
    // is that the next order continues June's sequence (NOT a fresh
    // July-001). The old code's bug was using `now` month, which would
    // have generated `ORD-2026-07-001` here.
    await pbMock.collection("orders").create({
      order_number: "ORD-2026-06-007",
      quote: "some-other-quote",
    });
    await pbMock.collection("quotes").create({
      id: "quote-seq",
      company: "c",
      customer: null,
      notes: "",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-1",
      quote: "quote-seq",
      description: "x",
      quantity: 1,
      selling_price: 1,
      cost_price: 0,
      markup: 0,
      notes: "",
    });

    await createOrderFromQuote("quote-seq");
    const orders = await pbMock.collection("orders").getFullList();
    const newOrder = orders.find((o) => o.quote === "quote-seq");
    expect(newOrder?.order_number).toBe("ORD-2026-06-008");
  });

  it("starts a fresh month at 001 when the orders table is empty", async () => {
    // The orders collection is empty → no most-recent order to extend
    // from. Falls back to wall-clock year/month, sequence at 001.
    await pbMock.collection("quotes").create({
      id: "q-fresh",
      company: "c",
      customer: null,
      notes: "",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-1",
      quote: "q-fresh",
      description: "x",
      quantity: 1,
      selling_price: 1,
      cost_price: 0,
      markup: 0,
      notes: "",
    });

    await createOrderFromQuote("q-fresh");
    const orders = await pbMock.collection("orders").getFullList();
    const newOrder = orders.find((o) => o.quote === "q-fresh");
    const now = new Date();
    const expected = `ORD-${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-001`;
    expect(newOrder?.order_number).toBe(expected);
  });

  it("falls back to wall-clock year/month when the latest order_number is unparseable", async () => {
    // A junk order_number (legacy import, manual edit, or old data with a
    // different prefix) should NOT break the generator. The service
    // detects unparseable prefixes and uses now year/month.
    await pbMock.collection("orders").create({
      order_number: "GARBAGE-2026-06-007",
      quote: "old",
    });
    await pbMock.collection("quotes").create({
      id: "q-junk",
      company: "c",
      customer: null,
      notes: "",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-1",
      quote: "q-junk",
      description: "x",
      quantity: 1,
      selling_price: 1,
      cost_price: 0,
      markup: 0,
      notes: "",
    });

    await createOrderFromQuote("q-junk");
    const orders = await pbMock.collection("orders").getFullList();
    const newOrder = orders.find((o) => o.quote === "q-junk");
    const now = new Date();
    const expected = `ORD-${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-001`;
    expect(newOrder?.order_number).toBe(expected);
  });

  it("writes to the collection named by ORDER_ITEMS_COLLECTION env var", async () => {
    process.env.ORDER_ITEMS_COLLECTION = "order_items_v2";
    await pbMock.collection("quotes").create({
      id: "q",
      company: "c",
      customer: null,
      notes: "",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-1",
      quote: "q",
      description: "x",
      quantity: 1,
      selling_price: 1,
      cost_price: 0,
      markup: 0,
      notes: "",
    });

    const result = await createOrderFromQuote("q");
    expect(result.order_items_collection).toBe("order_items_v2");

    const v2Rows = await pbMock.collection("order_items_v2").getFullList();
    expect(v2Rows.length).toBe(1);
    expect(v2Rows[0].order).toBeDefined();

    delete process.env.ORDER_ITEMS_COLLECTION;
  });

  it("concurrent calls produce unique order numbers (no race)", async () => {
    // Set up the dependencies for a single order.
    await pbMock.collection("quotes").create({
      id: "q-race",
      company: "c",
      customer: null,
      notes: "",
    });
    await pbMock.collection("quote_items").create({
      id: "qi-1",
      quote: "q-race",
      description: "x",
      quantity: 1,
      selling_price: 1,
      cost_price: 0,
      markup: 0,
      notes: "",
    });
    // Run 5 createOrderFromQuote calls in parallel against distinct
    // quotes. The counter must give each a unique number even under
    // simulated concurrency. (Note: the test mock is not actually
    // concurrent — the `await`s in the implementation interleave the
    // operations — so the assertion verifies the counter pattern, not
    // true concurrency. Real concurrency safety comes from PB's
    // `last_seq+` server-side increment.)
    const quotes = ["q-race-a", "q-race-b", "q-race-c", "q-race-d", "q-race-e"];
    for (const id of quotes) {
      await pbMock.collection("quotes").create({ id, company: "c", customer: null, notes: "" });
      await pbMock.collection("quote_items").create({
        id: `qi-${id}`,
        quote: id,
        description: "x",
        quantity: 1,
        selling_price: 1,
        cost_price: 0,
        markup: 0,
        notes: "",
      });
    }
    const results = await Promise.all(quotes.map((id) => createOrderFromQuote(id)));
    const numbers = results.map((r) => String((r.order as unknown as { order_number: string }).order_number));
    expect(new Set(numbers).size).toBe(5);
  });
});

// ----------------------------------------------------------------------------
// Standalone order creation — createOrder. Use for counter sales / walk-ins /
// internal transfers where there's no originating quote.
// ----------------------------------------------------------------------------

describe("createOrder", () => {
  it("creates an order with no quote and the supplied items", async () => {
    // Seed the relation targets.
    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({ id: "comp-x", name: "Acme (Pty) Ltd" });

    const result = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      notes: "Counter sale — cash",
      contact_name: "Mr Dreyer",
      rep: "Giellie",
      items: [
        { description: "M16 Bolt", quantity: 50, cost_price: 5, markup: 50, selling_price: 7.5 },
        { description: "M16 Nut", quantity: 50, cost_price: 3, markup: 50, selling_price: 4.5 },
      ],
    });

    expect(result.order.id).toBeDefined();
    expect(result.order.customer).toBe("cust-x");
    expect(result.order.company).toBe("comp-x");
    expect(result.order.notes).toBe("Counter sale — cash");
    expect(result.order.contact_name).toBe("Mr Dreyer");
    expect(result.order.rep).toBe("Giellie");
    // Quote-related fields stay blank — no originating quote.
    expect(result.order.quote).toBeNull();
    expect(result.order.potential_quote).toBeNull();
    expect(result.order.quote_matching_attempted).toBe(false);
    expect(result.order.quote_match_confidence).toBe(0);
    expect(result.order.potential_quote_confidence).toBe(0);
    expect(result.order.is_repair_order).toBe(false);
    expect(result.order.invoiced).toBe(false);

    // Two items created, with the per-row defaults the rest of the
    // pipeline relies on.
    expect(result.items_created.length).toBe(2);
    expect(result.items_failed.length).toBe(0);

    const orderItems = await pbMock.collection("order_items").getFullList();
    const ours = orderItems.filter((o) => o.order === result.order.id);
    expect(ours.length).toBe(2);
    for (const it of ours) {
      expect(it.item_status).toBe("pending");
      expect(it.drv_status).toBe("unassigned");
      expect(it.status).toBe("active");
    }
  });

  it("patches secondary fields (sku/unit/supplier_id/notes) onto each item", async () => {
    await pbMock.collection("customers").create({ id: "cust-y" });
    await pbMock.collection("companies").create({ id: "comp-y" });
    await pbMock.collection("suppliers").create({ id: "sup-y" });

    const result = await createOrder({
      customer_id: "cust-y",
      company_id: "comp-y",
      items: [
        {
          description: "Bearing 6205",
          quantity: 4,
          cost_price: 80,
          markup: 25,
          selling_price: 100,
          sku: "BRG-6205",
          unit: "EA",
          supplier_id: "sup-y",
          notes: "From shelf",
        },
      ],
    });

    expect(result.items_created.length).toBe(1);
    expect(result.items_failed.length).toBe(0);

    const orderItems = await pbMock.collection("order_items").getFullList();
    const ours = orderItems.filter((o) => o.order === result.order.id);
    expect(ours[0]).toMatchObject({
      sku: "BRG-6205",
      unit: "EA",
      supplier: "sup-y",
      notes: "From shelf",
      selling_price: 100,
      cost_price: 80,
    });
  });

  it("throws when customer_id does not resolve", async () => {
    // No customers seeded — getOne will 404.
    await pbMock.collection("companies").create({ id: "comp-z" });

    await expect(
      createOrder({
        customer_id: "ghost",
        company_id: "comp-z",
        items: [{ description: "x" }],
      }),
    ).rejects.toThrow(/Customer not found/);
  });

  it("throws when company_id does not resolve", async () => {
    await pbMock.collection("customers").create({ id: "cust-z" });

    await expect(
      createOrder({
        customer_id: "cust-z",
        company_id: "ghost",
        items: [{ description: "x" }],
      }),
    ).rejects.toThrow(/Company not found/);
  });

  it("throws when items array is empty", async () => {
    await pbMock.collection("customers").create({ id: "cust-1" });
    await pbMock.collection("companies").create({ id: "comp-1" });

    await expect(
      createOrder({ customer_id: "cust-1", company_id: "comp-1", items: [] }),
    ).rejects.toThrow(/items must be a non-empty array/);
  });

  it("throws when customer_id is missing", async () => {
    await pbMock.collection("companies").create({ id: "comp-1" });

    await expect(
      createOrder({
        customer_id: "",
        company_id: "comp-1",
        items: [{ description: "x" }],
      }),
    ).rejects.toThrow(/customer_id and company_id are required/);
  });
});

// ----------------------------------------------------------------------------
// createOrder email_message_id dedup pre-check.
//
// The n8n email-intake pipeline can pick up the same IMAP message multiple
// times if the seen-flag races the workflow execution. Without this
// dedup check, every poll cycle creates a brand new `orders` row.
// `createOrder` (the service layer) is the line of defense for the
// agent-API / counter / quote pipeline; the n8n workflow has its own
// parallel check at the workflow layer.
//
// See docs/audit/order-pipeline-investigation-2026-08-20.md §2.
// ----------------------------------------------------------------------------

describe("createOrder — email_message_id dedup", () => {
  it("returns the existing order when an email_message_id already exists, and marks duplicate=true", async () => {
    await pbMock.collection("customers").create({ id: "cust-d1" });
    await pbMock.collection("companies").create({ id: "comp-d1" });

    // Seed an existing order with the same email_message_id — this is
    // what would happen if the n8n pipeline already created one and
    // the next poll cycle is asking for the same write.
    await pbMock.collection("orders").create({
      id: "order-existing",
      order_number: "ZA10PO26002142",
      company: "comp-d1",
      customer: "cust-d1",
      email_message_id: "<DUPLICATE-MSG-ID@eurprd05.prod.outlook.com>",
      contact_name: "Neville Benadé",
    });

    const result = await createOrder({
      customer_id: "cust-d1",
      company_id: "comp-d1",
      contact_name: "Nbenade", // a different LLM-extracted name — irrelevant, we should NOT overwrite
      email_message_id: "<DUPLICATE-MSG-ID@eurprd05.prod.outlook.com>",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    // Same record came back, no new order created.
    expect(result.duplicate).toBe(true);
    expect(result.order.id).toBe("order-existing");
    expect(result.order.order_number).toBe("ZA10PO26002142");
    expect(result.order.contact_name).toBe("Neville Benadé");
    expect(result.items_created).toEqual([]);
    expect(result.items_failed).toEqual([]);

    // The store should still have exactly one record keyed by this id.
    const orders = await pbMock.collection("orders").getFullList();
    expect(orders.filter((o) => o.email_message_id === "<DUPLICATE-MSG-ID@eurprd05.prod.outlook.com>")).toHaveLength(1);
  });

  it("creates a brand-new order when email_message_id is unique", async () => {
    await pbMock.collection("customers").create({ id: "cust-d2" });
    await pbMock.collection("companies").create({ id: "comp-d2" });

    const result = await createOrder({
      customer_id: "cust-d2",
      company_id: "comp-d2",
      contact_name: "Mr Fresh",
      email_message_id: "<FRESH-MSG-ID@eurprd05.prod.outlook.com>",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(result.duplicate).toBeUndefined();
    expect(result.order.id).toBeDefined();
    expect(result.order.email_message_id).toBe("<FRESH-MSG-ID@eurprd05.prod.outlook.com>");
    expect(result.items_created.length).toBe(1);
  });

  it("skips the dedup check entirely when email_message_id is empty string", async () => {
    await pbMock.collection("customers").create({ id: "cust-d3" });
    await pbMock.collection("companies").create({ id: "comp-d3" });

    const first = await createOrder({
      customer_id: "cust-d3",
      company_id: "comp-d3",
      email_message_id: "",
      items: [{ description: "Counter sale item" }],
    });

    // Counter-form orders don't carry an email_message_id — we never
    // dedup them, so two should be creatable.
    const second = await createOrder({
      customer_id: "cust-d3",
      company_id: "comp-d3",
      email_message_id: "",
      items: [{ description: "Another counter sale" }],
    });

    expect(first.duplicate).toBeUndefined();
    expect(second.duplicate).toBeUndefined();
    expect(first.order.id).not.toBe(second.order.id);
  });

  it("skips the dedup check when email_message_id is undefined", async () => {
    await pbMock.collection("customers").create({ id: "cust-d4" });
    await pbMock.collection("companies").create({ id: "comp-d4" });

    const result = await createOrder({
      customer_id: "cust-d4",
      company_id: "comp-d4",
      // email_message_id omitted entirely
      items: [{ description: "Walk-in" }],
    });

    expect(result.duplicate).toBeUndefined();
    expect(result.order.id).toBeDefined();
  });

  it("trims whitespace before the dedup lookup", async () => {
    await pbMock.collection("customers").create({ id: "cust-d5" });
    await pbMock.collection("companies").create({ id: "comp-d5" });

    await pbMock.collection("orders").create({
      id: "order-padded",
      order_number: "ZA10PO26002142",
      company: "comp-d5",
      customer: "cust-d5",
      email_message_id: "<PADDED@x.com>",
    });

    // Caller passes the same id with surrounding whitespace — should
    // still hit the dedup path.
    const result = await createOrder({
      customer_id: "cust-d5",
      company_id: "comp-d5",
      email_message_id: "  <PADDED@x.com>\n",
      items: [{ description: "x" }],
    });

    expect(result.duplicate).toBe(true);
    expect(result.order.id).toBe("order-padded");
  });

  it("returns the existing record when the DB-level UNIQUE constraint rejects the insert (race)", async () => {
    await pbMock.collection("customers").create({ id: "cust-d6" });
    await pbMock.collection("companies").create({ id: "comp-d6" });

    // Race scenario: the pre-check finds NO existing record (no
    // contention yet), but by the time we INSERT, another worker
    // has already created the row (parallel n8n execution, or a
    // manual /api/v1/orders/create call). The DB rejects our insert
    // with a unique-constraint error. The catch block in createOrder
    // re-queries by email_message_id, finds the existing record, and
    // returns it as duplicate.
    //
    // The mock's `collection(name)` returns a fresh object every call,
    // so we wrap `pbMock.collection` itself to cache the per-collection
    // objects — that way monkey-patching `ordersColl.create` actually
    // affects the object createOrder will see.
    const collectionCache = new Map<string, ReturnType<typeof pbMock.collection>>();
    const originalCollection = pbMock.collection;
    pbMock.collection = ((name: string) => {
      if (!collectionCache.has(name)) {
        collectionCache.set(name, originalCollection(name));
      }
      return collectionCache.get(name)!;
    }) as typeof pbMock.collection;

    const ordersColl = pbMock.collection("orders") as unknown as { create: (data: Record<string, unknown>) => Promise<Record<string, unknown>> };
    const originalCreate = ordersColl.create;
    let insertAttempts = 0;
    ordersColl.create = async (data: Record<string, unknown>) => {
      insertAttempts++;
      if (insertAttempts === 1) {
        // First attempt: the DB-level UNIQUE constraint rejects us
        // because another worker already inserted the same
        // email_message_id. Before throwing, insert the "raced"
        // record so the catch block's lookup can find it.
        const err = new Error(
          "Failed to create record. UNIQUE constraint failed: index idx_orders_email_message_id",
        ) as Error & { status: number };
        err.status = 409;
        await originalCreate({
          id: "order-race",
          order_number: "RACE-1",
          company: "comp-d6",
          customer: "cust-d6",
          email_message_id: "<RACE@x.com>",
          ...data,
        });
        throw err;
      }
      return originalCreate(data);
    };

    try {
      const result = await createOrder({
        customer_id: "cust-d6",
        company_id: "comp-d6",
        email_message_id: "<RACE@x.com>",
        items: [{ description: "x" }],
      });

      expect(result.duplicate).toBe(true);
      expect(result.order.id).toBe("order-race");
      expect(insertAttempts).toBe(1); // we did try to insert; the catch caught the unique violation
    } finally {
      ordersColl.create = originalCreate;
      pbMock.collection = originalCollection;
    }
  });
});


// ----------------------------------------------------------------------------
// Order split — splitOrderForContinuation. Caller passes the item IDs they
// want moved; unlisted items stay on the parent.
// ----------------------------------------------------------------------------

describe("splitOrderForContinuation", () => {
  it("moves pending items to a new continuation order and stamps breadcrumbs", async () => {
    // Seed: a parent order with three pending items.
    await pbMock.collection("orders").create({
      id: "ord-1",
      order_number: "ORD-2026-08-001",
      company: "comp-1",
      customer: "cust-1",
      quote: "q-1",
      notes: "Original notes",
      rep: "Alice",
      contact_name: "Mr Buyer",
      quote_reference_text: "RFQ-123",
      rfq_number: "RFQ-123",
    });
    for (let i = 0; i < 3; i++) {
      await pbMock.collection("order_items").create({
        id: `oi-${i + 1}`,
        order: "ord-1",
        description: `Item ${i + 1}`,
        quantity: 1,
        order_qty: 1,
        item_status: "pending",
        drv_status: "unassigned",
        status: "active",
        selling_price: 10,
        cost_price: 5,
        markup: 50,
        markup_percent: 50,
        sku: `SKU-${i + 1}`,
        unit: "EA",
        notes: "",
        quote_item: `qi-${i + 1}`,
      });
    }

    const result = await splitOrderForContinuation("ord-1", ["oi-1", "oi-2"]);

    // Continuation order exists, inherited the parent's identity fields.
    expect(result.continuation.id).toBeDefined();
    expect(result.continuation.id).not.toBe("ord-1");
    expect(result.continuation.company).toBe("comp-1");
    expect(result.continuation.customer).toBe("cust-1");
    expect(result.continuation.quote).toBe("q-1");
    expect(result.continuation.rep).toBe("Alice");
    expect(result.continuation.contact_name).toBe("Mr Buyer");
    expect(result.continuation.quote_reference_text).toBe("RFQ-123");
    expect(result.continuation.rfq_number).toBe("RFQ-123");
    // Notes get the breadcrumb appended.
    expect(result.continuation.notes).toMatch(/Original notes/);
    expect(result.continuation.notes).toMatch(/Split from ORD-2026-08-001/);

    // Two items moved, one kept.
    expect(result.itemsMoved).toBe(2);
    expect(result.itemsKept).toBe(1);
    expect(result.itemsFailed).toEqual([]);

    // Original items still belong to the parent (order relation unchanged).
    const allItems = await pbMock.collection("order_items").getFullList();
    const onParent = allItems.filter((it) => it.order === "ord-1");
    expect(onParent.length).toBe(3);
    // Moved items have the breadcrumb in their notes.
    const movedO1 = onParent.find((it) => it.id === "oi-1");
    const movedO2 = onParent.find((it) => it.id === "oi-2");
    expect(movedO1?.notes).toMatch(/Moved to ORD-/);
    expect(movedO2?.notes).toMatch(/Moved to ORD-/);
    expect(movedO1?.notes).toMatch(/via order split on /);
    // Unmoved item has no breadcrumb.
    const keptO3 = onParent.find((it) => it.id === "oi-3");
    expect(keptO3?.notes ?? "").not.toMatch(/Moved to/);

    // New order gets two clones with the original fields preserved
    // and workflow flags reset to defaults.
    const onContinuation = allItems.filter((it) => it.order === result.continuation.id);
    expect(onContinuation.length).toBe(2);
    for (const clone of onContinuation) {
      expect(clone.item_status).toBe("pending");
      expect(clone.drv_status).toBe("unassigned");
      expect(clone.status).toBe("active");
      expect(clone.quote_item).toMatch(/^qi-/);
    }
  });

  it("refuses to move items in non-pending statuses, reporting them per-item", async () => {
    await pbMock.collection("orders").create({
      id: "ord-2",
      order_number: "ORD-2026-08-002",
      company: "comp-1",
      customer: "cust-1",
      quote: "",
      notes: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-pending",
      order: "ord-2",
      description: "Pending",
      item_status: "pending",
      quantity: 1,
    });
    await pbMock.collection("order_items").create({
      id: "oi-po",
      order: "ord-2",
      description: "PO generated",
      item_status: "po_generated",
      quantity: 1,
    });
    await pbMock.collection("order_items").create({
      id: "oi-delivered",
      order: "ord-2",
      description: "Delivered",
      item_status: "delivered",
      quantity: 1,
    });

    const result = await splitOrderForContinuation("ord-2", [
      "oi-pending",
      "oi-po",
      "oi-delivered",
    ]);

    // Only the pending one moves. The other two are reported in itemsFailed
    // with their original status names in the message.
    expect(result.itemsMoved).toBe(1);
    expect(result.itemsFailed.length).toBe(2);
    expect(result.itemsFailed.find((f) => f.id === "oi-po")).toMatchObject({
      id: "oi-po",
    });
    expect(result.itemsFailed.find((f) => f.id === "oi-delivered")?.error).toMatch(
      /delivered/,
    );

    // The continuation order still exists even with partial moves.
    expect(result.continuation.id).toBeDefined();
    const allItems = await pbMock.collection("order_items").getFullList();
    expect(allItems.filter((it) => it.order === result.continuation.id).length).toBe(1);
    // The refused items are untouched on the parent (no notes breadcrumb).
    expect(allItems.find((it) => it.id === "oi-po")?.notes ?? "").not.toMatch(/Moved to/);
  });

  it("reports items that do not belong to the parent order", async () => {
    await pbMock.collection("orders").create({
      id: "ord-3",
      order_number: "ORD-2026-08-003",
      company: "comp-1",
      customer: "cust-1",
      notes: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-on-ord-3",
      order: "ord-3",
      description: "Belongs",
      item_status: "pending",
      quantity: 1,
    });
    await pbMock.collection("orders").create({
      id: "ord-other",
      order_number: "ORD-2026-08-099",
      company: "comp-1",
      customer: "cust-1",
      notes: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-other-order",
      order: "ord-other",
      description: "Foreign",
      item_status: "pending",
      quantity: 1,
    });

    const result = await splitOrderForContinuation("ord-3", [
      "oi-on-ord-3",
      "oi-other-order",
      "oi-doesnt-exist",
    ]);

    expect(result.itemsMoved).toBe(1);
    expect(result.itemsFailed.length).toBe(2);
    expect(result.itemsFailed.find((f) => f.id === "oi-other-order")?.error).toMatch(
      /does not belong to order ord-3/,
    );
    expect(result.itemsFailed.find((f) => f.id === "oi-doesnt-exist")?.error).toMatch(
      /does not belong to order ord-3/,
    );
  });

  it("throws when the parent order does not exist", async () => {
    await expect(
      splitOrderForContinuation("ghost-order", ["oi-1"]),
    ).rejects.toThrow(/Order not found/);
  });

  it("throws when itemIds is empty", async () => {
    await pbMock.collection("orders").create({
      id: "ord-4",
      order_number: "ORD-2026-08-004",
      company: "comp-1",
      customer: "cust-1",
      notes: "",
    });
    await expect(splitOrderForContinuation("ord-4", [])).rejects.toThrow(
      /itemIds must be a non-empty array/,
    );
  });
});

// ----------------------------------------------------------------------------
// /orders dashboard read model — tab filter, counts cache, rep lookup.
//
// These tests cover the bug surface fixed in 2026-07: the old
// `getOrdersDashboardData` returned the global orders pagination
// (Page 1 of 226, 4520 total orders) regardless of which tab the
// operator selected, so "Processing (4)" badges showed empty pages
// when the four matching orders happened to fall on later pages.
// ----------------------------------------------------------------------------

describe("getOrderIdsForTabGroup", () => {
  it("returns the distinct order ids with at least one item in the tab group", async () => {
    // Three orders, each with one item. Statuses cover "new",
    // "processing", and "delivered" tabs so we can verify partition
    // membership.
    await pbMock.collection("orders").create({
      id: "o-new",
      order_number: "ORD-2025-01-001",
      quote: "q1",
    });
    await pbMock.collection("orders").create({
      id: "o-processing",
      order_number: "ORD-2025-01-002",
      quote: "q2",
    });
    await pbMock.collection("orders").create({
      id: "o-delivered",
      order_number: "ORD-2025-01-003",
      quote: "q3",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-new", description: "Widget",
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-processing", description: "Sprocket",
      item_status: "processed",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o-delivered", description: "Gear",
      item_status: "delivered",
    });

    const processingIds = await getOrderIdsForTabGroup(pbMock as never, "processing");
    expect(processingIds.sort()).toEqual(["o-processing"]);

    const newIds = await getOrderIdsForTabGroup(pbMock as never, "new");
    expect(newIds.sort()).toEqual(["o-new"]);

    const deliveredIds = await getOrderIdsForTabGroup(pbMock as never, "delivered");
    expect(deliveredIds.sort()).toEqual(["o-delivered"]);
  });

  it("dedupes when an order has multiple items in the same tab", async () => {
    await pbMock.collection("orders").create({
      id: "o-multi",
      order_number: "ORD-2025-01-010",
      quote: "q",
    });
    await pbMock.collection("order_items").create({
      id: "oi-a", order: "o-multi", description: "A",
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-b", order: "o-multi", description: "B",
      item_status: "pending",
    });

    const ids = await getOrderIdsForTabGroup(pbMock as never, "new");
    expect(ids).toEqual(["o-multi"]);
  });
});

describe("getOrderItemStatusTabCounts", () => {
  beforeEach(() => clearOrderItemStatusTabCountsCache());

  it("returns the count of distinct orders per tab", async () => {
    await pbMock.collection("orders").create({
      id: "o-a", order_number: "ORD-2025-01-001", quote: "qa",
    });
    await pbMock.collection("orders").create({
      id: "o-b", order_number: "ORD-2025-01-002", quote: "qb",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-a", description: "x", item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-a", description: "y", item_status: "processed",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o-b", description: "z", item_status: "pending",
    });

    const counts = await getOrderItemStatusTabCounts(pbMock as never);
    expect(counts.new).toBe(2);
    expect(counts.processing).toBe(1);
  });

  it("bypasses the cache when bypassCache is true", async () => {
    await pbMock.collection("orders").create({
      id: "o-cache", order_number: "ORD-2025-01-001", quote: "qc",
    });
    await pbMock.collection("order_items").create({
      id: "oi-cache", order: "o-cache", description: "x", item_status: "pending",
    });

    const first = await getOrderItemStatusTabCounts(pbMock as never);
    expect(first.new).toBe(1);

    // Mutate the underlying store directly — bypasses our normal
    // service writes, but lets us verify the cache is being served
    // if `bypassCache` is not set.
    await pbMock.collection("orders").create({
      id: "o-cache-2", order_number: "ORD-2025-01-002", quote: "qc2",
    });
    await pbMock.collection("order_items").create({
      id: "oi-cache-2", order: "o-cache-2", description: "x", item_status: "pending",
    });

    const cached = await getOrderItemStatusTabCounts(pbMock as never);
    expect(cached.new).toBe(1); // unchanged — cache hit

    const fresh = await getOrderItemStatusTabCounts(pbMock as never, { bypassCache: true });
    expect(fresh.new).toBe(2); // refresh sees the new order
  });

  it("clearOrderItemStatusTabCountsCache forces a fresh read", async () => {
    await pbMock.collection("orders").create({
      id: "o-clear", order_number: "ORD-2025-01-001", quote: "qclr",
    });
    await pbMock.collection("order_items").create({
      id: "oi-clear", order: "o-clear", description: "x", item_status: "pending",
    });

    await getOrderItemStatusTabCounts(pbMock as never); // prime the cache
    clearOrderItemStatusTabCountsCache();
    const fresh = await getOrderItemStatusTabCounts(pbMock as never);
    expect(fresh.new).toBe(1);
  });

  it("fires two combined getFullList calls (combined tab scan + completed time-window scan)", async () => {
    // Regression guard: the pre-`completed`-tab implementation issued
    // 6 parallel `getFullList` calls (one per tab), each with a
    // separate filter scan. With ~18k rows in `order_items` and no
    // `item_status` index, those 6 scans dominated the page-load
    // budget. The current implementation collapses to:
    //   (a) ONE combined scan covering every tab status, used to
    //       bucket the partition's "primary" tab counts, plus
    //   (b) ONE time-windowed scan for the `completed` tab (recent
    //       `delivered` + `completed` items only).
    // Total = 2 scans — still O(1) on the number of tabs, and each
    // scan is fields-only so the wire payload stays tiny. This test
    // intercepts the mock's `collection()` to count how many times
    // `getFullList` is called on the `order_items` collection.
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o1", description: "x", item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o2", description: "x", item_status: "processed",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o3", description: "x", item_status: "delivered",
    });

    const originalCollection = pbMock.collection;
    let getFullListCalls = 0;
    pbMock.collection = ((name: string) => {
      const proxy = originalCollection(name);
      if (name === "order_items") {
        const originalGetFullList = proxy.getFullList;
        proxy.getFullList = ((...args: unknown[]) => {
          getFullListCalls++;
          return (originalGetFullList as (...a: unknown[]) => unknown).call(
            proxy,
            ...args,
          );
        }) as typeof proxy.getFullList;
      }
      return proxy;
    }) as typeof pbMock.collection;

    try {
      await getOrderItemStatusTabCounts(pbMock as never, { bypassCache: true });
      expect(getFullListCalls).toBe(2);
    } finally {
      pbMock.collection = originalCollection;
    }
  });

  it("can skip archive tabs for the main orders page", async () => {
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o1", description: "x", item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o2", description: "x", item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o3", description: "x", item_status: "cancelled",
    });

    const counts = await getOrderItemStatusTabCounts(pbMock as never, {
      bypassCache: true,
      includeArchivedTabs: false,
    });

    expect(counts.new).toBe(1);
    expect(counts.delivered).toBe(0);
    expect(counts.cancelled).toBe(0);
  });
});

describe("listOrdersWithItems — tab filter", () => {
  it("returns only orders that have at least one item in the requested tab", async () => {
    // Two orders: one with a "pending" item, one with a "processed"
    // item. Filtered to "processing" should yield only the second.
    await pbMock.collection("orders").create({
      id: "o-pending", order_number: "ORD-2025-01-001", quote: "qp",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("orders").create({
      id: "o-processed", order_number: "ORD-2025-01-002", quote: "qpr",
      created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-pending", order: "o-pending", description: "Widget",
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-processed", order: "o-processed", description: "Sprocket",
      item_status: "processed",
    });

    const result = await listOrdersWithItems({
      page: 1,
      perPage: 20,
      tabGroup: "processing",
    });

    expect(result.items.map((i) => i.order.id)).toEqual(["o-processed"]);
    expect(result.totalItems).toBe(1);
    expect(result.totalPages).toBe(1);
  });

  it("returns an empty list with totalPages=0 when no orders match the tab", async () => {
    await pbMock.collection("orders").create({
      id: "o-only-new", order_number: "ORD-2025-01-001", quote: "qn",
    });
    await pbMock.collection("order_items").create({
      id: "oi-only-new", order: "o-only-new", description: "x",
      item_status: "pending",
    });

    const result = await listOrdersWithItems({
      page: 1,
      perPage: 20,
      tabGroup: "cancelled",
    });
    expect(result.items).toEqual([]);
    expect(result.totalItems).toBe(0);
  });

  it("reports totalItems from the matching set, not the page slice (pagination honesty)", async () => {
    // Five orders with processed items, perPage=2. The page-1 response
    // should have 2 items but totalItems=5 / totalPages=3 so the
    // footer says "Page 1 of 3" — matching the operator's mental
    // model of how many orders the tab actually contains.
    for (let i = 0; i < 5; i++) {
      await pbMock.collection("orders").create({
        id: `o-${i}`,
        order_number: `ORD-2025-01-00${i + 1}`,
        quote: `q-${i}`,
        created: `2025-01-0${i + 1}T00:00:00Z`,
      });
      await pbMock.collection("order_items").create({
        id: `oi-${i}`,
        order: `o-${i}`,
        description: "x",
        item_status: "processed",
      });
    }

    const result = await listOrdersWithItems({
      page: 1,
      perPage: 2,
      tabGroup: "processing",
    });
    expect(result.items.length).toBe(2);
    expect(result.totalItems).toBe(5);
    expect(result.totalPages).toBe(3);
  });

  it("falls back to all-orders pagination when no tab is supplied", async () => {
    // Sanity check — the existing all-orders path is unchanged. PB's
    // `getList(page, perPage, { sort })` returns a paginated slice;
    // the test mock mirrors that with `totalItems = items.length`,
    // so totalPages = 1 here regardless of the underlying set size.
    await pbMock.collection("orders").create({
      id: "o-a", order_number: "ORD-2025-01-001", quote: "qa",
    });
    await pbMock.collection("orders").create({
      id: "o-b", order_number: "ORD-2025-01-002", quote: "qb",
    });

    const result = await listOrdersWithItems({
      page: 1,
      perPage: 20,
    });
    expect(result.items.length).toBe(2);
  });

  it("does not pass a `fields` parameter on the orders list (PB 0.26 breaks expand when fields is set)", async () => {
    // Regression guard: earlier I tried to limit the wire payload
    // by passing a `fields` list with per-expand syntax. PB 0.26
    // treats `fields` as a hard allowlist of MAIN record columns,
    // and the moment you set it the `expand` payload is dropped
    // from the response — so customer/company/rep/quote names
    // vanish from every order card. The orders list deliberately
    // omits `fields`; this test pins that behaviour so a future
    // "let's slim the payload" change doesn't reintroduce the bug.
    let capturedFields: string | undefined;
    let capturedExpand: string | undefined;
    const originalCollection = pbMock.collection;
    pbMock.collection = ((name: string) => {
      const proxy = originalCollection(name);
      if (name === "orders") {
        const originalGetList = proxy.getList;
        proxy.getList = ((page: number, perPage: number, opts: { filter?: string; sort?: string; fields?: string; expand?: string }) => {
          capturedFields = opts?.fields;
          capturedExpand = opts?.expand;
          return (originalGetList as (...a: unknown[]) => unknown).call(
            proxy,
            page,
            perPage,
            opts,
          );
        }) as typeof proxy.getList;
      }
      return proxy;
    }) as typeof pbMock.collection;

    try {
      await listOrdersWithItems({ page: 1, perPage: 20 });

      // `fields` must NOT be sent — PB 0.26 drops the expand payload
      // when it sees it.
      expect(capturedFields).toBeUndefined();
      // Expand IS sent, and includes the four relations the list view
      // reads (company, customer, customer.rep, quote). Importantly
      // it does NOT include `potential_quote` — the list view only
      // checks the field's existence, never the expanded record.
      expect(capturedExpand).toContain("company");
      expect(capturedExpand).toContain("customer");
      expect(capturedExpand).toContain("customer.rep");
      expect(capturedExpand).toContain("quote");
      expect(capturedExpand).not.toContain("potential_quote");
    } finally {
      pbMock.collection = originalCollection;
    }
  });
});

describe("listOrdersWithItems — search scope + per-tab match counts", () => {
  /**
   * Seed one order per active tab, all sharing the token "widget" in
   * their item description, plus a delivered (archived) order that also
   * matches. Lets each test assert both cross-tab counting and the
   * archive exclusion.
   */
  async function seedCrossTabMatches() {
    const rows: [string, string, string][] = [
      ["o-new", "pending", "2025-01-01T00:00:00Z"],
      ["o-proc", "processed", "2025-01-02T00:00:00Z"],
      ["o-pool", "collection_pool", "2025-01-03T00:00:00Z"],
      ["o-coll", "collected", "2025-01-04T00:00:00Z"],
      ["o-archived", "delivered", "2025-01-05T00:00:00Z"],
    ];
    for (const [id, status, created] of rows) {
      await pbMock.collection("orders").create({
        id,
        order_number: `ORD-${id}`,
        quote: `q-${id}`,
        created,
      });
      await pbMock.collection("order_items").create({
        id: `oi-${id}`,
        order: id,
        description: "Widget assembly",
        item_status: status,
      });
    }
  }

  it("counts matches across every active tab, not just the active one", async () => {
    await seedCrossTabMatches();

    // Operator is standing on "new" — but the hits in processing,
    // collection_pool and collected must still be counted so the tab
    // strip can point at them. This is the core of "show me where it is".
    const result = await listOrdersWithItems({
      page: 1,
      perPage: 20,
      search: "widget",
      tabGroup: "new",
    });

    expect(result.searchCounts).toMatchObject({
      new: 1,
      processing: 1,
      collection_pool: 1,
      collected: 1,
    });
    // ...while the visible list is still narrowed to the active tab.
    expect(result.items.map((i) => i.order.id)).toEqual(["o-new"]);
  });

  it("excludes archived (delivered/cancelled) orders from search", async () => {
    await seedCrossTabMatches();

    const result = await listOrdersWithItems({
      page: 1,
      perPage: 20,
      search: "widget",
    });

    // "o-archived" matches the text but is delivered-only, so it is out
    // of scope — it belongs to /orders/archive.
    expect(result.items.map((i) => i.order.id)).not.toContain("o-archived");
    expect(result.searchCounts?.delivered ?? 0).toBe(0);
  });

  it("is unaffected by sort direction (regression: the 500-cap coupling)", async () => {
    // The old implementation fetched the first 500 orders BY SORT and
    // filtered those, so an ascending sort would hide newer matches.
    // Search now scopes by active-order id, so both directions agree.
    await seedCrossTabMatches();

    const ascending = await listOrdersWithItems({
      search: "widget",
      sort: "created",
    });
    const descending = await listOrdersWithItems({
      search: "widget",
      sort: "-created",
    });

    expect(ascending.items.map((i) => i.order.id).sort()).toEqual(
      descending.items.map((i) => i.order.id).sort(),
    );
    expect(ascending.searchCounts).toEqual(descending.searchCounts);
  });

  it("counts an order once per tab it has items in", async () => {
    // A single order straddling two tabs should appear in both counts —
    // the counts are 'distinct orders per tab', not a partition.
    await pbMock.collection("orders").create({
      id: "o-split", order_number: "ORD-split", quote: "q-split",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-split-a", order: "o-split", description: "Widget",
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-split-b", order: "o-split", description: "Widget",
      item_status: "processed",
    });

    const result = await listOrdersWithItems({ search: "widget" });
    expect(result.searchCounts).toMatchObject({ new: 1, processing: 1 });
  });

  it("omits searchCounts entirely when no search is active", async () => {
    await seedCrossTabMatches();
    const result = await listOrdersWithItems({ page: 1, perPage: 20 });
    expect(result.searchCounts).toBeUndefined();
  });
});

describe("listOrdersWithItems — tab taxonomy completeness", () => {
  /**
   * Regression guard. The `ItemStatus` union and `TAB_GROUP_ITEM_STATUSES`
   * must stay in lockstep — every status MUST be assigned to a tab,
   * because:
   *   1. Unmapped statuses are invisible to /orders (they fail the
   *      tab filter).
   *   2. They drop out of `TAB_STATUSES` and therefore out of the
   *      search candidate set built by `getActiveOrderIds`.
   *   3. They drop out of the tab counts query entirely.
   *
   * This caught the bug where 60 active items (ready_invoice,
   * invoiced, delivery_note, removed) were silently missing from
   * search and mis-bucketed as "new" — including order 4500704208
   * (ready_invoice, expected: Collected).
   */
  it("returns search hits whose item_status is mapped to a non-new tab", async () => {
    // ready_invoice should land on the Collected tab now. Previously
    // it was bucketed as "new" and excluded from the search candidate
    // set, so the order was unfindable.
    await pbMock.collection("orders").create({
      id: "o-inv",
      order_number: "ORD-invoice-ready",
      quote: "q-inv",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-inv",
      order: "o-inv",
      description: "Widget",
      item_status: "ready_invoice",
    });

    const result = await listOrdersWithItems({ search: "invoice" });

    expect(result.items.map((i) => i.order.id)).toEqual(["o-inv"]);
    expect(result.searchCounts).toMatchObject({ collected: 1 });
    expect(result.searchCounts?.new ?? 0).toBe(0);
  });

  it("counts every item_status in the live union across the active set", async () => {
    // Build one item per ItemStatus union member, confirm each one
    // surfaces in `getActiveOrderIds` (the search candidate set).
    const allStatuses = [
      "pending", "approval_needed", "approval_rejected",
      "processed", "po_generated",
      "collection_pool", "assigned", "ready_delivery",
      "collected", "stock_verified", "picking",
      "delivered", "cancelled",
      "ready_invoice", "invoiced",
      "stock_booked", "with_driver", "checked_in", "completed",
      "removed", "delivery_note",
    ];
    for (const s of allStatuses) {
      await pbMock.collection("orders").create({
        id: `o-${s}`,
        order_number: `ORD-${s}`,
        quote: `q-${s}`,
      });
      await pbMock.collection("order_items").create({
        id: `oi-${s}-${allStatuses.indexOf(s)}`,
        order: `o-${s}`,
        description: "x",
        item_status: s,
      });
    }
    // If this fails, an ItemStatus union member has been added to
    // src/lib/types.ts without a matching TAB_GROUP_ITEM_STATUSES entry
    // in src/lib/item-status-ui.ts — and that item is invisible to
    // /orders search and counts.
    const result = await listOrdersWithItems({
      search: "ORD-",
    });
    const foundIds = new Set(result.items.map(i => i.order.id));
    // Every active-tab status should appear; delivered and cancelled
    // remain excluded by design (they live on /orders/archive).
    const active = allStatuses.filter(s => s !== "delivered" && s !== "cancelled");
    for (const s of active) {
      expect(foundIds, `item_status "${s}" should be in search results`).toContain(`o-${s}`);
    }
  });
});

describe("getOrdersDashboardData — search counts replace global counts", () => {
  it("promotes per-tab match counts over the global tab counts while searching", async () => {
    await pbMock.collection("orders").create({
      id: "o-hit", order_number: "ORD-hit", quote: "q-hit",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-hit", order: "o-hit", description: "Unobtainium",
      item_status: "processed",
    });
    // A second order that must NOT contribute to the badges during a
    // search for "unobtainium".
    await pbMock.collection("orders").create({
      id: "o-miss", order_number: "ORD-miss", quote: "q-miss",
      created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-miss", order: "o-miss", description: "Something else",
      item_status: "processed",
    });

    const searched = await getOrdersDashboardData({
      search: "unobtainium",
      includeArchivedCounts: false,
      bypassCountsCache: true,
    });
    // Badge shows 1 match in processing, not the global 2 orders.
    expect(searched.counts.processing).toBe(1);

    const browsing = await getOrdersDashboardData({
      includeArchivedCounts: false,
      bypassCountsCache: true,
    });
    expect(browsing.counts.processing).toBe(2);
  });
});

describe("getOrdersDashboardData — end-to-end", () => {
  beforeEach(() => clearOrderItemStatusTabCountsCache());

  it("returns tab-scoped counts and items in a single response", async () => {
    // Three orders: a pending one (new tab), a processed one
    // (processing tab), and a delivered one.
    await pbMock.collection("orders").create({
      id: "o-p", order_number: "ORD-2025-01-001", quote: "qp",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("orders").create({
      id: "o-pr", order_number: "ORD-2025-01-002", quote: "qpr",
      created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("orders").create({
      id: "o-d", order_number: "ORD-2025-01-003", quote: "qd",
      created: "2025-01-03T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-p", order: "o-p", description: "Widget",
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-pr", order: "o-pr", description: "Sprocket",
      item_status: "processed",
    });
    await pbMock.collection("order_items").create({
      id: "oi-d", order: "o-d", description: "Gear",
      item_status: "delivered",
      // The completed tab requires a recent `delivered_at` (last 30
      // days) — see `completedTabFilter`. The fixture here uses
      // `now` so the row qualifies regardless of when the test runs.
      delivered_at: new Date().toISOString(),
    });

    const result = await getOrdersDashboardData({
      page: 1,
      perPage: 20,
      tabGroup: "processing",
    });

    // Counts are global (always were) — the badge still tells the truth.
    // `delivered` items now bucket into the `completed` tab (the
    // partition lists `completed` before `delivered` in TAB_GROUP_ORDER
    // so the time-windowed slice wins as the "primary" tab). The
    // archive page reads its own delivered count from
    // `getOrdersArchiveData` rather than this map.
    expect(result.counts.new).toBe(1);
    expect(result.counts.processing).toBe(1);
    expect(result.counts.completed).toBe(1);
    expect(result.counts.delivered).toBe(0);

    // Items are scoped to the active tab.
    expect(result.items.map((i) => i.order.id)).toEqual(["o-pr"]);
    expect(result.totalPages).toBe(1);
    expect(result.totalItems).toBe(1);
  });

  it("can omit archive counts for the main orders page", async () => {
    await pbMock.collection("orders").create({
      id: "o-p", order_number: "ORD-2025-01-001", quote: "qp",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("orders").create({
      id: "o-d", order_number: "ORD-2025-01-002", quote: "qd",
      created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-p", order: "o-p", description: "Widget",
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-d", order: "o-d", description: "Gear",
      item_status: "delivered",
    });

    const result = await getOrdersDashboardData({
      page: 1,
      perPage: 20,
      tabGroup: "new",
      includeArchivedCounts: false,
    });

    expect(result.counts.new).toBe(1);
    expect(result.counts.delivered).toBe(0);
    expect(result.counts.cancelled).toBe(0);
  });
});

// ----------------------------------------------------------------------------
// Orders archive — read model for /orders/archive.
//
// The archive is the home for orders with at least one item in
// (delivered, cancelled) status. On the live PB that holds ~99% of
// all orders, so it gets its own paginated page rather than living
// as a tab on the main orders view. These tests pin the contract.
// ----------------------------------------------------------------------------

describe("getOrdersArchiveData", () => {
  function makeOrdersArchivePb(options: { failOnArchiveItemScan?: boolean } = {}) {
    const listRecords = (name: string) =>
      Array.from((store[name] || new Map()).values()) as Array<Record<string, unknown>>;

    const matchesArchiveFilter = (
      order: Record<string, unknown>,
      filter: string,
    ) => {
      const orderItems = listRecords("order_items").filter(
        (item) => String(item.order ?? "") === String(order.id ?? ""),
      );
      const hasDelivered = orderItems.some((item) => item.item_status === "delivered");
      const hasCancelled = orderItems.some((item) => item.item_status === "cancelled");
      const wantsDelivered = filter.includes('order_items_via_order.item_status ?= "delivered"');
      const wantsCancelled = filter.includes('order_items_via_order.item_status ?= "cancelled"');
      if (wantsDelivered && wantsCancelled) return hasDelivered || hasCancelled;
      if (wantsDelivered) return hasDelivered;
      if (wantsCancelled) return hasCancelled;
      return true;
    };

    const matchesSearch = (order: Record<string, unknown>, filter: string) => {
      const orderNumberMatch = filter.match(/order_number ~ "([^"]+)"/);
      if (orderNumberMatch) {
        return String(order.order_number ?? "")
          .toLowerCase()
          .includes(orderNumberMatch[1].toLowerCase());
      }
      const contactMatch = filter.match(/contact_name ~ "([^"]+)"/);
      if (contactMatch) {
        return String(order.contact_name ?? "")
          .toLowerCase()
          .includes(contactMatch[1].toLowerCase());
      }
      return true;
    };

    return {
      autoCancellation: () => undefined,
      collection: (name: string) => {
        if (name === "orders") {
          return {
            async getList(
              page = 1,
              perPage = 25,
              opts: { filter?: string; sort?: string; expand?: string } = {},
            ) {
              let items = listRecords("orders").filter((order) =>
                matchesArchiveFilter(order, opts.filter || "") &&
                matchesSearch(order, opts.filter || ""),
              );
              if (opts.sort === "-created") {
                items = items.sort((a, b) =>
                  String(b.created ?? "").localeCompare(String(a.created ?? "")),
                );
              }
              const totalItems = items.length;
              const totalPages = Math.max(1, Math.ceil(totalItems / perPage));
              const start = (page - 1) * perPage;
              return {
                items: items.slice(start, start + perPage),
                totalItems,
                totalPages,
                page,
                perPage,
              };
            },
            getFullList: pbMock.collection("orders").getFullList,
          };
        }
        if (name === "order_items" && options.failOnArchiveItemScan) {
          return {
            async getFullList(opts: { filter?: string } = {}) {
              if (!(opts.filter || "").includes('order = "')) {
                throw new Error("unexpected full archive item scan");
              }
              return pbMock.collection("order_items").getFullList(opts);
            },
          };
        }
        return pbMock.collection(name);
      },
    };
  }

  it("returns orders with at least one delivered or cancelled item, plus header counts", async () => {
    // 2 delivered orders, 1 cancelled, 1 active (no delivered/cancelled).
    await pbMock.collection("orders").create({
      id: "o-d1", order_number: "ORD-2025-01-001", quote: "q1",
    });
    await pbMock.collection("orders").create({
      id: "o-d2", order_number: "ORD-2025-01-002", quote: "q2",
    });
    await pbMock.collection("orders").create({
      id: "o-c1", order_number: "ORD-2025-01-003", quote: "q3",
    });
    await pbMock.collection("orders").create({
      id: "o-active", order_number: "ORD-2025-01-004", quote: "q4",
    });

    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-d1", description: "x", item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-d2", description: "x", item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o-c1", description: "x", item_status: "cancelled",
    });
    await pbMock.collection("order_items").create({
      id: "oi-4", order: "o-active", description: "x", item_status: "pending",
    });

    const result = await getOrdersArchiveData(
      { page: 1, perPage: 20 },
      makeOrdersArchivePb() as never,
    );

    // 3 archived orders (the active one is excluded).
    expect(result.items.map((i) => i.order.id).sort()).toEqual([
      "o-c1",
      "o-d1",
      "o-d2",
    ]);
    expect(result.totalItems).toBe(3);
    // Header counts: distinct orders per status.
    expect(result.counts.delivered).toBe(2);
    expect(result.counts.cancelled).toBe(1);
  });

  it("dedupes orders that have multiple items in the matching statuses", async () => {
    // An order with two delivered items should still count as 1 order.
    await pbMock.collection("orders").create({
      id: "o-multi", order_number: "ORD-2025-01-001", quote: "q1",
    });
    await pbMock.collection("order_items").create({
      id: "oi-a", order: "o-multi", description: "A",
      item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-b", order: "o-multi", description: "B",
      item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-c", order: "o-multi", description: "C",
      item_status: "cancelled",
    });

    const result = await getOrdersArchiveData(
      { page: 1, perPage: 20 },
      makeOrdersArchivePb() as never,
    );
    expect(result.totalItems).toBe(1);
    expect(result.counts.delivered).toBe(1);
    expect(result.counts.cancelled).toBe(1);
  });

  it("filters archive results by search (order_number, company, customer, contact)", async () => {
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-2025-FINDME", quote: "q1",
      contact_name: "Specific Contact",
    });
    await pbMock.collection("orders").create({
      id: "o-2", order_number: "ORD-2025-OTHER", quote: "q2",
    });

    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-2", description: "x", item_status: "delivered",
    });

    // Search by order_number
    const byOrderNum = await getOrdersArchiveData(
      { page: 1, perPage: 20, search: "FINDME" },
      makeOrdersArchivePb() as never,
    );
    expect(byOrderNum.items.map((i) => i.order.id)).toEqual(["o-1"]);

    // Search by contact_name
    const byContact = await getOrdersArchiveData(
      { page: 1, perPage: 20, search: "specific" },
      makeOrdersArchivePb() as never,
    );
    expect(byContact.items.map((i) => i.order.id)).toEqual(["o-1"]);
  });

  it("returns an empty result when no orders have delivered/cancelled items", async () => {
    await pbMock.collection("orders").create({
      id: "o-active", order_number: "ORD-2025-01-001", quote: "q1",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-active", description: "x",
      item_status: "pending",
    });

    const result = await getOrdersArchiveData(
      { page: 1, perPage: 20 },
      makeOrdersArchivePb() as never,
    );
    expect(result.items).toEqual([]);
    expect(result.totalItems).toBe(0);
    expect(result.counts.delivered).toBe(0);
    expect(result.counts.cancelled).toBe(0);
  });

  it("loads the default archive page without scanning every order_item first", async () => {
    await pbMock.collection("orders").create({
      id: "o-d1", order_number: "ORD-2025-01-001", quote: "q1",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-d1", description: "x", item_status: "delivered",
    });

    const result = await getOrdersArchiveData(
      { page: 1, perPage: 20 },
      makeOrdersArchivePb({ failOnArchiveItemScan: true }) as never,
    );

    expect(result.items.map((i) => i.order.id)).toEqual(["o-d1"]);
    expect(result.counts.delivered).toBe(1);
  });
});

/* ============================================================================
 * cancelOrder / cancelOrdersBulk / findDuplicateOrders
 * ----------------------------------------------------------------------------
 * Smoke tests for the soft-cancel + duplicate-detection flow added on
 * 2026-08-12. Real PB verification lives in the live script in the
 * scratchpad directory; these tests pin the basic contract.
 * ========================================================================== */

describe("cancelOrder", () => {
  it("flips every in-flight item_status to 'cancelled'", async () => {
    await pbMock.collection("orders").create({
      id: "o-cancel", order_number: "ORD-cancel", quote: "qc",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-cancel", description: "a", item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-cancel", description: "b", item_status: "po_generated",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o-cancel", description: "c", item_status: "collected",
    });

    const result = await cancelOrder("o-cancel");

    expect(result.itemsCancelled).toBe(3);
    expect(result.itemsSkipped).toEqual([]);
    const after = await pbMock.collection("order_items").getFullList();
    expect(after.every((i) => i.item_status === "cancelled")).toBe(true);
  });

  it("refuses to cancel an order where every item is terminal", async () => {
    await pbMock.collection("orders").create({
      id: "o-shipped", order_number: "ORD-shipped", quote: "qs",
    });
    await pbMock.collection("order_items").create({
      id: "oi-d1", order: "o-shipped", description: "a", item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-d2", order: "o-shipped", description: "b", item_status: "delivered",
    });

    await expect(cancelOrder("o-shipped")).rejects.toThrow(/terminal state/);
  });

  it("partially cancels an order with mixed statuses, reporting the skipped ones", async () => {
    await pbMock.collection("orders").create({
      id: "o-mixed", order_number: "ORD-mixed", quote: "qm",
    });
    await pbMock.collection("order_items").create({
      id: "oi-m1", order: "o-mixed", description: "a", item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-m2", order: "o-mixed", description: "b", item_status: "delivered",
    });

    const result = await cancelOrder("o-mixed");

    expect(result.itemsCancelled).toBe(1);
    expect(result.itemsSkipped).toEqual([{ id: "oi-m2", item_status: "delivered" }]);
  });

  it("allowDelivered flag lets the bulk-cancel path skip the terminal guard", async () => {
    await pbMock.collection("orders").create({
      id: "o-bulk", order_number: "ORD-bulk", quote: "qb",
    });
    await pbMock.collection("order_items").create({
      id: "oi-b1", order: "o-bulk", description: "a", item_status: "delivered",
    });
    await pbMock.collection("order_items").create({
      id: "oi-b2", order: "o-bulk", description: "b", item_status: "pending",
    });

    const result = await cancelOrder("o-bulk", { allowDelivered: true });

    expect(result.itemsCancelled).toBe(2);
    expect(result.itemsSkipped).toEqual([]);
  });
});

describe("cancelOrdersBulk", () => {
  it("returns per-order success/failure", async () => {
    await pbMock.collection("orders").create({
      id: "o-ok", order_number: "ORD-ok", quote: "qk",
    });
    await pbMock.collection("order_items").create({
      id: "oi-ok", order: "o-ok", description: "x", item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-missing", order_number: "ORD-missing", quote: "qm",
    });
    // (no items — empty order, will succeed with 0 cancelled)

    const result = await cancelOrdersBulk(["o-ok", "o-missing", "o-doesnt-exist"]);

    expect(result.succeeded.map((r) => r.orderId).sort()).toEqual(["o-missing", "o-ok"]);
    expect(result.failed).toEqual([{ orderId: "o-doesnt-exist", error: expect.stringContaining("not found") }]);
  });
});

describe("findDuplicateOrders", () => {
  it("only returns groups with ≥2 active records (the ones visible on the order board)", async () => {
    // The 389020 pattern from live data: 4 records share the number,
    // but only 2 are "on the board" (have items in active status).
    // The other 2 are off the board — the operator never sees them
    // — so the duplicates endpoint should hide them. With the new
    // `completed` tab, *recent* `delivered` rows count as on the
    // board (they show up on the Completed tab), so we use a row
    // whose `delivered_at` is older than the 30-day window as the
    // "off the board" example.
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "Widget", item_status: "po_generated",
    });
    await pbMock.collection("orders").create({
      id: "o-2", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00.100Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-2", description: "Widget", item_status: "po_generated",
    });
    // Third copy — off the board. `delivered_at` is set years ago,
    // well outside the 30-day Completed window, so it falls through
    // to the archive and isn't visible to the operator.
    await pbMock.collection("orders").create({
      id: "o-3", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00.200Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-3", order: "o-3", description: "Widget", item_status: "delivered",
      delivered_at: "2024-01-01T00:00:00Z",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(1);
    expect(groups[0].records.map((r) => r.id).sort()).toEqual(["o-1", "o-2"]);
  });

  it("does not surface groups where only one record is active", async () => {
    // Two records share the number, but only one has items in active
    // status. The off-board copy is hidden, leaving only 1 record,
    // so the group doesn't qualify as a duplicate from the operator's
    // perspective.
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "Widget", item_status: "po_generated",
    });
    // Off-board copy: `delivered_at` set years ago, well outside the
    // 30-day Completed window — so it lives on /orders/archive and
    // the operator can't see it. (Naïvely setting `item_status =
    // delivered` without a stale `delivered_at` would now show up on
    // the Completed tab and count as on the board.)
    await pbMock.collection("orders").create({
      id: "o-2", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00.100Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-2", description: "Widget", item_status: "delivered",
      delivered_at: "2024-01-01T00:00:00Z",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(0);
  });

  it("does not surface singletons or orders with no active items", async () => {
    await pbMock.collection("orders").create({
      id: "o-solo", order_number: "SOLO", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    // Off-board: a delivered row whose `delivered_at` is well outside
    // the 30-day Completed window (so it lives only on
    // /orders/archive).
    await pbMock.collection("orders").create({
      id: "o-delivered", order_number: "ALSO-SOLO", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-d", order: "o-delivered", description: "Widget", item_status: "delivered",
      delivered_at: "2024-01-01T00:00:00Z",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(0);
  });

  it("enriches each active record with company, customer, and item statuses", async () => {
    await pbMock.collection("customers").create({ id: "c-x", customer: "Cust" });
    await pbMock.collection("companies").create({ id: "co-x", company: "Co" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "DUP", quote: "q",
      customer: "c-x", company: "co-x", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "M16x50 bolt", quantity: 400, item_status: "po_generated",
    });
    await pbMock.collection("orders").create({
      id: "o-2", order_number: "DUP", quote: "q",
      customer: "c-x", company: "co-x", created: "2025-01-01T00:00:00.100Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-2", description: "M16x50 bolt", quantity: 400, item_status: "invoiced",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(1);
    const r1 = groups[0].records.find((r) => r.id === "o-1")!;
    const r2 = groups[0].records.find((r) => r.id === "o-2")!;
    expect(r1.customerName).toBe("Cust");
    expect(r1.companyName).toBe("Co");
    expect(r1.itemStatusSummary).toEqual({ po_generated: 1 });
    // The invoiced copy shows the operator how far each got — the
    // "invoiced" one is the natural keeper.
    expect(r2.itemStatusSummary).toEqual({ invoiced: 1 });
  });

  it("sorts records by created asc so the oldest is first", async () => {
    await pbMock.collection("orders").create({
      id: "o-newer", order_number: "DUP", quote: "q",
      created: "2025-01-01T01:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-n", order: "o-newer", description: "x", item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-older", order_number: "DUP", quote: "q",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-o", order: "o-older", description: "x", item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    expect(groups[0].records.map((r) => r.id)).toEqual(["o-older", "o-newer"]);
  });

  it("returns groups sorted by size (largest first)", async () => {
    // Use distinct quantities per order_number so the cross-number
    // line-aggregate pass doesn't accidentally fire here — this test
    // is about the order-number pass's sort order.
    for (const [id, num, qty] of [
      ["o-s1", "SOLO", 1],
      ["o-s2", "SOLO", 1],
      ["o-t1", "TRIPLE", 2],
      ["o-t2", "TRIPLE", 2],
      ["o-t3", "TRIPLE", 2],
    ]) {
      await pbMock.collection("orders").create({
        id, order_number: num, quote: "q",
        created: "2025-01-01T00:00:00Z",
      });
      await pbMock.collection("order_items").create({
        id: `oi-${id}`, order: id, description: "x", quantity: qty, item_status: "pending",
      });
    }

    const groups = await findDuplicateOrders();
    expect(groups.map((g) => g.orderNumber)).toEqual(["TRIPLE", "SOLO"]);
  });

  // ────── line-aggregate ("Same line items") pass ──────
  it("flags cross-order_number line-aggregate duplicates even when descriptions differ", async () => {
    // Two orders under different order_numbers, same line breakdown
    // (1 line, qty 5, R100). Descriptions and created-timestamps
    // differ — the kind: "line_aggregate" pass should still flag it.
    await pbMock.collection("orders").create({
      id: "o-a", order_number: "ORD-A", quote: "q",
      created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-a", order: "o-a", description: "M16 hex bolt 50mm grade 8.8",
      quantity: 5, selling_price: 100, item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-b", order_number: "ORD-B", quote: "q",
      created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-b", order: "o-b", description: "M16 x 50 hex bolt", // different text
      quantity: 5, selling_price: 100, item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    const aggregateGroups = groups.filter((g) => g.kind === "line_aggregate");
    expect(aggregateGroups).toHaveLength(1);
    expect(aggregateGroups[0].records.map((r) => r.id).sort()).toEqual(["o-a", "o-b"]);
    expect(aggregateGroups[0].orderNumber).toMatch(/^1 line · 5 · R/);
  });

  it("does not double-list a same-number group under line-aggregate (cross-number filter)", async () => {
    // Two records under the SAME order_number with matching content
    // — already an order-number duplicate. The line-aggregate pass
    // must NOT surface them again.
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", quantity: 5, selling_price: 100,
      item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-2", order_number: "DUP", quote: "q", created: "2025-01-01T00:00:00.100Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-2", description: "x", quantity: 5, selling_price: 100,
      item_status: "invoiced",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(1);
    expect(groups[0].kind).toBe("order_number");
    expect(groups[0].records.map((r) => r.id)).toEqual(["o-1", "o-2"]);
  });

  it("excludes orders with zero items from line-aggregate matching", async () => {
    // Empty orders would all match each other on (0 lines, 0 qty, R0)
    // — must not be flagged.
    await pbMock.collection("orders").create({
      id: "o-empty-1", order_number: "EMPTY-A", quote: "q",
    });
    await pbMock.collection("orders").create({
      id: "o-empty-2", order_number: "EMPTY-B", quote: "q",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(0);
  });

  it("rounds sub-cent price differences so 1499.998 and 1500.002 both match 1500.00", async () => {
    await pbMock.collection("orders").create({
      id: "o-x", order_number: "X", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-x", order: "o-x", description: "x", quantity: 1,
      selling_price: 1499.998, item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-y", order_number: "Y", quote: "q", created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-y", order: "o-y", description: "x", quantity: 1,
      selling_price: 1500.002, item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    expect(groups.filter((g) => g.kind === "line_aggregate")).toHaveLength(1);
  });

  it("matches when both sides are entirely zero-priced", async () => {
    await pbMock.collection("orders").create({
      id: "o-z1", order_number: "Z1", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-z1", order: "o-z1", description: "x", quantity: 5,
      selling_price: 0, item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-z2", order_number: "Z2", quote: "q", created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-z2", order: "o-z2", description: "x", quantity: 5,
      selling_price: 0, item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    expect(groups.filter((g) => g.kind === "line_aggregate")).toHaveLength(1);
  });

  it("does not match when one side is zero-priced and the other is not", async () => {
    await pbMock.collection("orders").create({
      id: "o-p1", order_number: "P1", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-p1", order: "o-p1", description: "x", quantity: 1,
      selling_price: 0, item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-p2", order_number: "P2", quote: "q", created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-p2", order: "o-p2", description: "x", quantity: 1,
      selling_price: 50, item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(0);
  });

  it("does not match when total quantity differs (everything else the same)", async () => {
    await pbMock.collection("orders").create({
      id: "o-q1", order_number: "Q1", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-q1", order: "o-q1", description: "x", quantity: 5,
      selling_price: 100, item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-q2", order_number: "Q2", quote: "q", created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-q2", order: "o-q2", description: "x", quantity: 6,
      selling_price: 100, item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(0);
  });

  it("does not match when line count differs (everything else the same)", async () => {
    await pbMock.collection("orders").create({
      id: "o-c1", order_number: "C1", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-c1a", order: "o-c1", description: "x", quantity: 5,
      selling_price: 100, item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-c1b", order: "o-c1", description: "y", quantity: 5,
      selling_price: 100, item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-c2", order_number: "C2", quote: "q", created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-c2", order: "o-c2", description: "x", quantity: 10,
      selling_price: 100, item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    expect(groups).toHaveLength(0);
  });

  it("computes totalSellingPrice as the sum of selling_price × quantity per line", async () => {
    // 2 lines: qty 2 @ R50 = R100, qty 3 @ R100 = R300 → total R400.
    // qty 5, R400. Match against another order with same aggregates.
    await pbMock.collection("orders").create({
      id: "o-m1", order_number: "M1", quote: "q", created: "2025-01-01T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-m1a", order: "o-m1", description: "a", quantity: 2, selling_price: 50,
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-m1b", order: "o-m1", description: "b", quantity: 3, selling_price: 100,
      item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-m2", order_number: "M2", quote: "q", created: "2025-01-02T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-m2a", order: "o-m2", description: "a", quantity: 2, selling_price: 50,
      item_status: "pending",
    });
    await pbMock.collection("order_items").create({
      id: "oi-m2b", order: "o-m2", description: "b", quantity: 3, selling_price: 100,
      item_status: "pending",
    });

    const groups = await findDuplicateOrders();
    const aggs = groups.filter((g) => g.kind === "line_aggregate");
    expect(aggs).toHaveLength(1);
    expect(aggs[0].orderNumber).toMatch(/^2 lines · 5 · R/);
    expect(aggs[0].records[0].totalQuantity).toBe(5);
    expect(aggs[0].records[0].totalSellingPrice).toBeCloseTo(400, 2);
  });
});

// ──────────────────────────────────────────────────────────────────────
// setOrderQuote (Hermes unblock)
// ──────────────────────────────────────────────────────────────────────

describe("setOrderQuote", () => {
  it("links an existing order to an existing quote, returns {order, previous}", async () => {
    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "", created: "2026-08-21T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    const result = await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });

    expect(result.previous).toEqual({ quote: "" });
    expect(result.order.id).toBe("o-1");
    expect(result.order.quote).toBe("q-1");

    // The store reflects the write.
    const stored = (store["orders"] || new Map()).get("o-1");
    expect(stored?.quote).toBe("q-1");
  });

  it("refuses 409 order_locked when any item is past pending", async () => {
    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "po_generated",
    });
    await pbMock.collection("order_items").create({
      id: "oi-2", order: "o-1", description: "y", item_status: "pending",
    });

    try {
      await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(409);
      const data = (err as Error & { data?: { code?: string; offendingItemIds?: string[] } }).data;
      expect(data?.code).toBe("order_locked");
      expect(data?.offendingItemIds).toContain("oi-1");
    }

    // Order quote must not have changed.
    const stored = (store["orders"] || new Map()).get("o-1");
    expect(stored?.quote).toBe("");
  });

  it("refuses 409 quote_already_linked when another order has the quote", async () => {
    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-other", order_number: "ORD-OTHER", quote: "q-1",
    });
    await pbMock.collection("order_items").create({
      id: "oi-other", order: "o-other", description: "x", item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    try {
      await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(409);
      const data = (err as Error & { data?: { code?: string; conflictingOrderId?: string } }).data;
      expect(data?.code).toBe("quote_already_linked");
      expect(data?.conflictingOrderId).toBe("o-other");
    }
  });

  it("404 when the order doesn't exist", async () => {
    await pbMock.collection("quotes").create({ id: "q-1" });

    try {
      await setOrderQuote({ orderId: "missing", quoteId: "q-1" });
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(404);
    }
  });

  it("404 when the quote doesn't exist", async () => {
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    try {
      await setOrderQuote({ orderId: "o-1", quoteId: "missing" });
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(404);
    }
  });

  it("is idempotent when the order already points at the quote (no-op + no audit stamp)", async () => {
    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "q-1", notes: "original note",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    const result = await setOrderQuote({
      orderId: "o-1",
      quoteId: "q-1",
      actor: { id: "agent-1", name: "Hermes" },
    });

    expect(result.previous).toEqual({ quote: "q-1" });
    expect(result.order.quote).toBe("q-1");

    // Notes must NOT be touched on idempotent no-op.
    expect((store["orders"] || new Map()).get("o-1")?.notes).toBe("original note");
  });

  it("stamps actor into notes when provided", async () => {
    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "", notes: "existing note",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    await setOrderQuote({
      orderId: "o-1",
      quoteId: "q-1",
      actor: { id: "agent-1", name: "Hermes" },
    });

    const stored = (store["orders"] || new Map()).get("o-1");
    expect(stored?.quote).toBe("q-1");
    expect(String(stored?.notes ?? "")).toMatch(/existing note/);
    expect(String(stored?.notes ?? "")).toMatch(/Hermes linked this order to quote q-1/);
  });
});

// ──────────────────────────────────────────────────────────────────────
// setOrderQuote line pairing (Task 5)
// ──────────────────────────────────────────────────────────────────────

describe("setOrderQuote line pairing", () => {
  it("pairs order lines to the quote's lines after writing the hard link", async () => {
    const { pairOrderLines } = await import("./order-quote-link-service");
    vi.mocked(pairOrderLines).mockClear();
    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "", created: "2026-08-21T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "hex bolt m20", item_status: "pending",
    });

    const result = await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });

    expect(pairOrderLines).toHaveBeenCalledWith("o-1", "q-1");
    expect(result.order.quote).toBe("q-1");
  });

  it("does not fail the link when pairing throws", async () => {
    const { pairOrderLines } = await import("./order-quote-link-service");
    vi.mocked(pairOrderLines).mockClear();
    vi.mocked(pairOrderLines).mockRejectedValueOnce(new Error("PB down"));

    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "", created: "2026-08-21T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "hex bolt m20", item_status: "pending",
    });

    const result = await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });

    // The link still landed despite the pairing failure.
    expect(result.order.quote).toBe("q-1");
  });

  it("does not pair lines when the link is refused (order_locked)", async () => {
    const { pairOrderLines } = await import("./order-quote-link-service");
    vi.mocked(pairOrderLines).mockClear();

    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "po_generated",
    });

    try {
      await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(409);
    }

    expect(pairOrderLines).not.toHaveBeenCalled();
  });

  it("also pairs lines on the idempotent no-op path (order already points at the quote)", async () => {
    const { pairOrderLines } = await import("./order-quote-link-service");
    vi.mocked(pairOrderLines).mockClear();

    await pbMock.collection("quotes").create({ id: "q-1" });
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "q-1",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "hex bolt m20", item_status: "pending",
    });

    await setOrderQuote({ orderId: "o-1", quoteId: "q-1" });

    // Re-running pairing on an already-linked order is safe (it never
    // overwrites an existing `quote_item`) and picks up lines added
    // or edited since the original link — so pairing runs here too,
    // even though the hard link itself is a no-op.
    expect(pairOrderLines).toHaveBeenCalledWith("o-1", "q-1");
  });
});

// ──────────────────────────────────────────────────────────────────────
// findOrderByOrderNumber (Hermes unblock)
// ──────────────────────────────────────────────────────────────────────

describe("findOrderByOrderNumber", () => {
  it("returns null on miss (no matching order)", async () => {
    const hit = await findOrderByOrderNumber("DOES-NOT-EXIST");
    expect(hit).toBeNull();
  });

  it("returns the full order record on hit", async () => {
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1", quote: "q", created: "2026-08-21T00:00:00Z",
    });
    const hit = await findOrderByOrderNumber("ORD-1");
    expect(hit).not.toBeNull();
    expect(hit?.id).toBe("o-1");
    expect(hit?.order_number).toBe("ORD-1");
  });

  it("escapes double-quotes in user input", async () => {
    // Filter "order_number = \"weird\\\"value\"" — the mock's where
    // only handles simple patterns, so we just confirm no crash on
    // a quote-containing input.
    const hit = await findOrderByOrderNumber('weird"value');
    expect(hit).toBeNull();
  });
});

// ──────────────────────────────────────────────────────────────────────
// findOrderByEmailMessageId (Hermes unblock)
// ──────────────────────────────────────────────────────────────────────

describe("findOrderByEmailMessageId", () => {
  it("returns null on miss", async () => {
    const hit = await findOrderByEmailMessageId("<missing@mail.example>");
    expect(hit).toBeNull();
  });

  it("returns the full order record on hit", async () => {
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1",
      email_message_id: "<msg-1@mail.example>",
    });
    const hit = await findOrderByEmailMessageId("<msg-1@mail.example>");
    expect(hit).not.toBeNull();
    expect(hit?.id).toBe("o-1");
    expect(hit?.email_message_id).toBe("<msg-1@mail.example>");
  });
});

// ──────────────────────────────────────────────────────────────────────
// findDuplicateOrders — email_message_id kind (Hermes unblock)
// ──────────────────────────────────────────────────────────────────────

describe("findDuplicateOrders — email_message_id kind", () => {
  it("flags a group of ≥2 records sharing the same email_message_id", async () => {
    const sharedEmail = "<msg-shared@mail.example>";
    await pbMock.collection("orders").create({
      id: "o-a", order_number: "ORD-A", quote: "q",
      email_message_id: sharedEmail, created: "2026-08-21T00:00:00Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-a", order: "o-a", description: "x", item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-b", order_number: "ORD-B", quote: "q",
      email_message_id: sharedEmail, created: "2026-08-21T00:00:01Z",
    });
    await pbMock.collection("order_items").create({
      id: "oi-b", order: "o-b", description: "x", item_status: "pending",
    });

    const groups = await findDuplicateOrders({ kind: "email_message_id" });
    expect(groups).toHaveLength(1);
    expect(groups[0].kind).toBe("email_message_id");
    expect(groups[0].orderNumber).toBe(sharedEmail);
    expect(groups[0].records.map((r) => r.id).sort()).toEqual(["o-a", "o-b"]);
  });

  it("skips records with an empty email_message_id", async () => {
    await pbMock.collection("orders").create({
      id: "o-empty-1", order_number: "E1", quote: "q", email_message_id: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-e1", order: "o-empty-1", description: "x", item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-empty-2", order_number: "E2", quote: "q", email_message_id: "",
    });
    await pbMock.collection("order_items").create({
      id: "oi-e2", order: "o-empty-2", description: "x", item_status: "pending",
    });

    const groups = await findDuplicateOrders({ kind: "email_message_id" });
    expect(groups).toHaveLength(0);
  });

  it("does not include email_message_id groups when kind filter is order_number", async () => {
    const sharedEmail = "<msg-shared@mail.example>";
    await pbMock.collection("orders").create({
      id: "o-a", order_number: "ORD-A", quote: "q",
      email_message_id: sharedEmail,
    });
    await pbMock.collection("order_items").create({
      id: "oi-a", order: "o-a", description: "x", item_status: "pending",
    });
    await pbMock.collection("orders").create({
      id: "o-b", order_number: "ORD-B", quote: "q",
      email_message_id: sharedEmail,
    });
    await pbMock.collection("order_items").create({
      id: "oi-b", order: "o-b", description: "x", item_status: "pending",
    });

    const groups = await findDuplicateOrders({ kind: "order_number" });
    expect(groups).toHaveLength(0);
  });
});

describe("createOrder quote auto-detection", () => {
  it("schedules a quote suggestion after the response", async () => {
    const { suggestQuoteForOrder } = await import("./order-quote-link-service");
    const { after } = await import("next/server");
    vi.mocked(suggestQuoteForOrder).mockClear();
    vi.mocked(after).mockClear();
    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({ id: "comp-x", name: "Acme (Pty) Ltd" });

    const created = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(after).toHaveBeenCalled();
    expect(suggestQuoteForOrder).toHaveBeenCalledWith(created.order.id);
  });

  it("never fails order creation when the matcher throws", async () => {
    const consoleErrorSpy = vi
      .spyOn(console, "error")
      .mockImplementation(() => {});
    const { suggestQuoteForOrder } = await import("./order-quote-link-service");
    vi.mocked(suggestQuoteForOrder).mockClear();
    vi.mocked(suggestQuoteForOrder).mockRejectedValueOnce(new Error("PB down"));
    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({ id: "comp-x", name: "Acme (Pty) Ltd" });

    const result = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(result.order.id).toBeDefined();
    expect(result.items_created.length).toBe(1);
    // Verifies the inner catch swallowed the matcher failure and
    // logged it — without this assertion the test passes purely
    // because the `after` mock detaches the promise regardless of
    // what production code does.
    expect(consoleErrorSpy).toHaveBeenCalledWith(
      expect.stringContaining("[createOrder] quote auto-detection failed for order"),
      expect.stringContaining("PB down"),
    );
    consoleErrorSpy.mockRestore();
  });

  it("falls back to an inline match when after() is unavailable", async () => {
    const consoleErrorSpy = vi
      .spyOn(console, "error")
      .mockImplementation(() => {});
    const { after } = await import("next/server");
    const { suggestQuoteForOrder } = await import("./order-quote-link-service");
    vi.mocked(suggestQuoteForOrder).mockClear();
    vi.mocked(after).mockClear();
    vi.mocked(after).mockImplementationOnce(() => {
      throw new Error("`after` was called outside a request scope.");
    });
    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({ id: "comp-x", name: "Acme (Pty) Ltd" });

    const r = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(r.order.id).toBeDefined();
    // Proves the catch fired AND ran the inline fallback — without
    // the call assertion the test would pass on the spy alone even
    // if `void runPostCreateMatchers()` was deleted.
    expect(suggestQuoteForOrder).toHaveBeenCalledWith(r.order.id);
    // The fallback logs its engagement so a silent switch to
    // fire-and-forget is impossible to miss in production logs.
    expect(consoleErrorSpy).toHaveBeenCalledWith(
      expect.stringContaining(
        "[createOrder] after() unavailable, running post-create matchers inline",
      ),
      expect.anything(),
    );
    consoleErrorSpy.mockRestore();
  });
});

describe("createOrder delivery-note auto-detection", () => {
  it("also schedules a delivery-note match after the response", async () => {
    const { suggestDeliveryNoteForOrder } = await import(
      "./order-delivery-note-link-service"
    );
    vi.mocked(suggestDeliveryNoteForOrder).mockClear();
    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({
      id: "comp-x",
      name: "Acme (Pty) Ltd",
    });

    const created = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(suggestDeliveryNoteForOrder).toHaveBeenCalledWith(created.order.id);
  });

  it("a delivery-note match failure does not prevent the quote suggestion from running", async () => {
    // The point of the two independent try/catch blocks — a delivery-
    // note match failure (e.g. PB down for delivery_notes collection)
    // must still leave the quote suggestion able to land. The two
    // matchers are independent: one failing cannot starve the other.
    const { suggestDeliveryNoteForOrder } = await import(
      "./order-delivery-note-link-service"
    );
    const { suggestQuoteForOrder } = await import("./order-quote-link-service");
    vi.mocked(suggestDeliveryNoteForOrder).mockClear();
    vi.mocked(suggestQuoteForOrder).mockClear();
    vi.mocked(suggestDeliveryNoteForOrder).mockRejectedValueOnce(
      new Error("DN lookup failed"),
    );

    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({
      id: "comp-x",
      name: "Acme (Pty) Ltd",
    });

    const created = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(suggestQuoteForOrder).toHaveBeenCalledWith(created.order.id);
  });

  it("a quote-match failure does not prevent the delivery-note match from running", async () => {
    // The reverse direction — the quote matcher throws, the delivery-
    // note matcher still runs. Proves the second try/catch is its
    // own scope and not a continuation of the first.
    const { suggestDeliveryNoteForOrder } = await import(
      "./order-delivery-note-link-service"
    );
    const { suggestQuoteForOrder } = await import("./order-quote-link-service");
    vi.mocked(suggestDeliveryNoteForOrder).mockClear();
    vi.mocked(suggestQuoteForOrder).mockClear();
    vi.mocked(suggestQuoteForOrder).mockRejectedValueOnce(
      new Error("quote lookup failed"),
    );

    await pbMock.collection("customers").create({ id: "cust-x", name: "Acme" });
    await pbMock.collection("companies").create({
      id: "comp-x",
      name: "Acme (Pty) Ltd",
    });

    const created = await createOrder({
      customer_id: "cust-x",
      company_id: "comp-x",
      items: [{ description: "M16 Bolt", quantity: 50 }],
    });

    expect(suggestDeliveryNoteForOrder).toHaveBeenCalledWith(created.order.id);
  });
});

describe("createOrderItemForOrder (mid-flight add)", () => {
  // Task 2 of the non-invoiceable-order-extras plan — the pending
  // gate that previously 409'd when siblings were po_generated is
  // removed because adding a new row is independent of any in-flight
  // PO's pricing/supplier reference. Three tests below cover the
  // contract: (a) the gate is gone, (b) the new flag is authoritative
  // for selling_price, (c) omission leaves the row billable.

  it("adds a line to an order whose siblings are po_generated (was previously 409 order_locked)", async () => {
    const { createOrderItemForOrder } = await import("./orders-service");
    await pbMock.collection("orders").create({
      id: "o-1",
      order_number: "ORD-1",
      // Customer + company required by createOrder's lead row — skip
      // for this targeted test by using a minimal stub.
    });
    await pbMock.collection("order_items").create({
      id: "oi-existing",
      order: "o-1",
      description: "Bolt",
      quantity: 50,
      item_status: "po_generated",
    });

    const result = await createOrderItemForOrder("o-1", {
      description: "Washer",
      quantity: 50,
      cost_price: 5,
    });

    expect(result.failed).toEqual([]);
    expect(result.created.length).toBe(1);
    expect(result.created[0].description).toBe("Washer");
    expect(result.orderLocked).toBe(false);
  });

  it("exclude_from_invoice forces selling_price to 0 even when caller passes a non-zero price", async () => {
    const { createOrderItemForOrder } = await import("./orders-service");
    await pbMock.collection("orders").create({
      id: "o-1",
      order_number: "ORD-1",
    });

    const result = await createOrderItemForOrder("o-1", {
      description: "Nut",
      quantity: 50,
      cost_price: 10,
      markup: 50, // would compute selling_price = 15 without the flag
      selling_price: 15, // would persist 15 without the flag
      exclude_from_invoice: true,
    });

    expect(result.created[0].selling_price).toBe(0);
    expect(result.created[0].markup).toBe(50); // markup stays as-is

    // The flag itself persists on the secondary update — separate
    // assertion because the `created[]` return shape doesn't include
    // it.
    const stored = (store["order_items"] as Map<string, Record<string, unknown>>).get(
      result.created[0].id,
    );
    expect(stored?.exclude_from_invoice).toBe(true);
    expect(stored?.selling_price).toBe(0);
  });

  it("omitting exclude_from_invoice preserves the existing markup-based selling_price calculation", async () => {
    const { createOrderItemForOrder } = await import("./orders-service");
    await pbMock.collection("orders").create({
      id: "o-1",
      order_number: "ORD-1",
    });

    const result = await createOrderItemForOrder("o-1", {
      description: "Bolt",
      quantity: 50,
      cost_price: 10,
      markup: 25,
    });

    expect(result.created[0].selling_price).toBe(12.5); // 10 * 1.25
    const stored = (store["order_items"] as Map<string, Record<string, unknown>>).get(
      result.created[0].id,
    );
    expect(stored?.exclude_from_invoice).toBeFalsy();
  });
});

describe("cancelOrderItem", () => {
  let cancelOrderItem: typeof import("./orders-service").cancelOrderItem;

  beforeEach(async () => {
    ({ cancelOrderItem } = await import("./orders-service"));
  });

  it("flips item_status to cancelled for a pending line", async () => {
    await pbMock.collection("orders").create({
      id: "o-1", order_number: "ORD-1",
    });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "M2 flat washer", item_status: "pending",
    });

    const result = await cancelOrderItem("o-1", "oi-1");

    expect(result.id).toBe("oi-1");
    expect(result.item_status).toBe("cancelled");
  });

  it("refuses 404 when the order doesn't exist", async () => {
    await pbMock.collection("order_items").create({
      id: "oi-orphan", order: "o-missing", description: "x", item_status: "pending",
    });

    // The item belongs to o-missing; we're calling with o-1.
    // Even though the item exists, the order check fires first.
    try {
      await cancelOrderItem("o-1", "oi-orphan");
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(404);
    }
  });

  it("refuses 404 when the item belongs to a different order", async () => {
    await pbMock.collection("orders").create({ id: "o-1", order_number: "ORD-1" });
    await pbMock.collection("orders").create({ id: "o-2", order_number: "ORD-2" });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    // Item is on o-1; we're calling with o-2.
    try {
      await cancelOrderItem("o-2", "oi-1");
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(404);
    }
  });

  it("refuses 409 when the line is already in a terminal status", async () => {
    await pbMock.collection("orders").create({ id: "o-1", order_number: "ORD-1" });

    // 'invoiced' is in CANCEL_BLOCKED_ITEM_STATUSES — cancelling
    // would orphan the customer invoice. Same for delivered /
    // cancelled. One test per status would be overkill; pick
    // 'invoiced' as the representative terminal state.
    await pbMock.collection("order_items").create({
      id: "oi-invoiced", order: "o-1", description: "x", item_status: "invoiced",
    });

    try {
      await cancelOrderItem("o-1", "oi-invoiced");
      expect.fail("should have thrown");
    } catch (err) {
      expect((err as Error & { status?: number }).status).toBe(409);
    }
  });

  it("stamps the operator identity on notes when an actor is supplied", async () => {
    await pbMock.collection("orders").create({ id: "o-1", order_number: "ORD-1" });
    await pbMock.collection("order_items").create({
      id: "oi-1", order: "o-1", description: "x", item_status: "pending",
    });

    await cancelOrderItem("o-1", "oi-1", { actor: { id: "u-1", name: "Dave" } });

    const stored = (store["order_items"] as Map<string, Record<string, unknown>>).get("oi-1");
    expect(stored?.item_status).toBe("cancelled");
    // The notes field is appended, not replaced — preserves any
    // operator note that was already on the line.
    const notes = String(stored?.notes ?? "");
    expect(notes).toMatch(/cancelled by Dave/);
  });
});