import { describe, it, expect, beforeEach, afterAll, vi } from "vitest";
import { createPool, mockDbWithPool, resetDB, seedParticipants, insertTransaction } from "./helpers";

// Create a pool and mock @/lib/db BEFORE any dynamic imports that use it.
// vi.doMock is NOT hoisted so it can close over the pool instance.
const pool = createPool();
mockDbWithPool(pool);

// Dynamic import AFTER the mock ensures getTransactions / getParticipantBalances
// use the test pool rather than Prisma's singleton.
const { getTransactions, getParticipantBalances, getTripAnalytics, getTripById, getStatements } = await import("@/lib/queries");

beforeEach(async () => {
  await resetDB(pool);
});

afterAll(async () => {
  await pool.end();
  vi.restoreAllMocks();
});

// ── getTransactions ───────────────────────────────────────────────────────────

describe("getTransactions — owner scoping", () => {
  it("returns only the owner's transactions", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { description: "Alice groceries" });
    await insertTransaction(pool, otherId, { description: "Bob petrol" });

    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(data[0].description).toBe("Alice groceries");
  });

  it("includes transactions where owner is a split participant", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, otherId, { description: "Shared dinner" });

    // Add Alice as a split participant
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, ownerId]
    );

    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    expect(data.some((t) => t.description === "Shared dinner")).toBe(true);
  });

  it("returns correct total count", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { description: "tx1" });
    await insertTransaction(pool, ownerId, { description: "tx2" });
    await insertTransaction(pool, ownerId, { description: "tx3" });

    const { total } = await getTransactions(ownerId, { limit: 2, offset: 0 });
    expect(total).toBe(3);
  });
});

describe("getTransactions — date filters", () => {
  it("filters by from date", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { description: "old tx", transaction_date: "2024-01-10" });
    await insertTransaction(pool, ownerId, { description: "new tx", transaction_date: "2024-03-01" });

    const { data } = await getTransactions(ownerId, { from: "2024-02-01", limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(data[0].description).toBe("new tx");
  });

  it("filters by to date", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { description: "old tx", transaction_date: "2024-01-10" });
    await insertTransaction(pool, ownerId, { description: "new tx", transaction_date: "2024-03-01" });

    const { data } = await getTransactions(ownerId, { to: "2024-01-31", limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(data[0].description).toBe("old tx");
  });
});

describe("getTransactions — category filter", () => {
  it("filters by category", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { description: "Grocery run", category: "groceries" });
    await insertTransaction(pool, ownerId, { description: "Dinner out", category: "dining" });

    const { data } = await getTransactions(ownerId, { categories: ["groceries"], limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(data[0].description).toBe("Grocery run");
  });

  it("category override takes precedence over raw category", async () => {
    const { ownerId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, { category: "dining" });
    await pool.query(
      `INSERT INTO transaction_overrides (transaction_id, category_override) VALUES ($1, 'groceries')`,
      [txId]
    );

    const { data: dining } = await getTransactions(ownerId, { categories: ["dining"], limit: 50, offset: 0 });
    const { data: groceries } = await getTransactions(ownerId, { categories: ["groceries"], limit: 50, offset: 0 });
    expect(dining).toHaveLength(0);   // override hides original
    expect(groceries).toHaveLength(1); // override exposes new category
  });
});

describe("getTransactions — search filter", () => {
  it("searches description case-insensitively", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { description: "COLES WYNDHAM" });
    await insertTransaction(pool, ownerId, { description: "ALDI POINT COOK" });

    const { data } = await getTransactions(ownerId, { search: "coles", limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(data[0].description).toBe("COLES WYNDHAM");
  });
});

describe("getTransactions — amount filters", () => {
  it("filters by amount_min", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { amount: 20 });
    await insertTransaction(pool, ownerId, { amount: 200 });

    const { data } = await getTransactions(ownerId, { amount_min: 100, limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(Number(data[0].amount)).toBe(200);
  });

  it("filters by amount_max", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId, { amount: 20 });
    await insertTransaction(pool, ownerId, { amount: 200 });

    const { data } = await getTransactions(ownerId, { amount_max: 50, limit: 50, offset: 0 });
    expect(data).toHaveLength(1);
    expect(Number(data[0].amount)).toBe(20);
  });
});

