InstrumentSearch

import { cn } from "cn"
import { useEffect, useId, useMemo, useRef, useState } from "react"
import { Badge } from "@/components/ui/badge"
import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from "@/components/ui/command"
import { QUERY_KIND_LABELS, recognizeQuery, type QueryHint, type QueryKind } from "@/lib/instrument-query"

// A typed field over the consumer's instrument search: it recognizes what was typed (a CUSIP with its
// check digit, an ISIN with its Luhn digit, a ticker, a coupon-and-maturity phrase) and hands the
// server the query with that hint, then lists what came back on the consumer's own `command`.
// Keyboard first: type, arrows, Enter. It knows no instruments; the server does.

export interface InstrumentHit {
  id: string
  /** The name the desk types: a ticker, a run's short form. */
  symbol: string
  /** The long name, "T 4 1/8 05/15/34", "Apple Inc." */
  name?: string
  /** Asset class or instrument type, drawn as a badge. */
  kind?: string
  exchange?: string
  cusip?: string
  isin?: string
}

/** The consumer's search: the query as typed, what it looks like, and a signal that aborts when the query moves on. */
export type InstrumentSearchFn = (query: string, hint: QueryHint, signal: AbortSignal) => Promise<readonly InstrumentHit[]>

export interface InstrumentSearchLabels {
  placeholder: string
  /** While a search is out. */
  searching: string
  /** A search that came back with nothing. `{query}`. */
  empty: string
  /** The list's heading. */
  results: string
  /** Under the field, what the query was taken for. `{kind}`. */
  recognized: string
}

export const DEFAULT_INSTRUMENT_SEARCH_LABELS: InstrumentSearchLabels = {
  placeholder: "Ticker, CUSIP, ISIN, or coupon and maturity",
  searching: "Searching…",
  empty: "Nothing matches {query}.",
  results: "Instruments",
  recognized: "Read as {kind}",
}

const NO_HITS: readonly InstrumentHit[] = []
const fill = (template: string, values: Record<string, string>) => template.replace(/\{(\w+)\}/g, (_, key: string) => values[key] ?? "")

/** The debounced, abortable search: only answers to the query on screen come back. */
export function useInstrumentSearch(search: InstrumentSearchFn | undefined, query: string, options: { minLength?: number; debounceMs?: number } = {}) {
  const minLength = options.minLength ?? 1
  const debounceMs = options.debounceMs ?? 150
  const hint = useMemo(() => recognizeQuery(query), [query])
  const [found, setFound] = useState<{ query: string; hits: readonly InstrumentHit[] }>({ query: "", hits: NO_HITS })
  const active = search !== undefined && hint.kind !== "empty" && query.trim().length >= minLength
  useEffect(() => {
    if (!search || !active) return
    const controller = new AbortController()
    const settle = (hits: readonly InstrumentHit[]) => {
      if (!controller.signal.aborted) setFound({ query, hits })
    }
    const timer = setTimeout(() => {
      search(query, hint, controller.signal).then(settle, () => settle(NO_HITS))
    }, debounceMs)
    return () => {
      clearTimeout(timer)
      controller.abort()
    }
  }, [search, active, query, hint, debounceMs])
  // Only answers to the query on screen. Enter on a row left over from three letters ago is how the wrong instrument gets loaded.
  const current = active && found.query === query
  return { hint, hits: current ? found.hits : NO_HITS, loading: active && !current }
}

/** An adapter the command palette's `symbols` takes, over the same search function. */
export function toSymbolAdapter(search: InstrumentSearchFn, options: { minLength?: number; debounceMs?: number } = {}) {
  return {
    search: async (query: string, signal: AbortSignal) => {
      const hits = await search(query, recognizeQuery(query), signal)
      return hits.map((hit) => ({ symbol: hit.symbol, name: hit.name, exchange: hit.exchange, kind: hit.kind }))
    },
    minLength: options.minLength,
    debounceMs: options.debounceMs,
  }
}

