//! Portfolio timeline analytics — pure compute over snapshot history.
//!
//! This module takes pre-loaded portfolio snapshots (see `src/history.zig`
//! for the IO layer that produces them) and reduces them to time-series
//! data for display or export. Nothing here touches the filesystem, the
//! network, or a writer — that's by design, so the logic can be tested
//! exhaustively with fixture data.
//!
//! Typical flow:
//!   snapshots : []const Snapshot      <- history.loadHistoryDir(...)
//!        │
//!        ▼
//!   buildSeries(snapshots)            -> TimelineSeries (sorted by date)
//!        │
//!        ▼
//!   filterByDate(series, since, until) (optional)
//!        │
//!        ▼
//!   extractMetric(series, .net_worth) -> []MetricPoint for rendering
//!
//! For rollup generation, `buildRollupRecords` emits a flat slice suitable
//! for `srf.fmtFrom` without any of the per-lot detail — the rollup is a
//! summary cache, not a replacement for the per-day snapshot files.

const std = @import("std");
const Date = @import("../models/date.zig").Date;
const snapshot = @import("../models/snapshot.zig");
const valuation = @import("valuation.zig");
const HistoricalPeriod = valuation.HistoricalPeriod;

// ── Public types ─────────────────────────────────────────────

/// A single point on the portfolio timeline. Totals are always present
/// (they're the three `kind::total` rows every snapshot emits); the
/// per-account / per-tax-type maps are only populated when the source
/// snapshot included analysis breakdowns.
///
/// Values are dollar amounts. Weights aren't stored — callers can
/// compute them cheaply from the totals when rendering.
pub const TimelinePoint = struct {
    as_of_date: Date,
    net_worth: f64,
    liquid: f64,
    illiquid: f64,
    /// Per-account totals. Empty when the source snapshot had no
    /// analysis breakdown (e.g. backfilled-from-.txt snapshots).
    /// Keys are account names; values are dollar totals.
    accounts: []const NamedValue,
    /// Per-tax-type totals. Same caveat as `accounts`.
    tax_types: []const NamedValue,

    /// Deinit releases only the owned slices (`accounts`, `tax_types`).
    /// The strings inside those slices are borrowed from the source
    /// Snapshot's arena and must not be freed here.
    pub fn deinit(self: TimelinePoint, allocator: std.mem.Allocator) void {
        allocator.free(self.accounts);
        allocator.free(self.tax_types);
    }
};

pub const NamedValue = struct {
    name: []const u8,
    value: f64,
};

/// An ordered series of TimelinePoint sorted ascending by as_of_date.
/// Duplicates by date shouldn't happen (snapshot filenames enforce one
/// per day) but if they do the caller's last-write-wins.
pub const TimelineSeries = struct {
    points: []TimelinePoint,
    allocator: std.mem.Allocator,

    pub fn deinit(self: TimelineSeries) void {
        for (self.points) |p| p.deinit(self.allocator);
        self.allocator.free(self.points);
    }
};

/// Which metric to extract for single-series display.
pub const Metric = enum {
    net_worth,
    liquid,
    illiquid,

    pub fn label(self: Metric) []const u8 {
        return switch (self) {
            .net_worth => "Net Worth",
            .liquid => "Liquid",
            .illiquid => "Illiquid",
        };
    }
};

/// One row of the extracted single-metric series. Used as input to
/// renderers and for mathematical operations (diffs, deltas, sparklines).
pub const MetricPoint = struct {
    date: Date,
    value: f64,
};

// ── Core construction ────────────────────────────────────────

/// Build a TimelineSeries from a slice of snapshots.
///
/// Input snapshots are NOT required to be sorted; this function sorts
/// by `as_of_date` ascending. Each returned point's `accounts` and
/// `tax_types` slices borrow strings from the source Snapshot's arena
/// but own their own outer slice (freed by TimelinePoint.deinit).
pub fn buildSeries(
    allocator: std.mem.Allocator,
    snapshots: []const snapshot.Snapshot,
) !TimelineSeries {
    var points = try allocator.alloc(TimelinePoint, snapshots.len);
    errdefer {
        // On error, free any already-populated points' nested slices.
        allocator.free(points);
    }

    var populated: usize = 0;
    errdefer {
        for (points[0..populated]) |p| p.deinit(allocator);
    }

    for (snapshots, 0..) |snap, idx| {
        points[idx] = try snapshotToPoint(allocator, snap);
        populated = idx + 1;
    }

    std.mem.sort(TimelinePoint, points, {}, lessByDate);

    return .{ .points = points, .allocator = allocator };
}

fn lessByDate(_: void, a: TimelinePoint, b: TimelinePoint) bool {
    return a.as_of_date.lessThan(b.as_of_date);
}

/// Derive a TimelinePoint from a single Snapshot. Pure — no IO.
///
/// Exposed for testability. `buildSeries` is the usual entry point.
pub fn snapshotToPoint(
    allocator: std.mem.Allocator,
    snap: snapshot.Snapshot,
) !TimelinePoint {
    var nw: f64 = 0;
    var liq: f64 = 0;
    var ill: f64 = 0;
    for (snap.totals) |t| {
        if (std.mem.eql(u8, t.scope, "net_worth")) nw = t.value;
        if (std.mem.eql(u8, t.scope, "liquid")) liq = t.value;
        if (std.mem.eql(u8, t.scope, "illiquid")) ill = t.value;
    }

    const accts = try allocator.alloc(NamedValue, snap.accounts.len);
    errdefer allocator.free(accts);
    for (snap.accounts, 0..) |a, i| {
        accts[i] = .{ .name = a.name, .value = a.value };
    }

    const tts = try allocator.alloc(NamedValue, snap.tax_types.len);
    errdefer allocator.free(tts);
    for (snap.tax_types, 0..) |t, i| {
        tts[i] = .{ .name = t.label, .value = t.value };
    }

    return .{
        .as_of_date = snap.meta.as_of_date,
        .net_worth = nw,
        .liquid = liq,
        .illiquid = ill,
        .accounts = accts,
        .tax_types = tts,
    };
}

// ── Filters ──────────────────────────────────────────────────