describe("getTransactions — pagination", () => {
  it("respects limit and offset", async () => {
    const { ownerId } = await seedParticipants(pool);
    for (let i = 0; i < 5; i++) {
      await insertTransaction(pool, ownerId, { description: `tx-${i}`, transaction_date: `2024-0${i + 1}-01` });
    }

    const page1 = await getTransactions(ownerId, { limit: 2, offset: 0 });
    const page2 = await getTransactions(ownerId, { limit: 2, offset: 2 });
    expect(page1.data).toHaveLength(2);
    expect(page2.data).toHaveLength(2);
    expect(page1.data[0].description).not.toBe(page2.data[0].description);
    expect(page1.total).toBe(5);
  });
});

describe("getTransactions — splits and tags attached", () => {
  it("attaches empty arrays when no splits or tags", async () => {
    const { ownerId } = await seedParticipants(pool);
    await insertTransaction(pool, ownerId);

    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    expect(data[0].splits).toEqual([]);
    expect(data[0].tags).toEqual([]);
  });

  it("attaches split participants", async () => {
    const { ownerId, otherId } = await seedParticipants(pool, ["Alice", "Bob"]);
    const txId = await insertTransaction(pool, ownerId);
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, otherId]
    );

    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    expect(data[0].splits).toHaveLength(1);
    expect(data[0].splits[0].name).toBe("Bob");
    expect(Number(data[0].splits[0].share_percent)).toBe(50);
  });
});

// ── getParticipantBalances ────────────────────────────────────────────────────