export interface InstrumentSearchProps {
  search: InstrumentSearchFn
  onSelect: (hit: InstrumentHit, hint: QueryHint) => void
  /** Controlled query, with `onQueryChange`. */
  query?: string
  onQueryChange?: (query: string) => void
  /** Default 1. */
  minLength?: number
  /** Default 150. */
  debounceMs?: number
  /** Clear the field after a pick. Default true. */
  clearOnSelect?: boolean
  /** Show what the query was read as under the field. Default true. */
  showHint?: boolean
  autoFocus?: boolean
  labels?: Partial<InstrumentSearchLabels>
  /** How a hit's row reads. Default: the symbol, the name, and the kind as a badge. */
  renderHit?: (hit: InstrumentHit, hint: QueryHint) => React.ReactNode
  className?: string
}

/** The identifier on a hit that the query named, for the row to show beside the name. */
export function matchedIdentifier(hit: InstrumentHit, hint: QueryHint): string | null {
  if (hint.kind === "cusip" && hit.cusip) return hit.cusip
  if (hint.kind === "isin" && hit.isin) return hit.isin
  return null
}

export function InstrumentSearch({ search, onSelect, query: queryProp, onQueryChange, minLength, debounceMs, clearOnSelect = true, showHint = true, autoFocus, labels: labelsProp, renderHit, className }: InstrumentSearchProps) {
  const labels = { ...DEFAULT_INSTRUMENT_SEARCH_LABELS, ...labelsProp }
  const [ownQuery, setOwnQuery] = useState("")
  const query = queryProp ?? ownQuery
  const latest = useRef({ onSelect, onQueryChange })
  useEffect(() => {
    latest.current = { onSelect, onQueryChange }
  })
  const setQuery = (next: string) => {
    if (queryProp === undefined) setOwnQuery(next)
    latest.current.onQueryChange?.(next)
  }
  const { hint, hits, loading } = useInstrumentSearch(search, query, { minLength, debounceMs })
  const hintId = useId()
  const kind: QueryKind = hint.kind
  const pick = (hit: InstrumentHit) => {
    latest.current.onSelect(hit, hint)
    if (clearOnSelect) setQuery("")
  }
  const showList = kind !== "empty" && query.trim().length >= (minLength ?? 1)
  return (
    <div data-slot="tradecn-instrument-search" data-query-kind={kind === "empty" ? undefined : kind} className={cn("flex flex-col gap-1 text-xs lining-nums tabular-nums", className)}>
      {/* The consumer's command does the filtering off: the server answered the query, and every answer stays. */}
      <Command shouldFilter={false} className="rounded-md border border-border">
        <CommandInput value={query} onValueChange={setQuery} placeholder={labels.placeholder} autoFocus={autoFocus} aria-describedby={showHint && kind !== "empty" ? hintId : undefined} className="h-8 text-xs" />
        {showList && (
          <CommandList>
            {loading && hits.length === 0 && <div className="px-2 py-1.5 text-muted-foreground">{labels.searching}</div>}
            {!loading && hits.length === 0 && <CommandEmpty>{fill(labels.empty, { query: query.trim() })}</CommandEmpty>}
            {hits.length > 0 && (
              <CommandGroup heading={labels.results}>
                {hits.map((hit) => (
                  <CommandItem key={hit.id} value={hit.id} data-instrument-hit={hit.id} onSelect={() => pick(hit)}>
                    {renderHit ? (
                      renderHit(hit, hint)
                    ) : (
                      <span className="flex min-w-0 flex-1 items-center gap-2">
                        <span className="font-semibold">{hit.symbol}</span>
                        {hit.name && <span className="min-w-0 truncate text-muted-foreground">{hit.name}</span>}
                        {matchedIdentifier(hit, hint) && <span className="font-(family-name:--tradecn-font-mono) text-muted-foreground lining-nums tabular-nums">{matchedIdentifier(hit, hint)}</span>}
                        {hit.kind && (
                          <Badge variant="outline" className="ml-auto h-4 px-1 text-xs">
                            {hit.kind}
                          </Badge>
                        )}
                      </span>
                    )}
                  </CommandItem>
                ))}
              </CommandGroup>
            )}
          </CommandList>
        )}
      </Command>
      {showHint && kind !== "empty" && (
        <p id={hintId} data-instrument-hint={kind} className="px-1 text-muted-foreground">
          {fill(labels.recognized, { kind: QUERY_KIND_LABELS[kind] })}
          {kind === "coupon-maturity" && hint.coupon !== undefined && " "}
          {kind === "coupon-maturity" && hint.coupon !== undefined && (
            <span className="font-(family-name:--tradecn-font-mono) lining-nums tabular-nums">
              {hint.ticker ? `${hint.ticker} ` : ""}
              {hint.coupon} {hint.maturity}
            </span>
          )}
        </p>
      )}
    </div>
  )
}

