#!/usr/bin/env node
/**
 * Seed Demo Data — a full "take it for a ride" dataset.
 *
 * Populates every user-facing surface (bills, categories + groups, payment
 * history with drift + debt paydown, monthly overrides/skips/snoozes, planning
 * income/starting amounts, spending budgets/rules/transactions, a demo bank
 * source + accounts + matched/unmatched/subscription transactions, an active
 * snowball plan, merchant rules, a calendar feed) so a new user can explore the
 * whole app.
 *
 * Removal contract: everything created here is either marked `is_seeded = 1` on a
 * user-scoped table, or is a bill-child that cascade-deletes with its seeded bill.
 * `POST /user/clear-demo-data` removes exactly these rows and nothing else — see
 * routes/user.cts. Keep that in sync when adding a new seeded surface.
 *
 * Idempotent: refuses to run when the account already has seeded bills.
 */

const path = require('path');

// DB_PATH is read at require-time by db/database — keep the default in sync.
process.env.DB_PATH = process.env.DB_PATH || path.join(__dirname, '..', 'db', 'bills.db');

const { getDb, ensureUserDefaultCategories } = require('../db/database.cts');
// Money columns are integer cents (migration v1.03) — convert demo dollars.
const { toCents } = require('../utils/money.mts');

// ── Static demo content ─────────────────────────────────────────────────────

const BILL_CATEGORIES = [
  'Utilities',
  'Housing',
  'Insurance',
  'Subscriptions',
  'Transportation',
  'Healthcare',
  'Credit Cards',
  'Loans',
  'Entertainment',
];

// Spending categories are distinct from bill categories and from the app's
// DEFAULT_CATEGORIES, so they are always seed-created (and thus removable).
const SPENDING_CATEGORIES = ['Groceries', 'Dining Out', 'Gas & Fuel', 'Shopping', 'Coffee'];

const CATEGORY_GROUPS = [
  { name: 'Living Expenses', members: ['Groceries', 'Gas & Fuel'] },
  { name: 'Discretionary', members: ['Dining Out', 'Shopping', 'Coffee'] },
];

