const std = @import("std");
const vaxis = @import("vaxis");
const zfin = @import("../root.zig");
const fmt = @import("../format.zig");
const cli = @import("../commands/common.zig");
const theme_mod = @import("theme.zig");
const tui = @import("../tui.zig");

const App = tui.App;
const StyledLine = tui.StyledLine;
const PortfolioRow = tui.PortfolioRow;
const PortfolioSortField = tui.PortfolioSortField;
const colLabel = tui.colLabel;
const glyph = tui.glyph;

// Portfolio column layout: gain/loss column start position (display columns).
// prefix(4) + sym(sym_col_width+1) + shares(9) + avgcost(11) + price(11) + mv(17) = 4 + sym_col_width + 49
const gl_col_start: usize = 4 + fmt.sym_col_width + 49;

// ── Data loading ──────────────────────────────────────────────

pub fn loadPortfolioData(self: *App) void {
    self.portfolio_loaded = true;
    self.freePortfolioSummary();

    const pf = self.portfolio orelse return;

    const positions = pf.positions(self.allocator) catch {
        self.setStatus("Error computing positions");
        return;
    };
    defer self.allocator.free(positions);

    var prices = std.StringHashMap(f64).init(self.allocator);
    defer prices.deinit();

    // Only fetch prices for stock/ETF symbols (skip options, CDs, cash)
    const syms = pf.stockSymbols(self.allocator) catch {
        self.setStatus("Error getting symbols");
        return;
    };
    defer self.allocator.free(syms);

    var latest_date: ?zfin.Date = null;
    var fail_count: usize = 0;
    var fetch_count: usize = 0;
    var stale_count: usize = 0;
    var failed_syms: [8][]const u8 = undefined;

    if (self.prefetched_prices) |*pp| {
        // Use pre-fetched prices from before TUI started (first load only)
        // Move stock prices into the working map
        for (syms) |sym| {
            if (pp.get(sym)) |price| {
                prices.put(sym, price) catch {};
            }
        }

        // Extract watchlist prices
        if (self.watchlist_prices) |*wp| wp.clearRetainingCapacity() else {
            self.watchlist_prices = std.StringHashMap(f64).init(self.allocator);
        }
        var wp = &(self.watchlist_prices.?);
        var pp_iter = pp.iterator();
        while (pp_iter.next()) |entry| {
            if (!prices.contains(entry.key_ptr.*)) {
                wp.put(entry.key_ptr.*, entry.value_ptr.*) catch {};
            }
        }

        pp.deinit();
        self.prefetched_prices = null;
    } else {
        // Live fetch (refresh path) — fetch watchlist first, then stock prices
        if (self.watchlist_prices) |*wp| wp.clearRetainingCapacity() else {
            self.watchlist_prices = std.StringHashMap(f64).init(self.allocator);
        }
        var wp = &(self.watchlist_prices.?);
        if (self.watchlist) |wl| {
            for (wl) |sym| {
                const result = self.svc.getCandles(sym) catch continue;
                defer self.allocator.free(result.data);
                if (result.data.len > 0) {
                    wp.put(sym, result.data[result.data.len - 1].close) catch {};
                }
            }
        }
        for (pf.lots) |lot| {
            if (lot.security_type == .watch) {
                const sym = lot.priceSymbol();
                const result = self.svc.getCandles(sym) catch continue;
                defer self.allocator.free(result.data);
                if (result.data.len > 0) {
                    wp.put(sym, result.data[result.data.len - 1].close) catch {};
                }
            }
        }

        // Fetch stock prices with TUI status-bar progress
        const TuiProgress = struct {
            app: *App,
            failed: *[8][]const u8,
            fail_n: usize = 0,

            fn onProgress(ctx: *anyopaque, _: usize, _: usize, symbol: []const u8, status: zfin.DataService.SymbolStatus) void {
                const s: *@This() = @ptrCast(@alignCast(ctx));
                switch (status) {
                    .fetching => {
                        var buf: [64]u8 = undefined;
                        const msg = std.fmt.bufPrint(&buf, "Loading {s}...", .{symbol}) catch "Loading...";
                        s.app.setStatus(msg);
                    },
                    .failed, .failed_used_stale => {
                        if (s.fail_n < s.failed.len) {
                            s.failed[s.fail_n] = symbol;
                            s.fail_n += 1;
                        }
                    },
                    else => {},
                }
            }

            fn callback(s: *@This()) zfin.DataService.ProgressCallback {
                return .{
                    .context = @ptrCast(s),
                    .on_progress = onProgress,
                };
            }
        };
        var tui_progress = TuiProgress{ .app = self, .failed = &failed_syms };
        const load_result = self.svc.loadPrices(syms, &prices, false, tui_progress.callback());
        latest_date = load_result.latest_date;
        fail_count = load_result.fail_count;
        fetch_count = load_result.fetched_count;
        stale_count = load_result.stale_count;
    }
    self.candle_last_date = latest_date;

    // Build fallback prices for symbols that failed API fetch
    var manual_price_set = zfin.valuation.buildFallbackPrices(self.allocator, pf.lots, positions, &prices) catch {
        self.setStatus("Error building fallback prices");
        return;
    };
    defer manual_price_set.deinit();

    var summary = zfin.valuation.portfolioSummary(self.allocator, pf, positions, prices, manual_price_set) catch {
        self.setStatus("Error computing portfolio summary");
        return;
    };

    if (summary.allocations.len == 0) {
        summary.deinit(self.allocator);
        self.setStatus("No cached prices. Run: zfin perf <SYMBOL> first");
        return;
    }

    self.portfolio_summary = summary;

    // Compute historical portfolio snapshots from cached candle data
    {
        var candle_map = std.StringHashMap([]const zfin.Candle).init(self.allocator);
        defer {
            var it = candle_map.valueIterator();
            while (it.next()) |v| self.allocator.free(v.*);
            candle_map.deinit();
        }
        for (syms) |sym| {
            if (self.svc.getCachedCandles(sym)) |cs| {
                candle_map.put(sym, cs) catch {};
            }
        }
        self.historical_snapshots = zfin.valuation.computeHistoricalSnapshots(
            fmt.todayDate(),
            positions,
            prices,
            candle_map,
        );
    }

    sortPortfolioAllocations(self);
    rebuildPortfolioRows(self);

    if (self.symbol.len == 0 and summary.allocations.len > 0) {
        self.setActiveSymbol(summary.allocations[0].symbol);
    }

    // Show warning if any securities failed to load
    if (fail_count > 0) {
        var warn_buf: [256]u8 = undefined;
        if (fail_count <= 3) {
            // Show actual symbol names for easier debugging
            var sym_buf: [128]u8 = undefined;
            var sym_len: usize = 0;
            const show = @min(fail_count, failed_syms.len);
            for (0..show) |fi| {
                if (sym_len > 0) {
                    if (sym_len + 2 < sym_buf.len) {
                        sym_buf[sym_len] = ',';
                        sym_buf[sym_len + 1] = ' ';
                        sym_len += 2;
                    }
                }
                const s = failed_syms[fi];
                const copy_len = @min(s.len, sym_buf.len - sym_len);
                @memcpy(sym_buf[sym_len..][0..copy_len], s[0..copy_len]);
                sym_len += copy_len;
            }
            if (stale_count > 0) {
                const warn_msg = std.fmt.bufPrint(&warn_buf, "Failed to refresh: {s} (using stale cache)", .{sym_buf[0..sym_len]}) catch "Warning: some securities failed";
                self.setStatus(warn_msg);
            } else {
                const warn_msg = std.fmt.bufPrint(&warn_buf, "Failed to load: {s}", .{sym_buf[0..sym_len]}) catch "Warning: some securities failed";
                self.setStatus(warn_msg);
            }
        } else {
            if (stale_count > 0 and stale_count == fail_count) {
                const warn_msg = std.fmt.bufPrint(&warn_buf, "{d} symbols failed to refresh (using stale cache) | r/F5 to retry", .{fail_count}) catch "Warning: some securities used stale cache";
                self.setStatus(warn_msg);
            } else {
                const warn_msg = std.fmt.bufPrint(&warn_buf, "Warning: {d} securities failed to load prices", .{fail_count}) catch "Warning: some securities failed";
                self.setStatus(warn_msg);
            }
        }
    } else if (fetch_count > 0) {
        var info_buf: [128]u8 = undefined;
        const info_msg = std.fmt.bufPrint(&info_buf, "Loaded {d} symbols ({d} fetched) | r/F5 to refresh", .{ syms.len, fetch_count }) catch "Loaded | r/F5 to refresh";
        self.setStatus(info_msg);
    } else {
        self.setStatus("j/k navigate | Enter expand | s select symbol | / search | ? help");
    }
}

