/* eslint-disable @typescript-eslint/no-explicit-any */
import * as cheerio from 'cheerio/slim';
import crypto from 'crypto';
import he from 'he';
import vm from 'vm';
import { DOMParser } from '@xmldom/xmldom';
import xpath from 'xpath';

import { getConfig } from './config';
import {
  BookAcquisitionLink,
  BookCatalogResult,
  BookChapter,
  BookChapterContent,
  BookDetail,
  BookListItem,
  BookSearchFailure,
  BookSearchResult,
  BookSource,
  BookSourceCapabilities,
  LegadoBookSourceRule,
  LegadoRuleSearch,
} from './book.types';
import { validateProxyUrlServerSide } from './server/ssrf';
import { legadoSubscriptionStore } from './legado/subscription-store';

interface ResolvedLegadoConfig {
  enabled: boolean;
  sources: BookSource[];
  cacheTTL: number;
}

const DEFAULT_TIMEOUT_MS = Number(process.env.LEGADO_TIMEOUT_MS || process.env.OPDS_TIMEOUT_MS || 20000);
const MAX_TEXT_BYTES = Number(process.env.LEGADO_MAX_TEXT_BYTES || 3 * 1024 * 1024);
const DEFAULT_LEGADO_SEARCH_PAGES = Number(process.env.LEGADO_SEARCH_PAGES || 5);
const textCache = new Map<string, { expiresAt: number; data: string }>();
const searchCache = new Map<string, { expiresAt: number; data: BookListItem[] }>();
const detailCache = new Map<string, { expiresAt: number; data: BookDetail }>();
const tocCache = new Map<string, { expiresAt: number; data: BookChapter[] }>();
const chapterCache = new Map<string, { expiresAt: number; data: BookChapterContent }>();

interface RequestOptions {
  url: string;
  method?: string;
  body?: string;
  headers?: Record<string, string>;
  charset?: string;
  retry?: number;
}

const cookieJar = new Map<string, string>();
const variableStore = new Map<string, any>();
const imageMemoryCache = new Map<string, { expiresAt: number; contentType: string; data: Uint8Array }>();

function stableId(input: string) {
  return crypto.createHash('sha1').update(input).digest('hex').slice(0, 16);
}

function isSafeHeaderName(name: string) {
  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name);
}

function asObjectHeader(value?: string | Record<string, string>, context?: Record<string, any>): Record<string, string> {
  if (!value) return {};
  if (typeof value === 'object') return value;
  let raw = value.trim();
  if (raw.startsWith('@js:')) {
    raw = runJsSnippet(raw, context || {});
  }
  try {
    const parsed = JSON.parse(raw);
    return parsed && typeof parsed === 'object' ? parsed : {};
  } catch {
    return raw.split('\n').reduce<Record<string, string>>((headers, line) => {
      const index = line.indexOf(':');
      if (index > 0) {
        const name = line.slice(0, index).trim();
        if (isSafeHeaderName(name)) headers[name] = line.slice(index + 1).trim();
      }
      return headers;
    }, {});
  }
}

function buildHeaders(source: BookSource): HeadersInit {
  const rule = source.legado;
  const baseUrl = sourceBase(source);
  const headers: Record<string, string> = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0 Safari/537.36',
    Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    ...asObjectHeader(rule?.header, { baseUrl, source: rule }),
  };
  if (source.authMode === 'header' && source.headerName && source.headerValue) headers[source.headerName] = source.headerValue;
  if (source.authMode === 'basic' && source.username) headers.Authorization = `Basic ${Buffer.from(`${source.username}:${source.password || ''}`).toString('base64')}`;
  delete headers.Host;
  delete headers.host;
  delete headers['Content-Length'];
  delete headers['content-length'];
  return headers;
}

function sourceBase(source: BookSource) {
  return source.legado?.bookSourceUrl || source.url;
}

function normalizeUrl(base: string, href?: string): string {
  if (!href) return base;
  const trimmed = href.trim();
  if (!trimmed) return base;
  if (/^javascript:/i.test(trimmed)) return '';
  return new URL(trimmed, base).toString();
}

function encodeRuleParam(value: string) {
  return encodeURIComponent(value).replace(/%20/g, '+');
}

function encryptTongrenKeyword(plainText: string) {
  const passphrase = 'zc89s30ipHG2Dw';
  const key = Buffer.alloc(32);
  const iv = Buffer.alloc(16);
  Buffer.from(passphrase).copy(key);
  Buffer.from(passphrase).copy(iv);
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  return encodeURIComponent(Buffer.concat([cipher.update(String(plainText), 'utf8'), cipher.final()]).toString('base64'));
}

function decryptTongrenOpenUrl(encryptedBase64: string, num: string, source?: LegadoBookSourceRule) {
  try {
    const numStr = Buffer.from(String(num || ''), 'base64').toString('utf8');
    const userAgent = (asObjectHeader(source?.header)['User-Agent'] || 'Mozilla/5.0 (Linux; Android 9) Mobile Safari/537.36').toLowerCase();
    const key = Buffer.from(crypto.createHash('md5').update(userAgent + numStr).digest('hex'), 'utf8');
    const encryptedData = Buffer.from(String(encryptedBase64 || ''), 'base64');
    const iv = encryptedData.subarray(0, 16);
    const data = encryptedData.subarray(16);
    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
    return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
  } catch {
    return '';
  }
}

function safeEvalTemplateExpression(expr: string, keyword: string, page: number) {
  const key = keyword;
  const searchTerms = keyword;
  const java = {
    base64Encode: (value: unknown) => Buffer.from(String(value ?? ''), 'utf8').toString('base64'),
    base64Decode: (value: unknown) => Buffer.from(String(value ?? ''), 'base64').toString('utf8'),
    encodeURI: (value: unknown) => encodeURIComponent(String(value ?? '')),
    encodeURIComponent: (value: unknown) => encodeURIComponent(String(value ?? '')),
  };
  try {
    // eslint-disable-next-line no-new-func
    const fn = new Function('key', 'keyword', 'searchTerms', 'page', 'java', `return (${expr});`);
    return jsonPrimitiveToString(fn(key, keyword, searchTerms, page, java));
  } catch {
    return '';
  }
}

function renderTemplateExpressions(raw: string, keyword = '', page = 1) {
  return raw.replace(/<([^,<>]*),\s*\{\{(.*?)\}\}>/g, (_, prefix, expr) => {
    const value = safeEvalTemplateExpression(String(expr).trim(), keyword, page);
    return value ? `${prefix || ''}${value}` : '';
  }).replace(/\{\{(.*?)\}\}/g, (_, expr) => {
    const value = String(expr).trim();
    if (/^(key|keyword|searchTerms)$/.test(value)) return encodeRuleParam(keyword || '');
    if (/^(page|pageIndex)$/.test(value)) return String(page);
    const evaluated = safeEvalTemplateExpression(value, keyword, page);
    return encodeRuleParam(evaluated);
  });
}

function runJsSnippet(code: string, context: Record<string, any>, timeout = 1000): string {
  const java = {
    base64Encode: (value: unknown) => Buffer.from(String(value ?? ''), 'utf8').toString('base64'),
    base64Decode: (value: unknown) => Buffer.from(String(value ?? ''), 'base64').toString('utf8'),
    md5Encode: (value: unknown) => crypto.createHash('md5').update(String(value ?? '')).digest('hex'),
    strToBytes: (value: unknown) => Buffer.from(String(value ?? ''), 'utf8'),
    base64DecodeToByteArray: (value: unknown) => Buffer.from(String(value ?? ''), 'base64'),
    encodeURI: (value: unknown) => encodeURIComponent(String(value ?? '')),
    encodeURIComponent: (value: unknown) => encodeURIComponent(String(value ?? '')),
    put: (key: string, value: any) => { variableStore.set(key, value); return value; },
    get: (key: string) => variableStore.get(key),
    log: () => undefined,
    htmlFormat: (value: unknown) => he.decode(String(value ?? '')).replace(/<br\s*\/?/gi, '\n').replace(/<[^>]+>/g, ''),
  };
  const cookie = {
    removeCookie: () => undefined,
    mapToCookie: (input: any) => typeof input === 'string' ? input : Array.isArray(input) ? input.join('; ') : '',
  };
  const sandbox: Record<string, any> = {
    ...context,
    java,
    cookie,
    Buffer,
    JSON,
    String,
    Number,
    Math,
    Array,
    Object,
    encodeURIComponent,
    encryptText: encryptTongrenKeyword,
    openUrl: (encryptedText: string, num: string) => decryptTongrenOpenUrl(encryptedText, num, context.source),
    console: { log: () => undefined },
  };
  const body = code.replace(/^@js:/, '').trim();
  try {
    const script = new vm.Script(`(function(){ ${body}\n})()`);
    const result = script.runInNewContext(sandbox, { timeout });
    const value = jsonPrimitiveToString(result ?? sandbox.result ?? '');
    if (value) return value;
  } catch {
    // 如果 @js 后面是单个表达式（例如 header: @js:JSON.stringify({...})），上面的函数体不会自动返回。
  }
  try {
    const script = new vm.Script(`(function(){ return (${body}); })()`);
    const result = script.runInNewContext(sandbox, { timeout });
    return jsonPrimitiveToString(result ?? sandbox.result ?? '');
  } catch {
    return '';
  }
}

