import { defineSource } from '@jaspers-ai/sdk'
import { z } from 'zod'
import { HOSTS, baseField, get, iso, list, upper } from './client'
import { snapRow } from './stocks-snap'

// Indices, forex, and crypto: snapshots, conversion, last quote and last trade. Their bars and
// previous close are the aggregates and previous-close sources with I:, C:, and X: tickers.

const n = (v: unknown): number | null => (typeof v === 'number' && Number.isFinite(v) ? v : null)
const prefixed = (t: string, p: string) => {
  const u = upper(t)
  return u.includes(':') ? u : `${p}:${u}`
}

const indexSnapshot = defineSource({
  description: 'Index snapshots: ticker, name, value, change, change %, session open/high/low/close, previous close, market status, updated.',
  hosts: HOSTS,
  input: z.object({
    tickers: z.array(z.string()).min(1).max(250).default(['I:SPX', 'I:NDX', 'I:DJI', 'I:VIX']).describe('Index tickers, like I:SPX.'),
    base: baseField,
  }),
  async run(args, ctx) {
    const tickers = args.tickers.map((t) => prefixed(t, 'I'))
    const res = await list(ctx, args.base, '/v3/snapshot/indices', { 'ticker.any_of': tickers.join(','), limit: 250 }, 250)
    return res.rows.map((r) => {
      const s = r.session ?? {}
      return {
        ticker: r.ticker ?? null,
        name: r.name ?? null,
        value: n(r.value),
        change: n(s.change),
        changePercent: n(s.change_percent),
        open: n(s.open),
        high: n(s.high),
        low: n(s.low),
        close: n(s.close),
        previousClose: n(s.previous_close),
        market_status: r.market_status ?? null,
        updated: iso(r.last_updated),
        error: r.error ? `${r.error}: ${r.message ?? ''}`.trim() : null,
      }
    })
  },
})

const fxInput = (example: string) =>
  z.object({
    tickers: z.array(z.string()).max(250).default([]).describe(`Tickers like ${example}. Empty for all.`),
    limit: z.number().int().min(1).max(5000).default(500).describe('Most rows to answer.'),
    base: baseField,
  })

async function globalSnapshot(ctx: any, base: string, market: 'forex' | 'crypto', raw: string[], limit: number) {
  const tickers = raw.map((t) => prefixed(t, market === 'forex' ? 'C' : 'X'))
  const path = `/v2/snapshot/locale/global/markets/${market}/tickers`
  if (tickers.length === 1) {
    const body = await get(ctx, base, `${path}/${tickers[0]}`)
    return body?.ticker ? [snapRow(body.ticker)] : []
  }
  const body = await get(ctx, base, path, { tickers: tickers.length ? tickers.join(',') : undefined })
  const rows = ((body?.tickers ?? []) as any[]).map(snapRow)
  if (!tickers.length) rows.sort((a, b) => Number(b.volume ?? 0) - Number(a.volume ?? 0))
  return rows.slice(0, limit)
}

const forexSnapshot = defineSource({
  description: 'Forex pair snapshots: ticker, last (mid of bid/ask), bid, ask, change, change %, day OHLC, previous close, updated.',
  hosts: HOSTS,
  input: fxInput('C:EURUSD'),
  async run(args, ctx) {
    return globalSnapshot(ctx, args.base, 'forex', args.tickers, args.limit)
  },
})

const cryptoSnapshot = defineSource({
  description: 'Crypto pair snapshots: ticker, last trade price, change, change %, day OHLCV, previous close, updated.',
  hosts: HOSTS,
  input: fxInput('X:BTCUSD'),
  async run(args, ctx) {
    return globalSnapshot(ctx, args.base, 'crypto', args.tickers, args.limit)
  },
})

const pair = {
  from: z.string().length(3).describe('The base currency, like EUR or BTC.'),
  to: z.string().length(3).describe('The quote currency, like USD.'),
}

const forexConversion = defineSource({
  description: 'Converts an amount between two currencies at the latest rate: from, to, amount, converted, bid, ask, time.',
  hosts: HOSTS,
  input: z.object({
    ...pair,
    amount: z.number().positive().default(1).describe('The amount of the base currency.'),
    precision: z.number().int().min(0).max(4).default(4).describe('Decimal places of the answer.'),
    base: baseField,
  }),
  async run(args, ctx) {
    const b = await get(ctx, args.base, `/v1/conversion/${upper(args.from)}/${upper(args.to)}`, {
      amount: args.amount,
      precision: args.precision,
    })
    const last = b?.last ?? {}
    return [
      {
        from: b?.from ?? upper(args.from),
        to: b?.to ?? upper(args.to),
        amount: n(b?.initialAmount) ?? args.amount,
        converted: n(b?.converted),
        bid: n(last.bid),
        ask: n(last.ask),
        exchange: last.exchange ?? null,
        time: iso(last.timestamp),
      },
    ]
  },
})

const forexLastQuote = defineSource({
  description: 'The last quote for a currency pair: bid, ask, exchange, time.',
  hosts: HOSTS,
  input: z.object({ ...pair, base: baseField }),
  async run(args, ctx) {
    const b = await get(ctx, args.base, `/v1/last_quote/currencies/${upper(args.from)}/${upper(args.to)}`)
    const last = b?.last ?? {}
    return [{ symbol: b?.symbol ?? `${upper(args.from)}/${upper(args.to)}`, bid: n(last.bid), ask: n(last.ask), exchange: last.exchange ?? null, time: iso(last.timestamp) }]
  },
})

const cryptoLastTrade = defineSource({
  description: 'The last trade for a crypto pair: price, size, exchange, conditions, time.',
  hosts: HOSTS,
  input: z.object({ ...pair, base: baseField }),
  async run(args, ctx) {
    const b = await get(ctx, args.base, `/v1/last/crypto/${upper(args.from)}/${upper(args.to)}`)
    const last = b?.last ?? {}
    return [
      {
        symbol: b?.symbol ?? `${upper(args.from)}-${upper(args.to)}`,
        price: n(last.price),
        size: n(last.size),
        exchange: last.exchange ?? null,
        conditions: Array.isArray(last.conditions) ? last.conditions.join(', ') : null,
        time: iso(last.timestamp),
      },
    ]
  },
})

export const globalSources = {
  'index-snapshot': indexSnapshot,
  'forex-snapshot': forexSnapshot,
  'crypto-snapshot': cryptoSnapshot,
  'forex-conversion': forexConversion,
  'forex-last-quote': forexLastQuote,
  'crypto-last-trade': cryptoLastTrade,
}