/// Return the subset of `points` whose `as_of_date` falls within the
/// inclusive `[since, until]` range. Either bound may be null to leave
/// that end open. The resulting slice is newly allocated; caller owns.
///
/// This does NOT free the input points — the caller remains responsible
/// for the original TimelineSeries.
pub fn filterByDate(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
    since: ?Date,
    until: ?Date,
) ![]TimelinePoint {
    var kept: std.ArrayList(TimelinePoint) = .empty;
    errdefer kept.deinit(allocator);

    for (points) |p| {
        if (since) |s| if (p.as_of_date.lessThan(s)) continue;
        if (until) |u| if (u.lessThan(p.as_of_date)) continue;
        try kept.append(allocator, p);
    }

    return kept.toOwnedSlice(allocator);
}

// ── Metric extraction ────────────────────────────────────────

/// Extract a single top-level metric into a flat `[]MetricPoint` ready
/// for rendering or statistical analysis. Result is caller-owned.
pub fn extractMetric(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
    metric: Metric,
) ![]MetricPoint {
    var out = try allocator.alloc(MetricPoint, points.len);
    for (points, 0..) |p, i| {
        out[i] = .{
            .date = p.as_of_date,
            .value = switch (metric) {
                .net_worth => p.net_worth,
                .liquid => p.liquid,
                .illiquid => p.illiquid,
            },
        };
    }
    return out;
}

/// Which collection of per-row named values on `TimelinePoint` to project.
pub const NamedSeriesSource = enum { accounts, tax_types };

/// Extract a single-metric series for a named row (an account or a
/// tax-type label) from the timeline. Dates without the named row emit
/// `value = 0` rather than being skipped, so the returned slice has
/// `points.len` entries — suitable for stacked displays that need a row
/// per named entity per date.
///
/// Caller owns the returned slice.
pub fn extractNamedSeries(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
    source: NamedSeriesSource,
    name: []const u8,
) ![]MetricPoint {
    var out = try allocator.alloc(MetricPoint, points.len);
    for (points, 0..) |p, i| {
        const rows = switch (source) {
            .accounts => p.accounts,
            .tax_types => p.tax_types,
        };
        var v: f64 = 0;
        for (rows) |r| {
            if (std.mem.eql(u8, r.name, name)) {
                v = r.value;
                break;
            }
        }
        out[i] = .{ .date = p.as_of_date, .value = v };
    }
    return out;
}

// ── Deltas / statistics ──────────────────────────────────────

/// Summary statistics over a single-metric series.
pub const MetricStats = struct {
    first: f64,
    last: f64,
    min: f64,
    max: f64,
    /// `last - first`. Dollars, not percent.
    delta_abs: f64,
    /// `(last - first) / first` — or null when `first == 0` (division
    /// by zero); callers should render "n/a" or similar.
    delta_pct: ?f64,
};

/// Compute min/max/first/last/delta over a MetricPoint slice. Returns
/// null on empty input — every field would be meaningless otherwise.
pub fn computeStats(points: []const MetricPoint) ?MetricStats {
    if (points.len == 0) return null;

    var min_v = points[0].value;
    var max_v = points[0].value;
    for (points[1..]) |p| {
        if (p.value < min_v) min_v = p.value;
        if (p.value > max_v) max_v = p.value;
    }

    const first = points[0].value;
    const last = points[points.len - 1].value;
    const delta = last - first;

    return .{
        .first = first,
        .last = last,
        .min = min_v,
        .max = max_v,
        .delta_abs = delta,
        .delta_pct = if (first == 0) null else delta / first,
    };
}

// ── Rollup emission ──────────────────────────────────────────

/// A single row in `history/rollup.srf`. Deliberately slim: one record
/// per date, carrying the three totals only. Per-account and per-
/// tax-type detail stays in the per-day files.
///
/// The `kind` discriminator pattern is consistent with the snapshot
/// format. Not strictly required here (the file has only one record
/// type) but future-proof if we ever add other rollup shapes.
pub const RollupRow = struct {
    kind: []const u8,
    as_of_date: Date,
    net_worth: f64,
    liquid: f64,
    illiquid: f64,
};

/// Produce a rollup-row slice from a TimelineSeries. Pure function —
/// caller owns the result, ready to hand to `srf.fmtFrom`.
pub fn buildRollupRecords(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
) ![]RollupRow {
    var out = try allocator.alloc(RollupRow, points.len);
    for (points, 0..) |p, i| {
        out[i] = .{
            .kind = "rollup",
            .as_of_date = p.as_of_date,
            .net_worth = p.net_worth,
            .liquid = p.liquid,
            .illiquid = p.illiquid,
        };
    }
    return out;
}

// ── Snap-backward for snapshot points ────────────────────────

fn pointDateOf(p: TimelinePoint) Date {
    return p.as_of_date;
}

/// Return the latest point on or before `target`. Null if `points` is
/// empty or every entry sits strictly after `target`.
///
/// Delegates to the shared `valuation.indexAtOrBefore` kernel — same
/// snap-backward behavior used by candle pricing, so holiday/weekend
/// semantics are identical across the app. No slack cap: snapshot
/// history is dense enough by construction (one entry per trading day)
/// that caps would only hide real gaps.
pub fn pointAtOrBefore(points: []const TimelinePoint, target: Date) ?*const TimelinePoint {
    const idx = valuation.indexAtOrBefore(TimelinePoint, points, target, pointDateOf) orelse return null;
    return &points[idx];
}

// ── Rolling-windows block ────────────────────────────────────

/// One row in the rolling-windows block. `anchor_date` / `start_value` /
/// `delta_*` are null when there isn't enough history to honor the
/// window (e.g. asking for 10-year on a 2-week-old portfolio).
///
/// `end_value` is always populated — it's the latest point in the
/// series, which must exist for the block to render at all.
pub const WindowStat = struct {
    /// The period this row represents. Null for the synthetic "All-time"
    /// row (anchored to the first snapshot rather than to `today - N`).
    period: ?HistoricalPeriod,
    /// Human-facing label ("1 day", "YTD", "All-time").
    label: []const u8,
    /// Short label used when horizontal space is tight ("1D", "YTD").
    short_label: []const u8,
    /// The snapshot date we anchored to. Null when no snapshot exists at
    /// or before the target date — i.e. not enough history.
    anchor_date: ?Date,
    /// The anchor snapshot's metric value. Null when anchor is missing.
    start_value: ?f64,
    /// Always populated — the latest snapshot's metric value.
    end_value: f64,
    /// `end_value - start_value`. Null when start is missing.
    delta_abs: ?f64,
    /// `(end_value - start_value) / start_value`. Null when start is
    /// missing OR when start is exactly zero (division by zero).
    delta_pct: ?f64,
};

