//! DataService -- unified data access layer for zfin.
//!
//! Encapsulates the "check cache -> fresh? return -> else fetch from provider -> cache -> return"
//! pattern that was previously duplicated between CLI and TUI. Both frontends should use this
//! as their sole data source.
//!
//! Provider selection is internal: each data type routes to the appropriate provider
//! based on available API keys. Callers never need to know which provider was used.

const std = @import("std");
const Date = @import("models/date.zig").Date;
const Candle = @import("models/candle.zig").Candle;
const Dividend = @import("models/dividend.zig").Dividend;
const Split = @import("models/split.zig").Split;
const OptionsChain = @import("models/option.zig").OptionsChain;
const EarningsEvent = @import("models/earnings.zig").EarningsEvent;
const Quote = @import("models/quote.zig").Quote;
const EtfProfile = @import("models/etf_profile.zig").EtfProfile;
const Config = @import("config.zig").Config;
const cache = @import("cache/store.zig");
const TwelveData = @import("providers/twelvedata.zig").TwelveData;
const Polygon = @import("providers/polygon.zig").Polygon;
const Finnhub = @import("providers/finnhub.zig").Finnhub;
const Cboe = @import("providers/cboe.zig").Cboe;
const AlphaVantage = @import("providers/alphavantage.zig").AlphaVantage;
const alphavantage = @import("providers/alphavantage.zig");
const OpenFigi = @import("providers/openfigi.zig");
const performance = @import("analytics/performance.zig");

pub const DataError = error{
    NoApiKey,
    FetchFailed,
    CacheError,
    ParseError,
    OutOfMemory,
};

/// Re-exported provider types needed by commands via DataService.
pub const CompanyOverview = alphavantage.CompanyOverview;

/// Result of a CUSIP-to-ticker lookup (provider-agnostic).
pub const CusipResult = OpenFigi.FigiResult;

/// Indicates whether the returned data came from cache or was freshly fetched.
pub const Source = enum {
    cached,
    fetched,
};