pub fn sortPortfolioAllocations(self: *App) void {
    if (self.portfolio_summary) |s| {
        const SortCtx = struct {
            field: PortfolioSortField,
            dir: tui.SortDirection,

            fn lessThan(ctx: @This(), a: zfin.valuation.Allocation, b: zfin.valuation.Allocation) bool {
                const lhs = if (ctx.dir == .asc) a else b;
                const rhs = if (ctx.dir == .asc) b else a;
                return switch (ctx.field) {
                    .symbol => std.mem.lessThan(u8, lhs.display_symbol, rhs.display_symbol),
                    .shares => lhs.shares < rhs.shares,
                    .avg_cost => lhs.avg_cost < rhs.avg_cost,
                    .price => lhs.current_price < rhs.current_price,
                    .market_value => lhs.market_value < rhs.market_value,
                    .gain_loss => lhs.unrealized_gain_loss < rhs.unrealized_gain_loss,
                    .weight => lhs.weight < rhs.weight,
                    .account => std.mem.lessThan(u8, lhs.account, rhs.account),
                };
            }
        };
        std.mem.sort(zfin.valuation.Allocation, s.allocations, SortCtx{ .field = self.portfolio_sort_field, .dir = self.portfolio_sort_dir }, SortCtx.lessThan);
    }
}