// billing_cycle: 'monthly' | 'quarterly' | 'annually' | 'irregular'
// cycle_type:    'monthly' | 'weekly' | 'biweekly' | 'quarterly' | 'annual'
const BILLS = [
  // ── Utilities ──
  {
    name: 'Electric Company',
    category: 'Utilities',
    amount: 85,
    dueDay: 15,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    autopayVerified: true,
  },
  {
    name: 'Gas Utility',
    category: 'Utilities',
    amount: 35,
    dueDay: 12,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
  },
  {
    name: 'City Water Dept',
    category: 'Utilities',
    amount: 45,
    dueDay: 20,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
  },
  {
    name: 'Internet Provider',
    category: 'Utilities',
    amount: 70,
    dueDay: 18,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    autopayVerified: true,
  },
  {
    name: 'Cell Phone',
    category: 'Utilities',
    amount: 65,
    dueDay: 25,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    currentBalance: 648,
    minPayment: 27,
    interestRate: 0,
    snowballOrder: 0,
    snowballInclude: 1,
  },
  {
    name: 'Trash Service',
    category: 'Utilities',
    amount: 25,
    dueDay: 28,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: false,
  },

  // ── Housing ──
  {
    name: 'Mortgage',
    category: 'Housing',
    amount: 1450,
    dueDay: 1,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    autopayVerified: true,
    interestRate: 3.25,
    currentBalance: 185000,
    minPayment: 1200,
    snowballInclude: 0,
    snowballExempt: 1,
  },

  // ── Insurance / Healthcare ──
  {
    name: 'Car Insurance',
    category: 'Insurance',
    amount: 120,
    dueDay: 5,
    cycle: 'quarterly',
    cycleType: 'quarterly',
    autopay: true,
  },
  {
    name: 'Homeowners Insurance',
    category: 'Insurance',
    amount: 300,
    dueDay: 10,
    cycle: 'annually',
    cycleType: 'annual',
    autopay: false,
  },
  {
    name: 'Health Insurance',
    category: 'Healthcare',
    amount: 200,
    dueDay: 1,
    cycle: 'quarterly',
    cycleType: 'quarterly',
    autopay: true,
  },
  {
    name: 'Dental Insurance',
    category: 'Healthcare',
    amount: 40,
    dueDay: 15,
    cycle: 'quarterly',
    cycleType: 'quarterly',
    autopay: true,
  },

  // ── Credit Cards (snowball, smallest→largest) ──
  {
    name: 'Discover It Card',
    category: 'Credit Cards',
    amount: 65,
    dueDay: 26,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    interestRate: 22.99,
    currentBalance: 920,
    minPayment: 35,
    snowballOrder: 1,
    snowballInclude: 1,
    website: 'https://discover.com',
    has2fa: true,
  },
  {
    name: 'Capital One Quicksilver',
    category: 'Credit Cards',
    amount: 95,
    dueDay: 28,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    interestRate: 24.49,
    currentBalance: 1850,
    minPayment: 55,
    snowballOrder: 2,
    snowballInclude: 1,
    website: 'https://capitalone.com',
    has2fa: true,
  },
  {
    name: 'Chase Freedom',
    category: 'Credit Cards',
    amount: 140,
    dueDay: 12,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    interestRate: 21.49,
    currentBalance: 3200,
    minPayment: 90,
    snowballOrder: 3,
    snowballInclude: 1,
    website: 'https://chase.com',
    has2fa: true,
  },

  // ── Loans ──
  {
    name: 'Car Payment',
    category: 'Loans',
    amount: 425,
    dueDay: 22,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    interestRate: 4.5,
    currentBalance: 8400,
    minPayment: 350,
    snowballOrder: 4,
    snowballInclude: 1,
  },
  {
    name: 'Student Loan',
    category: 'Loans',
    amount: 250,
    dueDay: 15,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    interestRate: 5.5,
    currentBalance: 12500,
    minPayment: 150,
    snowballOrder: 5,
    snowballInclude: 1,
  },

  // ── Subscriptions ──
  {
    name: 'Netflix',
    category: 'Subscriptions',
    amount: 15.99,
    dueDay: 22,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'streaming',
    website: 'https://netflix.com',
  },
  {
    name: 'Spotify',
    category: 'Subscriptions',
    amount: 9.99,
    dueDay: 14,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'music',
    website: 'https://spotify.com',
  },
  {
    name: 'Adobe Creative Cloud',
    category: 'Subscriptions',
    amount: 54.99,
    dueDay: 8,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'software',
    website: 'https://adobe.com',
    has2fa: true,
  },
  {
    name: 'Amazon Prime',
    category: 'Subscriptions',
    amount: 139,
    dueDay: 1,
    cycle: 'annually',
    cycleType: 'annual',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'shopping',
    website: 'https://amazon.com',
  },
  {
    name: 'Apple iCloud+',
    category: 'Subscriptions',
    amount: 2.99,
    dueDay: 18,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'cloud',
    website: 'https://icloud.com',
  },
  {
    name: 'Gym Membership',
    category: 'Subscriptions',
    amount: 45,
    dueDay: 10,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'fitness',
  },

  // ── Entertainment (a genuine recurring entertainment bill, monthly) ──
  {
    name: 'AMC A-List',
    category: 'Entertainment',
    amount: 24.99,
    dueDay: 3,
    cycle: 'monthly',
    cycleType: 'monthly',
    autopay: true,
    isSubscription: true,
    subscriptionType: 'entertainment',
    website: 'https://amctheatres.com',
  },
];

