// Persist uploaded .seq files in the browser (IndexedDB). Small, promise-based
// wrapper — no dependency. Each record keeps the raw .seq text plus a
// user-editable name.
export interface StoredSequence {
  id: string
  name: string
  text: string
  size: number
  addedAt: number
}

const DB_NAME = 'mri-scanner'
const STORE = 'sequences'
const VERSION = 1

let dbPromise: Promise<IDBDatabase> | null = null

function openDb(): Promise<IDBDatabase> {
  if (dbPromise) return dbPromise
  dbPromise = new Promise((resolve, reject) => {
    const req = indexedDB.open(DB_NAME, VERSION)
    req.onupgradeneeded = () => {
      const db = req.result
      if (!db.objectStoreNames.contains(STORE)) {
        db.createObjectStore(STORE, { keyPath: 'id' })
      }
    }
    req.onsuccess = () => resolve(req.result)
    req.onerror = () => reject(req.error)
  })
  return dbPromise
}

function tx<T>(mode: IDBTransactionMode, fn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T> {
  return openDb().then(
    (db) =>
      new Promise<T>((resolve, reject) => {
        const t = db.transaction(STORE, mode)
        const req = fn(t.objectStore(STORE))
        req.onsuccess = () => resolve(req.result)
        req.onerror = () => reject(req.error)
      }),
  )
}

export async function listSequences(): Promise<StoredSequence[]> {
  const all = await tx<StoredSequence[]>('readonly', (s) => s.getAll() as IDBRequest<StoredSequence[]>)
  return all.sort((a, b) => b.addedAt - a.addedAt)
}

function uid(): string {
  if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) return crypto.randomUUID()
  return 'seq_' + Math.floor(performance.now() * 1000).toString(36) + Math.floor(performance.now()).toString(36)
}

export async function addSequence(name: string, text: string): Promise<StoredSequence> {
  const record: StoredSequence = {
    id: uid(),
    name,
    text,
    size: text.length,
    addedAt: Date.now(),
  }
  await tx('readwrite', (s) => s.put(record))
  return record
}

export async function renameSequence(id: string, name: string): Promise<void> {
  const rec = await tx<StoredSequence | undefined>('readonly', (s) => s.get(id) as IDBRequest<StoredSequence | undefined>)
  if (!rec) return
  rec.name = name
  await tx('readwrite', (s) => s.put(rec))
}

export async function deleteSequence(id: string): Promise<void> {
  await tx('readwrite', (s) => s.delete(id) as unknown as IDBRequest<undefined>)
}