pub fn rebuildPortfolioRows(self: *App) void {
    self.portfolio_rows.clearRetainingCapacity();

    if (self.portfolio_summary) |s| {
        for (s.allocations, 0..) |a, i| {
            // Count lots for this symbol
            var lcount: usize = 0;
            if (self.portfolio) |pf| {
                for (pf.lots) |lot| {
                    if (lot.security_type == .stock and std.mem.eql(u8, lot.priceSymbol(), a.symbol)) lcount += 1;
                }
            }

            self.portfolio_rows.append(self.allocator, .{
                .kind = .position,
                .symbol = a.symbol,
                .pos_idx = i,
                .lot_count = lcount,
            }) catch continue;

            // Only expand if multi-lot
            if (lcount > 1 and i < self.expanded.len and self.expanded[i]) {
                if (self.portfolio) |pf| {
                    // Collect matching lots, sort: open first (date desc), then closed (date desc)
                    var matching: std.ArrayList(zfin.Lot) = .empty;
                    defer matching.deinit(self.allocator);
                    for (pf.lots) |lot| {
                        if (lot.security_type == .stock and std.mem.eql(u8, lot.priceSymbol(), a.symbol)) {
                            matching.append(self.allocator, lot) catch continue;
                        }
                    }
                    std.mem.sort(zfin.Lot, matching.items, {}, fmt.lotSortFn);

                    // Check if any lots are DRIP
                    var has_drip = false;
                    for (matching.items) |lot| {
                        if (lot.drip) {
                            has_drip = true;
                            break;
                        }
                    }

                    if (!has_drip) {
                        // No DRIP lots: show all individually
                        for (matching.items) |lot| {
                            self.portfolio_rows.append(self.allocator, .{
                                .kind = .lot,
                                .symbol = lot.symbol,
                                .pos_idx = i,
                                .lot = lot,
                            }) catch continue;
                        }
                    } else {
                        // Has DRIP lots: show non-DRIP individually, summarize DRIP as ST/LT
                        for (matching.items) |lot| {
                            if (!lot.drip) {
                                self.portfolio_rows.append(self.allocator, .{
                                    .kind = .lot,
                                    .symbol = lot.symbol,
                                    .pos_idx = i,
                                    .lot = lot,
                                }) catch continue;
                            }
                        }

                        // Build ST and LT DRIP summaries
                        const drip = fmt.aggregateDripLots(matching.items);

                        if (!drip.st.isEmpty()) {
                            self.portfolio_rows.append(self.allocator, .{
                                .kind = .drip_summary,
                                .symbol = a.symbol,
                                .pos_idx = i,
                                .drip_is_lt = false,
                                .drip_lot_count = drip.st.lot_count,
                                .drip_shares = drip.st.shares,
                                .drip_avg_cost = drip.st.avgCost(),
                                .drip_date_first = drip.st.first_date,
                                .drip_date_last = drip.st.last_date,
                            }) catch {};
                        }
                        if (!drip.lt.isEmpty()) {
                            self.portfolio_rows.append(self.allocator, .{
                                .kind = .drip_summary,
                                .symbol = a.symbol,
                                .pos_idx = i,
                                .drip_is_lt = true,
                                .drip_lot_count = drip.lt.lot_count,
                                .drip_shares = drip.lt.shares,
                                .drip_avg_cost = drip.lt.avgCost(),
                                .drip_date_first = drip.lt.first_date,
                                .drip_date_last = drip.lt.last_date,
                            }) catch {};
                        }
                    }
                }
            }
        }
    }

    // Add watchlist items from both the separate watchlist file and
    // watch lots embedded in the portfolio. Skip symbols already in allocations.
    var watch_seen = std.StringHashMap(void).init(self.allocator);
    defer watch_seen.deinit();

    // Mark all portfolio position symbols as seen
    if (self.portfolio_summary) |s| {
        for (s.allocations) |a| {
            watch_seen.put(a.symbol, {}) catch {};
        }
    }

    // Watch lots from portfolio file
    if (self.portfolio) |pf| {
        for (pf.lots) |lot| {
            if (lot.security_type == .watch) {
                if (watch_seen.contains(lot.priceSymbol())) continue;
                watch_seen.put(lot.priceSymbol(), {}) catch {};
                self.portfolio_rows.append(self.allocator, .{
                    .kind = .watchlist,
                    .symbol = lot.symbol,
                }) catch continue;
            }
        }
    }

    // Separate watchlist file (backward compat)
    if (self.watchlist) |wl| {
        for (wl) |sym| {
            if (watch_seen.contains(sym)) continue;
            watch_seen.put(sym, {}) catch {};
            self.portfolio_rows.append(self.allocator, .{
                .kind = .watchlist,
                .symbol = sym,
            }) catch continue;
        }
    }

    // Options section
    if (self.portfolio) |pf| {
        if (pf.hasType(.option)) {
            self.portfolio_rows.append(self.allocator, .{
                .kind = .section_header,
                .symbol = "Options",
            }) catch {};
            for (pf.lots) |lot| {
                if (lot.security_type == .option) {
                    self.portfolio_rows.append(self.allocator, .{
                        .kind = .option_row,
                        .symbol = lot.symbol,
                        .lot = lot,
                    }) catch continue;
                }
            }
        }

        // CDs section (sorted by maturity date, earliest first)
        if (pf.hasType(.cd)) {
            self.portfolio_rows.append(self.allocator, .{
                .kind = .section_header,
                .symbol = "Certificates of Deposit",
            }) catch {};
            var cd_lots: std.ArrayList(zfin.Lot) = .empty;
            defer cd_lots.deinit(self.allocator);
            for (pf.lots) |lot| {
                if (lot.security_type == .cd) {
                    cd_lots.append(self.allocator, lot) catch continue;
                }
            }
            std.mem.sort(zfin.Lot, cd_lots.items, {}, fmt.lotMaturitySortFn);
            for (cd_lots.items) |lot| {
                self.portfolio_rows.append(self.allocator, .{
                    .kind = .cd_row,
                    .symbol = lot.symbol,
                    .lot = lot,
                }) catch continue;
            }
        }

        // Cash section (single total row, expandable to show per-account)
        if (pf.hasType(.cash)) {
            self.portfolio_rows.append(self.allocator, .{
                .kind = .section_header,
                .symbol = "Cash",
            }) catch {};
            // Total cash row
            self.portfolio_rows.append(self.allocator, .{
                .kind = .cash_total,
                .symbol = "CASH",
            }) catch {};
            // Per-account cash rows (expanded when cash_total is toggled)
            if (self.cash_expanded) {
                for (pf.lots) |lot| {
                    if (lot.security_type == .cash) {
                        self.portfolio_rows.append(self.allocator, .{
                            .kind = .cash_row,
                            .symbol = lot.account orelse "Unknown",
                            .lot = lot,
                        }) catch continue;
                    }
                }
            }
        }

        // Illiquid assets section (similar to cash: total row, expandable)
        if (pf.hasType(.illiquid)) {
            self.portfolio_rows.append(self.allocator, .{
                .kind = .section_header,
                .symbol = "Illiquid Assets",
            }) catch {};
            // Total illiquid row
            self.portfolio_rows.append(self.allocator, .{
                .kind = .illiquid_total,
                .symbol = "ILLIQUID",
            }) catch {};
            // Per-asset rows (expanded when illiquid_total is toggled)
            if (self.illiquid_expanded) {
                for (pf.lots) |lot| {
                    if (lot.security_type == .illiquid) {
                        self.portfolio_rows.append(self.allocator, .{
                            .kind = .illiquid_row,
                            .symbol = lot.symbol,
                            .lot = lot,
                        }) catch continue;
                    }
                }
            }
        }
    }
}