/// Rolling-windows block for a single metric. Owns the `rows` slice.
/// Order: 8 relative-to-today periods (from HistoricalPeriod.timeline_windows),
/// then a final synthetic "All-time" row anchored to the first snapshot.
pub const WindowSet = struct {
    rows: []WindowStat,
    allocator: std.mem.Allocator,

    pub fn deinit(self: WindowSet) void {
        self.allocator.free(self.rows);
    }
};

fn extractValue(p: TimelinePoint, metric: Metric) f64 {
    return switch (metric) {
        .net_worth => p.net_worth,
        .liquid => p.liquid,
        .illiquid => p.illiquid,
    };
}

/// Build the rolling-windows block for one metric. `today` is the
/// reference "now" — almost always the last snapshot's as_of_date, but
/// taken as a parameter so tests can pin deterministic scenarios.
///
/// Returns an empty set when `points` is empty.
pub fn computeWindowSet(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
    metric: Metric,
    today: Date,
) !WindowSet {
    if (points.len == 0) {
        return .{ .rows = &.{}, .allocator = allocator };
    }

    const windows = HistoricalPeriod.timeline_windows;
    var rows = try allocator.alloc(WindowStat, windows.len + 1);
    errdefer allocator.free(rows);

    const end_point = points[points.len - 1];
    const end_value = extractValue(end_point, metric);

    for (windows, 0..) |period, i| {
        const target = period.targetDate(today);
        const anchor_opt = pointAtOrBefore(points, target);

        rows[i] = if (anchor_opt) |a| .{
            .period = period,
            .label = period.longLabel(),
            .short_label = period.label(),
            .anchor_date = a.as_of_date,
            .start_value = extractValue(a.*, metric),
            .end_value = end_value,
            .delta_abs = end_value - extractValue(a.*, metric),
            .delta_pct = blk: {
                const sv = extractValue(a.*, metric);
                break :blk if (sv == 0) null else (end_value - sv) / sv;
            },
        } else .{
            .period = period,
            .label = period.longLabel(),
            .short_label = period.label(),
            .anchor_date = null,
            .start_value = null,
            .end_value = end_value,
            .delta_abs = null,
            .delta_pct = null,
        };
    }

    // All-time = vs. first snapshot in series. Not a HistoricalPeriod
    // member because it isn't relative to `today` (see valuation.zig
    // doc block).
    const first = points[0];
    const first_value = extractValue(first, metric);
    rows[windows.len] = .{
        .period = null,
        .label = "All-time",
        .short_label = "All",
        .anchor_date = first.as_of_date,
        .start_value = first_value,
        .end_value = end_value,
        .delta_abs = end_value - first_value,
        .delta_pct = if (first_value == 0) null else (end_value - first_value) / first_value,
    };

    return .{ .rows = rows, .allocator = allocator };
}

// ── Per-row day-over-day deltas ──────────────────────────────

/// One row in the "Recent snapshots" table after per-row deltas have
/// been computed. The delta is *relative to the previous row in the
/// same resolution* — i.e. when the table is aggregated to weekly,
/// `d_*` fields hold week-over-week change.
///
/// First row has all `d_*` fields null (no prior row to compare against).
pub const RowDelta = struct {
    date: Date,
    liquid: f64,
    illiquid: f64,
    net_worth: f64,
    d_liquid: ?f64,
    d_illiquid: ?f64,
    d_net_worth: ?f64,
};

/// Compute per-row deltas against the previous row. Returns a
/// newly-allocated slice the caller owns. Empty input -> empty output.
pub fn computeRowDeltas(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
) ![]RowDelta {
    var out = try allocator.alloc(RowDelta, points.len);
    for (points, 0..) |p, i| {
        out[i] = .{
            .date = p.as_of_date,
            .liquid = p.liquid,
            .illiquid = p.illiquid,
            .net_worth = p.net_worth,
            .d_liquid = if (i == 0) null else p.liquid - points[i - 1].liquid,
            .d_illiquid = if (i == 0) null else p.illiquid - points[i - 1].illiquid,
            .d_net_worth = if (i == 0) null else p.net_worth - points[i - 1].net_worth,
        };
    }
    return out;
}

// ── Resolution (daily / weekly / monthly) ────────────────────

pub const Resolution = enum {
    daily,
    weekly,
    monthly,

    pub fn label(self: Resolution) []const u8 {
        return switch (self) {
            .daily => "daily",
            .weekly => "weekly",
            .monthly => "monthly",
        };
    }
};

/// Pick a default resolution based on series span.
///   span ≤ 90d  → daily
///   span ≤ 730d → weekly
///   else        → monthly
///
/// Empty / single-point series always return `daily` (there's nothing
/// to aggregate).
pub fn selectResolution(points: []const TimelinePoint) Resolution {
    if (points.len < 2) return .daily;
    const first = points[0].as_of_date;
    const last = points[points.len - 1].as_of_date;
    const span_days = last.days - first.days;
    if (span_days <= 90) return .daily;
    if (span_days <= 730) return .weekly;
    return .monthly;
}

/// Aggregate `points` to the requested resolution. Returns a
/// newly-allocated slice the caller owns.
///
/// `daily`   → returns a copy of the input.
/// `weekly`  → rolling 7-day buckets walking *backward from latest*, one
///             representative point per bucket (the latest in the bucket,
///             not the oldest — matches brokerage weekly-bar convention).
///             The returned slice is sorted ascending by date.
/// `monthly` → groups by calendar (year, month); picks the latest snapshot
///             in each month. Sorted ascending by date.
///
/// Empty input returns an empty owned slice.
pub fn aggregatePoints(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
    resolution: Resolution,
) ![]TimelinePoint {
    if (points.len == 0) return allocator.alloc(TimelinePoint, 0);

    switch (resolution) {
        .daily => {
            const out = try allocator.alloc(TimelinePoint, points.len);
            @memcpy(out, points);
            return out;
        },
        .weekly => return aggregateWeeklyRolling(allocator, points),
        .monthly => return aggregateMonthly(allocator, points),
    }
}

