import { describe, expect, test } from "bun:test";
import type { DataProvider } from "../../types/data-provider";
import type { InstrumentSearchResult } from "../../types/instrument";
import type { TickerRecord } from "../../types/ticker";
import { createTestDataProvider } from "../../test-support/data-provider";
import { loadYahooQuote } from "../../sources/yahoo-finance/snapshots";
import {
  AmbiguousTickerError,
  buildTickerSearchCandidates,
  createLocalTickerSearchCandidates,
  findExactTickerSearchMatch,
  normalizeTickerInput,
  rankTickerSearchItems,
  resolveTickerSearch,
  searchTickerCandidates,
  upsertTickerFromSearchResult,
} from "./index";

function makeTicker(
  symbol: string,
  name = symbol,
  overrides: Partial<TickerRecord["metadata"]> = {},
): TickerRecord {
  return {
    metadata: {
      ticker: symbol,
      exchange: "NASDAQ",
      currency: "USD",
      name,
      portfolios: [],
      watchlists: [],
      positions: [],
      custom: {},
      tags: [],
      ...overrides,
    },
  };
}

function makeSearchResult(
  symbol: string,
  name = symbol,
  overrides: Partial<InstrumentSearchResult> = {},
): InstrumentSearchResult {
  return {
    providerId: "test",
    symbol,
    name,
    exchange: "NASDAQ",
    type: "EQUITY",
    ...overrides,
  };
}

function makeDataProvider(results: InstrumentSearchResult[]): DataProvider {
  return createTestDataProvider({
    id: "test",
    search: async () => results,
  });
}

