const std = @import("std");
const vaxis = @import("vaxis");
const zfin = @import("../root.zig");
const fmt = @import("../format.zig");
const theme = @import("theme.zig");
const tui = @import("../tui.zig");
const App = tui.App;
const StyledLine = tui.StyledLine;

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

pub fn loadData(app: *App) void {
    app.earnings_loaded = true;
    app.earnings_error = null;
    app.freeEarnings();

    const result = app.svc.getEarnings(app.symbol) catch |err| {
        switch (err) {
            zfin.DataError.NoApiKey => {
                app.earnings_error = "No API key. Set FINNHUB_API_KEY (free at finnhub.io)";
                app.setStatus("No API key. Set FINNHUB_API_KEY");
            },
            zfin.DataError.FetchFailed => {
                app.earnings_disabled = true;
                app.setStatus("No earnings data (ETF/index?)");
            },
            else => {
                app.earnings_error = "Error loading earnings data. Press r to retry.";
                app.setStatus("Error loading earnings");
            },
        }
        return;
    };
    app.earnings_data = result.data;
    app.earnings_timestamp = result.timestamp;

    // Sort chronologically (oldest first) — providers may return in any order
    if (result.data.len > 1) {
        std.mem.sort(zfin.EarningsEvent, result.data, {}, struct {
            fn f(_: void, a: zfin.EarningsEvent, b: zfin.EarningsEvent) bool {
                return a.date.days < b.date.days;
            }
        }.f);
    }

    if (result.data.len == 0) {
        app.earnings_disabled = true;
        app.setStatus("No earnings data available (ETF/index?)");
        return;
    }
    app.setStatus(if (result.source == .cached) "r/F5 to refresh" else "Fetched | r/F5 to refresh");
}

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

pub fn buildStyledLines(app: *App, arena: std.mem.Allocator) ![]const StyledLine {
    return renderEarningsLines(arena, app.theme, app.symbol, app.earnings_disabled, app.earnings_data, app.earnings_timestamp, app.earnings_error);
}

/// Render earnings tab content. Pure function — no App dependency.
pub fn renderEarningsLines(
    arena: std.mem.Allocator,
    th: theme.Theme,
    symbol: []const u8,
    earnings_disabled: bool,
    earnings_data: ?[]const zfin.EarningsEvent,
    earnings_timestamp: i64,
    earnings_error: ?[]const u8,
) ![]const StyledLine {
    var lines: std.ArrayList(StyledLine) = .empty;

    try lines.append(arena, .{ .text = "", .style = th.contentStyle() });

    if (symbol.len == 0) {
        try lines.append(arena, .{ .text = "  No symbol selected. Press / to enter a symbol.", .style = th.mutedStyle() });
        return lines.toOwnedSlice(arena);
    }
    if (earnings_disabled) {
        try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  Earnings not available for {s} (ETF/index)", .{symbol}), .style = th.mutedStyle() });
        return lines.toOwnedSlice(arena);
    }

    var earn_ago_buf: [16]u8 = undefined;
    const earn_ago = fmt.fmtTimeAgo(&earn_ago_buf, earnings_timestamp);
    if (earn_ago.len > 0) {
        try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  Earnings: {s}  (data {s})", .{ symbol, earn_ago }), .style = th.headerStyle() });
    } else {
        try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  Earnings: {s}", .{symbol}), .style = th.headerStyle() });
    }
    try lines.append(arena, .{ .text = "", .style = th.contentStyle() });

    const ev = earnings_data orelse {
        if (earnings_error) |err_msg| {
            try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  {s}", .{err_msg}), .style = th.warningStyle() });
        } else {
            try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  No data. Run: zfin earnings {s}", .{symbol}), .style = th.mutedStyle() });
        }
        return lines.toOwnedSlice(arena);
    };
    if (ev.len == 0) {
        try lines.append(arena, .{ .text = "  No earnings events found.", .style = th.mutedStyle() });
        return lines.toOwnedSlice(arena);
    }

    try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  {s:>12} {s:>4} {s:>12} {s:>12} {s:>12} {s:>10} {s:>5}", .{
        "Date", "Q", "EPS Est", "EPS Act", "Surprise", "Surprise %", "When",
    }), .style = th.mutedStyle() });

    for (ev) |e| {
        var row_buf: [128]u8 = undefined;
        const row = fmt.fmtEarningsRow(&row_buf, e);

        const text = try std.fmt.allocPrint(arena, "  {s} {s:>5}", .{ row.text, @tagName(e.report_time) });
        const row_style = if (row.is_future) th.mutedStyle() else if (row.is_positive) th.positiveStyle() else th.negativeStyle();

        try lines.append(arena, .{ .text = text, .style = row_style });
    }

    try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
    try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "  {d} earnings event(s)", .{ev.len}), .style = th.mutedStyle() });

    return lines.toOwnedSlice(arena);
}

// ── Tests ─────────────────────────────────────────────────────────────

const testing = std.testing;

test "renderEarningsLines with earnings data" {
    var arena_state = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena_state.deinit();
    const arena = arena_state.allocator();
    const th = theme.default_theme;

    const events = [_]zfin.EarningsEvent{.{
        .symbol = "AAPL",
        .date = try zfin.Date.parse("2025-01-15"),
        .quarter = 4,
        .estimate = 1.50,
        .actual = 1.65,
    }};
    const lines = try renderEarningsLines(arena, th, "AAPL", false, &events, 0, null);
    // blank + header + blank + col_header + data_row + blank + count = 7
    try testing.expectEqual(@as(usize, 7), lines.len);
    try testing.expect(std.mem.indexOf(u8, lines[1].text, "AAPL") != null);
    try testing.expect(std.mem.indexOf(u8, lines[3].text, "EPS Est") != null);
    // Data row should contain the date
    try testing.expect(std.mem.indexOf(u8, lines[4].text, "2025-01-15") != null);
}

test "renderEarningsLines no symbol" {
    var arena_state = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena_state.deinit();
    const arena = arena_state.allocator();
    const th = theme.default_theme;

    const lines = try renderEarningsLines(arena, th, "", false, null, 0, null);
    try testing.expectEqual(@as(usize, 2), lines.len);
    try testing.expect(std.mem.indexOf(u8, lines[1].text, "No symbol") != null);
}

test "renderEarningsLines disabled" {
    var arena_state = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena_state.deinit();
    const arena = arena_state.allocator();
    const th = theme.default_theme;

    const lines = try renderEarningsLines(arena, th, "VTI", true, null, 0, null);
    try testing.expectEqual(@as(usize, 2), lines.len);
    try testing.expect(std.mem.indexOf(u8, lines[1].text, "ETF/index") != null);
}

test "renderEarningsLines no data" {
    var arena_state = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena_state.deinit();
    const arena = arena_state.allocator();
    const th = theme.default_theme;

    const lines = try renderEarningsLines(arena, th, "AAPL", false, null, 0, null);
    try testing.expectEqual(@as(usize, 4), lines.len);
    try testing.expect(std.mem.indexOf(u8, lines[3].text, "No data") != null);
}

test "renderEarningsLines with error message" {
    var arena_state = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena_state.deinit();
    const arena = arena_state.allocator();
    const th = theme.default_theme;

    const lines = try renderEarningsLines(arena, th, "AAPL", false, null, 0, "No API key. Set FINNHUB_API_KEY");
    try testing.expectEqual(@as(usize, 4), lines.len);
    try testing.expect(std.mem.indexOf(u8, lines[3].text, "FINNHUB_API_KEY") != null);
}