/// Walk backward in 7-day strides from the latest point. The latest
/// point always seeds bucket 0; subsequent buckets cover
/// `(latest - 7i - 6) … (latest - 7i)` inclusive. Each bucket emits
/// its latest-date member. Output is sorted ascending.
fn aggregateWeeklyRolling(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
) ![]TimelinePoint {
    var picked: std.ArrayList(TimelinePoint) = .empty;
    errdefer picked.deinit(allocator);

    const last_date = points[points.len - 1].as_of_date;

    // Bucket index i covers dates in [last - 7i - 6, last - 7i].
    // We scan points newest-first. For each point, compute its bucket
    // relative to `last`; keep the first (i.e. newest) one we see per
    // bucket.
    var current_bucket: i32 = -1;
    var i: usize = points.len;
    while (i > 0) {
        i -= 1;
        const p = points[i];
        const age_days = last_date.days - p.as_of_date.days;
        if (age_days < 0) continue; // shouldn't happen (series is sorted)
        const bucket: i32 = @divFloor(age_days, 7);
        if (bucket != current_bucket) {
            try picked.append(allocator, p);
            current_bucket = bucket;
        }
    }

    // picked is newest-first; reverse to ascending.
    std.mem.reverse(TimelinePoint, picked.items);
    return picked.toOwnedSlice(allocator);
}

/// Group by (year, month); emit the latest-date member of each group.
fn aggregateMonthly(
    allocator: std.mem.Allocator,
    points: []const TimelinePoint,
) ![]TimelinePoint {
    var picked: std.ArrayList(TimelinePoint) = .empty;
    errdefer picked.deinit(allocator);

    // Scan ascending (points are already sorted). For each (year, month)
    // key, keep updating the "representative" point until the key
    // changes; then commit the previous one.
    var cur_year: i16 = 0;
    var cur_month: u8 = 0;
    var cur_point: ?TimelinePoint = null;

    for (points) |p| {
        const y = p.as_of_date.year();
        const m = p.as_of_date.month();
        if (cur_point == null) {
            cur_year = y;
            cur_month = m;
            cur_point = p;
            continue;
        }
        if (y == cur_year and m == cur_month) {
            cur_point = p; // same month; keep the latest
        } else {
            try picked.append(allocator, cur_point.?);
            cur_year = y;
            cur_month = m;
            cur_point = p;
        }
    }
    if (cur_point) |p| try picked.append(allocator, p);

    return picked.toOwnedSlice(allocator);
}

// ── Tests ────────────────────────────────────────────────────
//
// Pure compute — every function here can be exercised with fixture
// structs. No IO, no writer, no colors.

const testing = std.testing;

/// Populate `buf` with the three total rows and return a minimal
/// Snapshot fixture for tests. Each test supplies its own `buf` (three
/// `TotalRow`s on the stack) so storage doesn't alias across calls.
fn fixtureSnapshot(
    buf: *[3]snapshot.TotalRow,
    y: i16,
    m: u8,
    d: u8,
    net_worth: f64,
    liquid: f64,
    illiquid: f64,
) snapshot.Snapshot {
    buf[0] = .{ .kind = "total", .scope = "net_worth", .value = net_worth };
    buf[1] = .{ .kind = "total", .scope = "liquid", .value = liquid };
    buf[2] = .{ .kind = "total", .scope = "illiquid", .value = illiquid };

    return .{
        .meta = .{
            .kind = "meta",
            .snapshot_version = 1,
            .as_of_date = Date.fromYmd(y, m, d),
            .captured_at = 0,
            .zfin_version = "test",
            .stale_count = 0,
        },
        .totals = buf,
        .tax_types = &.{},
        .accounts = &.{},
        .lots = &.{},
    };
}

test "snapshotToPoint: extracts the three totals" {
    var buf: [3]snapshot.TotalRow = undefined;
    const snap = fixtureSnapshot(&buf, 2026, 4, 17, 1000, 800, 200);
    const p = try snapshotToPoint(testing.allocator, snap);
    defer p.deinit(testing.allocator);

    try testing.expect(p.as_of_date.eql(Date.fromYmd(2026, 4, 17)));
    try testing.expectEqual(@as(f64, 1000), p.net_worth);
    try testing.expectEqual(@as(f64, 800), p.liquid);
    try testing.expectEqual(@as(f64, 200), p.illiquid);
    try testing.expectEqual(@as(usize, 0), p.accounts.len);
    try testing.expectEqual(@as(usize, 0), p.tax_types.len);
}

test "snapshotToPoint: missing totals default to zero" {
    // Snapshot with empty totals slice — nothing at all to extract.
    const snap: snapshot.Snapshot = .{
        .meta = .{
            .kind = "meta",
            .snapshot_version = 1,
            .as_of_date = Date.fromYmd(2026, 4, 17),
            .captured_at = 0,
            .zfin_version = "test",
            .stale_count = 0,
        },
        .totals = &.{},
        .tax_types = &.{},
        .accounts = &.{},
        .lots = &.{},
    };
    const p = try snapshotToPoint(testing.allocator, snap);
    defer p.deinit(testing.allocator);
    try testing.expectEqual(@as(f64, 0), p.net_worth);
    try testing.expectEqual(@as(f64, 0), p.liquid);
    try testing.expectEqual(@as(f64, 0), p.illiquid);
}

