import { beforeEach, describe, expect, it, mock } from "bun:test";

import type { FinancialStatementKind } from "@/lib/types";
import type {
  TaxonomyHydrationInput,
  TaxonomyHydrationResult,
} from "@/lib/server/taxonomy/types";

function createStatementRecord<T>(
  factory: () => T,
): Record<FinancialStatementKind, T> {
  return {
    income: factory(),
    balance: factory(),
    cash_flow: factory(),
    disclosure: factory(),
    equity: factory(),
    comprehensive_income: factory(),
  };
}

function createHydrationResult(): TaxonomyHydrationResult {
  return {
    filing_id: 1,
    ticker: "TEST",
    filing_date: "2025-12-31",
    filing_type: "10-K",
    parse_status: "ready",
    parse_error: null,
    source: "xbrl_instance_with_linkbase",
    parser_engine: "fiscal-xbrl",
    parser_version: "0.1.0",
    taxonomy_regime: "us-gaap",
    fiscal_pack: "core",
    periods: [],
    faithful_rows: createStatementRecord(() => []),
    statement_rows: createStatementRecord(() => []),
    surface_rows: createStatementRecord(() => []),
    detail_rows: createStatementRecord(() => ({})),
    kpi_rows: [],
    computed_definitions: [],
    contexts: [],
    derived_metrics: null,
    validation_result: null,
    facts_count: 0,
    concepts_count: 0,
    dimensions_count: 0,
    assets: [],
    concepts: [],
    facts: [],
    metric_validations: [],
    normalization_summary: {
      surface_row_count: 0,
      detail_row_count: 0,
      kpi_row_count: 0,
      unmapped_row_count: 0,
      material_unmapped_row_count: 0,
      residual_primary_count: 0,
      residual_disclosure_count: 0,
      unsupported_concept_count: 0,
      issuer_overlay_match_count: 0,
      warnings: ["rust_warning"],
    },
    xbrl_validation: {
      status: "passed",
    },
  };
}

const mockHydrateFromSidecar = mock(async () => createHydrationResult());
mock.module("@/lib/server/taxonomy/parser-client", () => ({
  hydrateFilingTaxonomySnapshotFromSidecar: mockHydrateFromSidecar,
}));

describe("taxonomy engine rust path", () => {
  beforeEach(() => {
    mockHydrateFromSidecar.mockClear();
  });

  it("returns sidecar output directly from the Rust sidecar", async () => {
    const { hydrateFilingTaxonomySnapshot } =
      await import("@/lib/server/taxonomy/engine");

    const input: TaxonomyHydrationInput = {
      filingId: 1,
      ticker: "TEST",
      cik: "0000000001",
      accessionNumber: "0000000001-25-000001",
      filingDate: "2025-12-31",
      filingType: "10-K",
      filingUrl:
        "https://www.sec.gov/Archives/edgar/data/1/000000000125000001/",
      primaryDocument: "test-20251231.htm",
    };

    const result = await hydrateFilingTaxonomySnapshot(input);

    expect(mockHydrateFromSidecar).toHaveBeenCalledTimes(1);
    expect(result.parser_engine).toBe("fiscal-xbrl");
    expect(result.normalization_summary.warnings).toEqual(["rust_warning"]);
  });
});