pub const DataService = struct {
    allocator: std.mem.Allocator,
    config: Config,

    // Lazily initialized providers (null until first use)
    td: ?TwelveData = null,
    pg: ?Polygon = null,
    fh: ?Finnhub = null,
    cboe: ?Cboe = null,
    av: ?AlphaVantage = null,

    pub fn init(allocator: std.mem.Allocator, config: Config) DataService {
        return .{
            .allocator = allocator,
            .config = config,
        };
    }

    pub fn deinit(self: *DataService) void {
        if (self.td) |*td| td.deinit();
        if (self.pg) |*pg| pg.deinit();
        if (self.fh) |*fh| fh.deinit();
        if (self.cboe) |*c| c.deinit();
        if (self.av) |*av| av.deinit();
    }

    // ── Provider accessors ───────────────────────────────────────

    fn getTwelveData(self: *DataService) DataError!*TwelveData {
        if (self.td) |*td| return td;
        const key = self.config.twelvedata_key orelse return DataError.NoApiKey;
        self.td = TwelveData.init(self.allocator, key);
        return &self.td.?;
    }

    fn getPolygon(self: *DataService) DataError!*Polygon {
        if (self.pg) |*pg| return pg;
        const key = self.config.polygon_key orelse return DataError.NoApiKey;
        self.pg = Polygon.init(self.allocator, key);
        return &self.pg.?;
    }

    fn getFinnhub(self: *DataService) DataError!*Finnhub {
        if (self.fh) |*fh| return fh;
        const key = self.config.finnhub_key orelse return DataError.NoApiKey;
        self.fh = Finnhub.init(self.allocator, key);
        return &self.fh.?;
    }

    fn getCboe(self: *DataService) *Cboe {
        if (self.cboe) |*c| return c;
        self.cboe = Cboe.init(self.allocator);
        return &self.cboe.?;
    }

    fn getAlphaVantage(self: *DataService) DataError!*AlphaVantage {
        if (self.av) |*av| return av;
        const key = self.config.alphavantage_key orelse return DataError.NoApiKey;
        self.av = AlphaVantage.init(self.allocator, key);
        return &self.av.?;
    }

    // ── Cache helper ─────────────────────────────────────────────

    fn store(self: *DataService) cache.Store {
        return cache.Store.init(self.allocator, self.config.cache_dir);
    }

    /// Invalidate cached data for a symbol so the next get* call forces a fresh fetch.
    pub fn invalidate(self: *DataService, symbol: []const u8, data_type: cache.DataType) void {
        var s = self.store();
        s.clearData(symbol, data_type);
    }

    // ── Public data methods ──────────────────────────────────────

    /// Fetch daily candles for a symbol (10+ years for trailing returns).
    /// Checks cache first; fetches from TwelveData if stale/missing.
    pub fn getCandles(self: *DataService, symbol: []const u8) DataError!struct { data: []Candle, source: Source, timestamp: i64 } {
        var s = self.store();

        // Try cache
        const cached_raw = s.readRaw(symbol, .candles_daily) catch return DataError.CacheError;
        if (cached_raw) |data| {
            defer self.allocator.free(data);
            if (cache.Store.isFreshData(data, self.allocator)) {
                const candles = cache.Store.deserializeCandles(self.allocator, data) catch null;
                if (candles) |c| return .{ .data = c, .source = .cached, .timestamp = s.getMtime(symbol, .candles_daily) orelse std.time.timestamp() };
            }
        }

        // Fetch from provider
        var td = try self.getTwelveData();
        const today = todayDate();
        const from = today.addDays(-365 * 10 - 60);

        const fetched = td.fetchCandles(self.allocator, symbol, from, today) catch {
            return DataError.FetchFailed;
        };

        // Cache the result
        if (fetched.len > 0) {
            const expires = std.time.timestamp() + cache.Ttl.candles_latest;
            if (cache.Store.serializeCandles(self.allocator, fetched, .{ .expires = expires })) |srf_data| {
                defer self.allocator.free(srf_data);
                s.writeRaw(symbol, .candles_daily, srf_data) catch {};
            } else |_| {}
        }

        return .{ .data = fetched, .source = .fetched, .timestamp = std.time.timestamp() };
    }

    /// Fetch dividend history for a symbol.
    /// Checks cache first; fetches from Polygon if stale/missing.
    pub fn getDividends(self: *DataService, symbol: []const u8) DataError!struct { data: []Dividend, source: Source, timestamp: i64 } {
        var s = self.store();

        const cached_raw = s.readRaw(symbol, .dividends) catch return DataError.CacheError;
        if (cached_raw) |data| {
            defer self.allocator.free(data);
            if (cache.Store.isFreshData(data, self.allocator)) {
                const divs = cache.Store.deserializeDividends(self.allocator, data) catch null;
                if (divs) |d| return .{ .data = d, .source = .cached, .timestamp = s.getMtime(symbol, .dividends) orelse std.time.timestamp() };
            }
        }

        var pg = try self.getPolygon();
        const fetched = pg.fetchDividends(self.allocator, symbol, null, null) catch {
            return DataError.FetchFailed;
        };

        if (fetched.len > 0) {
            const expires = std.time.timestamp() + cache.Ttl.dividends;
            if (cache.Store.serializeDividends(self.allocator, fetched, .{ .expires = expires })) |srf_data| {
                defer self.allocator.free(srf_data);
                s.writeRaw(symbol, .dividends, srf_data) catch {};
            } else |_| {}
        }

        return .{ .data = fetched, .source = .fetched, .timestamp = std.time.timestamp() };
    }

    /// Fetch split history for a symbol.
    /// Checks cache first; fetches from Polygon if stale/missing.
    pub fn getSplits(self: *DataService, symbol: []const u8) DataError!struct { data: []Split, source: Source, timestamp: i64 } {
        var s = self.store();

        const cached_raw = s.readRaw(symbol, .splits) catch return DataError.CacheError;
        if (cached_raw) |data| {
            defer self.allocator.free(data);
            if (cache.Store.isFreshData(data, self.allocator)) {
                const splits = cache.Store.deserializeSplits(self.allocator, data) catch null;
                if (splits) |sp| return .{ .data = sp, .source = .cached, .timestamp = s.getMtime(symbol, .splits) orelse std.time.timestamp() };
            }
        }

        var pg = try self.getPolygon();
        const fetched = pg.fetchSplits(self.allocator, symbol) catch {
            return DataError.FetchFailed;
        };

        if (cache.Store.serializeSplits(self.allocator, fetched, .{ .expires = std.time.timestamp() + cache.Ttl.splits })) |srf_data| {
            defer self.allocator.free(srf_data);
            s.writeRaw(symbol, .splits, srf_data) catch {};
        } else |_| {}

        return .{ .data = fetched, .source = .fetched, .timestamp = std.time.timestamp() };
    }

    /// Fetch options chain for a symbol (all expirations).
    /// Checks cache first; fetches from CBOE if stale/missing (no API key needed).
    pub fn getOptions(self: *DataService, symbol: []const u8) DataError!struct { data: []OptionsChain, source: Source, timestamp: i64 } {
        var s = self.store();

        const cached_raw = s.readRaw(symbol, .options) catch return DataError.CacheError;
        if (cached_raw) |data| {
            defer self.allocator.free(data);
            if (cache.Store.isFreshData(data, self.allocator)) {
                const chains = cache.Store.deserializeOptions(self.allocator, data) catch null;
                if (chains) |c| return .{ .data = c, .source = .cached, .timestamp = s.getMtime(symbol, .options) orelse std.time.timestamp() };
            }
        }

        var cboe = self.getCboe();
        const fetched = cboe.fetchOptionsChain(self.allocator, symbol) catch {
            return DataError.FetchFailed;
        };

        if (fetched.len > 0) {
            const expires = std.time.timestamp() + cache.Ttl.options;
            if (cache.Store.serializeOptions(self.allocator, fetched, .{ .expires = expires })) |srf_data| {
                defer self.allocator.free(srf_data);
                s.writeRaw(symbol, .options, srf_data) catch {};
            } else |_| {}
        }

        return .{ .data = fetched, .source = .fetched, .timestamp = std.time.timestamp() };
    }

    /// Fetch earnings history for a symbol (5 years back, 1 year forward).
    /// Checks cache first; fetches from Finnhub if stale/missing.
    /// Smart refresh: even if cache is fresh, re-fetches when a past earnings
    /// date has no actual results yet (i.e. results just came out).
    pub fn getEarnings(self: *DataService, symbol: []const u8) DataError!struct { data: []EarningsEvent, source: Source, timestamp: i64 } {
        var s = self.store();
        const today = todayDate();

        const cached_raw = s.readRaw(symbol, .earnings) catch return DataError.CacheError;
        if (cached_raw) |data| {
            defer self.allocator.free(data);
            if (cache.Store.isFreshData(data, self.allocator)) {
                const events = cache.Store.deserializeEarnings(self.allocator, data) catch null;
                if (events) |e| {
                    // Check if any past/today earnings event is still missing actual results.
                    // If so, the announcement likely just happened — force a refresh.
                    const needs_refresh = for (e) |ev| {
                        if (ev.actual == null and !today.lessThan(ev.date)) break true;
                    } else false;

                    if (!needs_refresh) {
                        return .{ .data = e, .source = .cached, .timestamp = s.getMtime(symbol, .earnings) orelse std.time.timestamp() };
                    }
                    // Stale: free cached events and re-fetch below
                    self.allocator.free(e);
                }
            }
        }

        var fh = try self.getFinnhub();
        const from = today.subtractYears(5);
        const to = today.addDays(365);

        const fetched = fh.fetchEarnings(self.allocator, symbol, from, to) catch {
            return DataError.FetchFailed;
        };

        if (fetched.len > 0) {
            const expires = std.time.timestamp() + cache.Ttl.earnings;
            if (cache.Store.serializeEarnings(self.allocator, fetched, .{ .expires = expires })) |srf_data| {
                defer self.allocator.free(srf_data);
                s.writeRaw(symbol, .earnings, srf_data) catch {};
            } else |_| {}
        }

        return .{ .data = fetched, .source = .fetched, .timestamp = std.time.timestamp() };
    }

    /// Fetch ETF profile for a symbol.
    /// Checks cache first; fetches from Alpha Vantage if stale/missing.
    pub fn getEtfProfile(self: *DataService, symbol: []const u8) DataError!struct { data: EtfProfile, source: Source, timestamp: i64 } {
        var s = self.store();

        const cached_raw = s.readRaw(symbol, .etf_profile) catch return DataError.CacheError;
        if (cached_raw) |data| {
            defer self.allocator.free(data);
            if (cache.Store.isFreshData(data, self.allocator)) {
                const profile = cache.Store.deserializeEtfProfile(self.allocator, data) catch null;
                if (profile) |p| return .{ .data = p, .source = .cached, .timestamp = s.getMtime(symbol, .etf_profile) orelse std.time.timestamp() };
            }
        }

        var av = try self.getAlphaVantage();
        const fetched = av.fetchEtfProfile(self.allocator, symbol) catch {
            return DataError.FetchFailed;
        };

        if (cache.Store.serializeEtfProfile(self.allocator, fetched, .{ .expires = std.time.timestamp() + cache.Ttl.etf_profile })) |srf_data| {
            defer self.allocator.free(srf_data);
            s.writeRaw(symbol, .etf_profile, srf_data) catch {};
        } else |_| {}

        return .{ .data = fetched, .source = .fetched, .timestamp = std.time.timestamp() };
    }

    /// Fetch a real-time (or 15-min delayed) quote for a symbol.
    /// No cache -- always fetches fresh from TwelveData.
    pub fn getQuote(self: *DataService, symbol: []const u8) DataError!Quote {
        var td = try self.getTwelveData();
        return td.fetchQuote(self.allocator, symbol) catch
            return DataError.FetchFailed;
    }

    /// Fetch company overview (sector, industry, country, market cap) from Alpha Vantage.
    /// No cache -- always fetches fresh. Caller must free the returned string fields.
    pub fn getCompanyOverview(self: *DataService, symbol: []const u8) DataError!CompanyOverview {
        var av = try self.getAlphaVantage();
        return av.fetchCompanyOverview(self.allocator, symbol) catch
            return DataError.FetchFailed;
    }

    /// Compute trailing returns for a symbol (fetches candles + dividends).
    /// Returns both as-of-date and month-end trailing returns.
    /// As-of-date: end = latest close. Matches Morningstar "Trailing Returns" page.
    /// Month-end:  end = last business day of prior month. Matches Morningstar "Performance" page.
    pub fn getTrailingReturns(self: *DataService, symbol: []const u8) DataError!struct {
        asof_price: performance.TrailingReturns,
        asof_total: ?performance.TrailingReturns,
        me_price: performance.TrailingReturns,
        me_total: ?performance.TrailingReturns,
        candles: []Candle,
        dividends: ?[]Dividend,
        source: Source,
        timestamp: i64,
    } {
        const candle_result = try self.getCandles(symbol);
        const c = candle_result.data;
        if (c.len == 0) return DataError.FetchFailed;

        const today = todayDate();

        // As-of-date (end = last candle)
        const asof_price = performance.trailingReturns(c);
        // Month-end (end = last business day of prior month)
        const me_price = performance.trailingReturnsMonthEnd(c, today);

        // Try to get dividends (non-fatal if unavailable)
        var divs: ?[]Dividend = null;
        var asof_total: ?performance.TrailingReturns = null;
        var me_total: ?performance.TrailingReturns = null;

        if (self.getDividends(symbol)) |div_result| {
            divs = div_result.data;
            asof_total = performance.trailingReturnsWithDividends(c, div_result.data);
            me_total = performance.trailingReturnsMonthEndWithDividends(c, div_result.data, today);
        } else |_| {}

        return .{
            .asof_price = asof_price,
            .asof_total = asof_total,
            .me_price = me_price,
            .me_total = me_total,
            .candles = c,
            .dividends = divs,
            .source = candle_result.source,
            .timestamp = candle_result.timestamp,
        };
    }

    /// Check if candle data is fresh in cache without full deserialization.
    pub fn isCandleCacheFresh(self: *DataService, symbol: []const u8) bool {
        var s = self.store();
        const data = s.readRaw(symbol, .candles_daily) catch return false;
        if (data) |d| {
            defer self.allocator.free(d);
            return cache.Store.isFreshData(d, self.allocator);
        }
        return false;
    }

    /// Read only the latest close price from cached candles (no full deserialization).
    /// Returns null if no cached data exists.
    pub fn getCachedLastClose(self: *DataService, symbol: []const u8) ?f64 {
        var s = self.store();
        return s.readLastClose(symbol);
    }

    /// Estimate wait time (in seconds) before the next TwelveData API call can proceed.
    /// Returns 0 if a request can be made immediately. Returns null if no API key.
    pub fn estimateWaitSeconds(self: *DataService) ?u64 {
        if (self.td) |*td| {
            const ns = td.rate_limiter.estimateWaitNs();
            return if (ns == 0) 0 else @max(1, ns / std.time.ns_per_s);
        }
        return null;
    }

    /// Read candles from cache only (no network fetch). Used by TUI for display.
    /// Returns null if no cached data exists or if the entry is a negative cache (fetch_failed).
    pub fn getCachedCandles(self: *DataService, symbol: []const u8) ?[]Candle {
        var s = self.store();
        if (s.isNegative(symbol, .candles_daily)) return null;
        const data = s.readRaw(symbol, .candles_daily) catch return null;
        if (data) |d| {
            defer self.allocator.free(d);
            return cache.Store.deserializeCandles(self.allocator, d) catch null;
        }
        return null;
    }

    /// Read dividends from cache only (no network fetch).
    pub fn getCachedDividends(self: *DataService, symbol: []const u8) ?[]Dividend {
        var s = self.store();
        const data = s.readRaw(symbol, .dividends) catch return null;
        if (data) |d| {
            defer self.allocator.free(d);
            return cache.Store.deserializeDividends(self.allocator, d) catch null;
        }
        return null;
    }

    /// Read earnings from cache only (no network fetch).
    pub fn getCachedEarnings(self: *DataService, symbol: []const u8) ?[]EarningsEvent {
        var s = self.store();
        const data = s.readRaw(symbol, .earnings) catch return null;
        if (data) |d| {
            defer self.allocator.free(d);
            return cache.Store.deserializeEarnings(self.allocator, d) catch null;
        }
        return null;
    }

    /// Read options from cache only (no network fetch).
    pub fn getCachedOptions(self: *DataService, symbol: []const u8) ?[]OptionsChain {
        var s = self.store();
        const data = s.readRaw(symbol, .options) catch return null;
        if (data) |d| {
            defer self.allocator.free(d);
            return cache.Store.deserializeOptions(self.allocator, d) catch null;
        }
        return null;
    }

    // ── Portfolio price loading ──────────────────────────────────

    /// Result of loading prices for a set of symbols.
    pub const PriceLoadResult = struct {
        /// Number of symbols whose price came from fresh cache.
        cached_count: usize,
        /// Number of symbols successfully fetched from API.
        fetched_count: usize,
        /// Number of symbols where API fetch failed.
        fail_count: usize,
        /// Number of failed symbols that fell back to stale cache.
        stale_count: usize,
        /// Latest candle date seen across all symbols.
        latest_date: ?Date,
    };

    /// Status emitted for each symbol during price loading.
    pub const SymbolStatus = enum {
        /// Price resolved from fresh cache.
        cached,
        /// About to attempt an API fetch (emitted before the network call).
        fetching,
        /// Price fetched successfully from API.
        fetched,
        /// API fetch failed but stale cached price was used.
        failed_used_stale,
        /// API fetch failed and no cached price exists.
        failed,
    };

    /// Callback for progress reporting during price loading.
    /// `context` is an opaque pointer to caller-owned state.
    pub const ProgressCallback = struct {
        context: *anyopaque,
        on_progress: *const fn (ctx: *anyopaque, index: usize, total: usize, symbol: []const u8, status: SymbolStatus) void,

        fn emit(self: ProgressCallback, index: usize, total: usize, symbol: []const u8, status: SymbolStatus) void {
            self.on_progress(self.context, index, total, symbol, status);
        }
    };

    /// Load current prices for a list of symbols into `prices`.
    ///
    /// For each symbol the resolution order is:
    ///   1. Fresh cache  -> use cached last close (fast, no deserialization)
    ///   2. API fetch     -> use latest candle close
    ///   3. Stale cache   -> use last close from expired cache entry
    ///
    /// If `force_refresh` is true, cache is invalidated before checking freshness.
    /// If `progress` is provided, it is called for each symbol with the outcome.
    pub fn loadPrices(
        self: *DataService,
        symbols: []const []const u8,
        prices: *std.StringHashMap(f64),
        force_refresh: bool,
        progress: ?ProgressCallback,
    ) PriceLoadResult {
        var result = PriceLoadResult{
            .cached_count = 0,
            .fetched_count = 0,
            .fail_count = 0,
            .stale_count = 0,
            .latest_date = null,
        };
        const total = symbols.len;

        for (symbols, 0..) |sym, i| {
            if (force_refresh) {
                self.invalidate(sym, .candles_daily);
            }

            // 1. Fresh cache — fast path (no full deserialization)
            if (!force_refresh and self.isCandleCacheFresh(sym)) {
                if (self.getCachedLastClose(sym)) |close| {
                    prices.put(sym, close) catch {};
                }
                result.cached_count += 1;
                if (progress) |p| p.emit(i, total, sym, .cached);
                continue;
            }

            // About to fetch — notify caller (so it can show rate-limit waits etc.)
            if (progress) |p| p.emit(i, total, sym, .fetching);

            // 2. Try API fetch
            if (self.getCandles(sym)) |candle_result| {
                defer self.allocator.free(candle_result.data);
                if (candle_result.data.len > 0) {
                    const last = candle_result.data[candle_result.data.len - 1];
                    prices.put(sym, last.close) catch {};
                    if (result.latest_date == null or last.date.days > result.latest_date.?.days) {
                        result.latest_date = last.date;
                    }
                }
                result.fetched_count += 1;
                if (progress) |p| p.emit(i, total, sym, .fetched);
                continue;
            } else |_| {}

            // 3. Fetch failed — fall back to stale cache
            result.fail_count += 1;
            if (self.getCachedLastClose(sym)) |close| {
                prices.put(sym, close) catch {};
                result.stale_count += 1;
                if (progress) |p| p.emit(i, total, sym, .failed_used_stale);
            } else {
                if (progress) |p| p.emit(i, total, sym, .failed);
            }
        }

        return result;
    }

    // ── CUSIP Resolution ──────────────────────────────────────────

    /// Look up multiple CUSIPs in a single batch request via OpenFIGI.
    /// Results array is parallel to the input cusips array (same length, same order).
    /// Caller owns the returned slice and all strings within each CusipResult.
    pub fn lookupCusips(self: *DataService, cusips: []const []const u8) DataError![]CusipResult {
        return OpenFigi.lookupCusips(self.allocator, cusips, self.config.openfigi_key) catch
            return DataError.FetchFailed;
    }

    /// Look up a CUSIP via OpenFIGI API. Returns the ticker if found, null otherwise.
    /// Results are cached in {cache_dir}/cusip_tickers.srf.
    /// Caller owns the returned string.
    pub fn lookupCusip(self: *DataService, cusip: []const u8) ?[]const u8 {
        // Check local cache first
        if (self.getCachedCusipTicker(cusip)) |t| return t;

        // Try OpenFIGI
        const result = OpenFigi.lookupCusip(self.allocator, cusip, self.config.openfigi_key) catch return null;
        defer {
            if (result.name) |n| self.allocator.free(n);
            if (result.security_type) |s| self.allocator.free(s);
        }

        if (result.ticker) |ticker| {
            // Cache the mapping
            self.cacheCusipTicker(cusip, ticker);
            return ticker; // caller takes ownership
        }

        return null;
    }

    /// Read a cached CUSIP->ticker mapping. Returns null if not cached.
    /// Caller owns the returned string.
    fn getCachedCusipTicker(self: *DataService, cusip: []const u8) ?[]const u8 {
        const path = std.fs.path.join(self.allocator, &.{ self.config.cache_dir, "cusip_tickers.srf" }) catch return null;
        defer self.allocator.free(path);

        const data = std.fs.cwd().readFileAlloc(self.allocator, path, 64 * 1024) catch return null;
        defer self.allocator.free(data);

        // Simple line-based format: cusip::XXXXX,ticker::YYYYY
        var lines = std.mem.splitScalar(u8, data, '\n');
        while (lines.next()) |line| {
            const trimmed = std.mem.trim(u8, line, &std.ascii.whitespace);
            if (trimmed.len == 0 or trimmed[0] == '#') continue;

            // Parse cusip:: field
            const cusip_prefix = "cusip::";
            if (!std.mem.startsWith(u8, trimmed, cusip_prefix)) continue;
            const after_cusip = trimmed[cusip_prefix.len..];
            const comma_idx = std.mem.indexOfScalar(u8, after_cusip, ',') orelse continue;
            const cached_cusip = after_cusip[0..comma_idx];
            if (!std.mem.eql(u8, cached_cusip, cusip)) continue;

            // Parse ticker:: field
            const rest = after_cusip[comma_idx + 1 ..];
            const ticker_prefix = "ticker::";
            if (!std.mem.startsWith(u8, rest, ticker_prefix)) continue;
            const ticker_val = rest[ticker_prefix.len..];
            // Trim any trailing comma/fields
            const ticker_end = std.mem.indexOfScalar(u8, ticker_val, ',') orelse ticker_val.len;
            const ticker = ticker_val[0..ticker_end];
            if (ticker.len > 0) {
                return self.allocator.dupe(u8, ticker) catch null;
            }
        }
        return null;
    }

    /// Append a CUSIP->ticker mapping to the cache file.
    pub fn cacheCusipTicker(self: *DataService, cusip: []const u8, ticker: []const u8) void {
        const path = std.fs.path.join(self.allocator, &.{ self.config.cache_dir, "cusip_tickers.srf" }) catch return;
        defer self.allocator.free(path);

        // Ensure cache dir exists
        if (std.fs.path.dirnamePosix(path)) |dir| {
            std.fs.cwd().makePath(dir) catch {};
        }

        // Append the mapping
        const file = std.fs.cwd().openFile(path, .{ .mode = .write_only }) catch blk: {
            // File doesn't exist, create it
            break :blk std.fs.cwd().createFile(path, .{}) catch return;
        };
        defer file.close();
        file.seekFromEnd(0) catch {};

        var buf: [256]u8 = undefined;
        const line = std.fmt.bufPrint(&buf, "cusip::{s},ticker::{s}\n", .{ cusip, ticker }) catch return;
        _ = file.write(line) catch {};
    }

    // ── Utility ──────────────────────────────────────────────────

    fn todayDate() Date {
        const ts = std.time.timestamp();
        const days: i32 = @intCast(@divFloor(ts, 86400));
        return .{ .days = days };
    }
};