test "snapshotToPoint: propagates accounts and tax_types" {
    const accts = [_]snapshot.AccountRow{
        .{ .kind = "account", .name = "Emil Roth", .value = 1000 },
        .{ .kind = "account", .name = "Kelly IRA", .value = 500 },
    };
    const taxes = [_]snapshot.TaxTypeRow{
        .{ .kind = "tax_type", .label = "Taxable", .value = 800 },
    };
    const totals = [_]snapshot.TotalRow{
        .{ .kind = "total", .scope = "net_worth", .value = 1500 },
    };
    const snap: snapshot.Snapshot = .{
        .meta = .{
            .kind = "meta",
            .snapshot_version = 1,
            .as_of_date = Date.fromYmd(2026, 4, 17),
            .captured_at = 0,
            .zfin_version = "test",
            .stale_count = 0,
        },
        .totals = @constCast(&totals),
        .tax_types = @constCast(&taxes),
        .accounts = @constCast(&accts),
        .lots = &.{},
    };
    const p = try snapshotToPoint(testing.allocator, snap);
    defer p.deinit(testing.allocator);

    try testing.expectEqual(@as(usize, 2), p.accounts.len);
    try testing.expectEqualStrings("Emil Roth", p.accounts[0].name);
    try testing.expectEqual(@as(f64, 1000), p.accounts[0].value);

    try testing.expectEqual(@as(usize, 1), p.tax_types.len);
    try testing.expectEqualStrings("Taxable", p.tax_types[0].name);
}

test "buildSeries: empty input" {
    const series = try buildSeries(testing.allocator, &.{});
    defer series.deinit();
    try testing.expectEqual(@as(usize, 0), series.points.len);
}

test "buildSeries: sorts ascending by date" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 20, 3000, 0, 0),
        fixtureSnapshot(&b2, 2026, 4, 17, 1000, 0, 0),
        fixtureSnapshot(&b3, 2026, 4, 18, 2000, 0, 0),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    try testing.expectEqual(@as(usize, 3), series.points.len);
    try testing.expect(series.points[0].as_of_date.eql(Date.fromYmd(2026, 4, 17)));
    try testing.expect(series.points[1].as_of_date.eql(Date.fromYmd(2026, 4, 18)));
    try testing.expect(series.points[2].as_of_date.eql(Date.fromYmd(2026, 4, 20)));
    try testing.expectEqual(@as(f64, 1000), series.points[0].net_worth);
    try testing.expectEqual(@as(f64, 3000), series.points[2].net_worth);
}

test "filterByDate: inclusive bounds" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    var b4: [3]snapshot.TotalRow = undefined;
    var b5: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1, 0, 0),
        fixtureSnapshot(&b2, 2026, 4, 18, 2, 0, 0),
        fixtureSnapshot(&b3, 2026, 4, 19, 3, 0, 0),
        fixtureSnapshot(&b4, 2026, 4, 20, 4, 0, 0),
        fixtureSnapshot(&b5, 2026, 4, 21, 5, 0, 0),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const kept = try filterByDate(
        testing.allocator,
        series.points,
        Date.fromYmd(2026, 4, 18),
        Date.fromYmd(2026, 4, 20),
    );
    defer testing.allocator.free(kept);

    try testing.expectEqual(@as(usize, 3), kept.len);
    try testing.expectEqual(@as(f64, 2), kept[0].net_worth);
    try testing.expectEqual(@as(f64, 4), kept[2].net_worth);
}

test "filterByDate: null since leaves left end open" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1, 0, 0),
        fixtureSnapshot(&b2, 2026, 4, 18, 2, 0, 0),
        fixtureSnapshot(&b3, 2026, 4, 19, 3, 0, 0),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const kept = try filterByDate(testing.allocator, series.points, null, Date.fromYmd(2026, 4, 18));
    defer testing.allocator.free(kept);
    try testing.expectEqual(@as(usize, 2), kept.len);
}

test "filterByDate: null until leaves right end open" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1, 0, 0),
        fixtureSnapshot(&b2, 2026, 4, 18, 2, 0, 0),
        fixtureSnapshot(&b3, 2026, 4, 19, 3, 0, 0),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const kept = try filterByDate(testing.allocator, series.points, Date.fromYmd(2026, 4, 18), null);
    defer testing.allocator.free(kept);
    try testing.expectEqual(@as(usize, 2), kept.len);
}

test "filterByDate: both bounds null returns everything" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1, 0, 0),
        fixtureSnapshot(&b2, 2026, 4, 18, 2, 0, 0),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();
    const kept = try filterByDate(testing.allocator, series.points, null, null);
    defer testing.allocator.free(kept);
    try testing.expectEqual(@as(usize, 2), kept.len);
}

test "filterByDate: out-of-range bounds return empty" {
    var b1: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1, 0, 0),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();
    const kept = try filterByDate(testing.allocator, series.points, Date.fromYmd(2030, 1, 1), null);
    defer testing.allocator.free(kept);
    try testing.expectEqual(@as(usize, 0), kept.len);
}

test "extractMetric: net_worth / liquid / illiquid" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 800, 200),
        fixtureSnapshot(&b2, 2026, 4, 18, 2000, 1500, 500),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    inline for (.{
        .{ Metric.net_worth, [_]f64{ 1000, 2000 } },
        .{ Metric.liquid, [_]f64{ 800, 1500 } },
        .{ Metric.illiquid, [_]f64{ 200, 500 } },
    }) |tc| {
        const out = try extractMetric(testing.allocator, series.points, tc[0]);
        defer testing.allocator.free(out);
        try testing.expectEqual(@as(usize, 2), out.len);
        try testing.expectEqual(tc[1][0], out[0].value);
        try testing.expectEqual(tc[1][1], out[1].value);
    }
}

test "Metric.label: stable strings" {
    try testing.expectEqualStrings("Net Worth", Metric.net_worth.label());
    try testing.expectEqualStrings("Liquid", Metric.liquid.label());
    try testing.expectEqualStrings("Illiquid", Metric.illiquid.label());
}