// ── Rendering ─────────────────────────────────────────────────

pub fn drawContent(self: *App, arena: std.mem.Allocator, buf: []vaxis.Cell, width: u16, height: u16) !void {
    const th = self.theme;

    if (self.portfolio == null and self.watchlist == null) {
        try drawWelcomeScreen(self, arena, buf, width, height);
        return;
    }

    var lines: std.ArrayList(StyledLine) = .empty;
    try lines.append(arena, .{ .text = "", .style = th.contentStyle() });

    if (self.portfolio_summary) |s| {
        var val_buf: [24]u8 = undefined;
        var cost_buf: [24]u8 = undefined;
        var gl_buf: [24]u8 = undefined;
        const val_str = fmt.fmtMoneyAbs(&val_buf, s.total_value);
        const cost_str = fmt.fmtMoneyAbs(&cost_buf, s.total_cost);
        const gl_abs = if (s.unrealized_gain_loss >= 0) s.unrealized_gain_loss else -s.unrealized_gain_loss;
        const gl_str = fmt.fmtMoneyAbs(&gl_buf, gl_abs);
        const summary_text = try std.fmt.allocPrint(arena, "  Value: {s}  Cost: {s}  Gain/Loss: {s}{s} ({d:.1}%)", .{
            val_str, cost_str, if (s.unrealized_gain_loss >= 0) @as([]const u8, "+") else @as([]const u8, "-"), gl_str, s.unrealized_return * 100.0,
        });
        const summary_style = if (s.unrealized_gain_loss >= 0) th.positiveStyle() else th.negativeStyle();
        try lines.append(arena, .{ .text = summary_text, .style = summary_style });

        // "as of" date indicator
        if (self.candle_last_date) |d| {
            var asof_buf: [10]u8 = undefined;
            const asof_text = try std.fmt.allocPrint(arena, "  (as of close on {s})", .{d.format(&asof_buf)});
            try lines.append(arena, .{ .text = asof_text, .style = th.mutedStyle() });
        }

        // Net Worth line (only if portfolio has illiquid assets)
        if (self.portfolio) |pf| {
            if (pf.hasType(.illiquid)) {
                const illiquid_total = pf.totalIlliquid();
                const net_worth = s.total_value + illiquid_total;
                var nw_buf: [24]u8 = undefined;
                var il_buf: [24]u8 = undefined;
                const nw_text = try std.fmt.allocPrint(arena, "  Net Worth: {s}  (Liquid: {s}  Illiquid: {s})", .{
                    fmt.fmtMoneyAbs(&nw_buf, net_worth),
                    val_str,
                    fmt.fmtMoneyAbs(&il_buf, illiquid_total),
                });
                try lines.append(arena, .{ .text = nw_text, .style = th.headerStyle() });
            }
        }

        // Historical portfolio value snapshots
        if (self.historical_snapshots) |snapshots| {
            try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
            // Build a single-line summary: "  Historical:  1M: +3.2%  3M: +8.1%  1Y: +22.4%  3Y: +45.1%  5Y: --  10Y: --"
            var hist_parts: [6][]const u8 = undefined;
            for (zfin.valuation.HistoricalPeriod.all, 0..) |period, pi| {
                const snap = snapshots[pi];
                var hbuf: [16]u8 = undefined;
                const change_str = fmt.fmtHistoricalChange(&hbuf, snap.position_count, snap.changePct());
                hist_parts[pi] = try std.fmt.allocPrint(arena, "{s}: {s}", .{ period.label(), change_str });
            }
            const hist_text = try std.fmt.allocPrint(arena, "  Historical:  {s}  {s}  {s}  {s}  {s}  {s}", .{
                hist_parts[0], hist_parts[1], hist_parts[2], hist_parts[3], hist_parts[4], hist_parts[5],
            });
            try lines.append(arena, .{ .text = hist_text, .style = th.mutedStyle() });
        }
    } else if (self.portfolio != null) {
        try lines.append(arena, .{ .text = "  No cached prices. Run 'zfin perf <SYMBOL>' for each holding.", .style = th.mutedStyle() });
    } else {
        try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
    }

    // Empty line before header
    try lines.append(arena, .{ .text = "", .style = th.contentStyle() });

    // Column header (4-char prefix to match arrow(2)+star(2) in data rows)
    // Active sort column gets a sort indicator within the column width
    const sf = self.portfolio_sort_field;
    const si = self.portfolio_sort_dir.indicator();
    // Build column labels with indicator embedded in padding
    // Left-aligned cols: "Name▲ " Right-aligned cols: " ▼Price"
    var sym_hdr_buf: [16]u8 = undefined;
    var shr_hdr_buf: [16]u8 = undefined;
    var avg_hdr_buf: [16]u8 = undefined;
    var prc_hdr_buf: [16]u8 = undefined;
    var mv_hdr_buf: [24]u8 = undefined;
    var gl_hdr_buf: [24]u8 = undefined;
    var wt_hdr_buf: [16]u8 = undefined;
    const sym_hdr = colLabel(&sym_hdr_buf, "Symbol", fmt.sym_col_width, true, if (sf == .symbol) si else null);
    const shr_hdr = colLabel(&shr_hdr_buf, "Shares", 8, false, if (sf == .shares) si else null);
    const avg_hdr = colLabel(&avg_hdr_buf, "Avg Cost", 10, false, if (sf == .avg_cost) si else null);
    const prc_hdr = colLabel(&prc_hdr_buf, "Price", 10, false, if (sf == .price) si else null);
    const mv_hdr = colLabel(&mv_hdr_buf, "Market Value", 16, false, if (sf == .market_value) si else null);
    const gl_hdr = colLabel(&gl_hdr_buf, "Gain/Loss", 14, false, if (sf == .gain_loss) si else null);
    const wt_hdr = colLabel(&wt_hdr_buf, "Weight", 8, false, if (sf == .weight) si else null);
    const acct_ind: []const u8 = if (sf == .account) si else "";

    const hdr = try std.fmt.allocPrint(arena, "    {s} {s} {s} {s} {s} {s} {s} {s:>13} {s}{s}", .{
        sym_hdr, shr_hdr, avg_hdr, prc_hdr, mv_hdr, gl_hdr, wt_hdr, "Date", acct_ind, "Account",
    });
    try lines.append(arena, .{ .text = hdr, .style = th.headerStyle() });

    // Track header line count for mouse click mapping (after all header lines)
    self.portfolio_header_lines = lines.items.len;
    self.portfolio_line_count = 0;

    // Data rows
    for (self.portfolio_rows.items, 0..) |row, ri| {
        const lines_before = lines.items.len;
        const is_cursor = ri == self.cursor;
        const is_active_sym = std.mem.eql(u8, row.symbol, self.symbol);
        switch (row.kind) {
            .position => {
                if (self.portfolio_summary) |s| {
                    if (row.pos_idx < s.allocations.len) {
                        const a = s.allocations[row.pos_idx];
                        const is_multi = row.lot_count > 1;
                        const is_expanded = is_multi and row.pos_idx < self.expanded.len and self.expanded[row.pos_idx];
                        const arrow: []const u8 = if (!is_multi) "  " else if (is_expanded) "v " else "> ";
                        const star: []const u8 = if (is_active_sym) "* " else "  ";
                        const pnl_pct = if (a.cost_basis > 0) (a.unrealized_gain_loss / a.cost_basis) * 100.0 else @as(f64, 0);
                        var gl_val_buf: [24]u8 = undefined;
                        const gl_abs = if (a.unrealized_gain_loss >= 0) a.unrealized_gain_loss else -a.unrealized_gain_loss;
                        const gl_money = fmt.fmtMoneyAbs(&gl_val_buf, gl_abs);
                        var pnl_buf: [20]u8 = undefined;
                        const pnl_str = if (a.unrealized_gain_loss >= 0)
                            std.fmt.bufPrint(&pnl_buf, "+{s}", .{gl_money}) catch "?"
                        else
                            std.fmt.bufPrint(&pnl_buf, "-{s}", .{gl_money}) catch "?";
                        var mv_buf: [24]u8 = undefined;
                        const mv_str = fmt.fmtMoneyAbs(&mv_buf, a.market_value);
                        var cost_buf2: [24]u8 = undefined;
                        const cost_str = fmt.fmtMoneyAbs(&cost_buf2, a.avg_cost);
                        var price_buf2: [24]u8 = undefined;
                        const price_str = fmt.fmtMoneyAbs(&price_buf2, a.current_price);

                        // Date + ST/LT: show for single-lot, blank for multi-lot
                        var pos_date_buf: [10]u8 = undefined;
                        var date_col: []const u8 = "";
                        var acct_col: []const u8 = "";
                        if (!is_multi) {
                            if (self.portfolio) |pf| {
                                for (pf.lots) |lot| {
                                    if (lot.security_type == .stock and std.mem.eql(u8, lot.priceSymbol(), a.symbol)) {
                                        const ds = lot.open_date.format(&pos_date_buf);
                                        const indicator = fmt.capitalGainsIndicator(lot.open_date);
                                        date_col = std.fmt.allocPrint(arena, "{s} {s}", .{ ds, indicator }) catch ds;
                                        acct_col = lot.account orelse "";
                                        break;
                                    }
                                }
                            }
                        } else {
                            // Multi-lot: show account if all lots share the same one
                            if (self.portfolio) |pf| {
                                var common_acct: ?[]const u8 = null;
                                var mixed = false;
                                for (pf.lots) |lot| {
                                    if (lot.security_type == .stock and std.mem.eql(u8, lot.priceSymbol(), a.symbol)) {
                                        if (common_acct) |ca| {
                                            const la = lot.account orelse "";
                                            if (!std.mem.eql(u8, ca, la)) {
                                                mixed = true;
                                                break;
                                            }
                                        } else {
                                            common_acct = lot.account orelse "";
                                        }
                                    }
                                }
                                if (!mixed) {
                                    acct_col = common_acct orelse "";
                                } else {
                                    acct_col = "Multiple";
                                }
                            }
                        }

                        const text = try std.fmt.allocPrint(arena, "{s}{s}" ++ fmt.sym_col_spec ++ " {d:>8.1} {s:>10} {s:>10} {s:>16} {s:>14} {d:>7.1}% {s:>13} {s}", .{
                            arrow, star, a.display_symbol, a.shares, cost_str, price_str, mv_str, pnl_str, a.weight * 100.0, date_col, acct_col,
                        });

                        // base: neutral text for main cols, green/red only for gain/loss col
                        // Manual-price positions use warning color to indicate stale/estimated price
                        const base_style = if (is_cursor) th.selectStyle() else if (a.is_manual_price) th.warningStyle() else th.contentStyle();
                        const gl_style = if (is_cursor) th.selectStyle() else if (pnl_pct >= 0) th.positiveStyle() else th.negativeStyle();

                        // The gain/loss column starts after market value
                        // prefix(4) + sym(6+1) + shares(8+1) + avgcost(10+1) + price(10+1) + mv(16+1) = 59
                        try lines.append(arena, .{
                            .text = text,
                            .style = base_style,
                            .alt_style = gl_style,
                            .alt_start = gl_col_start,
                            .alt_end = gl_col_start + 14,
                        });
                    }
                }
            },
            .lot => {
                if (row.lot) |lot| {
                    var date_buf: [10]u8 = undefined;
                    const date_str = lot.open_date.format(&date_buf);

                    // Compute lot gain/loss and market value if we have a price
                    var lot_gl_str: []const u8 = "";
                    var lot_mv_str: []const u8 = "";
                    var lot_positive = true;
                    if (self.portfolio_summary) |s| {
                        if (row.pos_idx < s.allocations.len) {
                            const price = s.allocations[row.pos_idx].current_price;
                            const use_price = lot.close_price orelse price;
                            const gl = lot.shares * (use_price - lot.open_price);
                            lot_positive = gl >= 0;
                            var lot_gl_money_buf: [24]u8 = undefined;
                            const lot_gl_money = fmt.fmtMoneyAbs(&lot_gl_money_buf, if (gl >= 0) gl else -gl);
                            lot_gl_str = try std.fmt.allocPrint(arena, "{s}{s}", .{
                                if (gl >= 0) @as([]const u8, "+") else @as([]const u8, "-"), lot_gl_money,
                            });
                            var lot_mv_buf: [24]u8 = undefined;
                            lot_mv_str = try std.fmt.allocPrint(arena, "{s}", .{fmt.fmtMoneyAbs(&lot_mv_buf, lot.shares * use_price)});
                        }
                    }

                    var price_str2: [24]u8 = undefined;
                    const lot_price_str = fmt.fmtMoneyAbs(&price_str2, lot.open_price);
                    const status_str: []const u8 = if (lot.isOpen()) "open" else "closed";
                    const indicator = fmt.capitalGainsIndicator(lot.open_date);
                    const lot_date_col = try std.fmt.allocPrint(arena, "{s} {s}", .{ date_str, indicator });
                    const acct_col: []const u8 = lot.account orelse "";
                    const text = try std.fmt.allocPrint(arena, "    " ++ fmt.sym_col_spec ++ " {d:>8.1} {s:>10} {s:>10} {s:>16} {s:>14} {s:>8} {s:>13} {s}", .{
                        status_str, lot.shares, lot_price_str, "", lot_mv_str, lot_gl_str, "", lot_date_col, acct_col,
                    });
                    const base_style = if (is_cursor) th.selectStyle() else th.mutedStyle();
                    const gl_col_style = if (is_cursor) th.selectStyle() else if (lot_positive) th.positiveStyle() else th.negativeStyle();
                    try lines.append(arena, .{
                        .text = text,
                        .style = base_style,
                        .alt_style = gl_col_style,
                        .alt_start = gl_col_start,
                        .alt_end = gl_col_start + 14,
                    });
                }
            },
            .watchlist => {
                var price_str3: [16]u8 = undefined;
                const ps: []const u8 = if (self.watchlist_prices) |wp|
                    (if (wp.get(row.symbol)) |p| fmt.fmtMoneyAbs(&price_str3, p) else "--")
                else
                    "--";
                const star2: []const u8 = if (is_active_sym) "* " else "  ";
                const text = try std.fmt.allocPrint(arena, "  {s}" ++ fmt.sym_col_spec ++ " {s:>8} {s:>10} {s:>10} {s:>16} {s:>14} {s:>8} {s:>13}", .{
                    star2, row.symbol, "--", "--", ps, "--", "--", "watch", "",
                });
                const row_style = if (is_cursor) th.selectStyle() else th.contentStyle();
                try lines.append(arena, .{ .text = text, .style = row_style });
            },
            .section_header => {
                // Blank line before section header
                try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
                const hdr_text = try std.fmt.allocPrint(arena, "  {s}", .{row.symbol});
                const hdr_style = if (is_cursor) th.selectStyle() else th.headerStyle();
                try lines.append(arena, .{ .text = hdr_text, .style = hdr_style });
                // Add column headers for each section type
                if (std.mem.eql(u8, row.symbol, "Options")) {
                    const col_hdr = try std.fmt.allocPrint(arena, "    {s:<30} {s:>6} {s:>12} {s:>14} {s}", .{
                        "Contract", "Qty", "Cost/Ctrct", "Total Cost", "Account",
                    });
                    try lines.append(arena, .{ .text = col_hdr, .style = th.mutedStyle() });
                } else if (std.mem.eql(u8, row.symbol, "Certificates of Deposit")) {
                    const col_hdr = try std.fmt.allocPrint(arena, "    {s:<12} {s:>14} {s:>7} {s:>10}  {s}  {s}", .{
                        "CUSIP", "Face Value", "Rate", "Maturity", "Description", "Account",
                    });
                    try lines.append(arena, .{ .text = col_hdr, .style = th.mutedStyle() });
                }
            },
            .option_row => {
                if (row.lot) |lot| {
                    // Options: symbol (description), qty (contracts), cost/contract, cost basis, account
                    const qty = lot.shares; // negative = short
                    const cost_per = lot.open_price; // per-contract cost
                    const total_cost = @abs(qty) * cost_per;
                    var cost_buf3: [24]u8 = undefined;
                    var total_buf: [24]u8 = undefined;
                    const acct_col2: []const u8 = lot.account orelse "";
                    const text = try std.fmt.allocPrint(arena, "    {s:<30} {d:>6.0} {s:>12} {s:>14} {s}", .{
                        lot.symbol,
                        qty,
                        fmt.fmtMoneyAbs(&cost_buf3, cost_per),
                        fmt.fmtMoneyAbs(&total_buf, total_cost),
                        acct_col2,
                    });
                    const row_style2 = if (is_cursor) th.selectStyle() else th.contentStyle();
                    try lines.append(arena, .{ .text = text, .style = row_style2 });
                }
            },
            .cd_row => {
                if (row.lot) |lot| {
                    // CDs: symbol (CUSIP), face value, rate%, maturity date, note, account
                    var face_buf: [24]u8 = undefined;
                    var mat_buf: [10]u8 = undefined;
                    const mat_str: []const u8 = if (lot.maturity_date) |md| md.format(&mat_buf) else "--";
                    var rate_str_buf: [10]u8 = undefined;
                    const rate_str: []const u8 = if (lot.rate) |r|
                        std.fmt.bufPrint(&rate_str_buf, "{d:.2}%", .{r}) catch "--"
                    else
                        "--";
                    const note_str: []const u8 = lot.note orelse "";
                    // Truncate note to 40 chars for display
                    const note_display = if (note_str.len > 40) note_str[0..40] else note_str;
                    const acct_col3: []const u8 = lot.account orelse "";
                    const text = try std.fmt.allocPrint(arena, "    {s:<12} {s:>14} {s:>7} {s:>10}  {s}  {s}", .{
                        lot.symbol,
                        fmt.fmtMoneyAbs(&face_buf, lot.shares),
                        rate_str,
                        mat_str,
                        note_display,
                        acct_col3,
                    });
                    const row_style3 = if (is_cursor) th.selectStyle() else th.contentStyle();
                    try lines.append(arena, .{ .text = text, .style = row_style3 });
                }
            },
            .cash_total => {
                if (self.portfolio) |pf| {
                    const total_cash = pf.totalCash();
                    var cash_buf: [24]u8 = undefined;
                    const arrow3: []const u8 = if (self.cash_expanded) "v " else "> ";
                    const text = try std.fmt.allocPrint(arena, "  {s}Total Cash {s:>14}", .{
                        arrow3,
                        fmt.fmtMoneyAbs(&cash_buf, total_cash),
                    });
                    const row_style4 = if (is_cursor) th.selectStyle() else th.contentStyle();
                    try lines.append(arena, .{ .text = text, .style = row_style4 });
                }
            },
            .cash_row => {
                if (row.lot) |lot| {
                    var cash_row_buf: [160]u8 = undefined;
                    const row_text = fmt.fmtCashRow(&cash_row_buf, row.symbol, lot.shares, lot.note);
                    const text = try std.fmt.allocPrint(arena, "    {s}", .{row_text});
                    const row_style5 = if (is_cursor) th.selectStyle() else th.mutedStyle();
                    try lines.append(arena, .{ .text = text, .style = row_style5 });
                }
            },
            .illiquid_total => {
                if (self.portfolio) |pf| {
                    const total_illiquid = pf.totalIlliquid();
                    var illiquid_buf: [24]u8 = undefined;
                    const arrow4: []const u8 = if (self.illiquid_expanded) "v " else "> ";
                    const text = try std.fmt.allocPrint(arena, "  {s}Total Illiquid {s:>14}", .{
                        arrow4,
                        fmt.fmtMoneyAbs(&illiquid_buf, total_illiquid),
                    });
                    const row_style6 = if (is_cursor) th.selectStyle() else th.contentStyle();
                    try lines.append(arena, .{ .text = text, .style = row_style6 });
                }
            },
            .illiquid_row => {
                if (row.lot) |lot| {
                    var illiquid_row_buf: [160]u8 = undefined;
                    const row_text = fmt.fmtIlliquidRow(&illiquid_row_buf, row.symbol, lot.shares, lot.note);
                    const text = try std.fmt.allocPrint(arena, "    {s}", .{row_text});
                    const row_style7 = if (is_cursor) th.selectStyle() else th.mutedStyle();
                    try lines.append(arena, .{ .text = text, .style = row_style7 });
                }
            },
            .drip_summary => {
                const label_str: []const u8 = if (row.drip_is_lt) "LT" else "ST";
                var drip_avg_buf: [24]u8 = undefined;
                var drip_d1_buf: [10]u8 = undefined;
                var drip_d2_buf: [10]u8 = undefined;
                const drip_d1: []const u8 = if (row.drip_date_first) |d| d.format(&drip_d1_buf)[0..7] else "?";
                const drip_d2: []const u8 = if (row.drip_date_last) |d| d.format(&drip_d2_buf)[0..7] else "?";
                const text = try std.fmt.allocPrint(arena, "    {s}: {d} DRIP lots, {d:.1} shares, avg {s}  ({s} to {s})", .{
                    label_str,
                    row.drip_lot_count,
                    row.drip_shares,
                    fmt.fmtMoneyAbs(&drip_avg_buf, row.drip_avg_cost),
                    drip_d1,
                    drip_d2,
                });
                const drip_style = if (is_cursor) th.selectStyle() else th.mutedStyle();
                try lines.append(arena, .{ .text = text, .style = drip_style });
            },
        }
        // Map all styled lines produced by this row back to the row index
        const lines_after = lines.items.len;
        for (lines_before..lines_after) |li| {
            const map_idx = li - self.portfolio_header_lines;
            if (map_idx < self.portfolio_line_to_row.len) {
                self.portfolio_line_to_row[map_idx] = ri;
            }
        }
        self.portfolio_line_count = lines_after - self.portfolio_header_lines;
    }

    // Render
    const start = @min(self.scroll_offset, if (lines.items.len > 0) lines.items.len - 1 else 0);
    try self.drawStyledContent(arena, buf, width, height, lines.items[start..]);
}