function applyPutGetRules(rule: string, value: string) {
  const putMatch = rule.match(/@put:\s*\{([\s\S]*?)\}/);
  if (putMatch) {
    try {
      const obj = JSON.parse(`{${putMatch[1]}}`);
      Object.entries(obj).forEach(([key, val]) => variableStore.set(key, val));
    } catch {
      const pair = putMatch[1].match(/([A-Za-z0-9_$-]+)\s*:\s*['"]?([^,'"]+)['"]?/);
      if (pair) variableStore.set(pair[1], value || pair[2]);
    }
  }
  const getMatch = rule.match(/@get:\s*\{\s*([A-Za-z0-9_$-]+)\s*\}/);
  if (getMatch) return jsonPrimitiveToString(variableStore.get(getMatch[1]));
  return value;
}

function buildUrlFromTemplate(template: string, source: BookSource, keyword?: string, page = 1, baseOverride?: string) {
  const base = baseOverride || sourceBase(source);
  let raw = template || base;
  if (raw.trim().startsWith('@js:')) {
    if (/\/k-\{\{encryptText\(key\)\}\}-\{\{page\}\}\.html/.test(raw)) {
      return `https://www.rrssk.com/k-${encryptTongrenKeyword(keyword || '')}-${page}.html`;
    }
    const evaluated = runJsSnippet(raw, { key: keyword || '', keyword: keyword || '', page, baseUrl: base, source: { ...(source.legado || {}), key: base } });
    raw = evaluated || raw;
    if (/,(\s*)\{/.test(raw)) return raw;
  }
  raw = renderTemplateExpressions(raw, keyword || '', page);
  raw = raw
    .replace(/\{searchTerms\}/g, encodeRuleParam(keyword || ''))
    .replace(/\{key\}/g, encodeRuleParam(keyword || ''))
    .replace(/\{keyword\}/g, encodeRuleParam(keyword || ''))
    .replace(/\{page\}/g, String(page))
    .replace(/\{pageIndex\}/g, String(page));
  return normalizeUrl(base, raw);
}

function stripRuleJsBlocks(rule?: string) {
  return (rule || '').replace(/<js>[\s\S]*?<\/js>/gi, '').trim();
}

function applyRuleJsBlocks(raw: string, rule?: string) {
  const blocks = Array.from((rule || '').matchAll(/<js>([\s\S]*?)<\/js>/gi));
  for (const block of blocks) {
    runJsSnippet(block[1], { src: raw, result: raw });
  }
}

function parseJsonMaybe(value: string): any | null {
  try {
    return JSON.parse(value.trim());
  } catch {
    return null;
  }
}

function jsonPrimitiveToString(value: any): string {
  if (value === undefined || value === null) return '';
  if (typeof value === 'string') return value.trim();
  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
  if (Array.isArray(value)) return value.map(jsonPrimitiveToString).filter(Boolean).join(', ');
  try {
    return JSON.stringify(value);
  } catch {
    return String(value);
  }
}

function readJsonPath(input: any, path?: string): any {
  if (!path) return input;
  let normalized = path.trim();
  if (normalized.startsWith('@json:')) normalized = normalized.slice(6);
  if (normalized.startsWith('-@json:')) normalized = normalized.slice(7);
  if (!normalized || normalized === '$') return input;

  const filterMatch = normalized.match(/^(.*)\[\?\(@\.([A-Za-z0-9_$-]+)\s*(==|=|!=)\s*['"]?([^'"\]]+)['"]?\)\](.*)$/);
  if (filterMatch) {
    const base = readJsonPath(input, filterMatch[1] || '$');
    const list = Array.isArray(base) ? base : [];
    const filtered = list.filter((item) => {
      const actual = jsonPrimitiveToString(item?.[filterMatch[2]]);
      return filterMatch[3] === '!=' ? actual !== filterMatch[4] : actual === filterMatch[4];
    });
    return filterMatch[5] ? readJsonPath(filtered, `$${filterMatch[5]}`) : filtered;
  }

  const recursive = normalized.match(/^\$\.\.([A-Za-z0-9_$-]+)(.*)$/);
  if (recursive) {
    const key = recursive[1];
    const rest = recursive[2] || '';
    const out: any[] = [];
    const walk = (node: any) => {
      if (!node || typeof node !== 'object') return;
      if (Array.isArray(node)) return node.forEach(walk);
      if (node[key] !== undefined) out.push(node[key]);
      Object.values(node).forEach(walk);
    };
    walk(input);
    return rest ? readJsonPath(out.flat(), `$${rest}`) : out.flat();
  }

  normalized = normalized.replace(/^\$\.?/, '');
  const tokens = normalized.match(/[^.[\]]+|\[\*\]|\[-?\d+\]|\[-?\d*:-?\d*(?::-?\d+)?\]|\[['"][^\]]+['"](?:,\s*['"][^\]]+['"])*\]/g) || [];
  let current = input;
  for (const token of tokens) {
    if (current === undefined || current === null) return undefined;
    if (token === '[*]') {
      current = Array.isArray(current) ? current.flat() : [];
    } else if (/^\[-?\d+\]$/.test(token)) {
      const idx = Number(token.slice(1, -1));
      current = Array.isArray(current) ? current[idx < 0 ? current.length + idx : idx] : undefined;
    } else if (/^\[-?\d*:-?\d*/.test(token)) {
      if (!Array.isArray(current)) return [];
      const parts = token.slice(1, -1).split(':').map((item) => item === '' ? undefined : Number(item));
      const start = parts[0] === undefined ? 0 : parts[0] < 0 ? current.length + parts[0] : parts[0];
      const end = parts[1] === undefined ? current.length : parts[1] < 0 ? current.length + parts[1] : parts[1];
      const step = parts[2] || 1;
      const sliced = current.slice(start, end);
      current = step === 1 ? sliced : sliced.filter((_, index) => index % Math.abs(step) === 0);
    } else if (/^\[/.test(token)) {
      const keys = Array.from(token.matchAll(/['"]([^'"]+)['"]/g)).map((m) => m[1]);
      if (Array.isArray(current)) current = current.map((item) => keys.map((key) => item?.[key])).flat().filter((item) => item !== undefined);
      else current = keys.map((key) => current?.[key]).filter((item) => item !== undefined);
    } else if (Array.isArray(current)) {
      current = current.map((item) => item?.[token]).filter((item) => item !== undefined);
    } else {
      current = current[token];
    }
  }
  return current;
}

function ruleIsJson(rule?: string) {
  return !!rule && /@json:|-@json:|^\$\./.test(rule.trim());
}

function selectJsonItems(json: any, rule?: string): any[] {
  const reverse = !!rule?.trim().startsWith('-');
  const value = readJsonPath(json, rule);
  const list = Array.isArray(value) ? value : value ? [value] : [];
  return reverse ? [...list].reverse() : list;
}

function renderTemplateWithJson(template: string, json: any, source: BookSource, baseUrl: string) {
  const rendered = template.replace(/\{\{(.*?)\}\}/g, (_, expr) => {
    const normalizedExpr = String(expr).trim().replace(/^@json:/, '');
    const value = readJsonPath(json, normalizedExpr);
    return encodeRuleParam(jsonPrimitiveToString(value));
  });
  return normalizeUrl(baseUrl || sourceBase(source), rendered);
}

function readJsonRule(json: any, rule?: string, source?: BookSource, baseUrl?: string): string {
  if (!rule) return '';
  const trimmed = rule.trim();
  if (trimmed.includes('{{')) return renderTemplateWithJson(trimmed, json, source as BookSource, baseUrl || sourceBase(source as BookSource));
  if (trimmed.startsWith('@js:')) {
    if (/result\s*=\s*['"]([^'"]+)['"]\s*\+\s*result\.([A-Za-z0-9_$-]+)/.test(trimmed)) {
      const match = trimmed.match(/result\s*=\s*['"]([^'"]+)['"]\s*\+\s*result\.([A-Za-z0-9_$-]+)/);
      return normalizeUrl(baseUrl || sourceBase(source as BookSource), `${match?.[1] || ''}${jsonPrimitiveToString(json?.[match?.[2] || ''])}`);
    }
    if (/item\.img|\.reverse\(\)/.test(trimmed)) {
      const data = Array.isArray(json?.data) ? [...json.data].reverse() : Array.isArray(json) ? [...json].reverse() : [];
      return data
        .map((item) => item?.img ? `<img src="${String(item.img)}" style="max-width:100%; display:block;" referrerpolicy="no-referrer">` : '')
        .filter(Boolean)
        .join('');
    }
    const resultText = typeof json === 'string' ? json : JSON.stringify(json);
    if (/java\.base64Decode/.test(trimmed)) return Buffer.from(resultText, 'base64').toString('utf8');
    if (/java\.base64Encode/.test(trimmed)) return Buffer.from(resultText, 'utf8').toString('base64');
    if (/java\.md5Encode/.test(trimmed)) return crypto.createHash('md5').update(resultText).digest('hex');
    const replaceMatch = trimmed.match(/result\.replace\(\s*\/([^/]+)\/[gimuy]*\s*,\s*['"]([^'"]*)['"]\s*\)/);
    if (replaceMatch) return resultText.replace(new RegExp(replaceMatch[1], 'g'), replaceMatch[2]);
    const matchMatch = trimmed.match(/result\.match\(\s*\/([^/]+)\/[gimuy]*\s*\)/);
    if (matchMatch) return resultText.match(new RegExp(matchMatch[1]))?.[1] || resultText.match(new RegExp(matchMatch[1]))?.[0] || '';
    return runJsSnippet(trimmed, { result: json, baseUrl, src: json });
  }
  const value = readJsonPath(json, trimmed);
  const text = jsonPrimitiveToString(value);
  if ((/url|href|pic|cover/i.test(trimmed) || /^https?:\/\//i.test(text)) && text && baseUrl) return normalizeUrl(baseUrl, text);
  return text;
}

function fallbackChapterHrefFromItem(item: any, rule?: string, baseUrl?: string): string {
  const id = jsonPrimitiveToString(item?.id || item?.cid || item?.chapter_id || item?.chapterId);
  if (!id) return '';
  const match = (rule || '').match(/['"]([^'"]*(?:pic|chapter)[^'"]*(?:cid|id)=)['"]/i);
  if (match?.[1]) return normalizeUrl(baseUrl || '', `${match[1]}${id}`);
  return '';
}

function splitAlternatives(rule?: string): string[] {
  return (rule || '').split('||').map((item) => item.trim()).filter(Boolean);
}

function splitRuleFilters(rule: string) {
  const parts = (rule || '').split('##');
  return { base: (parts.shift() || '').trim(), filters: parts };
}

function applyRuleFilters(value: string, filters: string[]) {
  let result = value;
  for (let index = 0; index < filters.length; index += 2) {
    const pattern = filters[index];
    const replacement = filters[index + 1] ?? '';
    if (!pattern) continue;
    try {
      result = result.replace(new RegExp(pattern, 'g'), replacement.replace(/\$(\d+)/g, '$$$$1'));
    } catch {
      result = result.split(pattern).join(replacement);
    }
  }
  return result;
}

function readAllInOneList(raw: string, rule?: string): Array<Record<string, string>> {
  const trimmed = (rule || '').trim();
  if (!trimmed.startsWith(':')) return [];
  const pattern = trimmed.slice(1);
  try {
    const regex = new RegExp(pattern, 'gs');
    const out: Array<Record<string, string>> = [];
    let match: RegExpExecArray | null;
    while ((match = regex.exec(raw)) !== null) {
      const groups = (match.groups || {}) as Record<string, string>;
      const item: Record<string, string> = { _0: match[0] };
      Array.from(match).forEach((value: string | undefined, index: number) => { item[`_${index}`] = value || ''; });
      Object.entries(groups).forEach(([key, value]) => { item[key] = String(value || ''); });
      out.push(item);
      if (match[0] === '') regex.lastIndex += 1;
    }
    return out;
  } catch {
    return [];
  }
}

function readRegexItem(item: Record<string, string>, rule?: string, baseUrl?: string) {
  const key = (rule || '').trim().replace(/^\$?\{?/, '').replace(/\}?$/, '');
  const value = item[key] || item[`_${key}`] || '';
  if ((/url|href|src|cover/i.test(key) || /^https?:\/\//i.test(value)) && value && baseUrl) return normalizeUrl(baseUrl, value);
  return value;
}

function isLegadoAttrToken(value: string) {
  return /^(href|src|title|alt|text|textNodes|ownText|all|html|content|value|data-[\w-]+)$/i.test(value.trim());
}

function normalizeLegadoSelector(selector: string) {
  const trimmed = selector.trim();
  if (!trimmed) return '';
  const classMatch = trimmed.match(/^class\.([\w-]+(?:\.[\w-]+)*)$/i);
  if (classMatch) return classMatch[1].split('.').map((item) => `.${item}`).join('');
  const idMatch = trimmed.match(/^id\.([\w-]+)$/i);
  if (idMatch) return `#${idMatch[1]}`;
  const tagMatch = trimmed.match(/^tag\.([\w-]+)$/i);
  if (tagMatch) return tagMatch[1];
  return trimmed;
}

function parseStep(step: string): { selector: string; attr: string } {
  const trimmed = step.trim();
  if (isLegadoAttrToken(trimmed)) return { selector: '', attr: trimmed };

  const parts = trimmed.split('@').map((item) => item.trim()).filter(Boolean);
  if (parts.length > 1) {
    const last = parts[parts.length - 1];
    const hasAttr = isLegadoAttrToken(last);
    const selectorParts = hasAttr ? parts.slice(0, -1) : parts;
    return {
      selector: selectorParts.map(normalizeLegadoSelector).filter(Boolean).join(' '),
      attr: hasAttr ? last : '',
    };
  }

  const attrMatch = trimmed.match(/(?:@|::)(text|textNodes|ownText|all|html|href|src|title|alt|content|value|data-[\w-]+)$/i);
  if (attrMatch) {
    return { selector: normalizeLegadoSelector(trimmed.slice(0, attrMatch.index).trim()), attr: attrMatch[1] };
  }
  const dotAttr = trimmed.match(/\.(text|html|href|src)$/i);
  if (dotAttr) return { selector: normalizeLegadoSelector(trimmed.slice(0, dotAttr.index).trim()), attr: dotAttr[1] };
  return { selector: normalizeLegadoSelector(trimmed), attr: '' };
}

function stripFilters(rule: string) {
  return splitRuleFilters(rule).base;
}

function applyLegadoIndexSelector(current: cheerio.Cheerio<any>, selector: string): { current: cheerio.Cheerio<any>; selector: string } {
  let normalized = selector.trim();
  const exclude = normalized.match(/\[!(-?\d+)\]$/);
  if (exclude) {
    normalized = normalized.slice(0, exclude.index).trim();
    current = normalized ? current.find(normalized) : current;
    const idx = Number(exclude[1]);
    const real = idx < 0 ? current.length + idx : idx;
    return { current: current.filter((index) => index !== real), selector: '' };
  }
  const range = normalized.match(/(?:\[(-?\d*):(-?\d*)(?::(-?\d+))?\]|\.(-?\d*):(-?\d*))$/);
  if (range) {
    normalized = normalized.slice(0, range.index).trim();
    current = normalized ? current.find(normalized) : current;
    const length = current.length;
    const startRaw = range[1] ?? range[4];
    const endRaw = range[2] ?? range[5];
    const start = startRaw ? Number(startRaw) : 0;
    const end = endRaw ? Number(endRaw) : length;
    const realStart = start < 0 ? length + start : start;
    const realEnd = end < 0 ? length + end : end;
    return { current: current.slice(realStart, realEnd), selector: '' };
  }
  const indexMatch = normalized.match(/(?:\[(-?\d+)\]|\.(-?\d+))$/);
  if (indexMatch) {
    normalized = normalized.slice(0, indexMatch.index).trim();
    current = normalized ? current.find(normalized) : current;
    const idx = Number(indexMatch[1] ?? indexMatch[2]);
    const real = idx < 0 ? current.length + idx : idx;
    return { current: current.eq(real), selector: '' };
  }
  return { current, selector: normalized };
}

function applyLegadoSelector($: cheerio.CheerioAPI, current: cheerio.Cheerio<any>, selector: string): cheerio.Cheerio<any> {
  const normalized = selector.trim();
  if (!normalized) return current;
  const textMatch = normalized.match(/^text\.(.+)$/);
  if (textMatch) {
    const keyword = textMatch[1].trim();
    const links = current.find('a[href]').filter((_, el) => $(el).text().includes(keyword));
    if (links.length > 0) return links;
    return current.find('button,span,div,p,li,a').filter((_, el) => $(el).text().includes(keyword));
  }
  const tokens = normalized.split(/\s+/).filter(Boolean);
  if (
    tokens.length > 1
    && tokens.every((token) => !/[>+~]/.test(token))
    && tokens.some((token) => /(?:\[!?\-?\d+\]|\[-?\d*:|-?\d+\]$|\.-?\d+(?::\-?\d*)?)$/.test(token))
  ) {
    let next = current;
    for (const token of tokens) {
      const indexed = applyLegadoIndexSelector(next, token);
      next = indexed.selector ? next.find(indexed.selector) : indexed.current;
    }
    return next;
  }
  const indexed = applyLegadoIndexSelector(current, normalized);
  return indexed.selector ? current.find(indexed.selector) : indexed.current;
}

function selectElements($: cheerio.CheerioAPI, root: cheerio.Cheerio<any>, rule?: string): cheerio.Cheerio<any> {
  const normalized = stripFilters(rule || '');
  const reverse = normalized.trim().startsWith('-') && !normalized.trim().startsWith('-@');
  const effective = reverse ? normalized.trim().slice(1).trim() : normalized;
  if (!effective) return root;
  const steps = effective.split(/&&|@css:/).map((item) => item.trim()).filter(Boolean);
  let current = root;
  for (const rawStep of steps) {
    const { selector, attr } = parseStep(rawStep);
    if (attr) break;
    if (!selector) continue;
    if (/^children$/i.test(selector)) {
      current = current.children();
      continue;
    }
    current = applyLegadoSelector($, current, selector);
  }
  if (reverse) current = $(current.toArray().reverse());
  return current;
}


function selectXPath($: cheerio.CheerioAPI, root: cheerio.Cheerio<any>, rule: string): { nodes: cheerio.Cheerio<any>; attr: string; value?: string } {
  const expr = rule.trim().replace(/^@XPath:/i, '');
  try {
    const html = $.html(root);
    const doc = new DOMParser({ errorHandler: () => undefined }).parseFromString(html, 'text/html');
    const selected = xpath.select(expr, doc as any) as any;
    const list = Array.isArray(selected) ? selected : [selected];
    const values = list.map((node) => {
      if (node === undefined || node === null) return '';
      if (typeof node === 'string' || typeof node === 'number' || typeof node === 'boolean') return String(node);
      if (node.nodeType === 2) return node.nodeValue || '';
      if (node.nodeType === 3 || node.nodeType === 4) return node.nodeValue || '';
      return node.textContent || '';
    }).filter(Boolean);
    if (values.length > 0) return { nodes: root, attr: '', value: values.join('\n') };
  } catch {
    // fallback below
  }

  let fallbackExpr = expr;
  let attr = '';
  const attrMatch = fallbackExpr.match(/\/@([A-Za-z0-9_-]+)$/);
  if (attrMatch) {
    attr = attrMatch[1];
    fallbackExpr = fallbackExpr.slice(0, attrMatch.index);
  } else if (/\/text\(\)$/.test(fallbackExpr)) {
    attr = 'text';
    fallbackExpr = fallbackExpr.replace(/\/text\(\)$/, '');
  }
  const parts = fallbackExpr.split('/').filter(Boolean).map((part) => {
    const match = part.match(/^([A-Za-z0-9_*.-]+)(?:\[@([A-Za-z0-9_-]+)=['"]([^'"]+)['"]\])?(?:\[(\d+)\])?$/);
    if (!match) return '';
    const tag = match[1] === '*' ? '*' : match[1];
    const filter = match[2] ? `[${match[2]}="${match[3]}"]` : '';
    const index = match[4] ? `:nth-of-type(${match[4]})` : '';
    return `${tag}${filter}${index}`;
  }).filter(Boolean);
  return { nodes: parts.length ? root.find(parts.join(' ')) : root, attr };
}

function readValue($: cheerio.CheerioAPI, root: cheerio.Cheerio<any>, rule?: string, baseUrl?: string, jsContext?: Record<string, any>): string {
  for (const alternative of splitAlternatives(rule)) {
    const jsIndex = alternative.indexOf('@js:');
    if (jsIndex > 0) {
      const selectorRule = alternative.slice(0, jsIndex).trim();
      const jsRule = alternative.slice(jsIndex).trim();
      const selected = readValue($, root, selectorRule, baseUrl, jsContext);
      const transformed = runJsSnippet(jsRule, { ...(jsContext || {}), result: selected, src: selected, baseUrl });
      if (transformed) {
        if (/,(\s*)\{/.test(transformed)) return transformed;
        return /^(?:https?:)?\/\//i.test(transformed) || transformed.startsWith('/') ? normalizeUrl(baseUrl || '', transformed) : transformed;
      }
      if (selected) return selected;
      continue;
    }
    const normalized = stripFilters(alternative);
    const getMatch = normalized.match(/^@get:\s*\{\s*([A-Za-z0-9_$-]+)\s*\}$/);
    if (getMatch) {
      const value = jsonPrimitiveToString(variableStore.get(getMatch[1]));
      if (value) return value;
      continue;
    }
    if (/^@?XPath:/i.test(normalized) || normalized.startsWith('//')) {
      const { nodes, attr, value: xpathValue } = selectXPath($, root, normalized);
      const node = nodes.first();
      let value = xpathValue !== undefined ? xpathValue : attr === 'text' || !attr ? node.text() : node.attr(attr) || '';
      value = he.decode(value || '').replace(/\u00a0/g, ' ').trim();
      value = applyRuleFilters(value, splitRuleFilters(alternative).filters);
      if (value) return value;
      continue;
    }
    const steps = normalized.split(/&&|@css:/).map((item) => item.trim()).filter(Boolean);
    let current = root;
    let attr = '';
    for (const rawStep of steps) {
      const parsed = parseStep(rawStep);
      if (parsed.selector) {
        if (/^children$/i.test(parsed.selector)) current = current.children();
        else {
          current = applyLegadoSelector($, current, parsed.selector);
        }
      }
      if (parsed.attr) attr = parsed.attr;
    }
    if (current.length === 0 && steps.length === 1) {
      const parsed = parseStep(steps[0]);
      if (!parsed.selector && parsed.attr) current = root;
    }
    const node = current.first();
    let value = '';
    const normalizedAttr = attr.toLowerCase();
    if (!attr || normalizedAttr === 'text' || normalizedAttr === 'textnodes') value = node.text();
    else if (normalizedAttr === 'owntext') value = node.clone().children().remove().end().text();
    else if (normalizedAttr === 'all') value = current.toArray().map((el) => $(el).text()).join('\n');
    else if (normalizedAttr === 'html') value = node.html() || '';
    else value = node.attr(attr) || '';
    value = he.decode(value || '').replace(/\u00a0/g, ' ').trim();
    if ((normalizedAttr === 'href' || normalizedAttr === 'src') && value && baseUrl) value = normalizeUrl(baseUrl, value);
    value = applyRuleFilters(value, splitRuleFilters(alternative).filters);
    value = applyPutGetRules(alternative, value);
    if (value) return value;
  }
  return '';
}

function readValues($: cheerio.CheerioAPI, root: cheerio.Cheerio<any>, rule?: string, baseUrl?: string): string[] {
  for (const alternative of splitAlternatives(rule)) {
    const normalized = stripFilters(alternative);
    const steps = normalized.split(/&&|@css:/).map((item) => item.trim()).filter(Boolean);
    let current = root;
    let attr = '';
    for (const rawStep of steps) {
      const parsed = parseStep(rawStep);
      if (parsed.selector) {
        if (/^children$/i.test(parsed.selector)) current = current.children();
        else {
          current = applyLegadoSelector($, current, parsed.selector);
        }
      }
      if (parsed.attr) attr = parsed.attr;
    }
    if (current.length === 0 && steps.length === 1) {
      const parsed = parseStep(steps[0]);
      if (!parsed.selector && parsed.attr) current = root;
    }
    const normalizedAttr = attr.toLowerCase();
    const values = current.toArray().map((element) => {
      const node = $(element);
      let value = '';
      if (!attr || normalizedAttr === 'text' || normalizedAttr === 'textnodes') value = node.text();
      else if (normalizedAttr === 'owntext') value = node.clone().children().remove().end().text();
      else if (normalizedAttr === 'all') value = node.text();
      else if (normalizedAttr === 'html') value = node.html() || '';
      else value = node.attr(attr) || '';
      value = he.decode(value || '').replace(/\u00a0/g, ' ').trim();
      if ((normalizedAttr === 'href' || normalizedAttr === 'src' || normalizedAttr === 'data-original') && value && baseUrl) value = normalizeUrl(baseUrl, value);
      return value;
    }).filter(Boolean);
    if (values.length > 0) return values;
  }
  return [];
}

function applyBookInfoInit($: cheerio.CheerioAPI, root: cheerio.Cheerio<any>, initRule?: string, baseUrl?: string) {
  const putMatch = (initRule || '').match(/@put:\s*\{([\s\S]*)\}\s*$/);
  if (!putMatch) return;
  const body = putMatch[1];
  const entryRegex = /([A-Za-z0-9_$-]+)\s*:\s*"((?:\\.|[^"\\])*)"/g;
  let match: RegExpExecArray | null;
  while ((match = entryRegex.exec(body)) !== null) {
    const key = match[1];
    const selector = match[2].replace(/\\"/g, '"').replace(/\\n/g, '\n');
    variableStore.set(key, readValue($, root, selector, baseUrl));
  }
}

function applyContentJsRule(value: string, jsRule: string): string {
  if (/result\.split\(["']\\n["']\)|<img\s+src=/.test(jsRule)) {
    return value
      .split(/\n+/)
      .map((item) => item.trim())
      .filter(Boolean)
      .map((src) => `<img src="${src}" style="max-width:100%; display:block;" referrerpolicy="no-referrer">`)
      .join('');
  }
  return runJsSnippet(jsRule, { result: value, src: value }) || value;
}

function contentFromRule(raw: string, rule?: string, baseUrl?: string): string {
  const json = parseJsonMaybe(raw);
  if (json && (ruleIsJson(rule) || rule?.trim().startsWith('@js:'))) {
    return readJsonRule(json, rule, undefined, baseUrl);
  }
  const rawRule = rule || '';
  const jsIndex = rawRule.indexOf('@js:');
  const selectorRule = jsIndex >= 0 ? rawRule.slice(0, jsIndex).trim() : rawRule;
  const jsRule = jsIndex >= 0 ? rawRule.slice(jsIndex + 4).trim() : '';
  const $ = cheerio.load(raw);
  if (jsRule) {
    const values = readValues($, $.root(), selectorRule, baseUrl);
    const value = values.length > 0 ? values.join('\n') : readValue($, $.root(), selectorRule, baseUrl);
    return applyContentJsRule(value, jsRule);
  }
  return readValue($, $.root(), selectorRule, baseUrl);
}

function cleanContent(value: string) {
  const decoded = he.decode(value || '').trim();
  if (/<img\b/i.test(decoded)) return decoded;
  return decoded
    .replace(/<br\s*\/?>/gi, '\n')
    .replace(/<\/p>/gi, '\n')
    .replace(/<[^>]+>/g, '')
    .replace(/\r/g, '')
    .split('\n')
    .map((line) => line.trim())
    .filter(Boolean)
    .join('\n\n');
}

function chapterPageStem(url: string) {
  try {
    const parsed = new URL(url);
    parsed.hash = '';
    parsed.search = '';
    parsed.pathname = parsed.pathname.replace(/_\d+(?=\.html?$)/i, '');
    return parsed.toString();
  } catch {
    return url.replace(/_\d+(?=\.html?(?:[?#]|$))/i, '');
  }
}

function proxyChapterImages(content: string, source: BookSource) {
  if (!/<img\b/i.test(content)) return content;
  const rule = source.legado;
  if (rule?.bookSourceType !== 2 && source.legado?.bookSourceType !== 2) return content;
  return content.replace(/<img\b([^>]*?)\bsrc=(['"])(.*?)\2([^>]*)>/gi, (match, before, quote, rawSrc, after) => {
    if (!rawSrc || rawSrc.startsWith('/api/books/image')) return match;
    const optionIndex = rawSrc.indexOf(',{');
    const src = optionIndex > 0 ? rawSrc.slice(0, optionIndex) : rawSrc;
    const options = optionIndex > 0 ? rawSrc.slice(optionIndex + 1) : '';
    const proxied = `/api/books/image?sourceId=${encodeURIComponent(source.id)}&url=${encodeURIComponent(src)}${options ? `&options=${encodeURIComponent(options)}` : ''}`;
    return `<img${before}src=${quote}${proxied}${quote}${after}>`;
  });
}

async function resolveLegadoConfig(): Promise<ResolvedLegadoConfig> {
  let enabled = process.env.OPDS_ENABLED === 'true' || process.env.LEGADO_ENABLED === 'true';
  let sources: BookSource[] = [];
  const cacheTTL = Number(process.env.LEGADO_CACHE_TTL_MS || process.env.OPDS_CACHE_TTL_MS || 10 * 60 * 1000);

  const envJson = process.env.LEGADO_SOURCES_JSON;
  if (envJson) {
    try {
      const parsed = JSON.parse(envJson);
      sources = normalizeImportedSources(parsed);
    } catch {}
  }

  try {
    const config = await getConfig();
    if (config.OPDSConfig) {
      enabled = config.OPDSConfig.Enabled ?? enabled;
      const subscriptionSources = await legadoSubscriptionStore.getSourcesForSubscriptions(config.OPDSConfig.LegadoSubscriptions || []);
      sources = [...sources, ...subscriptionSources];
    }
  } catch {}

  return { enabled, cacheTTL, sources: sources.filter((source) => !!source.url && source.enabled !== false) };
}

export function normalizeImportedSources(input: unknown): BookSource[] {
  const list = Array.isArray(input) ? input : [input];
  return list
    .filter((item): item is LegadoBookSourceRule => !!item && typeof item === 'object')
    .map((rule, index) => {
      const name = rule.bookSourceName || `Legado 书源 ${index + 1}`;
      const url = rule.bookSourceUrl || '';
      return {
        id: `legado_${stableId(`${name}|${url}|${index}`)}`,
        name,
        type: 'legado' as const,
        url,
        enabled: rule.enabled !== false,
        authMode: 'none' as const,
        preferFormat: ['epub' as const],
        language: '',
        legado: rule,
      };
    })
    .filter((source) => !!source.url);
}

function normalizeConfiguredLegadoSource(item: any, index: number): BookSource | null {
  if (!item || typeof item !== 'object') return null;
  if (item.type === 'legado' || item.legado) {
    const rule = item.legado || item;
    const name = item.name || rule.bookSourceName || `Legado 书源 ${index + 1}`;
    const url = item.url || rule.bookSourceUrl || '';
    if (!url) return null;
    return {
      ...item,
      id: item.id || `legado_${stableId(`${name}|${url}|${index}`)}`,
      name,
      type: 'legado',
      url,
      enabled: item.enabled !== false && rule.enabled !== false,
      authMode: item.authMode || 'none',
      legado: { ...rule, bookSourceName: rule.bookSourceName || name, bookSourceUrl: rule.bookSourceUrl || url },
    };
  }
  if (item.bookSourceUrl || item.searchUrl || item.ruleSearch) {
    return normalizeImportedSources([item])[0] || null;
  }
  return null;
}

function wait(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function splitUrlOptions(input: string): RequestOptions {
  const raw = input.trim();
  const comma = raw.indexOf(',');
  if (comma <= 0) return { url: raw };
  const candidate = raw.slice(comma + 1).trim();
  if (!candidate.startsWith('{')) return { url: raw };
  try {
    const options = JSON.parse(candidate);
    return {
      url: raw.slice(0, comma).trim(),
      method: options.method,
      body: options.body,
      headers: options.headers && typeof options.headers === 'object' ? options.headers : undefined,
      charset: options.charset,
      retry: Number.isFinite(Number(options.retry)) ? Number(options.retry) : undefined,
    };
  } catch {
    return { url: raw };
  }
}

function getCookieHeader(sourceId: string) {
  return cookieJar.get(sourceId) || '';
}

function mergeSetCookie(sourceId: string, setCookie: string | null) {
  if (!setCookie) return;
  const current = new Map<string, string>();
  (cookieJar.get(sourceId) || '').split(/;\s*/).filter(Boolean).forEach((item) => {
    const idx = item.indexOf('=');
    if (idx > 0) current.set(item.slice(0, idx), item.slice(idx + 1));
  });
  setCookie.split(/,(?=\s*[^;,]+=)/).forEach((cookie) => {
    const pair = cookie.split(';')[0]?.trim();
    const idx = pair?.indexOf('=') ?? -1;
    if (idx > 0) current.set(pair.slice(0, idx), pair.slice(idx + 1));
  });
  cookieJar.set(sourceId, Array.from(current.entries()).map(([key, value]) => `${key}=${value}`).join('; '));
}

async function fetchText(source: BookSource, url: string): Promise<string> {
  if (!url?.trim()) throw new Error('书源请求地址为空');
  const request = splitUrlOptions(url);
  const safe = await validateProxyUrlServerSide(request.url);
  if (!safe) throw new Error(`书源地址未通过安全校验: ${request.url}`);
  const cacheKey = `text|${source.id}|${request.method || 'GET'}|${request.url}|${request.body || ''}`;
  const cached = textCache.get(cacheKey);
  const { cacheTTL } = await resolveLegadoConfig();
  if (cached && cached.expiresAt > Date.now()) return cached.data;

  let lastError: unknown;
  const maxAttempts = Math.max(1, (request.retry ?? 2) + 1);
  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
    try {
      const headers: Record<string, string> = {
        ...(buildHeaders(source) as Record<string, string>),
        ...(request.headers || {}),
      };
      const cookie = getCookieHeader(source.id);
      if (source.legado?.enabledCookieJar && cookie) headers.Cookie = cookie;
      const method = (request.method || (request.body ? 'POST' : 'GET')).toUpperCase();
      const response = await fetch(request.url, {
        method,
        headers,
        body: method === 'GET' || method === 'HEAD' ? undefined : request.body,
        signal: controller.signal,
        cache: 'no-store',
      });
      if (source.legado?.enabledCookieJar) mergeSetCookie(source.id, response.headers.get('set-cookie'));
      if (!response.ok) throw new Error(`请求失败: ${response.status}`);
      const contentLength = Number(response.headers.get('content-length') || '0');
      if (contentLength > MAX_TEXT_BYTES) throw new Error('响应内容过大');
      const buffer = await response.arrayBuffer();
      const contentType = response.headers.get('content-type') || '';
      const charset = request.charset || contentType.match(/charset=([^;]+)/i)?.[1]?.trim().replace(/^['"]|['"]$/g, '');
      const decoderName = /gbk|gb2312|gb18030/i.test(charset || '') ? 'gb18030' : (charset || 'utf-8');
      let text: string;
      try {
        text = new TextDecoder(decoderName).decode(buffer);
      } catch {
        text = new TextDecoder('utf-8').decode(buffer);
      }
      if (text.length > MAX_TEXT_BYTES) throw new Error('响应内容过大');
      textCache.set(cacheKey, { data: text, expiresAt: Date.now() + cacheTTL });
      return text;
    } catch (error) {
      lastError = error;
      if (attempt < maxAttempts - 1) await wait(300 * (attempt + 1));
    } finally {
      clearTimeout(timeout);
    }
  }
  throw lastError instanceof Error ? lastError : new Error('请求失败');
}

async function getSourceById(sourceId: string): Promise<BookSource> {
  const config = await resolveLegadoConfig();
  const source = config.sources.find((item) => item.id === sourceId);
  if (!source) throw new Error('未找到对应的 Legado 书源');
  return source;
}

function getRule(source: BookSource): LegadoBookSourceRule {
  if (!source.legado) throw new Error('Legado 书源缺少规则');
  return source.legado;
}

function makeItem(source: BookSource, partial: Partial<BookListItem> & { detailHref?: string; title?: string }): BookListItem {
  const detailHref = partial.detailHref || '';
  return {
    id: partial.id || stableId(`${source.id}|${detailHref || partial.title || Date.now()}`),
    sourceId: source.id,
    sourceName: source.name,
    title: partial.title || '未命名电子书',
    author: partial.author,
    cover: partial.cover,
    summary: partial.summary,
    tags: partial.tags,
    detailHref,
    acquisitionLinks: partial.acquisitionLinks || [],
  };
}

interface ExploreTarget {
  title: string;
  template: string;
  page: number;
}

function hasRuleBookList(rule?: LegadoRuleSearch) {
  return !!rule?.bookList?.trim();
}

function getEffectiveExploreRule(rule: LegadoBookSourceRule): LegadoRuleSearch | undefined {
  if (hasRuleBookList(rule.ruleExplore)) return rule.ruleExplore;
  if (hasRuleBookList(rule.ruleSearch)) return rule.ruleSearch;
  return undefined;
}

function hasExplore(rule: LegadoBookSourceRule) {
  return rule.enabledExplore !== false && (!!rule.exploreUrl?.trim().startsWith('@js:') || parseExploreUrl(rule.exploreUrl).length > 0) && !!getEffectiveExploreRule(rule);
}

function parseExploreUrl(exploreUrl?: string): Array<{ title: string; template: string }> {
  const raw = (exploreUrl || '').trim();
  if (!raw) return [];
  if (raw.startsWith('@js:')) return [];
  const json = parseJsonMaybe(raw);
  if (Array.isArray(json)) {
    return json
      .map((item) => ({ title: jsonPrimitiveToString(item?.title), template: jsonPrimitiveToString(item?.url) || `__group__:${jsonPrimitiveToString(item?.title)}` }))
      .filter((item) => !!item.title);
  }
  return raw
    .split('&&')
    .map((item) => item.trim())
    .filter(Boolean)
    .map((item) => {
      const index = item.indexOf('::');
      if (index >= 0) return { title: item.slice(0, index).trim(), template: item.slice(index + 2).trim() };
      return { title: item, template: item };
    })
    .filter((item) => !!item.template);
}

function encodeExploreTarget(target: ExploreTarget) {
  return `legado-explore:${Buffer.from(JSON.stringify(target), 'utf8').toString('base64url')}`;
}

function decodeExploreTarget(href?: string): ExploreTarget | null {
  if (!href?.startsWith('legado-explore:')) return null;
  try {
    const raw = Buffer.from(href.slice('legado-explore:'.length), 'base64url').toString('utf8');
    const parsed = JSON.parse(raw);
    if (!parsed?.template) return null;
    return { title: parsed.title || '分类', template: parsed.template, page: Number(parsed.page || 1) || 1 };
  } catch {
    return null;
  }
}

function buildExploreTargetUrl(source: BookSource, target: ExploreTarget) {
  return buildUrlFromTemplate(target.template, source, undefined, target.page);
}

async function resolveExploreCategories(source: BookSource, rule: LegadoBookSourceRule): Promise<Array<{ title: string; template: string }>> {
  const raw = (rule.exploreUrl || '').trim();
  if (!raw.startsWith('@js:')) return parseExploreUrl(raw);
  try {
    const html = await fetchText(source, sourceBase(source));
    const $ = cheerio.load(html);
    const categories = $('a[href^="/list"]').toArray().map((el) => {
      const title = $(el).text().trim();
      const href = ($(el).attr('href') || '').replace(/\/$/, '-{{page}}/');
      return title && href ? { title, template: href } : null;
    }).filter(Boolean) as Array<{ title: string; template: string }>;
    if (categories.length > 0) return [{ title: '全部分类', template: '__group__:全部分类' }, ...categories];
  } catch {
    // 动态分类首页被源站拦截时，至少不要把 @js 当成分类项显示。
  }
  return [];
}

export class LegadoClient {
  async getSources(): Promise<BookSource[]> {
    const config = await resolveLegadoConfig();
    if (!config.enabled) return [];
    return config.sources.map((source) => ({
      ...source,
      capabilities: {
        searchSupported: !!source.legado?.searchUrl,
        catalogSupported: hasExplore(source.legado || {}),
        searchMode: source.legado?.searchUrl ? 'legado' : 'disabled',
        catalogMode: hasExplore(source.legado || {}) ? 'legado' : 'disabled',
        acquisitionTypes: ['application/x-legado-chapters+json'],
        lastCheckedAt: Date.now(),
      },
    }));
  }

  async getSearchSources(sourceId?: string): Promise<BookSource[]> {
    return sourceId ? [await getSourceById(sourceId)] : (await resolveLegadoConfig()).sources;
  }

  async searchBooksSource(q: string, source: BookSource): Promise<{ source: BookSource; results: BookListItem[] }> {
    const rule = getRule(source);
    if (!rule.searchUrl || !rule.ruleSearch?.bookList) throw new Error('该 Legado 书源不支持搜索');
    const cacheKey = `search|${source.id}|${q}`;
    const { cacheTTL } = await resolveLegadoConfig();
    const cached = searchCache.get(cacheKey);
    if (cached && cached.expiresAt > Date.now()) return { source, results: cached.data };

    const results: BookListItem[] = [];
    const seen = new Set<string>();
    for (let page = 1; page <= DEFAULT_LEGADO_SEARCH_PAGES; page += 1) {
      const targetUrl = buildUrlFromTemplate(rule.searchUrl, source, q, page);
      const html = await fetchText(source, targetUrl);
      applyRuleJsBlocks(html, rule.ruleSearch.bookList);
      if (page === 1 && rule.ruleSearch.checkKeyWord && !html.includes(rule.ruleSearch.checkKeyWord) && !html.includes(q)) {
        throw new Error('搜索结果校验失败');
      }
      let pageCount = 0;
      const json = parseJsonMaybe(html);
      const searchBookListRule = stripRuleJsBlocks(rule.ruleSearch.bookList);
      if (json && ruleIsJson(searchBookListRule)) {
        const items = selectJsonItems(json, searchBookListRule);
        pageCount = items.length;
        items.forEach((item) => {
          const detailHref = readJsonRule(item, rule.ruleSearch?.bookUrl, source, targetUrl);
          const title = readJsonRule(item, rule.ruleSearch?.name, source, targetUrl);
          if (!title && !detailHref) return;
          const cover = readJsonRule(item, rule.ruleSearch?.coverUrl, source, targetUrl);
          const itemId = jsonPrimitiveToString(item?.id) || undefined;
          const dedupeKey = itemId || detailHref || `${title}|${cover}`;
          if (dedupeKey && seen.has(dedupeKey)) return;
          if (dedupeKey) seen.add(dedupeKey);
          results.push(makeItem(source, {
            id: itemId,
            title,
            author: readJsonRule(item, rule.ruleSearch?.author, source, targetUrl),
            summary: readJsonRule(item, rule.ruleSearch?.intro, source, targetUrl),
            cover: cover || undefined,
            detailHref,
            tags: readJsonRule(item, rule.ruleSearch?.kind, source, targetUrl).split(/[,，\s]+/).filter(Boolean),
          }));
        });
      } else if (searchBookListRule.trim().startsWith(':')) {
        const items = readAllInOneList(html, searchBookListRule);
        pageCount = items.length;
        items.forEach((item) => {
          const detailHref = readRegexItem(item, rule.ruleSearch?.bookUrl, targetUrl);
          const title = readRegexItem(item, rule.ruleSearch?.name, targetUrl);
          if (!title && !detailHref) return;
          const cover = readRegexItem(item, rule.ruleSearch?.coverUrl, targetUrl);
          const dedupeKey = detailHref || `${title}|${cover}`;
          if (dedupeKey && seen.has(dedupeKey)) return;
          if (dedupeKey) seen.add(dedupeKey);
          results.push(makeItem(source, {
            id: detailHref || undefined,
            title,
            author: readRegexItem(item, rule.ruleSearch?.author, targetUrl),
            summary: readRegexItem(item, rule.ruleSearch?.intro, targetUrl),
            cover: cover || undefined,
            detailHref,
            tags: readRegexItem(item, rule.ruleSearch?.kind, targetUrl).split(/[,，\s]+/).filter(Boolean),
          }));
        });
      } else {
        const $ = cheerio.load(html);
        const items = selectElements($, $.root(), searchBookListRule);
        pageCount = items.length;
        items.each((_, element) => {
          const root = $(element);
          const detailHref = readValue($, root, rule.ruleSearch?.bookUrl, targetUrl, { source: rule });
          const title = readValue($, root, rule.ruleSearch?.name, targetUrl);
          if (!title && !detailHref) return;
          const cover = readValue($, root, rule.ruleSearch?.coverUrl, targetUrl);
          const dedupeKey = detailHref || `${title}|${cover}`;
          if (dedupeKey && seen.has(dedupeKey)) return;
          if (dedupeKey) seen.add(dedupeKey);
          results.push(makeItem(source, {
            id: detailHref || undefined,
            title,
            author: readValue($, root, rule.ruleSearch?.author, targetUrl),
            summary: readValue($, root, rule.ruleSearch?.intro, targetUrl),
            cover: cover || undefined,
            detailHref,
            tags: readValue($, root, rule.ruleSearch?.kind, targetUrl).split(/[,，\s]+/).filter(Boolean),
          }));
        });
      }
      if (pageCount === 0) break;
    }
    searchCache.set(cacheKey, { data: results, expiresAt: Date.now() + cacheTTL });
    return { source, results };
  }

  async searchBooks(q: string, sourceId?: string): Promise<BookSearchResult> {
    const sources = await this.getSearchSources(sourceId);
    const results: BookListItem[] = [];
    const failedSources: BookSearchFailure[] = [];
    await Promise.all(sources.map(async (source) => {
      try {
        const sourceResult = await this.searchBooksSource(q, source);
        results.push(...sourceResult.results);
      } catch (error) {
        failedSources.push({ sourceId: source.id, sourceName: source.name, error: (error as Error).message });
      }
    }));
    return { results, failedSources };
  }

  async getCatalog(sourceId: string, href?: string): Promise<BookCatalogResult> {
    const source = await getSourceById(sourceId);
    const rule = getRule(source);
    if (!hasExplore(rule)) {
      return { sourceId: source.id, sourceName: source.name, title: source.name, href: href || source.url, entries: [], navigation: [] };
    }

    const categories = await resolveExploreCategories(source, rule);
    const target = decodeExploreTarget(href) || null;
    const navigation = categories.map((item) => ({
      title: item.title,
      href: item.template.startsWith('__group__:') ? '' : encodeExploreTarget({ title: item.title, template: item.template, page: 1 }),
      rel: item.template.startsWith('__group__:') ? 'legado:group' : 'legado:explore',
      type: 'application/x-legado-explore',
    }));

    if (!target) {
      return { sourceId: source.id, sourceName: source.name, title: source.name, subtitle: '请选择分类', href: href || source.url, entries: [], navigation };
    }

    if (target.template.startsWith('__group__:')) {
      return { sourceId: source.id, sourceName: source.name, title: target.title, href: href || '', entries: [], navigation };
    }
    const targetUrl = buildExploreTargetUrl(source, target);
    const html = await fetchText(source, targetUrl);
    const exploreRule = getEffectiveExploreRule(rule);
    const entries: BookListItem[] = [];
    let pageCount = 0;
    const json = parseJsonMaybe(html);
    if (json && ruleIsJson(exploreRule?.bookList)) {
      const items = selectJsonItems(json, exploreRule?.bookList);
      pageCount = items.length;
      items.forEach((item) => {
        const detailHref = readJsonRule(item, exploreRule?.bookUrl, source, targetUrl);
        const title = readJsonRule(item, exploreRule?.name, source, targetUrl);
        if (!title && !detailHref) return;
        const cover = readJsonRule(item, exploreRule?.coverUrl, source, targetUrl);
        entries.push(makeItem(source, {
          id: jsonPrimitiveToString(item?.id) || detailHref || undefined,
          title,
          author: readJsonRule(item, exploreRule?.author, source, targetUrl),
          summary: readJsonRule(item, exploreRule?.intro, source, targetUrl),
          cover: cover || undefined,
          detailHref,
          tags: readJsonRule(item, exploreRule?.kind, source, targetUrl).split(/[,，\s]+/).filter(Boolean),
        }));
      });
    } else {
      const $ = cheerio.load(html);
      const items = selectElements($, $.root(), exploreRule?.bookList);
      pageCount = items.length;
      items.each((_, element) => {
        const root = $(element);
        const detailHref = readValue($, root, exploreRule?.bookUrl, targetUrl);
        const title = readValue($, root, exploreRule?.name, targetUrl);
        if (!title && !detailHref) return;
        const cover = readValue($, root, exploreRule?.coverUrl, targetUrl);
        entries.push(makeItem(source, {
          id: detailHref || undefined,
          title,
          author: readValue($, root, exploreRule?.author, targetUrl),
          summary: readValue($, root, exploreRule?.intro, targetUrl),
          cover: cover || undefined,
          detailHref,
          tags: readValue($, root, exploreRule?.kind, targetUrl).split(/[,，\s]+/).filter(Boolean),
        }));
      });
    }

    return {
      sourceId: source.id,
      sourceName: source.name,
      title: target.title || source.name,
      subtitle: `第 ${target.page} 页`,
      href: href || encodeExploreTarget(target),
      entries,
      navigation,
      nextHref: pageCount > 0 ? encodeExploreTarget({ ...target, page: target.page + 1 }) : undefined,
      previousHref: target.page > 1 ? encodeExploreTarget({ ...target, page: target.page - 1 }) : undefined,
    };
  }

  async getChaptersByBookId(sourceId: string, bookId: string): Promise<BookChapter[]> {
    const source = await getSourceById(sourceId);
    const rule = getRule(source);
    const base = sourceBase(source);
    const searchBookUrlRule = rule.ruleSearch?.bookUrl || '';
    const detailHref = /^https?:\/\//i.test(bookId) || bookId.startsWith('/')
      ? normalizeUrl(base, bookId)
      : /\{\{\s*(?:\$\.id|id)\s*\}\}|\{id\}/.test(searchBookUrlRule)
        ? normalizeUrl(base, searchBookUrlRule
          .replace(/\{\{\s*\$\.id\s*\}\}/g, encodeURIComponent(bookId))
          .replace(/\{\{\s*id\s*\}\}/g, encodeURIComponent(bookId))
          .replace(/\{id\}/g, encodeURIComponent(bookId)))
        : '';
    if (!detailHref) throw new Error('该 Legado 书源无法通过 bookId 定位详情，请重新搜索后打开');
    const detail = await this.getBookDetail(sourceId, detailHref, { id: bookId, detailHref });
    const tocHref = detail.acquisitionLinks.find((item) => item.rel === 'legado:chapters' || item.type.toLowerCase().includes('legado-chapters'))?.href;
    if (!tocHref) return [];
    return this.getChapters(sourceId, tocHref);
  }

  async getBookDetail(sourceId: string, href: string, fallback?: Partial<BookDetail>): Promise<BookDetail> {
    const source = await getSourceById(sourceId);
    const rule = getRule(source);
    const detailHref = href || fallback?.detailHref || '';
    const cacheKey = `detail|${source.id}|${detailHref}`;
    const { cacheTTL } = await resolveLegadoConfig();
    const cached = detailCache.get(cacheKey);
    if (cached && cached.expiresAt > Date.now()) return { ...cached.data, ...(!href && fallback ? fallback : {}) };

    let detail: BookDetail | null = null;
    if (detailHref && rule.ruleBookInfo) {
      const targetUrl = rule.bookInfoUrl ? buildUrlFromTemplate(rule.bookInfoUrl, source, undefined, 1, detailHref).replace(/\{bookUrl\}/g, encodeURIComponent(detailHref)) : detailHref;
      const html = await fetchText(source, targetUrl);
      const initData = rule.bookInfoInit?.trim().startsWith(':') ? readAllInOneList(html, rule.bookInfoInit)[0] : null;
      const json = initData || parseJsonMaybe(html);
      const $ = json && initData ? null : json ? null : cheerio.load(html);
      const root = $?.root();
      if ($ && root) applyBookInfoInit($, root, (rule.ruleBookInfo as any).init || rule.bookInfoInit, targetUrl);
      const read = (itemRule?: string) => initData
        ? readRegexItem(initData, itemRule, targetUrl)
        : json
          ? readJsonRule(json, itemRule, source, targetUrl)
          : readValue($ as cheerio.CheerioAPI, root as cheerio.Cheerio<any>, itemRule, targetUrl);
      const tocUrl = read(rule.ruleBookInfo.tocUrl) || (rule.tocUrl ? buildUrlFromTemplate(rule.tocUrl, source, undefined, 1, detailHref).replace(/\{bookUrl\}/g, encodeURIComponent(detailHref)) : targetUrl);
      const cover = read(rule.ruleBookInfo.coverUrl) || fallback?.cover;
      const title = read(rule.ruleBookInfo.name) || fallback?.title || '未命名电子书';
      const chapterCountText = json
        ? jsonPrimitiveToString(readJsonPath(json, '@json:$.data.nums') ?? readJsonPath(json, '@json:$.data.chapter_nums'))
        : '';
      const chapterCount = chapterCountText ? Number(chapterCountText) : NaN;
      const hasKnownEmptyChapters = Number.isFinite(chapterCount) && chapterCount <= 0;
      const acquisitionLinks: BookAcquisitionLink[] = hasKnownEmptyChapters ? [] : [{ rel: 'legado:chapters', type: 'application/x-legado-chapters+json', href: tocUrl, title: '章节目录' }];
      detail = {
        id: fallback?.id || stableId(`${source.id}|${detailHref || title}`),
        sourceId,
        sourceName: source.name,
        title,
        author: read(rule.ruleBookInfo.author) || fallback?.author,
        cover: cover || undefined,
        summary: read(rule.ruleBookInfo.intro) || fallback?.summary,
        tags: read(rule.ruleBookInfo.kind).split(/[,，\s]+/).filter(Boolean),
        categories: read(rule.ruleBookInfo.kind).split(/[,，\s]+/).filter(Boolean),
        detailHref,
        acquisitionLinks,
        navigation: hasKnownEmptyChapters ? [] : [{ title: '目录', href: tocUrl, rel: 'legado:toc', type: 'application/x-legado-chapters+json' }],
      };
    }

    if (!detail) {
      const tocUrl = fallback?.acquisitionLinks?.[0]?.href || detailHref;
      detail = {
        id: fallback?.id || stableId(`${source.id}|${detailHref || fallback?.title || ''}`),
        sourceId,
        sourceName: source.name,
        title: fallback?.title || '未命名电子书',
        author: fallback?.author,
        cover: fallback?.cover,
        summary: fallback?.summary,
        detailHref,
        acquisitionLinks: [{ rel: 'legado:chapters', type: 'application/x-legado-chapters+json', href: tocUrl, title: '章节目录' }],
        navigation: [{ title: '目录', href: tocUrl, rel: 'legado:toc', type: 'application/x-legado-chapters+json' }],
      };
    }
    detailCache.set(cacheKey, { data: detail, expiresAt: Date.now() + cacheTTL });
    return detail;
  }

  async getChapters(sourceId: string, tocHref: string): Promise<BookChapter[]> {
    const source = await getSourceById(sourceId);
    const rule = getRule(source);
    if (!rule.ruleToc?.chapterList) throw new Error('该 Legado 书源缺少目录规则');
    const cacheKey = `toc|${source.id}|${tocHref}`;
    const { cacheTTL } = await resolveLegadoConfig();
    const cached = tocCache.get(cacheKey);
    if (cached && cached.expiresAt > Date.now()) return cached.data;

    const targetUrl = normalizeUrl(sourceBase(source), tocHref);
    const html = await fetchText(source, targetUrl);
    const chapters: BookChapter[] = [];
    const json = parseJsonMaybe(html);
    if (json && ruleIsJson(rule.ruleToc.chapterList)) {
      const items = selectJsonItems(json, rule.ruleToc.chapterList);
      items.forEach((item, index) => {
        const title = readJsonRule(item, rule.ruleToc?.chapterName, source, targetUrl) || `第 ${index + 1} 章`;
        const href = readJsonRule(item, rule.ruleToc?.chapterUrl, source, targetUrl)
          || fallbackChapterHrefFromItem(item, rule.ruleToc?.chapterUrl, targetUrl);
        if (!href) return;
        const normalizedHref = normalizeUrl(targetUrl, href);
        chapters.push({ id: stableId(`${source.id}|${normalizedHref}`), title, href: normalizedHref, order: index });
      });
    } else {
      const $ = cheerio.load(html);
      const items = selectElements($, $.root(), rule.ruleToc.chapterList);
      items.each((index, element) => {
        const root = $(element);
        const title = readValue($, root, rule.ruleToc?.chapterName, targetUrl) || `第 ${index + 1} 章`;
        const href = readValue($, root, rule.ruleToc?.chapterUrl, targetUrl) || root.attr('href') || '';
        if (!href) return;
        const normalizedHref = normalizeUrl(targetUrl, href);
        chapters.push({ id: stableId(`${source.id}|${normalizedHref}`), title, href: normalizedHref, order: index });
      });
    }
    if (rule.ruleToc.nextTocUrl) {
      let nextTocUrl = contentFromRule(html, rule.ruleToc.nextTocUrl, targetUrl);
      const visited = new Set([targetUrl]);
      for (let page = 0; page < 8 && nextTocUrl; page += 1) {
        const normalizedNext = normalizeUrl(targetUrl, nextTocUrl);
        if (!normalizedNext || visited.has(normalizedNext)) break;
        visited.add(normalizedNext);
        const nextHtml = await fetchText(source, normalizedNext);
        const $next = cheerio.load(nextHtml);
        const nextItems = selectElements($next, $next.root(), rule.ruleToc.chapterList);
        nextItems.each((index, element) => {
          const root = $next(element);
          const title = readValue($next, root, rule.ruleToc?.chapterName, normalizedNext) || `第 ${chapters.length + index + 1} 章`;
          const href = readValue($next, root, rule.ruleToc?.chapterUrl, normalizedNext) || root.attr('href') || '';
          if (!href) return;
          const normalizedHref = normalizeUrl(normalizedNext, href);
          chapters.push({ id: stableId(`${source.id}|${normalizedHref}`), title, href: normalizedHref, order: chapters.length });
        });
        nextTocUrl = contentFromRule(nextHtml, rule.ruleToc.nextTocUrl, normalizedNext);
      }
    }
    tocCache.set(cacheKey, { data: chapters, expiresAt: Date.now() + cacheTTL });
    return chapters;
  }

  async getChapterContent(sourceId: string, chapterHref: string, tocHref?: string): Promise<BookChapterContent> {
    const source = await getSourceById(sourceId);
    const rule = getRule(source);
    if (!rule.ruleContent?.content) throw new Error('该 Legado 书源缺少正文规则');
    const targetUrl = normalizeUrl(sourceBase(source), chapterHref);
    const cacheKey = `chapter|${source.id}|${targetUrl}`;
    const cached = chapterCache.get(cacheKey);
    if (cached && cached.expiresAt > Date.now()) return cached.data;

    let pageUrl = targetUrl;
    const parts: string[] = [];
    const visited = new Set<string>();
    for (let page = 0; page < 8 && pageUrl && !visited.has(pageUrl); page += 1) {
      visited.add(pageUrl);
      const html = await fetchText(source, pageUrl);
      const part = contentFromRule(html, rule.ruleContent.content, pageUrl);
      if (part) parts.push(part);
      const next = rule.ruleContent.nextContentUrl ? contentFromRule(html, rule.ruleContent.nextContentUrl, pageUrl) : '';
      const normalizedNext = next ? normalizeUrl(pageUrl, next) : '';
      if (!normalizedNext || normalizedNext === pageUrl || visited.has(normalizedNext)) break;
      if (chapterPageStem(normalizedNext) !== chapterPageStem(targetUrl)) break;
      pageUrl = normalizedNext;
    }
    const rawContent = parts.join('\\n\\n');
    const chapters = tocHref ? await this.getChapters(sourceId, tocHref).catch(() => []) : [];
    const index = chapters.findIndex((item) => item.href === targetUrl || item.href === chapterHref);
    const content: BookChapterContent = {
      id: stableId(`${source.id}|${targetUrl}`),
      title: index >= 0 ? chapters[index].title : '',
      href: targetUrl,
      content: proxyChapterImages(cleanContent(applyRuleFilters(rawContent, [
        ...(rule.ruleContent.sourceRegex ? [rule.ruleContent.sourceRegex, ''] : []),
        ...((rule.ruleContent as any).replaceRegex ? splitRuleFilters((rule.ruleContent as any).replaceRegex).filters : []),
      ])), source),
      previousHref: index > 0 ? chapters[index - 1].href : undefined,
      nextHref: index >= 0 && index + 1 < chapters.length ? chapters[index + 1].href : undefined,
    };
    chapterCache.set(cacheKey, { data: content, expiresAt: Date.now() + 24 * 60 * 60 * 1000 });
    return content;
  }

  async getSourceById(sourceId: string): Promise<BookSource> {
    return getSourceById(sourceId);
  }

  async detectCapabilitiesFromSource(source: BookSource): Promise<BookSourceCapabilities> {
    return {
      searchSupported: !!source.legado?.searchUrl,
      catalogSupported: hasExplore(source.legado || {}),
      searchMode: source.legado?.searchUrl ? 'legado' : 'disabled',
      catalogMode: hasExplore(source.legado || {}) ? 'legado' : 'disabled',
      acquisitionTypes: ['application/x-legado-chapters+json'],
      lastCheckedAt: Date.now(),
    };
  }
}

export const legadoClient = new LegadoClient();