// Libros de texto (EPUB). El EPUB se convierte aquí en una lista cerrada de bloques: al navegador nunca llega
// HTML del libro, y es él quien maqueta los bloques en páginas según su pantalla (ver maquetado en app.js).
//   bloque: { k: 'p' | 'q' | 'h' | 'hr' | 'img', l?: nivel de título, n?: imagen, c?: centrado, v?: verso,
//             r?: [[texto, estilo]] }   estilo: 1 cursiva, 2 negrita (sumables)
// Título, autores e idioma salen del propio EPUB, así que abrir un libro solo necesita el archivo. Orígenes:
// - Project Gutenberg, con su catálogo OPDS. IDs: libro "gb~<n>", capítulo "gb~<n>~<i>".
// - Wikisource en español, con el EPUB que genera ws-export. IDs: "ws~<título en base64url>", "ws~<título>~<i>".
// - Los EPUB que sube cada usuario, solo visibles para él. IDs: "ub~<32 hex>", "ub~<32 hex>~<i>".
// En <DATA_DIR>/books/ se guardan el EPUB (de ahí salen las imágenes) y el libro ya convertido.
import fs from 'node:fs'
import zlib from 'node:zlib'
import crypto from 'node:crypto'
import path from 'node:path'
import { readZipIndex, readCbzEntry, imageType } from './cbz.js'

export const isBookId = id => /^(gb|ws|ub)~/.test(id || '')
const GUTENBERG = 'https://www.gutenberg.org'
const WS_API = 'https://es.wikisource.org/w/api.php'
const WS_EXPORT = 'https://ws-export.wmcloud.org/'
const WS_MIN_WORDS = 2000 // sin subpáginas, lo que no llega a esto es un poema o un texto suelto, no un libro
const OPDS_PAGE = 25
const GB_NAME = 'Project Gutenberg'
const WS_NAME = 'Wikisource'
// El buscador de Gutenberg filtra por el nombre del idioma, no por el código.
const LANG_NAMES = { es: 'spanish', en: 'english', fr: 'french', pt: 'portuguese', it: 'italian', de: 'german', ru: 'russian', ja: 'japanese', zh: 'chinese', ko: 'korean', ca: 'catalan', nl: 'dutch', pl: 'polish' }
const PARSER_VERSION = 3
const MAX_EPUB_BYTES = 100 * 1024 * 1024
const MAX_UNZIPPED_ENTRY = 64 * 1024 * 1024 // un XHTML o una imagen
const MAX_UNZIPPED_TOTAL = 256 * 1024 * 1024 // todo lo que se lee del libro: lo que pase de aquí es una ZIP bomb
const MAX_UPLOADS_PER_USER = 500
const BOOK_IMAGE = /\.(jpe?g|png|gif|webp)$/i