// Bills deliberately left OVERDUE this month (due date passed, no payment).
const OVERDUE_THIS_MONTH = new Set(['Trash Service', 'Dental Insurance']);
// Bills whose most-recent payments also appear as matched bank transactions.
const BANK_MATCHED = new Set([
  'Electric Company',
  'Internet Provider',
  'Netflix',
  'Spotify',
  'Car Payment',
]);
// One skipped month (bill leaves that month unpaid, flagged skipped not overdue).
const SKIP = { bill: 'Gym Membership', monthsAgo: 1 };
// One amount override (actual differs from expected) and one note.
const OVERRIDE = { bill: 'Electric Company', monthsAgo: 1, actual: 132.4 };
const NOTE = {
  bill: 'City Water Dept',
  text: 'Called about the leak — credit expected next cycle.',
};

// Un-tracked subscription charges (in the catalog, no matching bill) → drive the
// Subscriptions "recommendations" surface.
const UNTRACKED_SUBS = [
  { payee: 'HULU', amount: 17.99, day: 6 },
  { payee: 'HBO MAX', amount: 15.99, day: 11 },
  { payee: 'YOUTUBE PREMIUM', amount: 13.99, day: 19 },
];

// Everyday spending (not bills) → populate the Spending page + budgets/rules.
const SPENDING_MERCHANTS = [
  { payee: 'WHOLE FOODS MARKET', category: 'Groceries', amounts: [82.14, 46.03, 118.77] },
  { payee: "TRADER JOE'S", category: 'Groceries', amounts: [54.2, 61.88] },
  { payee: 'CHIPOTLE', category: 'Dining Out', amounts: [14.85, 22.4] },
  { payee: 'OLIVE GARDEN', category: 'Dining Out', amounts: [63.12] },
  { payee: 'SHELL OIL', category: 'Gas & Fuel', amounts: [48.9, 51.35] },
  { payee: 'AMAZON MARKETPLACE', category: 'Shopping', amounts: [39.99, 27.49, 112.0] },
  { payee: 'STARBUCKS', category: 'Coffee', amounts: [6.45, 5.75, 6.45] },
];
const SPENDING_RULES = [
  { merchant: 'WHOLE FOODS', category: 'Groceries' },
  { merchant: 'SHELL', category: 'Gas & Fuel' },
  { merchant: 'STARBUCKS', category: 'Coffee' },
  { merchant: 'AMAZON', category: 'Shopping' },
];
const SPENDING_BUDGETS = {
  Groceries: 500,
  'Dining Out': 200,
  'Gas & Fuel': 160,
  Shopping: 250,
  Coffee: 40,
};

const HISTORY_MONTHS = 6; // months of payment history to generate (incl. current)

// ── Date helpers ────────────────────────────────────────────────────────────

function ymd(d) {
  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}
function clampedDate(year, monthIdx0, day) {
  const lastDay = new Date(year, monthIdx0 + 1, 0).getDate();
  return new Date(year, monthIdx0, Math.min(day, lastDay));
}
// Month offsets (0 = current, negative = past) a bill occurs in, within the window.
function cycleOffsets(bill) {
  switch (bill.cycle) {
    case 'annually':
      return [-1];
    case 'quarterly':
      return [0, -3];
    case 'irregular':
      return [0, -1, -2];
    default:
      return Array.from({ length: HISTORY_MONTHS }, (_, i) => -(HISTORY_MONTHS - 1) + i); // -5..0
  }
}
// Small deterministic-ish drift on variable bills so amounts differ from expected.
function driftedAmount(bill, offset) {
  const variable = ['Utilities'].includes(bill.category) && !bill.currentBalance;
  if (!variable) return bill.amount;
  const pct = ((Math.abs(bill.name.length * 7 + offset * 13) % 21) - 10) / 100; // ±10%
  return Math.round(bill.amount * (1 + pct) * 100) / 100;
}

// ── Main ────────────────────────────────────────────────────────────────────