test "extractNamedSeries accounts: matches + absent days emit 0" {
    // Build three snapshots: day1 has account A; day2 has account B; day3 has both.
    // Extracting "A" should see value on day1, 0 on day2, value on day3.
    var day1_accts = [_]snapshot.AccountRow{.{ .kind = "account", .name = "A", .value = 100 }};
    var day2_accts = [_]snapshot.AccountRow{.{ .kind = "account", .name = "B", .value = 200 }};
    var day3_accts = [_]snapshot.AccountRow{
        .{ .kind = "account", .name = "A", .value = 300 },
        .{ .kind = "account", .name = "B", .value = 400 },
    };

    var t1 = [_]snapshot.TotalRow{.{ .kind = "total", .scope = "net_worth", .value = 100 }};
    var t2 = [_]snapshot.TotalRow{.{ .kind = "total", .scope = "net_worth", .value = 200 }};
    var t3 = [_]snapshot.TotalRow{.{ .kind = "total", .scope = "net_worth", .value = 700 }};

    const mk = struct {
        fn f(y: i16, m: u8, d: u8, totals: []snapshot.TotalRow, accts: []snapshot.AccountRow) snapshot.Snapshot {
            return .{
                .meta = .{
                    .kind = "meta",
                    .snapshot_version = 1,
                    .as_of_date = Date.fromYmd(y, m, d),
                    .captured_at = 0,
                    .zfin_version = "test",
                    .stale_count = 0,
                },
                .totals = totals,
                .tax_types = &.{},
                .accounts = accts,
                .lots = &.{},
            };
        }
    }.f;

    const snaps = [_]snapshot.Snapshot{
        mk(2026, 4, 17, &t1, &day1_accts),
        mk(2026, 4, 18, &t2, &day2_accts),
        mk(2026, 4, 19, &t3, &day3_accts),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const a_series = try extractNamedSeries(testing.allocator, series.points, .accounts, "A");
    defer testing.allocator.free(a_series);
    try testing.expectEqual(@as(f64, 100), a_series[0].value);
    try testing.expectEqual(@as(f64, 0), a_series[1].value); // absent -> 0
    try testing.expectEqual(@as(f64, 300), a_series[2].value);
}

test "extractNamedSeries tax_types: absent days emit 0" {
    var taxes1 = [_]snapshot.TaxTypeRow{.{ .kind = "tax_type", .label = "Taxable", .value = 500 }};
    var taxes2 = [_]snapshot.TaxTypeRow{};
    var tot1 = [_]snapshot.TotalRow{.{ .kind = "total", .scope = "net_worth", .value = 500 }};
    var tot2 = [_]snapshot.TotalRow{.{ .kind = "total", .scope = "net_worth", .value = 0 }};

    const mk = struct {
        fn f(d: u8, totals: []snapshot.TotalRow, tt: []snapshot.TaxTypeRow) snapshot.Snapshot {
            return .{
                .meta = .{
                    .kind = "meta",
                    .snapshot_version = 1,
                    .as_of_date = Date.fromYmd(2026, 4, d),
                    .captured_at = 0,
                    .zfin_version = "test",
                    .stale_count = 0,
                },
                .totals = totals,
                .tax_types = tt,
                .accounts = &.{},
                .lots = &.{},
            };
        }
    }.f;

    const snaps = [_]snapshot.Snapshot{
        mk(17, &tot1, &taxes1),
        mk(18, &tot2, &taxes2),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const s = try extractNamedSeries(testing.allocator, series.points, .tax_types, "Taxable");
    defer testing.allocator.free(s);
    try testing.expectEqual(@as(f64, 500), s[0].value);
    try testing.expectEqual(@as(f64, 0), s[1].value);
}

test "computeStats: typical case" {
    const pts = [_]MetricPoint{
        .{ .date = Date.fromYmd(2026, 4, 17), .value = 1000 },
        .{ .date = Date.fromYmd(2026, 4, 18), .value = 900 },
        .{ .date = Date.fromYmd(2026, 4, 19), .value = 1500 },
        .{ .date = Date.fromYmd(2026, 4, 20), .value = 1100 },
    };
    const s = computeStats(&pts).?;
    try testing.expectEqual(@as(f64, 1000), s.first);
    try testing.expectEqual(@as(f64, 1100), s.last);
    try testing.expectEqual(@as(f64, 900), s.min);
    try testing.expectEqual(@as(f64, 1500), s.max);
    try testing.expectEqual(@as(f64, 100), s.delta_abs);
    try testing.expect(s.delta_pct != null);
    try testing.expectApproxEqAbs(@as(f64, 0.10), s.delta_pct.?, 1e-9);
}

test "computeStats: empty input returns null" {
    const empty: []const MetricPoint = &.{};
    try testing.expect(computeStats(empty) == null);
}

test "computeStats: single point — all fields equal" {
    const pts = [_]MetricPoint{.{ .date = Date.fromYmd(2026, 4, 17), .value = 5000 }};
    const s = computeStats(&pts).?;
    try testing.expectEqual(@as(f64, 5000), s.first);
    try testing.expectEqual(@as(f64, 5000), s.last);
    try testing.expectEqual(@as(f64, 5000), s.min);
    try testing.expectEqual(@as(f64, 5000), s.max);
    try testing.expectEqual(@as(f64, 0), s.delta_abs);
    try testing.expectEqual(@as(f64, 0), s.delta_pct.?);
}

test "computeStats: first-zero yields null delta_pct (no div-by-zero)" {
    const pts = [_]MetricPoint{
        .{ .date = Date.fromYmd(2026, 4, 17), .value = 0 },
        .{ .date = Date.fromYmd(2026, 4, 18), .value = 1000 },
    };
    const s = computeStats(&pts).?;
    try testing.expectEqual(@as(f64, 1000), s.delta_abs);
    try testing.expect(s.delta_pct == null);
}

test "computeStats: negative delta" {
    const pts = [_]MetricPoint{
        .{ .date = Date.fromYmd(2026, 4, 17), .value = 1000 },
        .{ .date = Date.fromYmd(2026, 4, 18), .value = 800 },
    };
    const s = computeStats(&pts).?;
    try testing.expectEqual(@as(f64, -200), s.delta_abs);
    try testing.expectApproxEqAbs(@as(f64, -0.20), s.delta_pct.?, 1e-9);
}

test "buildRollupRecords: one row per point, kind discriminator set" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 800, 200),
        fixtureSnapshot(&b2, 2026, 4, 18, 1100, 850, 250),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const rows = try buildRollupRecords(testing.allocator, series.points);
    defer testing.allocator.free(rows);

    try testing.expectEqual(@as(usize, 2), rows.len);
    try testing.expectEqualStrings("rollup", rows[0].kind);
    try testing.expect(rows[0].as_of_date.eql(Date.fromYmd(2026, 4, 17)));
    try testing.expectEqual(@as(f64, 1000), rows[0].net_worth);
    try testing.expectEqual(@as(f64, 800), rows[0].liquid);
    try testing.expectEqual(@as(f64, 200), rows[0].illiquid);
    try testing.expectEqual(@as(f64, 1100), rows[1].net_worth);
}