describe("getParticipantBalances", () => {
  it("shows zero balance when no splits", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    void otherId;
    const balances = await getParticipantBalances(ownerId);
    expect(balances.every((b) => Number(b.total_owed) === 0)).toBe(true);
  });

  it("calculates positive balance when participant owes owner", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    // Alice pays $100, Bob owes 50%
    const txId = await insertTransaction(pool, ownerId, { amount: 100 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, otherId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bobBalance = balances.find((b) => b.id === otherId);
    expect(bobBalance).toBeDefined();
    expect(Number(bobBalance!.total_owed)).toBeCloseTo(50);
  });

  it("reduces balance after recording a payment", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, { amount: 100 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, otherId]
    );
    // Bob pays Alice $30
    await pool.query(
      `INSERT INTO split_payments (from_participant_id, to_participant_id, amount, payment_date)
       VALUES ($1, $2, 30, '2024-06-20')`,
      [otherId, ownerId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bobBalance = balances.find((b) => b.id === otherId);
    expect(Number(bobBalance!.total_owed)).toBeCloseTo(20);
  });

  it("shows negative balance when owner owes participant", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    // Bob pays $100 for a shared expense, Alice owes 50%
    const txId = await insertTransaction(pool, otherId, { amount: 100 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, ownerId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bobBalance = balances.find((b) => b.id === otherId);
    expect(Number(bobBalance!.total_owed)).toBeCloseTo(-50);
  });

  it("unsettled_count reflects open splits", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const tx1 = await insertTransaction(pool, ownerId, { amount: 100 });
    const tx2 = await insertTransaction(pool, ownerId, { amount: 80 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent)
       VALUES ($1, $2, 50), ($3, $4, 50)`,
      [tx1, otherId, tx2, otherId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bobBalance = balances.find((b) => b.id === otherId);
    expect(bobBalance!.unsettled_count).toBe(2);
  });
});

describe("getTransactions — order provenance for the description sub-line", () => {
  it("carries the route and platform of an order-derived row", async () => {
    // Five rows all reading "Order - Uber Trip" are indistinguishable in the
    // list; where the trip went is the only thing that separates them, and it
    // was already stored.
    const { ownerId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, { description: "Order - Uber Trip" });
    await pool.query(
      `INSERT INTO expense_metadata (source, order_reference, platform, route, transaction_id)
       VALUES ('email', $1, 'uber',
         '[{"label":"Pick-up","time":"7:32 pm","address":"Terminal 2, Melbourne Airport (MEL), Tullamarine VIC 3045, Australia"},
           {"label":"Drop-off","time":"8:10 pm","address":"19 Lady Penrhyn Dr, Wyndham Vale VIC 3024, Australia"}]'::jsonb,
         $2)`,
      [`route-${Date.now()}`, txId]
    );

    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    const row = data.find((r) => r.id === txId)!;
    expect(row.order_platform).toBe("uber");
    expect(row.order_route).toHaveLength(2);
    expect(row.order_route![0].address).toContain("Melbourne Airport");
  });

  it("resolves from the statement line for a card-settled order", async () => {
    // A card-settled order creates no transaction of its own (I5) — the
    // receipt points at the statement line through matched_transaction_id.
    const { ownerId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, { description: "UBER *TRIP AUCKLAND" });
    await pool.query(
      `INSERT INTO expense_metadata (source, order_reference, platform, route, matched_transaction_id)
       VALUES ('email', $1, 'uber',
         '[{"label":"Pick-up","time":null,"address":"64 Federal Street, Auckland 1010, NZ"},
           {"label":"Drop-off","time":null,"address":"International Terminal, Auckland 2022, New Zealand"}]'::jsonb,
         $2)`,
      [`route-card-${Date.now()}`, txId]
    );

    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    const row = data.find((r) => r.id === txId)!;
    expect(row.order_route).toHaveLength(2);
  });

  it("leaves an ordinary transaction with no route", async () => {
    const { ownerId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, { description: "COLES 1234" });
    const { data } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    const row = data.find((r) => r.id === txId)!;
    expect(row.order_route).toBeNull();
    expect(row.order_platform).toBeNull();
  });
});

// ── settlement scope: settled + split_payments.trip_id (migration 0022) ───────

describe("getParticipantBalances — settled", () => {
  it("excludes a settled split from what is owed", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, { amount: 100 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent, settled)
       VALUES ($1, $2, 50, true)`,
      [txId, otherId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bob = balances.find((b) => b.id === otherId);
    expect(Number(bob!.total_owed)).toBeCloseTo(0);
  });

  it("still counts an unsettled split alongside a settled one", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const settledTx = await insertTransaction(pool, ownerId, { amount: 100 });
    const liveTx = await insertTransaction(pool, ownerId, { amount: 40 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent, settled)
       VALUES ($1, $2, 50, true), ($3, $2, 50, false)`,
      [settledTx, otherId, liveTx]
    );

    const balances = await getParticipantBalances(ownerId);
    const bob = balances.find((b) => b.id === otherId);
    // Only the live split counts: 50% of 40.
    expect(Number(bob!.total_owed)).toBeCloseTo(20);
  });
});

describe("getTripAnalytics — per-trip settlement", () => {
  async function seedTrip(ownerId: number, otherId: number) {
    const trip = await pool.query(
      `INSERT INTO trips (owner_id, name, start_date, end_date)
       VALUES ($1, 'Test Trip', '2026-03-01', '2026-03-10') RETURNING id`,
      [ownerId]
    );
    const tripId = trip.rows[0].id as number;
    const txId = await insertTransaction(pool, ownerId, { amount: 200, category: "travel" });
    await pool.query(
      `INSERT INTO transaction_overrides (transaction_id, trip_id) VALUES ($1, $2)`,
      [txId, tripId]
    );
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent)
       VALUES ($1, $2, 50)`,
      [txId, otherId]
    );
    return tripId;
  }

  it("reports the gross share before any payment", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const tripId = await seedTrip(ownerId, otherId);

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const bob = participant_splits.find((r) => r.participant_id === otherId);
    expect(Number(bob!.owed)).toBeCloseTo(100);
  });

  it("nets off a payment scoped to that trip", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const tripId = await seedTrip(ownerId, otherId);
    await pool.query(
      `INSERT INTO split_payments (from_participant_id, to_participant_id, amount, payment_date, trip_id)
       VALUES ($1, $2, 60, '2026-03-15', $3)`,
      [otherId, ownerId, tripId]
    );

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const bob = participant_splits.find((r) => r.participant_id === otherId);
    expect(Number(bob!.owed)).toBeCloseTo(40);
  });

  // The point of the whole scope column: settling the household tab must not
  // make a trip look paid. Before trip_id existed there was one global pool and
  // this distinction could not be expressed.
  it("ignores a household payment when reporting the trip", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const tripId = await seedTrip(ownerId, otherId);
    await pool.query(
      `INSERT INTO split_payments (from_participant_id, to_participant_id, amount, payment_date, trip_id)
       VALUES ($1, $2, 60, '2026-03-15', NULL)`,
      [otherId, ownerId]
    );

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const bob = participant_splits.find((r) => r.participant_id === otherId);
    expect(Number(bob!.owed)).toBeCloseTo(100);
  });

  it("drops a settled split from the trip figure", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const tripId = await seedTrip(ownerId, otherId);
    await pool.query(`UPDATE transaction_splits SET settled = true WHERE participant_id = $1`, [otherId]);

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const bob = participant_splits.find((r) => r.participant_id === otherId);
    expect(bob === undefined || Number(bob.owed) === 0).toBe(true);
  });
});