function seedDemoData(userId = null) {
  const db = getDb();
  const now = new Date();
  const todayStr = ymd(now);

  const targetUser =
    userId !== null
      ? db.prepare('SELECT id FROM users WHERE id = ?').get(userId)
      : db.prepare("SELECT id FROM users WHERE role = 'admin' ORDER BY id LIMIT 1").get();
  if (!targetUser) throw new Error('User not found. Please create a user first.');
  const uid = targetUser.id;

  const alreadySeeded = db
    .prepare('SELECT COUNT(*) AS c FROM bills WHERE user_id = ? AND is_seeded = 1')
    .get(uid).c;
  if (alreadySeeded > 0) {
    const err = new Error(
      'Demo data is already seeded for this account. Clear it first to re-seed.',
    );
    err.status = 409;
    err.code = 'ALREADY_SEEDED';
    throw err;
  }

  const counts = {
    bills: 0,
    categories: 0,
    groups: 0,
    payments: 0,
    transactions: 0,
    monthlyState: 0,
    planning: 0,
    budgets: 0,
    spendingRules: 0,
    merchantRules: 0,
    snowballPlans: 0,
    calendarTokens: 0,
  };

  db.transaction(() => {
    ensureUserDefaultCategories(uid);

    // ── Categories (bill + spending), flagging ONLY ones this seed creates ──
    const catId = {};
    const getOrCreateCategory = (name, { spending = false } = {}) => {
      const existing = db
        .prepare('SELECT id FROM categories WHERE user_id = ? AND name = ? COLLATE NOCASE')
        .get(uid, name);
      if (existing) {
        catId[name] = existing.id;
        return;
      }
      const r = db
        .prepare(
          'INSERT INTO categories (user_id, name, spending_enabled, is_seeded) VALUES (?, ?, ?, 1)',
        )
        .run(uid, name, spending ? 1 : 0);
      catId[name] = r.lastInsertRowid;
      counts.categories++;
    };
    for (const name of BILL_CATEGORIES) getOrCreateCategory(name);
    for (const name of SPENDING_CATEGORIES) getOrCreateCategory(name, { spending: true });

    // ── Category groups (organise spending categories) ──
    for (const [i, grp] of CATEGORY_GROUPS.entries()) {
      const r = db
        .prepare(
          'INSERT INTO category_groups (user_id, name, sort_order, is_seeded) VALUES (?, ?, ?, 1)',
        )
        .run(uid, grp.name, i);
      counts.groups++;
      for (const member of grp.members) {
        if (catId[member])
          db.prepare('UPDATE categories SET group_id = ? WHERE id = ?').run(
            r.lastInsertRowid,
            catId[member],
          );
      }
    }

    // ── Bills ──
    const insertBill = db.prepare(`
      INSERT INTO bills (
        user_id, name, category_id, due_day, billing_cycle, cycle_type,
        expected_amount, autopay_enabled, autodraft_status, autopay_verified_at, interest_rate,
        current_balance, minimum_payment, snowball_order, snowball_include, snowball_exempt,
        is_subscription, subscription_type, website, has_2fa, active, is_seeded
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 1)
    `);
    const billId = {};
    for (const b of BILLS) {
      const verifiedAt = b.autopayVerified
        ? ymd(clampedDate(now.getFullYear(), now.getMonth(), Math.min(b.dueDay, 28)))
        : null;
      const r = insertBill.run(
        uid,
        b.name,
        catId[b.category] ?? null,
        b.dueDay,
        b.cycle,
        b.cycleType,
        toCents(b.amount),
        b.autopay ? 1 : 0,
        b.autopayVerified ? 'confirmed' : 'none',
        verifiedAt,
        b.interestRate ?? 0,
        b.currentBalance != null ? toCents(b.currentBalance) : null,
        b.minPayment != null ? toCents(b.minPayment) : null,
        b.snowballOrder ?? null,
        b.snowballInclude ?? 0,
        b.snowballExempt ?? 0,
        b.isSubscription ? 1 : 0,
        b.subscriptionType ?? null,
        b.website ?? null,
        b.has2fa ? 1 : 0,
      );
      billId[b.name] = r.lastInsertRowid;
      counts.bills++;
    }

    // ── Demo bank source + account (for matched/unmatched transactions) ──
    const source = db
      .prepare(
        "INSERT INTO data_sources (user_id, type, provider, name, status, is_seeded) VALUES (?, 'manual', 'demo', 'Demo Bank', 'active', 1)",
      )
      .run(uid);
    const sourceId = source.lastInsertRowid;
    const account = db
      .prepare(
        `
      INSERT INTO financial_accounts
        (user_id, data_source_id, provider_account_id, name, org_name, account_type, currency, balance, available_balance, monitored, is_seeded)
      VALUES (?, ?, 'demo-checking', 'Everyday Checking', 'Demo Bank', 'checking', 'USD', ?, ?, 1, 1)
    `,
      )
      .run(uid, sourceId, toCents(4210.55), toCents(4210.55));
    const accountId = account.lastInsertRowid;

    let txnSeq = 0;
    const insertTxn = db.prepare(`
      INSERT INTO transactions
        (user_id, data_source_id, account_id, provider_transaction_id, source_type, transaction_type,
         posted_date, transacted_at, amount, currency, description, payee, category,
         matched_bill_id, match_status, spending_category_id, is_seeded)
      VALUES (?, ?, ?, ?, 'manual', ?, ?, ?, ?, 'USD', ?, ?, ?, ?, ?, ?, 1)
    `);
    const addTxn = ({
      type = 'debit',
      date,
      amountDollars,
      description,
      payee,
      category = null,
      matchedBillId = null,
      matchStatus = 'unmatched',
      spendingCategoryId = null,
    }) => {
      const cents =
        type === 'credit' ? toCents(Math.abs(amountDollars)) : -toCents(Math.abs(amountDollars));
      const r = insertTxn.run(
        uid,
        sourceId,
        accountId,
        `demo-${++txnSeq}`,
        type,
        date,
        date,
        cents,
        description,
        payee,
        category,
        matchedBillId,
        matchStatus,
        spendingCategoryId,
      );
      counts.transactions++;
      return r.lastInsertRowid;
    };

    // ── Payment history + matched bank transactions + monthly overrides ──
    const insertPayment = db.prepare(`
      INSERT INTO payments (bill_id, amount, paid_date, method, notes, balance_delta, payment_source, transaction_id)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
    `);
    for (const b of BILLS) {
      const bid = billId[b.name];
      for (const offset of cycleOffsets(b)) {
        const y = now.getFullYear(),
          m = now.getMonth() + offset;
        const payDate = clampedDate(y, m, b.dueDay);
        if (payDate > now) continue; // future occurrence → naturally "upcoming", no payment

        // Deliberate skipped month → recorded as a monthly_bill_state skip, no payment.
        if (b.name === SKIP.bill && offset === -SKIP.monthsAgo) {
          db.prepare(
            'INSERT INTO monthly_bill_state (bill_id, year, month, is_skipped) VALUES (?, ?, ?, 1)',
          ).run(bid, payDate.getFullYear(), payDate.getMonth() + 1);
          counts.monthlyState++;
          continue;
        }
        // Current month: leave the designated overdue bills unpaid (past due, no payment).
        if (offset === 0 && OVERDUE_THIS_MONTH.has(b.name)) continue;

        let amount = driftedAmount(b, offset);
        if (b.name === OVERRIDE.bill && offset === -OVERRIDE.monthsAgo) amount = OVERRIDE.actual;

        // Debt bills: split into interest + principal so the balance pays down.
        let balanceDelta = null;
        if (b.currentBalance) {
          const interest = Math.round(
            (toCents(b.currentBalance) * (b.interestRate ?? 0)) / 100 / 12,
          );
          balanceDelta = -Math.max(0, toCents(amount) - interest);
        }

        // A subset of recent payments are auto-matched to a seeded bank transaction.
        let txnId = null,
          source_ = 'manual';
        if (BANK_MATCHED.has(b.name) && offset >= -1) {
          txnId = addTxn({
            date: ymd(payDate),
            amountDollars: amount,
            description: `${b.name.toUpperCase()} AUTOPAY`,
            payee: b.name,
            matchedBillId: bid,
            matchStatus: 'matched',
          });
          source_ = 'transaction_match';
        }

        insertPayment.run(
          bid,
          toCents(amount),
          ymd(payDate),
          'demo',
          null,
          balanceDelta,
          source_,
          txnId,
        );
        counts.payments++;
      }
    }

    // Amount-override state (actual recorded above; flag the month's actual_amount) + a note.
    {
      const od = clampedDate(now.getFullYear(), now.getMonth() - OVERRIDE.monthsAgo, 1);
      db.prepare(
        'INSERT INTO monthly_bill_state (bill_id, year, month, actual_amount) VALUES (?, ?, ?, ?)',
      ).run(billId[OVERRIDE.bill], od.getFullYear(), od.getMonth() + 1, toCents(OVERRIDE.actual));
      counts.monthlyState++;
      db.prepare(
        'INSERT INTO monthly_bill_state (bill_id, year, month, notes) VALUES (?, ?, ?, ?)',
      ).run(billId[NOTE.bill], now.getFullYear(), now.getMonth() + 1, NOTE.text);
      counts.monthlyState++;
      // Snooze one overdue bill's alert (Overdue Command Center demo).
      const snoozeUntil = ymd(new Date(now.getFullYear(), now.getMonth(), now.getDate() + 5));
      db.prepare(
        'INSERT INTO monthly_bill_state (bill_id, year, month, snoozed_until) VALUES (?, ?, ?, ?)',
      ).run(billId['Trash Service'], now.getFullYear(), now.getMonth() + 1, snoozeUntil);
      counts.monthlyState++;
    }

    // ── Unmatched bank transactions that look like bills → Matches suggestions ──
    for (const name of ['Gas Utility', 'City Water Dept']) {
      const b = BILLS.find((x) => x.name === name);
      const d = clampedDate(now.getFullYear(), now.getMonth(), b.dueDay);
      if (d <= now)
        addTxn({
          date: ymd(d),
          amountDollars: b.amount,
          description: `${name.toUpperCase()} PMT`,
          payee: name,
        });
    }
    // ── Un-tracked subscription charges → Subscriptions recommendations ──
    for (const s of UNTRACKED_SUBS) {
      const d = clampedDate(now.getFullYear(), now.getMonth(), s.day);
      if (d <= now)
        addTxn({
          date: ymd(d),
          amountDollars: s.amount,
          description: `${s.payee} SUBSCRIPTION`,
          payee: s.payee,
        });
    }
    // ── Everyday spending transactions (categorised) → Spending page ──
    for (const merchant of SPENDING_MERCHANTS) {
      const scid = catId[merchant.category] ?? null;
      merchant.amounts.forEach((amt, i) => {
        const d = clampedDate(now.getFullYear(), now.getMonth() - (i % 2), 2 + ((i * 5) % 26));
        if (d <= now)
          addTxn({
            date: ymd(d),
            amountDollars: amt,
            description: merchant.payee,
            payee: merchant.payee,
            spendingCategoryId: scid,
          });
      });
    }

    // ── Planning: monthly income + starting amounts (recent months) ──
    for (let off = -3; off <= 0; off++) {
      const d = new Date(now.getFullYear(), now.getMonth() + off, 1);
      const y = d.getFullYear(),
        mo = d.getMonth() + 1;
      const hasIncome = db
        .prepare('SELECT 1 FROM monthly_income WHERE user_id = ? AND year = ? AND month = ?')
        .get(uid, y, mo);
      if (!hasIncome) {
        db.prepare(
          'INSERT INTO monthly_income (user_id, year, month, label, amount, is_seeded) VALUES (?, ?, ?, ?, ?, 1)',
        ).run(uid, y, mo, 'Paycheck', toCents(5200));
        counts.planning++;
      }
      const hasStart = db
        .prepare(
          'SELECT 1 FROM monthly_starting_amounts WHERE user_id = ? AND year = ? AND month = ?',
        )
        .get(uid, y, mo);
      if (!hasStart) {
        db.prepare(
          'INSERT INTO monthly_starting_amounts (user_id, year, month, first_amount, fifteenth_amount, is_seeded) VALUES (?, ?, ?, ?, ?, 1)',
        ).run(uid, y, mo, toCents(3200), toCents(2800));
        counts.planning++;
      }
    }

    // ── Spending budgets + auto-categorise rules ──
    for (const [cat, amount] of Object.entries(SPENDING_BUDGETS)) {
      if (!catId[cat]) continue;
      db.prepare(
        'INSERT INTO spending_budgets (user_id, category_id, year, month, amount, is_seeded) VALUES (?, ?, ?, ?, ?, 1)',
      ).run(uid, catId[cat], now.getFullYear(), now.getMonth() + 1, toCents(amount));
      counts.budgets++;
    }
    for (const rule of SPENDING_RULES) {
      if (!catId[rule.category]) continue;
      db.prepare(
        'INSERT INTO spending_category_rules (user_id, category_id, merchant, is_seeded) VALUES (?, ?, ?, 1)',
      ).run(uid, catId[rule.category], rule.merchant);
      counts.spendingRules++;
    }

    // ── Snowball: an active plan + the user's extra-payment setting ──
    const debtBills = BILLS.filter((b) => b.snowballInclude).sort(
      (a, b) => (a.snowballOrder ?? 99) - (b.snowballOrder ?? 99),
    );
    const snapshot = JSON.stringify({
      method: 'snowball',
      extra_payment_cents: toCents(200),
      order: debtBills.map((b) => ({
        bill_id: billId[b.name],
        name: b.name,
        balance_cents: toCents(b.currentBalance),
      })),
    });
    db.prepare(
      `INSERT INTO snowball_plans (user_id, name, method, status, extra_payment, plan_snapshot, is_seeded)
                VALUES (?, 'My Debt Snowball', 'snowball', 'active', ?, ?, 1)`,
    ).run(uid, toCents(200), snapshot);
    counts.snowballPlans++;
    // Only set the extra-payment if the user hasn't chosen one (don't clobber real data).
    db.prepare(
      'UPDATE users SET snowball_extra_payment = ? WHERE id = ? AND COALESCE(snowball_extra_payment, 0) = 0',
    ).run(toCents(200), uid);

    // ── Merchant → bill auto-match rules (cascade with their bill) ──
    for (const name of ['Netflix', 'Spotify']) {
      db.prepare(
        'INSERT INTO bill_merchant_rules (user_id, bill_id, merchant) VALUES (?, ?, ?)',
      ).run(uid, billId[name], name.toUpperCase());
      counts.merchantRules++;
    }

    // ── Calendar feed subscription token ──
    const crypto = require('crypto');
    db.prepare(
      'INSERT INTO calendar_tokens (user_id, token, label, active, is_seeded) VALUES (?, ?, ?, 1, 1)',
    ).run(uid, crypto.randomBytes(24).toString('hex'), 'Demo Calendar Feed');
    counts.calendarTokens++;
  })();

  return {
    billsCreated: counts.bills,
    categoriesCreated: counts.categories,
    paymentsCreated: counts.payments,
    transactionsCreated: counts.transactions,
    counts,
  };
}

// CLI entry
if (require.main === module) {
  try {
    const result = seedDemoData();
    console.log('\n✅ Seed complete:', JSON.stringify(result.counts, null, 2));
    process.exit(0);
  } catch (err) {
    console.error('Seed failed:', err.message);
    process.exit(err.code === 'ALREADY_SEEDED' ? 0 : 1);
  }
}

module.exports = { seedDemoData };