/// <reference lib="webworker" />
import { parseDump } from '../lib/dump-parse'
import { DumpStore, type Query } from '../lib/dump-store'
import { fingerprint, saveDump, loadDump } from '../lib/persist'

/**
 * The store never crosses to the main thread. The UI asks for a window of
 * rows and gets back ~60 plain objects; the 30–80 MB of columns stay here.
 */
let store: DumpStore | null = null
let current: Uint32Array = new Uint32Array(0)

type Req =
  | { id: number; op: 'parse'; buffer: ArrayBuffer; name: string }
  | { id: number; op: 'restore'; key: string }
  | { id: number; op: 'query'; query: Query }
  | { id: number; op: 'window'; start: number; end: number }
  | { id: number; op: 'children'; prefix: string }
  | { id: number; op: 'resolve'; address: number }
  | { id: number; op: 'close' }

function summary() {
  const s = store!
  const { addr, count, types } = s.cols
  let min = Infinity
  let max = 0
  for (let i = 0; i < count; i++) {
    const el = addr[i];
    if(!el) continue
    if (el < min) min = el
    if (el > max) max = el
  }
  // Every address in a dump shares a leading run of hex digits. Finding it
  // lets the table ghost the noise and highlight the digits that differ.
  const a = min.toString(16).padStart(12, '0').toUpperCase()
  const b = max.toString(16).padStart(12, '0').toUpperCase()
  let shared = 0
  while (shared < a.length && a[shared] === b[shared]) shared++
  return { count, types, sharedAddressDigits: shared, skipped: s.cols.skipped }
}

async function handle(msg: Req) {
  switch (msg.op) {
    case 'parse': {
      const src = new Uint8Array(msg.buffer)
      const key = fingerprint(msg.name, src)
      const cached = await loadDump(key).catch(() => undefined)
      if (cached) {
        store = new DumpStore(cached.cols)
        return { ...summary(), key, label: cached.label, cached: true }
      }
      const t0 = performance.now()
      const cols = parseDump(src, (f) =>
        self.postMessage({ id: -1, event: 'progress', fraction: f }),
      )
      const ms = performance.now() - t0
      store = new DumpStore(cols)
      await saveDump({
        key,
        label: msg.name,
        bytes: src.length,
        parsedAt: Date.now(),
        cols,
      }).catch(() => {})
      return { ...summary(), key, label: msg.name, cached: false, parseMs: ms }
    }

    case 'restore': {
      const cached = await loadDump(msg.key)
      if (!cached) throw new Error('That dump is no longer cached. Load the file again.')
      store = new DumpStore(cached.cols)
      return { ...summary(), key: cached.key, label: cached.label, cached: true }
    }

    case 'query': {
      const t0 = performance.now()
      const { rows, typeCounts } = store!.query(msg.query)
      current = rows
      return { total: rows.length, typeCounts, ms: performance.now() - t0 }
    }

    case 'window': {
      const end = Math.min(msg.end, current.length)
      const out = []
      for (let i = msg.start; i < end; i++) {
        const el = current[i];
        if(!el) continue
        const row = store!.row(el)
        if (row) out.push(row)
      }
      return { start: msg.start, rows: out }
    }

    case 'children':
      return { prefix: msg.prefix, children: store!.children(msg.prefix) }

    case 'resolve': {
      const row = store!.rowByAddress(msg.address)
      return { row: row >= 0 ? store!.row(row) : null }
    }

    // Drops the only references to the columns; the dump stays in IndexedDB,
    // so 'restore' can bring it back without re-parsing.
    case 'close': {
      store = null
      current = new Uint32Array(0)
      return { closed: true }
    }
  }
}

self.onmessage = async (e: MessageEvent<Req>) => {
  try {
    self.postMessage({ id: e.data.id, result: await handle(e.data) })
  } catch (err) {
    self.postMessage({ id: e.data.id, error: (err as Error).message })
  }
}