// What was typed into an instrument search, recognized before it goes to the server: a CUSIP, an ISIN, a
// ticker, or a coupon-and-maturity phrase the way a run prints it, "4 1/8 05/34". The recognizers are pure
// and check what can be checked here (the CUSIP's modulus-10 digit, the ISIN's Luhn digit); what an
// identifier names is the server's to say.

export type QueryKind = "cusip" | "isin" | "coupon-maturity" | "ticker" | "text" | "empty"

export interface QueryHint {
  kind: QueryKind
  /** The query with its spaces and case settled: a CUSIP or ISIN upper-cased, a ticker upper-cased. */
  normalized: string
  cusip?: string
  isin?: string
  ticker?: string
  /** The coupon as a number, 4.125 for "4 1/8". */
  coupon?: number
  /** The maturity as typed, settled to MM/YY or MM/DD/YY or the full date, whichever was given. */
  maturity?: string
  /** The maturity's month, day (when given), and two- or four-digit year, as numbers. */
  maturityParts?: { month: number; day?: number; year: number }
}

const CUSIP_VALUES: Record<string, number> = { "*": 36, "@": 37, "#": 38 }

/** A character's value in a CUSIP: digits as they are, letters 10 to 35, then *, @, #. */
function cusipValue(ch: string): number | null {
  if (/[0-9]/.test(ch)) return Number(ch)
  if (/[A-Z]/.test(ch)) return ch.charCodeAt(0) - 55
  return CUSIP_VALUES[ch] ?? null
}