test "buildRollupRecords: empty input produces empty slice" {
    const rows = try buildRollupRecords(testing.allocator, &.{});
    defer testing.allocator.free(rows);
    try testing.expectEqual(@as(usize, 0), rows.len);
}

// ── pointAtOrBefore ──────────────────────────────────────────

test "pointAtOrBefore: exact / snap-backward / null" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 18, 1100, 750, 350),
        fixtureSnapshot(&b3, 2026, 4, 21, 1200, 800, 400), // gap over weekend
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    // Exact match
    try testing.expect(pointAtOrBefore(series.points, Date.fromYmd(2026, 4, 18)).?.net_worth == 1100);
    // Snap backward over weekend: Saturday -> Friday's snapshot
    try testing.expect(pointAtOrBefore(series.points, Date.fromYmd(2026, 4, 19)).?.net_worth == 1100);
    // Before all -> null
    try testing.expect(pointAtOrBefore(series.points, Date.fromYmd(2026, 4, 1)) == null);
    // After all -> latest
    try testing.expect(pointAtOrBefore(series.points, Date.fromYmd(2099, 1, 1)).?.net_worth == 1200);
}

// ── computeWindowSet ─────────────────────────────────────────

test "computeWindowSet: empty series produces empty rows" {
    const ws = try computeWindowSet(testing.allocator, &.{}, .net_worth, Date.fromYmd(2026, 4, 22));
    defer ws.deinit();
    try testing.expectEqual(@as(usize, 0), ws.rows.len);
}

test "computeWindowSet: 8 period rows + 1 all-time row" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 22, 1500, 1000, 500),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const ws = try computeWindowSet(testing.allocator, series.points, .net_worth, Date.fromYmd(2026, 4, 22));
    defer ws.deinit();

    // 8 HistoricalPeriod windows + 1 all-time
    try testing.expectEqual(@as(usize, 9), ws.rows.len);

    // Last row is all-time (period is null, label matches)
    const all_time = ws.rows[ws.rows.len - 1];
    try testing.expect(all_time.period == null);
    try testing.expectEqualStrings("All-time", all_time.label);
    try testing.expect(all_time.start_value.? == 1000);
    try testing.expect(all_time.end_value == 1500);
    try testing.expect(all_time.delta_abs.? == 500);
    try testing.expectApproxEqAbs(@as(f64, 0.5), all_time.delta_pct.?, 1e-9);
}

test "computeWindowSet: not-enough-history leaves start_value/delta null" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 21, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 22, 1100, 750, 350),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const ws = try computeWindowSet(testing.allocator, series.points, .net_worth, Date.fromYmd(2026, 4, 22));
    defer ws.deinit();

    // First row is 1-day: anchor = 2026-04-21 (exact match). Fully populated.
    try testing.expect(ws.rows[0].period == HistoricalPeriod.@"1D");
    try testing.expect(ws.rows[0].anchor_date != null);
    try testing.expect(ws.rows[0].delta_abs != null);

    // 1-year row (index 4 in timeline_windows: 1D, 1W, 1M, YTD, 1Y, 3Y, 5Y, 10Y)
    // with only 2 days of history: no anchor.
    try testing.expect(ws.rows[4].period == HistoricalPeriod.@"1Y");
    try testing.expect(ws.rows[4].anchor_date == null);
    try testing.expect(ws.rows[4].start_value == null);
    try testing.expect(ws.rows[4].delta_abs == null);
    try testing.expect(ws.rows[4].delta_pct == null);
    // end_value still populated
    try testing.expect(ws.rows[4].end_value == 1100);
}

test "computeWindowSet: YTD anchors to Jan 1 (snaps to prior year's last close)" {
    // Dec 31 2025 snapshot + one in April 2026. YTD on 2026-04-22 should
    // anchor to Dec 31 2025 (pointAtOrBefore snaps Jan 1 2026 back to the
    // prior-year close).
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2025, 12, 31, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 22, 1500, 1000, 500),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const ws = try computeWindowSet(testing.allocator, series.points, .net_worth, Date.fromYmd(2026, 4, 22));
    defer ws.deinit();

    // ytd is index 3 in timeline_windows
    const ytd = ws.rows[3];
    try testing.expect(ytd.period == HistoricalPeriod.ytd);
    try testing.expect(ytd.anchor_date.?.eql(Date.fromYmd(2025, 12, 31)));
    try testing.expect(ytd.start_value.? == 1000);
    try testing.expect(ytd.delta_abs.? == 500);
}

test "computeWindowSet: liquid metric is independent of net_worth" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 22, 1500, 1100, 400),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const ws = try computeWindowSet(testing.allocator, series.points, .liquid, Date.fromYmd(2026, 4, 22));
    defer ws.deinit();

    const all_time = ws.rows[ws.rows.len - 1];
    try testing.expect(all_time.start_value.? == 700);
    try testing.expect(all_time.end_value == 1100);
    try testing.expect(all_time.delta_abs.? == 400);
}

// ── computeRowDeltas ─────────────────────────────────────────

test "computeRowDeltas: first row has null deltas; others populated" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 18, 1100, 750, 350),
        fixtureSnapshot(&b3, 2026, 4, 19, 1050, 720, 330),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();

    const rows = try computeRowDeltas(testing.allocator, series.points);
    defer testing.allocator.free(rows);

    try testing.expectEqual(@as(usize, 3), rows.len);

    // First row: all deltas null
    try testing.expect(rows[0].d_net_worth == null);
    try testing.expect(rows[0].d_liquid == null);
    try testing.expect(rows[0].d_illiquid == null);

    // Second row: +100 net_worth
    try testing.expect(rows[1].d_net_worth.? == 100);
    try testing.expect(rows[1].d_liquid.? == 50);
    try testing.expect(rows[1].d_illiquid.? == 50);

    // Third row: -50 net_worth
    try testing.expect(rows[2].d_net_worth.? == -50);
}