describe("ticker-search utilities", () => {
  test("duplicate bare symbols follow verified quote identity independent of catalogue order", async () => {
    for (const [symbol, venue, currency, providerCurrency] of [
      ["GLD", "NYSE", "USD", "USD"],
      ["VOD", "LSE", "GBP", "GBp"],
      ["7203", "TYO", "JPY", "JPY"],
    ]) {
      const wanted = makeSearchResult(symbol!, "Exact listing", { exchange: venue, currency: providerCurrency });
      const other = makeSearchResult(symbol!, "Other listing", { exchange: "BYMA", currency: "ARS" });
      for (const results of [[other, wanted], [wanted, other]]) {
        const quoteCalls: Parameters<DataProvider["getQuote"]>[] = [];
        const resolved = await resolveTickerSearch({ query: symbol, activeTicker: null, tickers: new Map(),
          searchContext: { brokerId: "ibkr", brokerInstanceId: "research-account", preferBroker: true, interactive: true, onPartial: () => {} },
          dataProvider: createTestDataProvider({ search: async () => results, getQuote: async (...args) => {
            quoteCalls.push(args);
            return { symbol: symbol!, listingExchangeName: venue, currency: currency!, price: 100, lastUpdated: 1, change: 0, changePercent: 0 };
          } }),
        });
        expect(resolved).toMatchObject({ kind: "provider", result: { exchange: venue, currency } });
        expect(quoteCalls).toEqual([[symbol, "", { brokerId: "ibkr", brokerInstanceId: "research-account" }]]);
      }
    }
  });

  test("ambiguous symbols require venue, currency and exact quote evidence", async () => {
    const results = [makeSearchResult("GLD", "SPDR", { exchange: "BYMA", currency: "ARS" }),
      makeSearchResult("GLD", "SPDR", { exchange: "NYSE", currency: "USD" })];
    const quote = { symbol: "GLD", listingExchangeName: "NYSE", currency: "USD", price: 400, lastUpdated: 1, change: 0, changePercent: 0 };
    for (const invalid of [null, { ...quote, listingExchangeName: undefined }, { ...quote, currency: "ARS" },
      { ...quote, symbol: "GLDM" }, { ...quote, price: Number.NaN }, { ...quote, lastUpdated: 0 }]) {
      await expect(resolveTickerSearch({ query: "GLD", activeTicker: null, tickers: new Map(),
        dataProvider: createTestDataProvider({ search: async () => results, getQuote: async () => {
          if (!invalid) throw new Error("Quote unavailable");
          return invalid;
        } }),
      })).rejects.toBeInstanceOf(AmbiguousTickerError);
    }
  });

  test("explicit venues and saved identities bypass default quote disambiguation", async () => {
    const results = [makeSearchResult("VOD", "Vodacom", { exchange: "JSE", currency: "ZAR" }),
      makeSearchResult("VOD", "Vodafone", { exchange: "LSE", currency: "GBP" }),
      makeSearchResult("VOD", "Vodafone ADR", { exchange: "NASDAQ", currency: "USD" })];
    let quoteCalls = 0;
    const dataProvider = createTestDataProvider({ search: async () => results, getQuote: async () => {
      quoteCalls++; throw new Error("Quote unavailable");
    } });
    for (const [query, exchange] of [["VOD:XLON", "LSE"], ["VOD:LSE", "LSE"], ["VOD:JSE", "JSE"], ["VOD:NASDAQ", "NASDAQ"]]) {
      expect(await resolveTickerSearch({ query, activeTicker: null, tickers: new Map(), dataProvider }))
        .toMatchObject({ kind: "provider", result: { exchange } });
    }
    const saved = makeTicker("VOD", "Saved Vodafone", { exchange: "LSE", currency: "GBP" });
    expect(await resolveTickerSearch({ query: "VOD", activeTicker: null, tickers: new Map([["VOD", saved]]), dataProvider }))
      .toMatchObject({ kind: "local", ticker: saved });
    expect(quoteCalls).toBe(0);
  });

  test("share-class aliases keep the requested security when duplicate venues need a quote", async () => {
    expect(await resolveTickerSearch({ query: "BRK-B", activeTicker: null, tickers: new Map(),
      dataProvider: createTestDataProvider({
        search: async () => [makeSearchResult("BRK.B", "Berkshire", { exchange: "BYMA", currency: "ARS" }),
          makeSearchResult("BRK.B", "Berkshire", { exchange: "NYSE", currency: "USD" })],
        getQuote: async () => ({ symbol: "BRK-B", listingExchangeName: "NYSE", currency: "USD", price: 400, lastUpdated: 1, change: 0, changePercent: 0 }),
      }),
    })).toMatchObject({ kind: "provider", symbol: "BRK.B", result: { exchange: "NYSE" } });
  });

  test("verifies omitted crypto symbols before selecting a punctuation alias on another venue", async () => {
    const alias = makeSearchResult("SHIB/USD", "SHIBA INU US Dollar", { type: "Digital Currency", exchange: "COINBASE PRO" });
    const quote = { symbol: "SHIB-USD", instrumentType: "CRYPTOCURRENCY", price: 0.00000509, currency: "USD", lastUpdated: 1789077420000,
      change: 0, changePercent: 0, listingExchangeName: "CCC" };
    const dataProvider = createTestDataProvider({ search: async () => [alias], getQuote: async () => quote });
    const savedAlias = makeTicker("SHIB/USD", "SHIBA INU US Dollar", { exchange: "COINBASE PRO", assetCategory: "Digital Currency" });
    const tickers = new Map([["SHIB/USD", savedAlias]]);
    expect(await resolveTickerSearch({ query: "SHIB-USD", activeTicker: null, tickers, dataProvider }))
      .toMatchObject({ kind: "provider", symbol: "SHIB-USD", result: { exchange: "CCC", currency: "USD", type: "CRYPTOCURRENCY" } });
    const candidates = await searchTickerCandidates({ query: "SHIB-USD", tickers, dataProvider });
    expect(candidates[0]?.symbol).toBe("SHIB-USD");
    expect(findExactTickerSearchMatch(candidates, "SHIB-USD")?.symbol).toBe("SHIB-USD");
    expect(await resolveTickerSearch({ query: "SHIB-USD:CCC", activeTicker: null, tickers, dataProvider }))
      .toMatchObject({ kind: "provider", result: { exchange: "CCC" } });
    expect(await resolveTickerSearch({ query: "SHIB-USD:COINBASE PRO", activeTicker: null, tickers, dataProvider })).toBeNull();
    // A hyphen alone cannot establish an instrument's type or its identity.
    for (const invalid of [{ instrumentType: "EQUITY" }, { symbol: "OTHER-USD" }, { price: 0 }, { price: -1 }, { instrumentType: undefined }]) {
      expect(await resolveTickerSearch({ query: "SHIB-USD", activeTicker: null, tickers: new Map(),
        dataProvider: createTestDataProvider({ search: async () => [alias], getQuote: async () => ({ ...quote, ...invalid }) }) })).toBeNull();
    }
  });

  test("prefers literal provider symbols without losing equity share-class aliases", async () => {
    const results = [makeSearchResult("SHIB/USD", "Shiba Inu", { type: "Digital Currency", exchange: "COINBASE PRO" }),
      makeSearchResult("SHIB-USD", "Shiba Inu", { type: "CRYPTOCURRENCY", exchange: "CCC", currency: "USD" })];
    expect(await resolveTickerSearch({ query: "SHIB-USD", activeTicker: null, tickers: new Map(), dataProvider: makeDataProvider(results) }))
      .toMatchObject({ symbol: "SHIB-USD" });
    expect(await resolveTickerSearch({ query: "BRK-B", activeTicker: null, tickers: new Map(),
      dataProvider: makeDataProvider([makeSearchResult("BRK.B", "Berkshire", { exchange: "NYSE" })]) }))
      .toMatchObject({ symbol: "BRK.B" });
  });

  test("native Yahoo chart instrument type verifies an omitted crypto catalogue entry", async () => {
    const dataProvider = createTestDataProvider({
      search: async () => [makeSearchResult("SHIB/USD", "Shiba Inu", { exchange: "COINBASE PRO", type: "Digital Currency" })],
      getQuote: async (symbol) => loadYahooQuote(symbol, {
        providerId: "yahoo-finance",
        fetchChart: async () => ({ meta: { instrumentType: "CRYPTOCURRENCY", currency: "USD", exchangeName: "CCC",
          regularMarketPrice: 0.00000509, regularMarketTime: 1789077420 }, history: [{ date: new Date("2026-09-10"), close: 0.00000509 }] }),
        fetchQuoteSupplement: async () => ({}), fetchExtendedHoursData: async () => ({}),
      }),
    });
    expect(await resolveTickerSearch({ query: "SHIB-USD", activeTicker: null, tickers: new Map(), dataProvider }))
      .toMatchObject({ symbol: "SHIB-USD", result: { type: "CRYPTOCURRENCY", exchange: "CCC" } });
  });

  test("preserves futures, FX and index identity across saved and provider search matches", async () => {
    for (const symbol of ["ES=F", "6J=F", "JPY=X", "EURUSD=X", "EUR/USD", "^GSPC"]) {
      const lookalike = symbol.replace(/[^A-Z0-9]/g, "");
      const tickers = new Map([[lookalike, makeTicker(lookalike)]]);
      const queries: string[] = [];
      const dataProvider = createTestDataProvider({
        search: async (query) => {
          queries.push(query);
          return [makeSearchResult(lookalike), makeSearchResult(symbol)];
        },
      });
      const resolved = await resolveTickerSearch({ query: symbol, activeTicker: null, tickers, dataProvider });
      expect(resolved).toMatchObject({ kind: "provider", symbol });
      expect(queries).not.toContain(lookalike);
      const candidates = await searchTickerCandidates({ query: symbol, tickers, dataProvider });
      expect(candidates[0]?.symbol).toBe(symbol);
      expect(candidates.some((candidate) => candidate.symbol === lookalike)).toBe(false);
      expect(findExactTickerSearchMatch([{ label: lookalike }], symbol)).toBeNull();
      expect(findExactTickerSearchMatch([{ label: symbol }], lookalike)).toBeNull();
    }
    expect(findExactTickerSearchMatch([{ label: "EURUSD=X" }], "EUR/USD")?.label).toBe("EURUSD=X");
    expect(findExactTickerSearchMatch([{ label: "USD/JPY" }], "JPY=X")?.label).toBe("USD/JPY");
    expect(findExactTickerSearchMatch([{ label: "JPY/USD" }], "JPY=X")).toBeNull();
  });

  test("retains the quote currency of FX catalogue rows and reuses saved qualified futures", async () => {
    for (const symbol of ["JPY=X", "USDJPY=X", "USD/JPY", "EUR/JPY"]) {
      expect(await resolveTickerSearch({
        query: symbol, activeTicker: null, tickers: new Map(),
        dataProvider: makeDataProvider([makeSearchResult(symbol, "Currency Pair", { type: "Physical Currency" })]),
      })).toMatchObject({ kind: "provider", result: { symbol, currency: "JPY" } });
    }
    const future = makeTicker("ES=F:CME", "S&P 500 Futures", { exchange: "CME", assetCategory: "FUTURE" });
    for (const query of ["ES=F", "ES=F:CME"]) {
      expect(await resolveTickerSearch({
        query, activeTicker: null, tickers: new Map([[future.metadata.ticker, future]]),
        dataProvider: createTestDataProvider({ search: async () => { throw new Error("saved future should resolve locally"); } }),
      })).toMatchObject({ kind: "local", symbol: "ES=F:CME" });
    }
    expect(findExactTickerSearchMatch([{ label: "ES=F:CME" }], "ES=F:NYMEX")).toBeNull();
  });

  test("resolves catalogue omissions through a quote for the exact market symbol only", async () => {
    const lookalike = makeSearchResult("ESF", "Eurotech", { exchange: "MTA" });
    const quoteCalls: string[] = [];
    const dataProvider = createTestDataProvider({
      search: async () => [lookalike],
      getQuote: async (symbol) => {
        quoteCalls.push(symbol);
        return {
          symbol, providerId: "market-data", name: "S&P 500 Futures", price: 6000,
          currency: "USD", lastUpdated: Date.now(), change: 10, changePercent: 0.1,
          exchangeName: "CME",
        };
      },
    });
    const candidates = await searchTickerCandidates({ query: "ES=F", tickers: new Map(), dataProvider });
    expect(candidates).toHaveLength(1);
    expect(candidates[0]).toMatchObject({ symbol: "ES=F", instrumentClass: "derivative", result: { currency: "USD", exchange: "CME", type: "FUTURE" } });
    expect(quoteCalls).toEqual(["ES=F"]);

    for (const invalidQuote of [
      { symbol: "ESF", price: 6000 },
      { symbol: "ES=F", price: NaN },
      { symbol: "ES=F", price: 0 },
    ]) {
      expect(await resolveTickerSearch({
        query: "ES=F", activeTicker: null, tickers: new Map(),
        dataProvider: createTestDataProvider({
          search: async () => [lookalike],
          getQuote: async () => ({ ...invalidQuote, currency: "USD", lastUpdated: Date.now(), change: 0, changePercent: 0 }),
        }),
      })).toBeNull();
    }
  });

  test("resolves explicit venues ahead of punctuation lookalikes and saved foreign listings", async () => {
    const tickers = new Map([["VOD", makeTicker("VOD", "Vodafone ADR", { exchange: "NASDAQ" })]]);
    const dataProvider = makeDataProvider([
      makeSearchResult("VODL", "Vodafone", { exchange: "CBOE" }),
      makeSearchResult("VOD", "Vodacom", { exchange: "JSE" }),
      makeSearchResult("VOD", "Vodafone", { exchange: "LSE" }),
    ]);
    for (const query of ["VOD.L", "VOD:XLON"]) {
      const results = await searchTickerCandidates({ query, tickers, dataProvider });
      expect(results[0]).toMatchObject({ symbol: "VOD", exchangeLabel: "LSE" });
      expect(findExactTickerSearchMatch(results, query)?.exchangeLabel).toBe("LSE");
      expect(await resolveTickerSearch({ query, activeTicker: null, tickers, dataProvider }))
        .toMatchObject({ kind: "provider", result: { symbol: "VOD", exchange: "LSE" } });
    }
    expect(findExactTickerSearchMatch([{ label: "VODL", right: "CBOE" }], "VOD.L")).toBeNull();
  });

  test("respects provider suffixes in Europe and numeric Asian listings", async () => {
    for (const [query, symbol, exchange] of [
      ["SAP.DE", "SAP", "XETRA"], ["AIR.PA", "AIR", "PAR"],
      ["ASML.AS", "ASML", "AMS"], ["7203.T", "7203", "JPX"], ["0700.HK", "700", "HKG"],
    ]) {
      const results = await searchTickerCandidates({
        query: query!, tickers: new Map(),
        dataProvider: makeDataProvider([makeSearchResult(symbol!, "Issuer", { exchange: exchange! })]),
      });
      expect(findExactTickerSearchMatch(results, query!)?.symbol).toBe(symbol!);
    }
  });

  test("normalizes explicit and focused ticker inputs", () => {
    expect(normalizeTickerInput("AAPL", undefined)).toBe("AAPL");
    expect(normalizeTickerInput("AAPL", " msft ")).toBe("MSFT");
    expect(normalizeTickerInput(null, undefined)).toBeNull();
  });

  test("finds exact provider matches for direct ticker resolution", async () => {
    const tickers = new Map<string, TickerRecord>([["AAPL", makeTicker("AAPL", "Apple")]]);
    const resolved = await resolveTickerSearch({
      query: "MSFT",
      activeTicker: null,
      tickers,
      dataProvider: makeDataProvider([
        makeSearchResult("MSFT", "Microsoft"),
        makeSearchResult("MSFTW", "Microsoft Warrants"),
      ]),
    });

    expect(resolved).toMatchObject({
      kind: "provider",
      symbol: "MSFT",
    });
  });

  test("combines local and provider candidates without duplicate saved symbols", async () => {
    const tickers = new Map<string, TickerRecord>([["AAPL", makeTicker("AAPL", "Apple")]]);
    const results = await searchTickerCandidates({
      query: "appl",
      tickers,
      dataProvider: makeDataProvider([
        makeSearchResult("AAPL", "Apple Inc"),
        makeSearchResult("APP", "AppLovin"),
      ]),
    });

    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APP:NASDAQ:TEST"]);
    expect(findExactTickerSearchMatch(results, "AAPL")?.id).toBe("goto:AAPL");
  });

  test("uses provider metadata to keep stale saved tickers intuitive in search results", async () => {
    const tickers = new Map<string, TickerRecord>([["AAPL", makeTicker("AAPL", "AAPL")]]);
    const results = await searchTickerCandidates({
      query: "apple",
      tickers,
      dataProvider: makeDataProvider([
        makeSearchResult("AAPL", "Apple Inc"),
        makeSearchResult("APLE", "Apple Hospitality REIT, Inc."),
      ]),
    });

    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APLE:NASDAQ:TEST"]);
    expect(results[0]).toMatchObject({
      id: "goto:AAPL",
      detail: "Apple Inc",
      category: "Saved",
    });
    expect(findExactTickerSearchMatch(results, "AAPL")?.id).toBe("goto:AAPL");
  });

  test("enriches duplicate provider symbols from the saved listing's exchange", () => {
    const results = buildTickerSearchCandidates({
      query: "Apple NASDAQ",
      tickers: new Map<string, TickerRecord>([
        ["APC", makeTicker("APC", "Apple Inc.", { exchange: "XETRA", assetCategory: "STK" })],
        ["AAPL", makeTicker("AAPL", "Apple Inc.", { exchange: "NASDAQ", assetCategory: "STK" })],
      ]),
      providerResults: [
        makeSearchResult("APC", "Apple Inc.", { exchange: "XETRA" }),
        makeSearchResult("AAPL", "Apple Inc. CEDEAR", {
          exchange: "BYMA",
          primaryExchange: "BYMA",
          currency: "ARS",
        }),
        makeSearchResult("AAPL", "Apple Inc.", {
          exchange: "SMART",
          brokerContract: {
            brokerId: "test",
            symbol: "AAPL",
            exchange: "NASDAQ",
          },
        }),
      ],
    });

    expect(results[0]).toMatchObject({
      id: "goto:AAPL",
      right: "NASDAQ",
      exchangeLabel: "NASDAQ",
    });
  });

  test("does not apply a conflicting provider primary exchange to a saved listing", () => {
    const results = buildTickerSearchCandidates({
      query: "Apple BUE",
      tickers: new Map<string, TickerRecord>([[
        "AAPL",
        makeTicker("AAPL", "Apple Inc.", { exchange: "NASDAQ", assetCategory: "STK" }),
      ]]),
      providerResults: [
        makeSearchResult("AAPL", "Apple Inc.", {
          exchange: "SMART",
          primaryExchange: "BUE",
        }),
        makeSearchResult("AAPLC.BA", "Apple Inc.", { exchange: "BUE" }),
      ],
    });

    expect(results.find((item) => item.id === "goto:AAPL")?.primaryExchangeLabel).toBeUndefined();
    expect(results.find((item) => item.kind === "search" && item.symbol === "AAPL")?.primaryExchangeLabel).toBe("BUE");
  });

  test("a saved listing keeps its own venue and type when only another venue's line matches", () => {
    const results = buildTickerSearchCandidates({
      query: "Microsoft",
      tickers: new Map([["MSFT", makeTicker("MSFT", "Microsoft Corporation", { exchange: "NASDAQ", assetCategory: "STK" })]]),
      providerResults: [makeSearchResult("MSFT", "Microsoft Corporation", {
        exchange: "BYMA", primaryExchange: "BYMA", currency: "ARS", type: "Depositary Receipt",
      })],
    });
    const saved = results.find((item) => item.id === "goto:MSFT")!;
    // Selecting it must not bind the BYMA receipt, and the row must not say so.
    expect(saved.result).toBeUndefined();
    expect(saved).toMatchObject({ right: "NASDAQ", instrumentType: "STK" });
  });

  for (const savedSymbol of ["SHOP", "SHOP:XNAS"]) {
    test(`saved ${savedSymbol} deduplicates venue aliases while retaining the unsaved TSX listing`, () => {
      const results = buildTickerSearchCandidates({
        query: "Shopify",
        tickers: new Map([[savedSymbol, makeTicker(savedSymbol, "Shopify Inc.", { exchange: "NASDAQ" })]]),
        providerResults: [
          makeSearchResult("SHOP", "Shopify Inc.", { exchange: "XNAS", currency: "USD" }),
          makeSearchResult("SHOP", "Shopify Inc.", { exchange: "NASDAQ", currency: "USD" }),
          makeSearchResult("SHOP", "Shopify Inc.", { exchange: "TSX", currency: "CAD" }),
          makeSearchResult("SHOP", "Shopify Inc.", { exchange: "SMART", primaryExchange: "XTSE", currency: "CAD" }),
        ],
      });
      expect(results).toHaveLength(2);
      expect(results.find((item) => item.kind === "ticker")?.id).toBe(`goto:${savedSymbol}`);
      const foreign = results.find((item) => item.kind === "search")!;
      expect(foreign.saved).toBe(false);
      expect(foreign.category).not.toBe("Saved");
      expect(foreign.result?.currency).toBe("CAD");
    });
  }

  test("uses provider ordering to prefer the canonical saved listing for company-name queries", () => {
    const tickers = new Map<string, TickerRecord>([
      ["APC", makeTicker("APC", "Apple Inc.", {
        exchange: "XETRA",
        currency: "EUR",
        assetCategory: "STK",
      })],
      ["AAPL", makeTicker("AAPL", "Apple Inc.", {
        exchange: "NASDAQ",
        currency: "USD",
        assetCategory: "STK",
      })],
    ]);

    const results = buildTickerSearchCandidates({
      query: "Apple",
      tickers,
      providerResults: [
        makeSearchResult("AAPL", "Apple Inc.", {
          exchange: "NASDAQ",
          primaryExchange: "NASDAQ",
          currency: "USD",
        }),
        makeSearchResult("APC", "Apple Inc.", {
          exchange: "XETRA",
          primaryExchange: "XETRA",
          currency: "EUR",
        }),
      ],
    });

    expect(results.slice(0, 2).map((item) => item.id)).toEqual([
      "goto:AAPL",
      "goto:APC",
    ]);
    expect(results.slice(0, 2).map((item) => item.category)).toEqual([
      "Saved",
      "Saved",
    ]);
  });

  test("keeps explicit symbol, exchange, and asset-class intent ahead of provider ordering", () => {
    const tickers = new Map<string, TickerRecord>([
      ["APC", makeTicker("APC", "Apple Inc.", {
        exchange: "XETRA",
        currency: "EUR",
        assetCategory: "STK",
      })],
      ["AAPL", makeTicker("AAPL", "Apple Inc.", {
        exchange: "NASDAQ",
        currency: "USD",
        assetCategory: "STK",
      })],
    ]);
    const providerResults = [
      makeSearchResult("AAPL", "Apple Inc.", { exchange: "NASDAQ" }),
      makeSearchResult("APC", "Apple Inc.", { exchange: "XETRA", currency: "EUR" }),
      makeSearchResult("APLY", "Yield Strategy Linked to Apple ETF", { exchange: "NYSE Arca", type: "ETF" }),
      makeSearchResult("APP", "AppLovin Corporation", { exchange: "NASDAQ" }),
    ];
    const firstSymbolFor = (query: string) => buildTickerSearchCandidates({
      query,
      tickers,
      providerResults,
    })[0]?.symbol;

    expect(firstSymbolFor("APC")).toBe("APC");
    expect(firstSymbolFor("APP")).toBe("APP");
    expect(firstSymbolFor("Apple XETRA")).toBe("APC");
    expect(firstSymbolFor("Apple NASDAQ")).toBe("AAPL");
    expect(firstSymbolFor("Apple ETF")).toBe("APLY");
  });

  test("uses provider ordering without assuming the canonical listing is on a US exchange", () => {
    const results = buildTickerSearchCandidates({
      query: "Toyota",
      tickers: new Map<string, TickerRecord>([[
        "TM",
        makeTicker("TM", "Toyota Motor Corporation", {
          exchange: "NYSE",
          currency: "USD",
          assetCategory: "STK",
        }),
      ]]),
      providerResults: [
        makeSearchResult("7203", "Toyota Motor Corp", {
          exchange: "Tokyo Stock Exchange",
          primaryExchange: "Tokyo Stock Exchange",
          currency: "JPY",
        }),
        makeSearchResult("TM", "Toyota Motor Corporation", {
          exchange: "NYSE",
          primaryExchange: "NYSE",
          currency: "USD",
        }),
        makeSearchResult("TOYOTA80.BK", "TOYOTA80 DR", {
          exchange: "SET",
          currency: "THB",
        }),
      ],
    });

    expect(results.slice(0, 2).map((item) => [item.symbol, item.category])).toEqual([
      ["7203", "Primary Listing"],
      ["TM", "Saved"],
    ]);
  });

  test("does not let provider order or an accidental symbol prefix overwhelm a closer company match", () => {
    const results = buildTickerSearchCandidates({
      query: "Apple",
      tickers: new Map<string, TickerRecord>(),
      providerResults: [
        makeSearchResult("APLE", "Apple Hospitality REIT, Inc.", { exchange: "NYSE" }),
        makeSearchResult("AAPL", "Apple Inc.", { exchange: "NASDAQ" }),
        makeSearchResult("APPLE80.BK", "APPLE80 DR", { exchange: "SET", currency: "THB" }),
      ],
    });

    expect(results[0]?.symbol).toBe("AAPL");
    expect(results.some((item) => item.symbol === "APPLE80.BK")).toBe(true);
  });

  test("orders companies matched by name alone by provider popularity, not name length", () => {
    const rank = (query: string, providerResults: InstrumentSearchResult[]) => buildTickerSearchCandidates({
      query,
      tickers: new Map<string, TickerRecord>(),
      providerResults,
    }).map((item) => item.symbol);

    expect(rank("Siemens", [
      makeSearchResult("SIE", "Siemens Aktiengesellschaft", { exchange: "XETRA" }),
      makeSearchResult("SHL", "Siemens Healthineers AG", { exchange: "XETRA", type: "Common Stock" }),
    ])).toEqual(["SIE", "SHL"]);
    // Accented names stay whole words, so the unaccented query still matches them.
    expect(rank("nestle", [
      makeSearchResult("NESTLEIND", "Nestle India Ltd.", { exchange: "NSE" }),
      makeSearchResult("NESN", "Nestlé S.A.", { exchange: "SWX" }),
    ])).toEqual(["NESN", "NESTLEIND"]);
  });

  describe("provider popularity", () => {
    // Cloud responses captured from Yahoo's search scores on 2026-09-23.
    const listing = (symbol: string, name: string, exchange: string, popularity?: number, type = "EQUITY") =>
      makeSearchResult(symbol, name, { exchange, type, ...(popularity == null ? {} : { popularity }) });
    const build = (query: string, providerResults: InstrumentSearchResult[]) => buildTickerSearchCandidates({
      query,
      tickers: new Map<string, TickerRecord>(),
      providerResults,
      totalLimit: 10,
    });
    const symbols = (query: string, providerResults: InstrumentSearchResult[]) =>
      build(query, providerResults).map((item) => item.symbol);
    const primary = (query: string, providerResults: InstrumentSearchResult[]) =>
      build(query, providerResults).find((item) => item.category === "Primary Listing")?.symbol;
    const withoutPopularity = (results: InstrumentSearchResult[]) =>
      results.map(({ popularity: _popularity, ...result }) => result);

    const taiwan = [
      listing("TSM", "Taiwan Semiconductor Manufacturing Company Limited", "NYSE", 94661),
      listing("2330", "Taiwan Semiconductor Manufacturing Company Limited", "TWSE", 22037),
      listing("TSMC34", "Taiwan Semiconductor Manufacturing Co., Ltd.", "B3", 20945, "Depositary Receipt"),
      listing("5425", "Taiwan Semiconductor Co., Ltd.", "TWSE", 20052),
      listing("057782", "Fubon Warrant on Taiwan Semiconductor", "TWSE", undefined, "Warrant"),
    ];

    test("a far more popular company outranks a small namesake typed exactly", () => {
      expect(symbols("Taiwan Semiconductor", taiwan)).toEqual(["TSM", "2330", "TSMC34", "5425", "057782"]);
      expect(primary("Taiwan Semiconductor", taiwan)).toBe("TSM");
      // Older servers send no popularity, so the exact name still leads there.
      expect(primary("Taiwan Semiconductor", withoutPopularity(taiwan))).toBe("5425");
    });

    test("comparable popularity keeps the exactly named company first", () => {
      const siemens = [
        listing("ENR", "Siemens Energy AG", "XETRA", 21317),
        listing("SIE", "Siemens Aktiengesellschaft", "XETRA", 20993),
        listing("SIEGY", "Siemens Aktiengesellschaft", "PNK", 20451),
        listing("SMERY", "Siemens Energy AG", "OQX", 20257),
        listing("SHL", "Siemens Healthineers AG", "XETRA", 20245),
      ];
      expect(symbols("Siemens", siemens)).toEqual(["SIE", "SIEGY", "ENR", "SMERY", "SHL"]);

      const nestle = [
        listing("NESN", "Nestlé S.A.", "SIX", 21186),
        listing("NSRGY", "Nestlé S.A.", "OID", 20886),
        listing("NESTLEIND", "Nestlé India Limited", "NSE", 20247),
      ];
      expect(symbols("nestle", nestle)).toEqual(["NESN", "NSRGY", "NESTLEIND"]);

      const apple = [
        listing("AAPL", "Apple Inc.", "NASDAQ", 235768),
        listing("APLE", "Apple Hospitality REIT, Inc.", "NYSE", 21233),
      ];
      for (const results of [apple, [...apple].reverse(), withoutPopularity([...apple].reverse())]) {
        expect(symbols("Apple", results)).toEqual(["AAPL", "APLE"]);
      }
    });

    test("a typed depositary receipt yields to its issuer's home listing; an untyped ADR keeps popularity order", () => {
      const toyota = [
        listing("TM", "Toyota Motor Corporation", "NYSE", 23125),
        listing("7203", "Toyota Motor Corporation", "JPX", 20228),
        listing("TOYOF", "Toyota Motor Corporation", "PNK", 20069),
        listing("8015", "Toyota Tsusho Corporation", "JPX", 20033),
        listing("TOM", "Toyota Motor Corp.", "XHAN"),
      ];
      // Yahoo files TM as plain NYSE equity, exactly like a second home line.
      expect(symbols("Toyota", toyota)).toEqual(["TM", "7203", "TOYOF", "TOM", "8015"]);
      const typed = toyota.map((result) => result.symbol === "TM" ? { ...result, type: "Depositary Receipt" } : result);
      expect(symbols("Toyota", typed)).toEqual(["7203", "TOYOF", "TOM", "TM", "8015"]);
      expect(primary("Toyota", typed)).toBe("7203");
      // A ticker search keeps the provider's order among that ticker's lines.
      expect(symbols("TM", typed)[0]).toBe("TM");
    });
  });

  test("normalizes legal suffixes in literal company-name queries", () => {
    const cases = [
      {
        query: "Apple Inc",
        canonical: makeSearchResult("AAPL", "Apple Inc.", { exchange: "NASDAQ" }),
        alternate: makeSearchResult("AAPL-ADR", "Apple Inc. ADR", { exchange: "OTC" }),
      },
      {
        query: "Toyota Motor Corporation",
        canonical: makeSearchResult("TM", "Toyota Motor Corporation", { exchange: "NYSE" }),
        alternate: makeSearchResult("TM-ADR", "Toyota Motor Corporation ADR", { exchange: "OTC" }),
      },
    ];

    for (const { query, canonical, alternate } of cases) {
      const results = buildTickerSearchCandidates({
        query,
        tickers: new Map<string, TickerRecord>(),
        providerResults: [alternate, canonical],
      });

      expect(results[0]?.symbol).toBe(canonical.symbol);
    }
  });

  test("keeps same-issuer provider ordering transitive across ambiguous company matches", () => {
    const candidates = [
      {
        id: "big-apple-primary",
        label: "ZZZ",
        symbol: "ZZZ",
        detail: "Big Apple",
        right: "NYSE",
        category: "Other Listings",
        kind: "search" as const,
        instrumentClass: "equity" as const,
        providerRank: 1,
      },
      {
        id: "big-apple-alternate",
        label: "APPLEB",
        symbol: "APPLEB",
        detail: "Big Apple",
        right: "NASDAQ",
        category: "Other Listings",
        kind: "search" as const,
        instrumentClass: "equity" as const,
        providerRank: 2,
      },
      {
        id: "unrelated-apple",
        label: "XAPL",
        symbol: "XAPL",
        detail: "X Apple",
        right: "NYSE",
        category: "Other Listings",
        kind: "search" as const,
        instrumentClass: "equity" as const,
        providerRank: 0,
      },
    ];

    const expected = ["ZZZ", "APPLEB", "XAPL"];
    expect(rankTickerSearchItems(candidates, "Apple").map((item) => item.symbol)).toEqual(expected);
    expect(rankTickerSearchItems([...candidates].reverse(), "Apple").map((item) => item.symbol)).toEqual(expected);
  });

  test("ranks the primary listing above leveraged and depositary look-alikes", () => {
    const make = (symbol: string, right: string, providerRank: number) => ({
      id: symbol,
      label: symbol,
      symbol,
      detail: "NVIDIA Corporation",
      right,
      category: "Other Listings",
      kind: "search" as const,
      instrumentClass: "equity" as const,
      providerRank,
    });
    // Provider order puts the Milan 4x product first; every text signal ties.
    const candidates = [make("4NVDA", "MTA", 0), make("NVDA", "NASDAQ", 1), make("NVDC34", "BOVESPA", 2)];

    expect(rankTickerSearchItems(candidates, "nvidia").map((item) => item.symbol))
      .toEqual(["NVDA", "4NVDA", "NVDC34"]);

    // All-digit symbols are Tokyo, Shanghai and Hong Kong primaries, not look-alikes.
    const toyota = [
      { ...make("7203", "TSE", 0), detail: "Toyota Motor Corporation" },
      { ...make("TM", "NYSE", 1), detail: "Toyota Motor Corporation" },
    ];
    expect(rankTickerSearchItems(toyota, "toyota").map((item) => item.symbol)).toEqual(["7203", "TM"]);
  });

  test("normalizes punctuated legal suffixes before applying same-issuer provider order", () => {
    const results = buildTickerSearchCandidates({
      query: "Acme",
      tickers: new Map<string, TickerRecord>(),
      providerResults: [
        makeSearchResult("AMS.MC", "Acme S.A.", { exchange: "BME" }),
        makeSearchResult("ACM", "Acme SA", { exchange: "NYSE" }),
      ],
    });

    expect(results.slice(0, 2).map((item) => item.symbol)).toEqual(["AMS.MC", "ACM"]);
  });

  test("keeps saved funds in the saved category", () => {
    const results = buildTickerSearchCandidates({
      query: "Vanguard",
      tickers: new Map<string, TickerRecord>([[
        "VTI",
        makeTicker("VTI", "Vanguard Total Stock Market ETF", {
          exchange: "NYSE Arca",
          assetCategory: "ETF",
        }),
      ]]),
      providerResults: [],
    });

    expect(results[0]).toMatchObject({ symbol: "VTI", category: "Saved" });
  });

  test("preserves exchange-qualified symbols and groups provider listings intuitively", () => {
    const results = buildTickerSearchCandidates({
      query: "apple",
      tickers: new Map<string, TickerRecord>(),
      providerResults: [
        makeSearchResult("AAPL", "Apple Inc"),
        { ...makeSearchResult("AAPL.BA", "Apple Inc"), exchange: "Buenos Aires" },
        { ...makeSearchResult("APLY.NE", "Apple Yield Shares Purpose ETF"), exchange: "NEO", type: "ETF" },
      ],
      localLimit: 6,
      totalLimit: 8,
    });

    expect(results.map((item) => [item.label, item.category])).toEqual([
      ["AAPL", "Primary Listing"],
      ["AAPL.BA", "Other Listings"],
      ["APLY.NE", "Funds & Derivatives"],
    ]);
  });

  test("finds exact symbol aliases for dotted share classes", () => {
    const match = findExactTickerSearchMatch([
      {
        id: "search:BRK.B",
        label: "BRK.B",
        detail: "Berkshire Hathaway Inc. Class B",
        kind: "search",
        category: "Primary Listing",
        searchAliases: ["BRK.B", "BRK B", "BRKB"],
      },
    ], "brkb");

    expect(match?.id).toBe("search:BRK.B");
  });

  test("expands compact share-class queries when searching providers", async () => {
    const queries: string[] = [];
    const expandedResults = await searchTickerCandidates({
      query: "brkb",
      tickers: new Map<string, TickerRecord>(),
      dataProvider: createTestDataProvider({
        id: "test",
        search: async (query) => {
          queries.push(query);
          return query.toLowerCase() === "brk-b"
            ? [{ providerId: "test", symbol: "BRK-B", name: "Berkshire Hathaway Inc. Class B", exchange: "NYSE", type: "EQUITY" }]
            : [];
        },
      }),
      totalLimit: 5,
    });

    expect(queries).toContain("BRK-B");
    expect(expandedResults[0]).toMatchObject({
      label: "BRK-B",
      category: "Primary Listing",
    });
  });

  test("tries canonical symbol aliases before raw lowercase provider searches", async () => {
    const queries: string[] = [];
    const results = await searchTickerCandidates({
      query: "nvda",
      tickers: new Map<string, TickerRecord>(),
      dataProvider: createTestDataProvider({
        id: "test",
        search: async (query) => {
          queries.push(query);
          return query === "NVDA"
            ? [makeSearchResult("NVDA", "NVIDIA Corporation")]
            : [{ ...makeSearchResult("NVD", "GraniteShares 2x Short NVDA Daily ETF"), exchange: "NYSEArca", type: "ETF" }];
        },
      }),
      totalLimit: 5,
      includeOptionContracts: false,
    });

    expect(queries[0]).toBe("NVDA");
    expect(results[0]).toMatchObject({
      label: "NVDA",
      category: "Primary Listing",
    });
  });

  test("upserts ticker records from provider search results", async () => {
    const saved: TickerRecord[] = [];
    const repository = {
      loadTicker: async () => null,
      createTicker: async (metadata: TickerRecord["metadata"]) => ({ metadata }),
      saveTicker: async (ticker: TickerRecord) => {
        saved.push(ticker);
      },
    };

    const { ticker, created } = await upsertTickerFromSearchResult(repository as any, {
      providerId: "test",
      symbol: "NVDA",
      name: "NVIDIA",
      exchange: "NASDAQ",
      type: "EQUITY",
      currency: "USD",
    });

    expect(created).toBe(true);
    expect(ticker.metadata.ticker).toBe("NVDA");
    expect(saved).toHaveLength(0);
  });

  test("refreshes low-quality saved metadata when opening a provider-backed result", async () => {
    const existing = makeTicker("AAPL", "AAPL");
    const saved: TickerRecord[] = [];
    const repository = {
      loadTicker: async () => existing,
      createTicker: async (metadata: TickerRecord["metadata"]) => ({ metadata }),
      saveTicker: async (ticker: TickerRecord) => {
        saved.push(ticker);
      },
    };

    const { ticker, created } = await upsertTickerFromSearchResult(repository as any, {
      providerId: "test",
      symbol: "AAPL",
      name: "Apple Inc.",
      exchange: "NASDAQ",
      type: "EQUITY",
      currency: "USD",
    });

    expect(created).toBe(false);
    expect(ticker.metadata.name).toBe("Apple Inc.");
    expect(saved).toHaveLength(1);
  });

  test("keeps holdings intact when opening a second listing with the same symbol", async () => {
    const existing = makeTicker("AAPL", "Apple Inc.");
    existing.metadata.exchange = "NASDAQ";
    existing.metadata.currency = "USD";
    existing.metadata.portfolios = ["Core"];
    existing.metadata.positions = [{ portfolio: "Core", quantity: 10, costBasis: 200, currency: "USD" }] as any;
    const original = structuredClone(existing);
    const records = new Map([["AAPL", existing]]);
    const saved: TickerRecord[] = [];
    const repository = {
      loadTicker: async (symbol: string) => records.get(symbol) ?? null,
      createTicker: async (metadata: TickerRecord["metadata"]) => {
        const ticker = { metadata };
        records.set(metadata.ticker, ticker);
        return ticker;
      },
      saveTicker: async (ticker: TickerRecord) => {
        saved.push(ticker);
      },
    };

    const result: InstrumentSearchResult = {
      providerId: "test",
      symbol: "AAPL",
      name: "Apple Inc.",
      exchange: "BYMA",
      type: "EQUITY",
      currency: "ARS",
    };
    const { ticker, created } = await upsertTickerFromSearchResult(repository as any, result);

    expect(created).toBe(true);
    expect(ticker.metadata.ticker).toBe("AAPL:BYMA");
    expect(ticker.metadata.exchange).toBe("BYMA");
    expect(ticker.metadata.currency).toBe("ARS");
    expect(ticker.metadata.positions).toEqual([]);
    expect(existing).toEqual(original);
    expect(saved).toHaveLength(0);
    expect(await upsertTickerFromSearchResult(repository as any, result)).toMatchObject({ created: false, ticker });
  });

  test("exposes local ticker candidates in saved category", () => {
    expect(createLocalTickerSearchCandidates([makeTicker("TSLA", "Tesla")])).toEqual([
      expect.objectContaining({
        id: "goto:TSLA",
        label: "TSLA",
        category: "Saved",
        kind: "ticker",
      }),
    ]);
  });
});