describe("getTripAnalytics — owner scoping", () => {
  it("ignores a trip expense someone else paid for", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const trip = await pool.query(
      `INSERT INTO trips (owner_id, name) VALUES ($1, 'Owner Scope Trip') RETURNING id`,
      [ownerId]
    );
    const tripId = trip.rows[0].id as number;

    // Bob paid this one. Alice's share of it is a debt Alice owes Bob — it is
    // not something Bob owes Alice, so it must not appear on Alice's trip view.
    const bobPaid = await insertTransaction(pool, otherId, { amount: 500, category: "travel" });
    await pool.query(`INSERT INTO transaction_overrides (transaction_id, trip_id) VALUES ($1, $2)`, [bobPaid, tripId]);
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent)
       VALUES ($1, $2, 50), ($1, $3, 50)`,
      [bobPaid, ownerId, otherId]
    );

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const bob = participant_splits.find((r) => r.participant_id === otherId);
    expect(bob === undefined || Number(bob.owed) === 0).toBe(true);
  });

  it("ignores a payment settled between the other two participants", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const third = await pool.query(
      `INSERT INTO participants (name, email) VALUES ('Carol', 'carol@example.com') RETURNING id`
    );
    const carolId = third.rows[0].id as number;
    const trip = await pool.query(
      `INSERT INTO trips (owner_id, name) VALUES ($1, 'Third Party Trip') RETURNING id`,
      [ownerId]
    );
    const tripId = trip.rows[0].id as number;

    const txId = await insertTransaction(pool, ownerId, { amount: 300, category: "travel" });
    await pool.query(`INSERT INTO transaction_overrides (transaction_id, trip_id) VALUES ($1, $2)`, [txId, tripId]);
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, carolId]
    );
    // Carol pays Bob, not the owner. Carol still owes the owner $150.
    await pool.query(
      `INSERT INTO split_payments (from_participant_id, to_participant_id, amount, payment_date, trip_id)
       VALUES ($1, $2, 150, '2026-03-15', $3)`,
      [carolId, otherId, tripId]
    );

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const carol = participant_splits.find((r) => r.participant_id === carolId);
    expect(Number(carol!.owed)).toBeCloseTo(150);
  });
});

// A refunded trip expense must not still read as trip cost. These queries
// filtered on debit/fee/interest, so a refund was dropped entirely and the
// original purchase stood at full value.
describe("getTripAnalytics — refunds reduce trip cost", () => {
  async function seedTripWithRefund(ownerId: number) {
    const trip = await pool.query(
      `INSERT INTO trips (owner_id, name, start_date, end_date)
       VALUES ($1, 'Refund Trip', '2026-03-01', '2026-03-10') RETURNING id`,
      [ownerId]
    );
    const tripId = trip.rows[0].id as number;

    const spend = await insertTransaction(pool, ownerId, {
      amount: 200, category: "travel", description: "Hotel booking", transaction_date: "2026-03-02",
    });
    const refund = await insertTransaction(pool, ownerId, {
      amount: 50, category: "travel", description: "Hotel partial refund",
      transaction_type: "refund", transaction_date: "2026-03-05",
    });
    await pool.query(
      `INSERT INTO transaction_overrides (transaction_id, trip_id) VALUES ($1, $3), ($2, $3)`,
      [spend, refund, tripId]
    );
    return tripId;
  }

  it("nets the refund out of the category total", async () => {
    const { ownerId } = await seedParticipants(pool);
    const tripId = await seedTripWithRefund(ownerId);

    const { category_breakdown } = await getTripAnalytics(tripId, ownerId);
    const travel = category_breakdown.find((c) => c.category === "travel");
    expect(Number(travel!.amount)).toBeCloseTo(150);
  });

  it("nets the refund out of the trip's headline total_spend", async () => {
    const { ownerId } = await seedParticipants(pool);
    const tripId = await seedTripWithRefund(ownerId);

    const trip = await getTripById(tripId, ownerId);
    expect(Number(trip!.total_spend)).toBeCloseTo(150);
  });

  it("shows the refund as a negative on its own day", async () => {
    const { ownerId } = await seedParticipants(pool);
    const tripId = await seedTripWithRefund(ownerId);

    const { daily_spend } = await getTripAnalytics(tripId, ownerId);
    const refundDay = daily_spend.find((d) => d.date === "2026-03-05");
    expect(Number(refundDay!.amount)).toBeCloseTo(-50);
  });

  // The owed side must be untouched: a refund carries no split, and the owed
  // query deliberately excludes credits. Netting cost must not move a balance.
  it("leaves what the other participant owes unchanged", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const tripId = await seedTripWithRefund(ownerId);
    const rows = await pool.query(
      `SELECT transaction_id FROM transaction_overrides WHERE trip_id = $1 ORDER BY transaction_id`,
      [tripId]
    );
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [rows.rows[0].transaction_id, otherId]
    );

    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
    const bob = participant_splits.find((r) => r.participant_id === otherId);
    expect(Number(bob!.owed)).toBeCloseTo(100);
  });
});

// An account cannot be billed twice for the same day. The boundary handling is
// the whole difficulty: these statements are issued back-to-back with one
// period ending the day the next begins, so naive inclusive ranges flag every
// consecutive pair.
describe("getStatements — overlapping billing periods", () => {
  async function addStatement(
    ownerId: number, account: string, start: string | null, end: string | null
  ): Promise<number> {
    const r = await pool.query(
      `INSERT INTO statements (filename, bank_name, account_number, owner_id,
                               billing_start_date, billing_end_date)
       VALUES ($1, 'ANZ', $2, $3, $4, $5) RETURNING id`,
      [`stmt-${account}-${start}.pdf`, account, ownerId, start, end]
    );
    return r.rows[0].id as number;
  }

  it("does not flag statements that merely touch at a boundary", async () => {
    const { ownerId } = await seedParticipants(pool);
    await addStatement(ownerId, "4085-56264", "2025-05-16", "2025-11-14");
    await addStatement(ownerId, "4085-56264", "2025-11-14", "2026-05-15");

    const rows = await getStatements(ownerId);
    expect(rows.every((r) => r.overlaps.length === 0)).toBe(true);
  });

  it("flags a genuine overlap on both statements, with the day count", async () => {
    const { ownerId } = await seedParticipants(pool);
    const a = await addStatement(ownerId, "4085-56264", "2025-11-12", "2026-03-12");
    const b = await addStatement(ownerId, "4085-56264", "2025-11-14", "2026-05-15");

    const rows = await getStatements(ownerId);
    const rowA = rows.find((r) => r.id === a)!;
    const rowB = rows.find((r) => r.id === b)!;
    expect(rowA.overlaps).toEqual([{ id: b, days: 118 }]);
    expect(rowB.overlaps).toEqual([{ id: a, days: 118 }]);
  });

  // The real duplicate got in because the existing key compared raw text and
  // ANZ wrote the same account both ways.
  it("matches the same account written with and without punctuation", async () => {
    const { ownerId } = await seedParticipants(pool);
    const a = await addStatement(ownerId, "408556264", "2025-11-12", "2026-03-12");
    const b = await addStatement(ownerId, "4085-56264", "2025-11-14", "2026-05-15");

    const rows = await getStatements(ownerId);
    expect(rows.find((r) => r.id === a)!.overlaps).toEqual([{ id: b, days: 118 }]);
  });

  it("ignores a different account billing the same days", async () => {
    const { ownerId } = await seedParticipants(pool);
    await addStatement(ownerId, "4085-56264", "2025-11-12", "2026-03-12");
    await addStatement(ownerId, "9999-11111", "2025-11-12", "2026-03-12");

    const rows = await getStatements(ownerId);
    expect(rows.every((r) => r.overlaps.length === 0)).toBe(true);
  });

  // NULL is unbounded to daterange, which would make an undated statement
  // overlap the entire history.
  it("does not treat an undated statement as overlapping everything", async () => {
    const { ownerId } = await seedParticipants(pool);
    await addStatement(ownerId, "4085-56264", "2025-11-12", "2026-03-12");
    await addStatement(ownerId, "4085-56264", null, null);

    const rows = await getStatements(ownerId);
    expect(rows.every((r) => r.overlaps.length === 0)).toBe(true);
  });
});

// A statement imported twice puts every transaction in the overlap in the
// ledger twice. The duplicate is superseded rather than deleted, because every
// child of `transactions` cascades on delete.
describe("superseded duplicates are excluded but kept", () => {
  it("hides a superseded row from the transaction list", async () => {
    const { ownerId } = await seedParticipants(pool);
    const keep = await insertTransaction(pool, ownerId, { description: "RAIZ INVESTMENT", amount: 1500 });
    const dup = await insertTransaction(pool, ownerId, { description: "RAIZ INVESTMENT", amount: 1500 });
    await pool.query(`UPDATE transactions SET superseded_by_id = $1 WHERE id = $2`, [keep, dup]);

    const { data, total } = await getTransactions(ownerId, { limit: 50, offset: 0 });
    expect(total).toBe(1);
    expect(data.map((t) => t.id)).toEqual([keep]);
  });

  it("keeps the superseded row and its children in the database", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const keep = await insertTransaction(pool, ownerId, { amount: 100 });
    const dup = await insertTransaction(pool, ownerId, { amount: 100 });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [dup, otherId]
    );
    await pool.query(`UPDATE transactions SET superseded_by_id = $1 WHERE id = $2`, [keep, dup]);

    const rows = await pool.query(`SELECT superseded_by_id FROM transactions WHERE id = $1`, [dup]);
    expect(rows.rows[0].superseded_by_id).toBe(keep);
    const kids = await pool.query(`SELECT count(*)::int AS n FROM transaction_splits WHERE transaction_id = $1`, [dup]);
    expect(kids.rows[0].n).toBe(1);
  });

  // The point of excluding it: a split on a duplicate must not be owed twice.
  it("does not count a superseded row towards what someone owes", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const keep = await insertTransaction(pool, ownerId, { amount: 100 });
    const dup = await insertTransaction(pool, ownerId, { amount: 100 });
    for (const id of [keep, dup]) {
      await pool.query(
        `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
        [id, otherId]
      );
    }
    await pool.query(`UPDATE transactions SET superseded_by_id = $1 WHERE id = $2`, [keep, dup]);

    const balances = await getParticipantBalances(ownerId);
    const bob = balances.find((b) => b.id === otherId);
    expect(Number(bob!.total_owed)).toBeCloseTo(50);
  });

  it("refuses to let a row supersede itself", async () => {
    const { ownerId } = await seedParticipants(pool);
    const id = await insertTransaction(pool, ownerId);
    await expect(
      pool.query(`UPDATE transactions SET superseded_by_id = $1 WHERE id = $1`, [id])
    ).rejects.toThrow();
  });
});