const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', mdash: '—', ndash: '–', hellip: '…', laquo: '«', raquo: '»', ldquo: '“', rdquo: '”', lsquo: '‘', rsquo: '’', iexcl: '¡', iquest: '¿', aacute: 'á', eacute: 'é', iacute: 'í', oacute: 'ó', uacute: 'ú', ntilde: 'ñ', uuml: 'ü', Aacute: 'Á', Eacute: 'É', Iacute: 'Í', Oacute: 'Ó', Uacute: 'Ú', Ntilde: 'Ñ', Uuml: 'Ü', agrave: 'à', egrave: 'è', igrave: 'ì', ograve: 'ò', ugrave: 'ù', ccedil: 'ç', shy: '', ensp: ' ', emsp: ' ', thinsp: ' ', zwnj: '', zwj: '', copy: '©', deg: '°', ordm: 'º', ordf: 'ª', sect: '§', para: '¶', middot: '·', dagger: '†', Dagger: '‡', bull: '•', times: '×' }
const entities = s => s.replace(/&(#x?[0-9a-f]+|[a-z0-9]+);/gi, (all, e) => {
  if (e[0] !== '#') return ENTITIES[e] ?? all
  const n = e[1].toLowerCase() === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10)
  return n > 0 && n <= 0x10ffff ? String.fromCodePoint(n) : ''
})
const attr = (attrs, name) => {
  const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, 'i').exec(attrs)
  return m ? entities(m[1] ?? m[2]) : null
}
// Ruta dentro del ZIP de un enlace relativo a un archivo del libro.
function resolveHref(base, href) {
  let rel = href.split('#')[0]
  try { rel = decodeURIComponent(rel) } catch {}
  return path.posix.normalize(path.posix.join(path.posix.dirname(base), rel)).replace(/^\.\//, '')
}

// ---------- XHTML a bloques ----------
const SKIP = new Set(['head', 'script', 'style', 'template', 'noscript', 'iframe', 'object', 'embed', 'audio', 'video', 'math', 'select', 'form', 'nav'])
const BLOCK = new Set(['p', 'div', 'section', 'article', 'aside', 'header', 'footer', 'figure', 'figcaption', 'main', 'body', 'ul', 'ol', 'li', 'dl', 'dt', 'dd', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'caption', 'pre', 'address', 'center', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote'])
const VOID = new Set(['br', 'hr', 'img', 'image', 'meta', 'link', 'input', 'col', 'area', 'base', 'wbr'])
const TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<[?!][^>]*>|<(\/?)([a-zA-Z][a-zA-Z0-9:_-]*)((?:[^<>"']|"[^"]*"|'[^']*')*)>/g

// onAnchor(id) se llama con cada id del documento; devuelve true si ahí empieza un capítulo.
function xhtmlToBlocks(xml, file, imageOf, onBlock, onAnchor) {
  let skip = 0, skipTag = null
  let italic = 0, bold = 0, quote = 0, center = 0, verse = 0
  const stack = [] // etiquetas de bloque con estilo, para deshacerlo al cerrarlas
  let runs = [], heading = 0
  const flush = () => {
    // Espacios del código fuente fuera; los saltos de línea reales (<br>) son \n.
    const out = []
    let atStart = true
    for (const [text, style] of runs) {
      let t = text === '\n' ? text : text.replace(/[ \t\r\n\f]+/g, ' ') // el \n solo viene de un <br>
      if (atStart) t = t.replace(/^ +/, '')
      if (!t) continue
      atStart = t.endsWith('\n')
      const last = out.at(-1)
      if (last && last[1] === style) last[0] += t
      else out.push([t, style])
    }
    while (out.length) {
      const last = out.at(-1)
      last[0] = last[0].replace(/[ \n]+$/, '')
      if (last[0]) break
      out.pop()
    }
    runs = []
    if (out.length && out.some(([t]) => t.trim())) {
      const b = heading ? { k: 'h', l: heading, r: out } : { k: quote ? 'q' : 'p', r: out }
      if (center || heading) b.c = 1
      if (verse || out.some(([t]) => t.includes('\n'))) b.v = 1
      onBlock(b)
    }
  }
  const body = xml.search(/<body[\s>]/i)
  let pos = body >= 0 ? body : 0
  TOKEN.lastIndex = pos
  for (let m; (m = TOKEN.exec(xml));) {
    if (!skip && m.index > pos) {
      const text = entities(xml.slice(pos, m.index))
      if (text) runs.push([text, (italic ? 1 : 0) + (bold ? 2 : 0)])
    }
    pos = TOKEN.lastIndex
    const tag = m[2]?.toLowerCase().replace(/^.*:/, '')
    if (!tag) { // comentario, DOCTYPE; CDATA se pierde a propósito (no es texto de libro)
      continue
    }
    const closing = m[1] === '/'
    const rawAttrs = m[3] || ''
    const selfClosed = /\/\s*$/.test(rawAttrs)
    if (skip) {
      if (tag === skipTag) {
        if (closing) { if (--skip === 0) skipTag = null } else if (!selfClosed) skip++
      }
      continue
    }
    if (closing) {
      if (BLOCK.has(tag)) {
        flush()
        const top = stack.findLastIndex(s => s.tag === tag)
        if (top >= 0) {
          for (const s of stack.splice(top)) {
            quote -= s.quote; center -= s.center; verse -= s.verse; italic -= s.italic; bold -= s.bold
            if (s.heading) heading = 0
          }
        }
      } else if (tag === 'i' || tag === 'em' || tag === 'cite' || tag === 'dfn') italic = Math.max(0, italic - 1)
      else if (tag === 'b' || tag === 'strong') bold = Math.max(0, bold - 1)
      continue
    }
    const id = attr(rawAttrs, 'id') ?? (tag === 'a' ? attr(rawAttrs, 'name') : null)
    if (id && onAnchor(id, flush)) { /* el capítulo nuevo ya vació lo pendiente */ }
    const cls = (attr(rawAttrs, 'class') || '').toLowerCase()
    const type = (attr(rawAttrs, 'epub:type') || '').toLowerCase()
    // Números de página de la edición impresa: ruido entre el texto.
    if (SKIP.has(tag) || /\bpage-?num(ber)?\b|\bpageno\b/.test(cls) || type.includes('pagebreak') || attr(rawAttrs, 'hidden') !== null) {
      if (!selfClosed && !VOID.has(tag)) { skip = 1; skipTag = tag }
      continue
    }
    if (tag === 'br') { runs.push(['\n', 0]); continue }
    if (tag === 'hr') { flush(); onBlock({ k: 'hr' }); continue }
    if (tag === 'img' || tag === 'image') {
      const src = attr(rawAttrs, 'src') ?? attr(rawAttrs, 'xlink:href') ?? attr(rawAttrs, 'href')
      const n = src != null && !/^[a-z]+:/i.test(src) ? imageOf(resolveHref(file, src)) : null
      if (n != null) { flush(); onBlock({ k: 'img', n }) }
      continue
    }
    if (BLOCK.has(tag)) {
      flush()
      const style = attr(rawAttrs, 'style') || ''
      const s = {
        tag,
        quote: tag === 'blockquote' ? 1 : 0,
        center: tag === 'center' || /\bcent(er|re)\b/.test(cls) || /text-align\s*:\s*center/i.test(style) ? 1 : 0,
        verse: tag === 'pre' || /\b(verse|poem|poetry|stanza|line-?block)\b/.test(cls) ? 1 : 0,
        italic: 0, bold: 0, heading: 0,
      }
      if (/^h[1-6]$/.test(tag)) { heading = Number(tag[1]); s.heading = 1 }
      quote += s.quote; center += s.center; verse += s.verse
      if (!selfClosed) stack.push(s)
      else { quote -= s.quote; center -= s.center; verse -= s.verse; if (s.heading) heading = 0 }
      continue
    }
    if (selfClosed) continue
    if (tag === 'i' || tag === 'em' || tag === 'cite' || tag === 'dfn') italic++
    else if (tag === 'b' || tag === 'strong') bold++
    else if (tag === 'td' || tag === 'th') { if (runs.length) runs.push(['   ', 0]) }
  }
  if (!skip && pos < xml.length) {
    const text = entities(xml.slice(pos).replace(/<[^>]*$/, ''))
    if (text.trim()) runs.push([text, 0])
  }
  flush()
}

// Ancho y alto de una imagen PNG, GIF, JPEG o WebP, por su cabecera.
function imageSize(b) {
  if (b.length > 24 && b.readUInt32BE(0) === 0x89504e47) return { w: b.readUInt32BE(16), h: b.readUInt32BE(20) }
  if (b.length > 10 && b.toString('latin1', 0, 3) === 'GIF') return { w: b.readUInt16LE(6), h: b.readUInt16LE(8) }
  if (b.length > 4 && b[0] === 0xff && b[1] === 0xd8) {
    for (let p = 2; p + 9 < b.length;) {
      if (b[p] !== 0xff) { p++; continue }
      const m = b[p + 1]
      if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) return { w: b.readUInt16BE(p + 7), h: b.readUInt16BE(p + 5) }
      if (m === 0xff) { p++; continue }
      p += 2 + b.readUInt16BE(p + 2)
    }
  }
  if (b.length > 30 && b.toString('latin1', 0, 4) === 'RIFF' && b.toString('latin1', 8, 12) === 'WEBP') {
    const kind = b.toString('latin1', 12, 16)
    if (kind === 'VP8X') return { w: b.readUIntLE(24, 3) + 1, h: b.readUIntLE(27, 3) + 1 }
    if (kind === 'VP8 ') return { w: b.readUInt16LE(26) & 0x3fff, h: b.readUInt16LE(28) & 0x3fff }
    if (kind === 'VP8L') { const v = b.readUInt32LE(21); return { w: (v & 0x3fff) + 1, h: ((v >> 14) & 0x3fff) + 1 } }
  }
  return {}
}

// ---------- EPUB ----------

// Índice del libro en orden: [{ file, anchor, title }]. EPUB 3 (nav) o EPUB 2 (toc.ncx).
function readToc(read, opf, manifest) {
  const navItem = [...manifest.values()].find(it => /\bnav\b/.test(it.props))
  if (navItem) {
    const xml = read(navItem.path)
    const nav = /<nav\b[^>]*(?:epub:)?type\s*=\s*["']toc["'][^>]*>([\s\S]*?)<\/nav>/i.exec(xml)?.[1]
    if (nav) {
      const out = []
      for (const m of nav.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi)) {
        const href = attr(m[1], 'href')
        if (!href) continue
        out.push({ file: resolveHref(navItem.path, href), anchor: href.split('#')[1] || null, title: clean(m[2]) })
      }
      if (out.length) return out
    }
  }
  const spineToc = /<spine\b[^>]*\btoc\s*=\s*["']([^"']+)["']/i.exec(opf)?.[1]
  const ncx = manifest.get(spineToc) || [...manifest.values()].find(it => /ncx/.test(it.type))
  if (!ncx) return []
  const xml = read(ncx.path)
  const out = []
  // Solo la etiqueta y el contenido propios de cada entrada: los navPoint se anidan.
  for (const m of xml.matchAll(/<navPoint\b[^>]*>\s*<navLabel\b[^>]*>\s*<text\b[^>]*>([\s\S]*?)<\/text>\s*<\/navLabel>\s*<content\b([^>]*)\/?>/gi)) {
    const src = attr(m[2], 'src')
    if (src) out.push({ file: resolveHref(ncx.path, src), anchor: src.split('#')[1] || null, title: clean(m[1]) })
  }
  return out
}
const clean = s => entities(String(s).replace(/<[^>]*>/g, ' ')).replace(/\s+/g, ' ').trim()

export function parseEpub(file) {
  const index = readZipIndex(file)
  const entries = new Map(index.map(e => [e.name, e]))
  if (index.reduce((n, e) => n + e.unzipped, 0) > MAX_UNZIPPED_TOTAL) throw new Error('EPUB demasiado grande al descomprimir')
  let unzipped = 0
  const readBuf = name => {
    const e = entries.get(name)
    if (!e) throw new Error(`Falta ${name} en el EPUB`)
    if (e.unzipped > MAX_UNZIPPED_ENTRY) throw new Error('Archivo demasiado grande dentro del EPUB')
    const buf = readCbzEntry(file, e, MAX_UNZIPPED_ENTRY)
    unzipped += buf.length // lo real: la cabecera del ZIP puede mentir
    if (unzipped > MAX_UNZIPPED_TOTAL) throw new Error('EPUB demasiado grande al descomprimir')
    return buf
  }
  const read = name => readBuf(name).toString('utf8').replace(/^/, '')

  const container = read('META-INF/container.xml')
  const opfPath = attr(/<rootfile\b([^>]*)>/i.exec(container)?.[1] || '', 'full-path')
  if (!opfPath) throw new Error('EPUB sin paquete')
  const opf = read(opfPath)
  const dc = name => clean(new RegExp(`<dc:${name}\\b[^>]*>([\\s\\S]*?)</dc:${name}>`, 'i').exec(opf)?.[1] || '')
  const manifest = new Map()
  for (const m of opf.matchAll(/<item\b([^>]*)>/gi)) {
    const id = attr(m[1], 'id'), href = attr(m[1], 'href')
    if (id && href) manifest.set(id, { path: resolveHref(opfPath, href), type: attr(m[1], 'media-type') || '', props: attr(m[1], 'properties') || '' })
  }
  const spine = [...opf.matchAll(/<itemref\b([^>]*)>/gi)].map(m => manifest.get(attr(m[1], 'idref'))).filter(it => it && /x?html/i.test(it.type))
  if (!spine.length) throw new Error('EPUB sin contenido')
  let toc = []
  try { toc = readToc(read, opf, manifest) } catch {}

  const images = []
  const imageIdx = new Map()
  const imageOf = name => {
    const e = entries.get(name)
    if (!e || !BOOK_IMAGE.test(name) || e.unzipped > MAX_UNZIPPED_ENTRY) return null
    if (!imageIdx.has(name)) { imageIdx.set(name, images.length); images.push(name) }
    return imageIdx.get(name)
  }

  // Las entradas del índice que apuntan a cada archivo. Un capítulo empieza en su ancla, o en el archivo si no tiene.
  const targets = new Map()
  for (const t of toc) {
    if (!targets.has(t.file)) targets.set(t.file, new Map())
    targets.get(t.file).set(t.anchor, t.title)
  }
  const chapters = []
  const start = title => chapters.push({ title, blocks: [] })
  for (const item of spine) {
    const here = targets.get(item.path)
    if (here?.has(null) || (!toc.length)) start(here?.get(null) || '')
    if (!chapters.length) start('')
    xhtmlToBlocks(read(item.path), item.path, imageOf,
      b => chapters.at(-1).blocks.push(b),
      (id, flush) => {
        if (!here?.has(id)) return false
        flush()
        start(here.get(id))
        here.delete(id) // un id repetido no abre otro capítulo
        return true
      })
  }

  // Limpieza: fuera los vacíos; un capítulo que solo trae su título ("Parte primera") se une al siguiente.
  const merged = []
  let carry = null
  for (const c of chapters) {
    if (!c.blocks.length) continue
    const blocks = carry ? [...carry.blocks, ...c.blocks] : c.blocks
    const title = c.title || carry?.title || ''
    carry = null
    if (blocks.every(b => b.k === 'h' || b.k === 'hr') && c !== chapters.at(-1)) { carry = { title, blocks }; continue }
    merged.push({ title, blocks })
  }
  if (carry) merged.push(carry)
  const out = merged
  if (!out.length) throw new Error('EPUB sin texto')
  // Portada: EPUB 3 la marca en el manifiesto y EPUB 2 con un <meta>, que a veces no apunta a una imagen.
  const coverId = /<meta\b(?=[^>]*\bname\s*=\s*["']cover["'])[^>]*\bcontent\s*=\s*["']([^"']+)["']/i.exec(opf)?.[1]
  const coverItem = [...manifest.values()].find(it => /\bcover-image\b/.test(it.props)) || manifest.get(coverId)
  const cover = coverItem ? imageOf(coverItem.path) : null
  out.forEach((c, i) => { if (!c.title) c.title = `Sección ${i + 1}` })
  // El navegador maqueta el libro entero sin cargar las imágenes: necesita saber su tamaño.
  for (const c of out) {
    for (const b of c.blocks) {
      if (b.k !== 'img') continue
      try { Object.assign(b, imageSize(readBuf(images[b.n]))) } catch {}
    }
  }
  const year = parseInt(dc('date'), 10)
  return {
    version: PARSER_VERSION,
    title: dc('title'), authors: [...opf.matchAll(/<dc:creator\b[^>]*>([\s\S]*?)<\/dc:creator>/gi)].map(m => clean(m[1])).filter(Boolean),
    language: dc('language').slice(0, 2).toLowerCase(), description: dc('description'), year: year > 0 && year < 2100 ? year : null,
    images, cover, chapters: out,
  }
}

// ---------- Fuente y caché ----------
// Portada generada para lo que no trae una: el título sobre un color que sale del propio título.
function titleCover(title, author) {
  const esc = t => String(t).replace(/[<>&"']/g, c => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;' }[c]))
  const wrap = (t, width, max) => {
    const lines = []
    let cur = ''
    for (const w of t.split(/\s+/)) {
      if (cur && cur.length + w.length + 1 > width) { lines.push(cur); cur = w } else cur = cur ? `${cur} ${w}` : w
    }
    if (cur) lines.push(cur)
    if (lines.length > max) { lines.length = max; lines[max - 1] += '…' }
    return lines.map(l => l.slice(0, width + 6))
  }
  const hue = [...String(title)].reduce((n, c) => (n * 31 + c.codePointAt(0)) % 360, 7)
  const lines = wrap(title, 15, 6)
  const by = author ? wrap(author, 22, 2) : []
  const text = (t, y, size, weight, fill) => `<text x="200" y="${y}" font-family="Georgia,'Times New Roman',serif" font-size="${size}" font-weight="${weight}" text-anchor="middle" fill="${fill}">${esc(t)}</text>`
  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 600" width="400" height="600"><rect width="400" height="600" fill="hsl(${hue} 38% 24%)"/><rect x="18" y="18" width="364" height="564" fill="none" stroke="hsl(${hue} 45% 72%)" stroke-width="2"/>${lines.map((l, i) => text(l, 150 + i * 48, 38, 'bold', '#f6f1e6')).join('')}${by.map((l, i) => text(l, 500 + i * 30, 23, 'normal', `hsl(${hue} 45% 80%)`)).join('')}</svg>`
}

export function setupBooks({ db, DATA_DIR, cached, HttpError, coverUrl, UA, net, safeFetch }) {
  const DIR = path.join(DATA_DIR, 'books')
  fs.mkdirSync(DIR, { recursive: true })
  db.exec(`CREATE TABLE IF NOT EXISTS user_books (
    id TEXT PRIMARY KEY,
    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    title TEXT NOT NULL,
    authors TEXT NOT NULL,
    created_at INTEGER NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_user_books_user ON user_books(user_id, created_at);`)
  // Un título de Wikisource puede ser largo para nombre de archivo.
  const fileKey = id => (id.startsWith('ws~') ? `ws-${crypto.createHash('sha256').update(id).digest('hex').slice(0, 32)}` : id.replace('~', '-'))
  const epubFile = id => path.join(DIR, `${fileKey(id)}.epub`)
  const jsonFile = id => path.join(DIR, `${fileKey(id)}.json`)

  // Hasta 3 intentos: un fallo de red o un 5xx de Gutenberg suele durar poco. El motivo real queda en el log.
  async function fetchSource(url, timeout, name) {
    for (let i = 1; ; i++) {
      net.guard()
      let why
      try {
        const r = await safeFetch(url, { headers: { 'User-Agent': UA }, signal: AbortSignal.timeout(timeout) })
        if (r.ok) return r
        if (r.status === 404) throw new HttpError(404, `Ese libro no está en ${name}`)
        if (r.status < 500 && r.status !== 429) throw new HttpError(502, `${name} respondió ${r.status}`)
        why = `HTTP ${r.status}`
      } catch (e) {
        if (e instanceof HttpError) throw e
        why = e.cause?.code || e.cause?.message || e.message
        net.failed()
      }
      console.warn(`${name} ${url}: intento ${i}: ${why}`)
      if (i >= 3) throw new HttpError(502, `${name} no responde ahora mismo. Prueba en un rato.`)
      await new Promise(r => setTimeout(r, 800 * i))
    }
  }
  const coverOf = (n, id) => coverUrl(`${GUTENBERG}/cache/epub/${n}/pg${n}.cover.medium.jpg`, id)
  // "Cervantes Saavedra, Miguel de" -> "Miguel de Cervantes Saavedra"
  const authorName = a => a.split(', ').reverse().join(' ')
  const entryText = (xml, tag) => clean(new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`).exec(xml)?.[1] || '')
  function parseFeed(xml) {
    const out = []
    for (const [entry] of xml.matchAll(/<entry>[\s\S]*?<\/entry>/g)) {
      const n = /<id>[^<]*\/ebooks\/(\d+)\.opds<\/id>/.exec(entry)?.[1]
      if (!n) continue // "Ordenar por…" y otras entradas de navegación
      const id = `gb~${n}`
      // El buscador añade el idioma al título: "Las Fábulas de Esopo (Spanish)".
      const title = entryText(entry, 'title').replace(/\s*\([A-Z][a-z]+\)$/, '')
      out.push({ id, source: 'gb', title, cover: coverOf(n, id), sub: entryText(entry, 'content') || undefined })
    }
    return out
  }
  // lang del usuario ("es-la") a idioma del catálogo ("spanish").
  async function search(q, mode, page, lang) {
    const name = LANG_NAMES[String(lang || 'es').slice(0, 2)]
    const text = q.trim().replace(/\s+/g, ' ')
    const qs = new URLSearchParams({ query: [text, name && `l.${name}`].filter(Boolean).join(' '), sort_order: mode === 'latest' && !text ? 'release_date' : 'downloads' })
    const start = (Math.max(1, page | 0) - 1) * OPDS_PAGE + 1
    if (start > 1) qs.set('start_index', String(start))
    return cached(`gb:${qs}`, 30 * 60e3, async () => parseFeed(await (await fetchSource(`${GUTENBERG}/ebooks/search.opds/?${qs}`, 15e3, GB_NAME)).text()))
  }

  // ---------- Wikisource ----------
  const wsId = title => `ws~${Buffer.from(title).toString('base64url')}`
  const wsTitle = id => Buffer.from(id.slice(3), 'base64url').toString('utf8')
  const wsCard = root => {
    const id = wsId(root)
    // "Realidad (Pérez Galdós)": la obra y, entre paréntesis, de quién es o de qué año.
    const m = /^(.+?)\s*\(([^()]+)\)$/.exec(root)
    return { id, source: 'ws', title: m ? m[1] : root, cover: `/api/book/${id}/cover`, sub: m ? m[2] : undefined }
  }
  const wsQuery = async params => {
    const qs = new URLSearchParams({ action: 'query', format: 'json', ...params })
    return (await fetchSource(`${WS_API}?${qs}`, 20e3, WS_NAME)).json()
  }
  async function wsList(q, mode) {
    const text = q.trim()
    if (text) {
      const d = await wsQuery({ list: 'search', srsearch: text, srnamespace: '0', srlimit: '200', srprop: 'wordcount' })
      // Una novela es una página índice corta con muchas subpáginas ("Obra/12"): cuenta la obra, una vez.
      const works = new Map()
      for (const r of d.query?.search || []) {
        const root = r.title.split('/')[0]
        const w = works.get(root) || { root, chapters: 0, words: 0 }
        if (r.title.includes('/')) w.chapters++
        else w.words = r.wordcount
        works.set(root, w)
      }
      return [...works.values()].filter(w => w.chapters || w.words >= WS_MIN_WORDS).map(w => w.root)
    }
    const d = await wsQuery({ list: 'categorymembers', cmtitle: 'Categoría:Novelas', cmnamespace: '0', cmlimit: '500', ...(mode === 'latest' ? { cmsort: 'timestamp', cmdir: 'desc' } : {}) })
    return (d.query?.categorymembers || []).map(m => m.title)
  }
  async function wsSearch(q, mode, page) {
    const list = await cached(`ws:${mode === 'latest' ? 'latest' : 'popular'}:${q.trim().toLowerCase()}`, 30 * 60e3, () => wsList(q, mode))
    const start = (Math.max(1, page | 0) - 1) * OPDS_PAGE
    return list.filter(t => Buffer.byteLength(t) <= 280).slice(start, start + OPDS_PAGE).map(wsCard)
  }

  // ---------- Libros subidos ----------
  const owns = (userId, id) => !!db.prepare('SELECT 1 FROM user_books WHERE id = ? AND user_id = ?').get(id, userId)
  const ubCard = r => ({ id: r.id, source: 'ub', title: r.title, cover: `/api/book/${r.id}/cover`, sub: JSON.parse(r.authors).join(', ') || undefined })
  function ubList(userId, q) {
    const fold = t => String(t).toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
    const words = fold(q).split(/\s+/).filter(Boolean)
    return db.prepare('SELECT * FROM user_books WHERE user_id = ? ORDER BY created_at DESC').all(userId)
      .filter(r => words.every(w => fold(`${r.title} ${r.authors}`).includes(w))).map(ubCard)
  }
  async function upload(req, user) {
    if (db.prepare('SELECT COUNT(*) n FROM user_books WHERE user_id = ?').get(user.id).n >= MAX_UPLOADS_PER_USER) throw new HttpError(400, `Se admiten hasta ${MAX_UPLOADS_PER_USER} libros por usuario`)
    let size = 0
    const chunks = []
    for await (const c of req) {
      size += c.length
      if (size > MAX_EPUB_BYTES) throw new HttpError(413, 'El libro es demasiado grande (máximo 100 MB)')
      chunks.push(c)
    }
    if (!size) throw new HttpError(400, 'No se recibió ningún archivo')
    const data = Buffer.concat(chunks)
    // El mismo archivo subido dos veces por la misma persona es el mismo libro.
    const id = `ub~${crypto.createHash('sha256').update(`${user.id}:`).update(data).digest('hex').slice(0, 32)}`
    const tmp = path.join(DIR, `up-${crypto.randomBytes(8).toString('hex')}.part`)
    fs.writeFileSync(tmp, data)
    let book
    try { book = parseEpub(tmp) } catch (e) {
      fs.rmSync(tmp, { force: true })
      throw new HttpError(400, `No se pudo leer ese archivo como EPUB: ${String(e.message).slice(0, 120)}`)
    }
    fs.renameSync(tmp, epubFile(id))
    fs.writeFileSync(jsonFile(id), JSON.stringify(book))
    remember(id, book)
    db.prepare(`INSERT INTO user_books (id, user_id, title, authors, created_at) VALUES (?, ?, ?, ?, ?)
                ON CONFLICT (id) DO UPDATE SET created_at = excluded.created_at`)
      .run(id, user.id, (book.title || 'Sin título').slice(0, 300), JSON.stringify(book.authors.map(authorName).slice(0, 10)), Date.now())
    return ubCard(db.prepare('SELECT * FROM user_books WHERE id = ?').get(id))
  }
  function removeUpload(id, userId) {
    db.prepare('DELETE FROM user_books WHERE id = ? AND user_id = ?').run(id, userId)
    db.prepare('DELETE FROM progress WHERE user_id = ? AND manga_id = ?').run(userId, id)
    db.prepare('DELETE FROM chapter_reads WHERE user_id = ? AND manga_id = ?').run(userId, id)
    db.prepare('DELETE FROM manga_prefs WHERE user_id = ? AND manga_id = ?').run(userId, id)
    db.prepare('DELETE FROM list_items WHERE manga_id = ? AND list_id IN (SELECT id FROM lists WHERE user_id = ?)').run(id, userId)
    memory.delete(id)
    packed.delete(id)
    fs.rmSync(epubFile(id), { force: true })
    fs.rmSync(jsonFile(id), { force: true })
  }

  // Una sola descarga y conversión a la vez por libro.
  const loading = new Map()
  const memory = new Map() // últimos libros convertidos
  function remember(id, book) {
    memory.delete(id)
    memory.set(id, book)
    if (memory.size > 4) memory.delete(memory.keys().next().value)
    return book
  }
  async function downloadEpub(id) {
    if (id.startsWith('ub~')) throw new HttpError(404, 'Ese libro ya no está')
    const r = id.startsWith('ws~')
      ? await fetchSource(`${WS_EXPORT}?${new URLSearchParams({ lang: 'es', page: wsTitle(id), format: 'epub-3' })}`, 120e3, WS_NAME)
      : await fetchSource(`${GUTENBERG}/ebooks/${id.slice(3)}.epub3.images`, 120e3, GB_NAME)
    if (Number(r.headers.get('content-length')) > MAX_EPUB_BYTES) throw new HttpError(502, 'El libro es demasiado grande')
    const buf = Buffer.from(await r.arrayBuffer())
    if (buf.length > MAX_EPUB_BYTES) throw new HttpError(502, 'El libro es demasiado grande')
    const tmp = `${epubFile(id)}.part`
    fs.writeFileSync(tmp, buf)
    fs.renameSync(tmp, epubFile(id))
  }
  function loadBook(id) {
    const hit = memory.get(id)
    if (hit) return Promise.resolve(remember(id, hit))
    if (loading.has(id)) return loading.get(id)
    const p = (async () => {
      try {
        const saved = JSON.parse(fs.readFileSync(jsonFile(id), 'utf8'))
        if (saved.version === PARSER_VERSION) return remember(id, saved)
      } catch {}
      if (!fs.existsSync(epubFile(id))) await downloadEpub(id)
      let book
      try { book = parseEpub(epubFile(id)) } catch (e) {
        console.warn(`EPUB ${id}: ${e.message}`)
        fs.rmSync(epubFile(id), { force: true }) // descarga mala: que el siguiente intento la repita
        throw new HttpError(502, 'No se pudo leer el EPUB de este libro')
      }
      const tmp = `${jsonFile(id)}.part`
      fs.writeFileSync(tmp, JSON.stringify(book))
      fs.renameSync(tmp, jsonFile(id))
      return remember(id, book)
    })().finally(() => loading.delete(id))
    loading.set(id, p)
    return p
  }

  async function manga(id) {
    const book = await loadBook(id)
    const source = id.slice(0, 2)
    return {
      manga: {
        id, source, type: 'Libro',
        title: book.title || (source === 'ws' ? wsCard(wsTitle(id)).title : `Libro ${id.slice(3)}`),
        description: book.description || '',
        status: null, year: null, // la fecha del EPUB es la de la edición digital, no la de la obra
        tags: [],
        authors: book.authors.map(authorName),
        languages: book.language ? [book.language] : [],
        cover: source === 'gb' ? coverOf(id.slice(3), id) : `/api/book/${id}/cover`,
      },
      chapters: book.chapters.map((c, i) => ({ id: `${id}~${i}`, num: String(i + 1), volume: null, title: c.title, pages: null, group: '', publishAt: null })),
    }
  }
  async function chapter(chapterId) {
    const cut = chapterId.lastIndexOf('~')
    const book = await loadBook(chapterId.slice(0, cut))
    const c = book.chapters[Number(chapterId.slice(cut + 1))]
    if (!c) throw new HttpError(404, 'Ese capítulo no existe')
    return { title: c.title }
  }
  // El libro entero (lo maqueta el navegador), comprimido una sola vez: son megas de texto.
  const packed = new Map()
  async function sendText(req, res, id) {
    const book = await loadBook(id)
    let hit = packed.get(id)
    if (hit?.book !== book) {
      hit = { book, gz: zlib.gzipSync(JSON.stringify({ title: book.title, chapters: book.chapters })) }
      packed.delete(id)
      packed.set(id, hit)
      if (packed.size > 4) packed.delete(packed.keys().next().value)
    }
    const headers = { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'private, no-cache', Vary: 'Accept-Encoding' }
    if (/\bgzip\b/.test(req.headers['accept-encoding'] || '')) { res.writeHead(200, { ...headers, 'Content-Encoding': 'gzip' }); return res.end(hit.gz) }
    res.writeHead(200, headers)
    res.end(zlib.gunzipSync(hit.gz))
  }
  async function sendImage(res, id, n) {
    const book = await loadBook(id)
    const name = book.images[n]
    const entry = name && readZipIndex(epubFile(id)).find(e => e.name === name)
    if (!entry) throw new HttpError(404, 'Imagen no encontrada')
    const data = readCbzEntry(epubFile(id), entry, MAX_UNZIPPED_ENTRY)
    res.writeHead(200, { 'Content-Type': imageType(name), 'Cache-Control': 'private, max-age=604800', 'X-Content-Type-Options': 'nosniff' })
    res.end(data)
  }
  async function sendCover(res, id) {
    if (id.startsWith('ub~')) {
      const book = await loadBook(id)
      if (book.cover != null) return sendImage(res, id, book.cover)
      const r = db.prepare('SELECT title, authors FROM user_books WHERE id = ?').get(id)
      return sendSvg(res, titleCover(r?.title || book.title || 'Sin título', book.authors.map(authorName)[0]))
    }
    if (!id.startsWith('ws~')) throw new HttpError(404, 'Sin portada')
    const card = wsCard(wsTitle(id)) // en un listado: sin descargar el libro
    sendSvg(res, titleCover(card.title, card.sub))
  }
  const sendSvg = (res, svg) => {
    res.writeHead(200, { 'Content-Type': 'image/svg+xml; charset=utf-8', 'Cache-Control': 'private, max-age=604800', 'X-Content-Type-Options': 'nosniff' })
    res.end(svg)
  }
  return { search, wsSearch, ubList, upload, removeUpload, owns, manga, chapter, sendText, sendImage, sendCover }
}