test "computeRowDeltas: empty input" {
    const rows = try computeRowDeltas(testing.allocator, &.{});
    defer testing.allocator.free(rows);
    try testing.expectEqual(@as(usize, 0), rows.len);
}

// ── selectResolution / aggregatePoints ───────────────────────

test "selectResolution: thresholds" {
    const mk = struct {
        fn f(day_span: i32) []TimelinePoint {
            var out = std.testing.allocator.alloc(TimelinePoint, 2) catch unreachable;
            out[0] = .{
                .as_of_date = Date.fromYmd(2026, 1, 1),
                .net_worth = 0,
                .liquid = 0,
                .illiquid = 0,
                .accounts = &.{},
                .tax_types = &.{},
            };
            out[1] = .{
                .as_of_date = Date.fromYmd(2026, 1, 1).addDays(day_span),
                .net_worth = 0,
                .liquid = 0,
                .illiquid = 0,
                .accounts = &.{},
                .tax_types = &.{},
            };
            return out;
        }
    }.f;

    const p90 = mk(90);
    defer testing.allocator.free(p90);
    try testing.expectEqual(Resolution.daily, selectResolution(p90));

    const p91 = mk(91);
    defer testing.allocator.free(p91);
    try testing.expectEqual(Resolution.weekly, selectResolution(p91));

    const p730 = mk(730);
    defer testing.allocator.free(p730);
    try testing.expectEqual(Resolution.weekly, selectResolution(p730));

    const p731 = mk(731);
    defer testing.allocator.free(p731);
    try testing.expectEqual(Resolution.monthly, selectResolution(p731));

    // Single-point: daily
    try testing.expectEqual(Resolution.daily, selectResolution(p90[0..1]));
}

test "aggregatePoints: daily returns a copy" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 4, 17, 1000, 700, 300),
        fixtureSnapshot(&b2, 2026, 4, 18, 1100, 750, 350),
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();
    const out = try aggregatePoints(testing.allocator, series.points, .daily);
    defer testing.allocator.free(out);
    try testing.expectEqual(@as(usize, 2), out.len);
    try testing.expect(out[0].net_worth == 1000);
    try testing.expect(out[1].net_worth == 1100);
}

test "aggregatePoints: weekly rolling, one pick per 7-day bucket from latest" {
    // Span 21 days: expect 3 buckets, one pick each.
    // Generate one point per day so we can see bucket boundaries clearly.
    var points_al: std.ArrayList(TimelinePoint) = .empty;
    defer points_al.deinit(testing.allocator);
    var i: i32 = 0;
    while (i <= 20) : (i += 1) {
        try points_al.append(testing.allocator, .{
            .as_of_date = Date.fromYmd(2026, 4, 1).addDays(i),
            .net_worth = @as(f64, @floatFromInt(1000 + i)),
            .liquid = 0,
            .illiquid = 0,
            .accounts = &.{},
            .tax_types = &.{},
        });
    }
    const out = try aggregatePoints(testing.allocator, points_al.items, .weekly);
    defer testing.allocator.free(out);

    // Last date is 2026-04-21. Buckets anchored from that:
    //   bucket 0: days [15..21] -> pick 2026-04-21 (1020)
    //   bucket 1: days [08..14] -> pick 2026-04-14 (1013)
    //   bucket 2: days [01..07] -> pick 2026-04-07 (1006)
    try testing.expectEqual(@as(usize, 3), out.len);
    try testing.expect(out[0].as_of_date.eql(Date.fromYmd(2026, 4, 7)));
    try testing.expect(out[0].net_worth == 1006);
    try testing.expect(out[1].as_of_date.eql(Date.fromYmd(2026, 4, 14)));
    try testing.expect(out[2].as_of_date.eql(Date.fromYmd(2026, 4, 21)));
    try testing.expect(out[2].net_worth == 1020);
}

test "aggregatePoints: monthly picks latest snapshot in each calendar month" {
    var b1: [3]snapshot.TotalRow = undefined;
    var b2: [3]snapshot.TotalRow = undefined;
    var b3: [3]snapshot.TotalRow = undefined;
    var b4: [3]snapshot.TotalRow = undefined;
    var b5: [3]snapshot.TotalRow = undefined;
    const snaps = [_]snapshot.Snapshot{
        fixtureSnapshot(&b1, 2026, 2, 5, 100, 0, 0),
        fixtureSnapshot(&b2, 2026, 2, 28, 200, 0, 0), // latest Feb
        fixtureSnapshot(&b3, 2026, 3, 1, 300, 0, 0),
        fixtureSnapshot(&b4, 2026, 3, 31, 400, 0, 0), // latest Mar
        fixtureSnapshot(&b5, 2026, 4, 10, 500, 0, 0), // only Apr entry
    };
    const series = try buildSeries(testing.allocator, &snaps);
    defer series.deinit();
    const out = try aggregatePoints(testing.allocator, series.points, .monthly);
    defer testing.allocator.free(out);

    try testing.expectEqual(@as(usize, 3), out.len);
    try testing.expect(out[0].as_of_date.eql(Date.fromYmd(2026, 2, 28)));
    try testing.expect(out[0].net_worth == 200);
    try testing.expect(out[1].as_of_date.eql(Date.fromYmd(2026, 3, 31)));
    try testing.expect(out[1].net_worth == 400);
    try testing.expect(out[2].as_of_date.eql(Date.fromYmd(2026, 4, 10)));
    try testing.expect(out[2].net_worth == 500);
}

test "aggregatePoints: empty input returns empty slice" {
    const out_d = try aggregatePoints(testing.allocator, &.{}, .daily);
    defer testing.allocator.free(out_d);
    try testing.expectEqual(@as(usize, 0), out_d.len);

    const out_w = try aggregatePoints(testing.allocator, &.{}, .weekly);
    defer testing.allocator.free(out_w);
    try testing.expectEqual(@as(usize, 0), out_w.len);

    const out_m = try aggregatePoints(testing.allocator, &.{}, .monthly);
    defer testing.allocator.free(out_m);
    try testing.expectEqual(@as(usize, 0), out_m.len);
}