fn drawWelcomeScreen(self: *App, arena: std.mem.Allocator, buf: []vaxis.Cell, width: u16, height: u16) !void {
    const th = self.theme;
    const welcome_lines = [_]StyledLine{
        .{ .text = "", .style = th.contentStyle() },
        .{ .text = "  zfin", .style = th.headerStyle() },
        .{ .text = "", .style = th.contentStyle() },
        .{ .text = "  No portfolio loaded.", .style = th.mutedStyle() },
        .{ .text = "", .style = th.contentStyle() },
        .{ .text = "  Getting started:", .style = th.contentStyle() },
        .{ .text = "    /         Enter a stock symbol (e.g. AAPL, VTI)", .style = th.contentStyle() },
        .{ .text = "", .style = th.contentStyle() },
        .{ .text = "  Portfolio mode:", .style = th.contentStyle() },
        .{ .text = "    zfin -p portfolio.srf     Load a portfolio file", .style = th.mutedStyle() },
        .{ .text = try std.fmt.allocPrint(arena, "    portfolio.srf             Auto-loaded from cwd if present", .{}), .style = th.mutedStyle() },
        .{ .text = "", .style = th.contentStyle() },
        .{ .text = "  Navigation:", .style = th.contentStyle() },
        .{ .text = "    h / l       Previous / next tab", .style = th.mutedStyle() },
        .{ .text = "    j / k       Select next / prev item", .style = th.mutedStyle() },
        .{ .text = "    Enter       Expand position lots", .style = th.mutedStyle() },
        .{ .text = "    s           Select symbol for other tabs", .style = th.mutedStyle() },
        .{ .text = "    1-5         Jump to tab", .style = th.mutedStyle() },
        .{ .text = "    ?           Full help", .style = th.mutedStyle() },
        .{ .text = "    q           Quit", .style = th.mutedStyle() },
        .{ .text = "", .style = th.contentStyle() },
        .{ .text = "  Sample portfolio.srf:", .style = th.contentStyle() },
        .{ .text = "    symbol::VTI,shares::100,open_date::2024-01-15,open_price::220.50", .style = th.dimStyle() },
        .{ .text = "    symbol::AAPL,shares::50,open_date::2024-03-01,open_price::170.00", .style = th.dimStyle() },
    };
    try self.drawStyledContent(arena, buf, width, height, &welcome_lines);
}

