import type { DataProvider, SecFilingItem } from "../../../types/data-provider";
import { parseInsiderFiling, type ParsedInsiderFiling } from "./model";
import { isInsiderForm } from "./insider-data";

export async function loadInsiderFilings(
  provider: DataProvider,
  symbol: string,
  count: number,
  exchange = "",
): Promise<SecFilingItem[]> {
  if (!provider.getSecFilings) throw new Error("Insider filing data unavailable");
  const filings = await provider.getSecFilings(symbol, count, exchange);
  return filings.filter((filing) => isInsiderForm(filing.form));
}

function throwIfAborted(signal: AbortSignal | undefined): void {
  if (!signal?.aborted) return;
  throw signal.reason instanceof Error ? signal.reason : new Error("Insider filing load was aborted.");
}

export async function loadParsedInsiderFilings(
  provider: DataProvider,
  symbol: string,
  options: { limit: number; exchange?: string; signal?: AbortSignal },
): Promise<ParsedInsiderFiling[]> {
  if (!provider.getSecFilingContent) throw new Error("Insider filing content unavailable");
  const filings = (await loadInsiderFilings(
    provider,
    symbol,
    20_000,
    options.exchange,
  )).slice(0, options.limit);

  const parsed: ParsedInsiderFiling[] = [];
  for (const filing of filings) {
    throwIfAborted(options.signal);
    try {
      const content = await provider.getSecFilingContent(filing);
      parsed.push(...parseInsiderFiling(filing, content));
    } catch {
      throwIfAborted(options.signal);
      parsed.push({ filing, transaction: null, isLoading: false });
    }
  }
  return parsed;
}