// Nothing before the cutover can be owed: carryover transaction 2348 already
// carries the entire pre-cutover balance as one figure. Splits on older
// transactions exist to describe how an expense was shared -- which keeps it
// out of spend -- without asserting a debt.
describe("the split cutover gates every balance", () => {
  it("ignores a split on a transaction before the cutover", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, {
      amount: 100, transaction_date: "2026-01-08",
    });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, otherId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bob = balances.find((b) => b.id === otherId);
    expect(Number(bob?.total_owed ?? 0)).toBeCloseTo(0);
  });

  // Inclusive: transaction 2348, which carries the whole pre-cutover balance,
  // is itself dated 2026-01-09. An exclusive bound would drop it.
  it("counts a split dated exactly on the cutover", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, {
      amount: 100, transaction_date: "2026-01-09",
    });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent) VALUES ($1, $2, 50)`,
      [txId, otherId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bob = balances.find((b) => b.id === otherId);
    expect(Number(bob!.total_owed)).toBeCloseTo(50);
  });

  // The point of the date guard: it does not depend on `settled` surviving.
  it("still ignores a pre-cutover split whose settled flag was lost", async () => {
    const { ownerId, otherId } = await seedParticipants(pool);
    const txId = await insertTransaction(pool, ownerId, {
      amount: 200, transaction_date: "2025-06-01",
    });
    await pool.query(
      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent, settled)
       VALUES ($1, $2, 50, false)`,
      [txId, otherId]
    );

    const balances = await getParticipantBalances(ownerId);
    const bob = balances.find((b) => b.id === otherId);
    expect(Number(bob?.total_owed ?? 0)).toBeCloseTo(0);
  });
});