/** Nine characters whose ninth is the modulus-10 double-add-double check digit of the first eight. */
export function isCusip(text: string): boolean {
  const s = text.trim().toUpperCase()
  if (!/^[0-9A-Z*@#]{8}[0-9]$/.test(s)) return false
  let sum = 0
  for (let i = 0; i < 8; i++) {
    let v = cusipValue(s[i]!)
    if (v === null) return false
    if (i % 2 === 1) v *= 2
    sum += Math.floor(v / 10) + (v % 10)
  }
  return (10 - (sum % 10)) % 10 === Number(s[8])
}

/** Twelve characters, two letters of country, nine of identifier, and a Luhn check digit over the letters expanded to numbers. */
export function isIsin(text: string): boolean {
  const s = text.trim().toUpperCase()
  if (!/^[A-Z]{2}[0-9A-Z]{9}[0-9]$/.test(s)) return false
  const digits = [...s].map((ch) => (/[0-9]/.test(ch) ? ch : String(ch.charCodeAt(0) - 55))).join("")
  let sum = 0
  let double = false
  for (let i = digits.length - 1; i >= 0; i--) {
    let d = Number(digits[i])
    if (double) {
      d *= 2
      if (d > 9) d -= 9
    }
    sum += d
    double = !double
  }
  return sum % 10 === 0
}

const EIGHTHS: Record<string, number> = { "1/8": 0.125, "1/4": 0.25, "3/8": 0.375, "1/2": 0.5, "5/8": 0.625, "3/4": 0.75, "7/8": 0.875 }

/** A coupon as a run prints it, "4 1/8", "4.125", "4", "4½" spelled with a slash: the number, or null. */
export function parseCoupon(text: string): number | null {
  const s = text.trim()
  const mixed = /^(\d{1,2})(?:\s+(\d\/\d))?$/.exec(s)
  if (mixed) {
    const whole = Number(mixed[1])
    if (!mixed[2]) return whole
    const eighth = EIGHTHS[mixed[2]]
    return eighth === undefined ? null : whole + eighth
  }
  const fraction = /^(\d\/\d)$/.exec(s)
  if (fraction) return EIGHTHS[fraction[1]!] ?? null
  const decimal = /^(\d{1,2}(?:\.\d{1,3})?)%?$/.exec(s)
  if (decimal) return Number(decimal[1])
  return null
}

/** A maturity as typed after a coupon: MM/YY, MM/YYYY, MM/DD/YY, MM/DD/YYYY, or an ISO date. */
export function parseMaturity(text: string): { month: number; day?: number; year: number; text: string } | null {
  const s = text.trim()
  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s)
  if (iso) {
    const [, y, m, d] = iso
    return { month: Number(m), day: Number(d), year: Number(y), text: s }
  }
  const slashed = /^(\d{1,2})\/(?:(\d{1,2})\/)?(\d{2}|\d{4})$/.exec(s)
  if (!slashed) return null
  const month = Number(slashed[1])
  const day = slashed[2] === undefined ? undefined : Number(slashed[2])
  const year = Number(slashed[3])
  if (month < 1 || month > 12 || (day !== undefined && (day < 1 || day > 31))) return null
  return { month, day, year, text: s }
}

/** "4 1/8 05/34", "4.125 5/15/2034", "T 4 1/8 05/15/34": a coupon and a maturity, or null. A leading word is a prefix the server may know. */
export function parseCouponMaturity(text: string): { coupon: number; maturity: string; maturityParts: { month: number; day?: number; year: number }; prefix?: string } | null {
  const words = text.trim().split(/\s+/)
  if (words.length < 2) return null
  const maturityWord = words[words.length - 1]!
  const maturity = parseMaturity(maturityWord)
  if (!maturity) return null
  const rest = words.slice(0, -1)
  // The coupon is the last one or two words before the maturity; anything before that is a prefix.
  for (const take of [2, 1]) {
    if (rest.length < take) continue
    const coupon = parseCoupon(rest.slice(rest.length - take).join(" "))
    if (coupon === null) continue
    const prefix = rest.slice(0, rest.length - take).join(" ")
    return { coupon, maturity: maturity.text, maturityParts: { month: maturity.month, day: maturity.day, year: maturity.year }, ...(prefix ? { prefix } : {}) }
  }
  return null
}

/** What the query looks like. Checked identifiers first, then a coupon-and-maturity phrase, then a ticker (letters and digits, up to twelve, one optional dot or dash), else text. */
export function recognizeQuery(text: string): QueryHint {
  const trimmed = text.trim().replace(/\s+/g, " ")
  if (!trimmed) return { kind: "empty", normalized: "" }
  const upper = trimmed.toUpperCase()
  if (isCusip(upper)) return { kind: "cusip", normalized: upper, cusip: upper }
  if (isIsin(upper)) return { kind: "isin", normalized: upper, isin: upper }
  const run = parseCouponMaturity(trimmed)
  if (run) return { kind: "coupon-maturity", normalized: trimmed, coupon: run.coupon, maturity: run.maturity, maturityParts: run.maturityParts, ...(run.prefix ? { ticker: run.prefix.toUpperCase() } : {}) }
  if (/^[A-Z][A-Z0-9]{0,11}(?:[.-][A-Z0-9]{1,4})?$/.test(upper)) return { kind: "ticker", normalized: upper, ticker: upper }
  return { kind: "text", normalized: trimmed }
}

export const QUERY_KIND_LABELS: Record<QueryKind, string> = {
  cusip: "CUSIP",
  isin: "ISIN",
  "coupon-maturity": "Coupon and maturity",
  ticker: "Ticker",
  text: "Text",
  empty: "",
}

:root {
  --tradecn-font-accessible: 'Atkinson Hyperlegible Next', 'Atkinson Hyperlegible', ui-sans-serif, system-ui, sans-serif;
  --tradecn-font-accessible-mono: 'Atkinson Hyperlegible Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  --tradecn-font-mono: 'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
}

.dark {
  --tradecn-font-accessible: 'Atkinson Hyperlegible Next', 'Atkinson Hyperlegible', ui-sans-serif, system-ui, sans-serif;
  --tradecn-font-accessible-mono: 'Atkinson Hyperlegible Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  --tradecn-font-mono: 'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
}

:root[data-accessibility="hyperlegible"], [data-accessibility="hyperlegible"] {
  --tradecn-font-sans: var(--tradecn-font-accessible);
  --tradecn-font-mono: var(--tradecn-font-accessible-mono);
}