/// Reload portfolio file from disk without re-fetching prices.
/// Uses cached candle data to recompute summary.
pub fn reloadPortfolioFile(self: *App) void {
    // Re-read the portfolio file
    if (self.portfolio) |*pf| pf.deinit();
    self.portfolio = null;
    if (self.portfolio_path) |path| {
        const file_data = std.fs.cwd().readFileAlloc(self.allocator, path, 10 * 1024 * 1024) catch {
            self.setStatus("Error reading portfolio file");
            return;
        };
        defer self.allocator.free(file_data);
        if (zfin.cache.deserializePortfolio(self.allocator, file_data)) |pf| {
            self.portfolio = pf;
        } else |_| {
            self.setStatus("Error parsing portfolio file");
            return;
        }
    } else {
        self.setStatus("No portfolio file to reload");
        return;
    }

    // Reload watchlist file too (if separate)
    tui.freeWatchlist(self.allocator, self.watchlist);
    self.watchlist = null;
    if (self.watchlist_path) |path| {
        self.watchlist = tui.loadWatchlist(self.allocator, path);
    }

    // Recompute summary using cached prices (no network)
    self.freePortfolioSummary();
    self.expanded = [_]bool{false} ** 64;
    self.cash_expanded = false;
    self.illiquid_expanded = false;
    self.cursor = 0;
    self.scroll_offset = 0;
    self.portfolio_rows.clearRetainingCapacity();

    const pf = self.portfolio orelse return;
    const positions = pf.positions(self.allocator) catch {
        self.setStatus("Error computing positions");
        return;
    };
    defer self.allocator.free(positions);

    var prices = std.StringHashMap(f64).init(self.allocator);
    defer prices.deinit();

    const syms = pf.stockSymbols(self.allocator) catch {
        self.setStatus("Error getting symbols");
        return;
    };
    defer self.allocator.free(syms);

    var latest_date: ?zfin.Date = null;
    var missing: usize = 0;
    for (syms) |sym| {
        // Cache only — no network
        const candles_slice = self.svc.getCachedCandles(sym);
        if (candles_slice) |cs| {
            defer self.allocator.free(cs);
            if (cs.len > 0) {
                prices.put(sym, cs[cs.len - 1].close) catch {};
                const d = cs[cs.len - 1].date;
                if (latest_date == null or d.days > latest_date.?.days) latest_date = d;
            }
        } else {
            missing += 1;
        }
    }
    self.candle_last_date = latest_date;

    // Build fallback prices for reload path
    var manual_price_set = zfin.valuation.buildFallbackPrices(self.allocator, pf.lots, positions, &prices) catch {
        self.setStatus("Error building fallback prices");
        return;
    };
    defer manual_price_set.deinit();

    var summary = zfin.valuation.portfolioSummary(self.allocator, pf, positions, prices, manual_price_set) catch {
        self.setStatus("Error computing portfolio summary");
        return;
    };

    if (summary.allocations.len == 0) {
        summary.deinit(self.allocator);
        self.setStatus("No cached prices available");
        return;
    }

    self.portfolio_summary = summary;

    // Compute historical snapshots from cache (reload path)
    {
        var candle_map = std.StringHashMap([]const zfin.Candle).init(self.allocator);
        defer {
            var it = candle_map.valueIterator();
            while (it.next()) |v| self.allocator.free(v.*);
            candle_map.deinit();
        }
        for (syms) |sym| {
            if (self.svc.getCachedCandles(sym)) |cs| {
                candle_map.put(sym, cs) catch {};
            }
        }
        self.historical_snapshots = zfin.valuation.computeHistoricalSnapshots(
            fmt.todayDate(),
            positions,
            prices,
            candle_map,
        );
    }

    sortPortfolioAllocations(self);
    rebuildPortfolioRows(self);

    // Invalidate analysis data -- it holds pointers into old portfolio memory
    if (self.analysis_result) |*ar| ar.deinit(self.allocator);
    self.analysis_result = null;
    self.analysis_loaded = false;

    // If currently on the analysis tab, eagerly recompute so the user
    // doesn't see an error message before switching away and back.
    if (self.active_tab == .analysis) {
        self.loadAnalysisData();
    }

    if (missing > 0) {
        var warn_buf: [128]u8 = undefined;
        const warn_msg = std.fmt.bufPrint(&warn_buf, "Reloaded. {d} symbols missing cached prices", .{missing}) catch "Reloaded (some prices missing)";
        self.setStatus(warn_msg);
    } else {
        self.setStatus("Portfolio reloaded from disk");
    }
}