// ========== 全局配置与工具函数 ==========
const corsHeaders = {
  "Access-Control-Allow-Methods": "GET, POST, PUT, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type, Authorization",
  "Access-Control-Max-Age": "86400"
};

const pageSecurityHeaders = {
  "Cache-Control": "no-store",
  "Content-Security-Policy": "default-src 'self'; script-src 'self' 'unsafe-inline' https://static.cloudflareinsights.com; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https://cloudflareinsights.com; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'",
  "Permissions-Policy": "camera=(), microphone=(), geolocation=()",
  "Referrer-Policy": "same-origin",
  "X-Content-Type-Options": "nosniff",
  "X-Frame-Options": "DENY"
};

const APP_ICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#176b5b" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></svg>`;
const CONFIG_CACHE_TTL = 300000;
const LOGIN_WINDOW_SECONDS = 900;
const LOGIN_MAX_FAILURES = 5;
const LOGIN_BLOCK_SECONDS = 900;
const MAX_FILE_NAME_BYTES = 255;
const DEFAULT_PAGE_SIZE = 20;
const MAX_PAGE_SIZE = 100;
const MULTIPART_PART_SIZE = 32 * 1024 * 1024;
const MAX_MULTIPART_SIZE = 1024 * 1024 * 1024;
const MAX_MULTIPART_PARTS = 10000;
const MULTIPART_TTL_SECONDS = 7 * 24 * 60 * 60;
const LATEST_SCHEMA_VERSION = 2;
const SHARE_PATH_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
const RESERVED_SHARE_PATHS = new Set(["api", "init", "app-icon", "favicon", "robots", "sitemap"]);
const KNOWN_PREVIEW_TYPES = {
  jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif",
  bmp: "image/bmp", webp: "image/webp", avif: "image/avif", ico: "image/x-icon", svg: "image/svg+xml",
  pdf: "application/pdf", txt: "text/plain", log: "text/plain", csv: "text/csv", md: "text/markdown",
  json: "application/json", xml: "application/xml", html: "text/html", htm: "text/html",
  css: "text/css", js: "text/javascript",
  mp4: "video/mp4", m4v: "video/mp4", webm: "video/webm", mkv: "video/x-matroska",
  ogg: "video/ogg", ogv: "video/ogg", mov: "video/quicktime", m3u8: "application/vnd.apple.mpegurl",
  mp3: "audio/mpeg", wav: "audio/wav", flac: "audio/flac", aac: "audio/aac",
  m4a: "audio/mp4", oga: "audio/ogg", opus: "audio/ogg", weba: "audio/webm"
};
const DEFAULT_PREVIEW_EXTENSIONS = "jpg,jpeg,png,gif,bmp,webp,ico,mp4,webm,ogg,ogv,mov,mp3,wav,flac,aac,weba";
const DEFAULT_APP_CONFIG = {
  site_name: "langaj.cn 私有云",
  favicon: "/app-icon.svg",
  max_multipart_size: String(MAX_MULTIPART_SIZE),
  max_total_size: String(6 * 1024 * 1024 * 1024),
  daily_max_a_class: "300",
  user_download_ttl: "600",
  preview_extensions: DEFAULT_PREVIEW_EXTENSIONS,
  preview_mime_types: "{}"
};

let configCache = null;
let configCacheTime = 0;
let configCacheSource = null;
let appConfigCache = null;
let appConfigCacheTime = 0;
let jwtKeyCache = null;
let downloadKeyCache = null;

class HttpError extends Error {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

function jsonResponse(data, status = 200, headers = {}) {
  return new Response(JSON.stringify(data), {
    status,
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Cache-Control": "no-store",
      "X-Content-Type-Options": "nosniff",
      ...corsHeaders,
      ...headers
    }
  });
}

function textResponse(text, status = 200, headers = {}) {
  return new Response(text, {
    status,
    headers: { "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", ...corsHeaders, ...headers }
  });
}

function bytesToBase64Url(bytes) {
  return btoa(String.fromCharCode(...bytes))
    .replace(/\+/g, "-")
    .replace(/\//g, "_")
    .replace(/=+$/g, "");
}

function base64UrlToBytes(value) {
  const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
  return Uint8Array.from(atob(padded), char => char.charCodeAt(0));
}

function encodeText(value) {
  return bytesToBase64Url(new TextEncoder().encode(value));
}

function decodeText(value) {
  return new TextDecoder().decode(base64UrlToBytes(value));
}

function encodeCursor(uploadedAt, key) {
  return encodeText(JSON.stringify({ uploadedAt, key }));
}

function decodeCursor(value) {
  if (!value) return null;
  try {
    const cursor = JSON.parse(decodeText(value));
    if (typeof cursor.uploadedAt !== "string" || typeof cursor.key !== "string") throw new Error();
    return cursor;
  } catch {
    throw new HttpError(400, "分页游标无效");
  }
}

function parsePositiveInt(value, fallback, max = Number.MAX_SAFE_INTEGER) {
  const parsed = Number.parseInt(value, 10);
  return Number.isSafeInteger(parsed) && parsed > 0 ? Math.min(parsed, max) : fallback;
}

function getFileExtension(fileName) {
  const index = fileName.lastIndexOf(".");
  return index > -1 ? fileName.slice(index + 1).toLowerCase() : "";
}

function isPreviewable(fileName, previewExts) {
  const extension = getFileExtension(fileName);
  return previewExts.includes(extension);
}

function normalizeContentType(value) {
  if (typeof value !== "string") return "";
  const contentType = value.trim().toLowerCase();
  return contentType.length <= 127 && /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/.test(contentType)
    ? contentType
    : "";
}

function getMappedContentType(map, extension) {
  return map && Object.prototype.hasOwnProperty.call(map, extension) ? map[extension] : "";
}

function getPreviewType(fileName, previewExts, previewMimeTypes, storedContentType = "") {
  if (!isPreviewable(fileName, previewExts)) return null;
  const extension = getFileExtension(fileName);
  const contentType = normalizeContentType(storedContentType);
  return getMappedContentType(previewMimeTypes, extension)
    || getMappedContentType(KNOWN_PREVIEW_TYPES, extension)
    || contentType
    || "application/octet-stream";
}

function normalizeFileName(value) {
  if (typeof value !== "string") throw new HttpError(400, "文件名无效");
  const fileName = value.normalize("NFC").trim();
  if (!fileName || /[\u0000-\u001f\u007f]/.test(fileName)) throw new HttpError(400, "文件名无效");
  if (new TextEncoder().encode(fileName).length > MAX_FILE_NAME_BYTES) throw new HttpError(400, "文件名过长");
  return fileName;
}

function createObjectKey(fileName) {
  return `pan/${crypto.randomUUID()}~${encodeText(fileName)}`;
}

function parseFileNameFromKey(key) {
  const modernIndex = key.indexOf("~");
  if (modernIndex > -1) {
    try { return decodeText(key.slice(modernIndex + 1)); } catch { return key; }
  }
  const legacyIndex = key.indexOf("-");
  if (legacyIndex === -1) return key;
  try {
    return decodeURIComponent(escape(atob(key.slice(legacyIndex + 1))));
  } catch {
    return key;
  }
}

function randomToken(byteLength = 16) {
  const bytes = new Uint8Array(byteLength);
  crypto.getRandomValues(bytes);
  return bytesToBase64Url(bytes);
}

function validateSharePath(value) {
  if (typeof value !== "string" || !SHARE_PATH_PATTERN.test(value) || RESERVED_SHARE_PATHS.has(value.toLowerCase())) {
    throw new HttpError(400, "分享路径需为 1-64 位字母、数字、下划线或连字符");
  }
  return value;
}

function getPathToken(path) {
  if (path.length <= 1 || path.slice(1).includes("/")) return null;
  try { return decodeURIComponent(path.slice(1)); } catch { return null; }
}

function escapeHtml(value) {
  return String(value)
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#39;");
}

function normalizeFavicon(value) {
  if (!value || value === "/app-icon.svg") return "/app-icon.svg";
  try {
    const url = new URL(value);
    if (url.protocol !== "https:") throw new Error();
    return url.href;
  } catch {
    throw new HttpError(400, "图标链接必须是 HTTPS 地址");
  }
}

async function importHmacKey(secret, currentCache) {
  if (typeof secret !== "string" || secret.length < 32) throw new HttpError(503, "签名密钥未配置或长度不足");
  if (currentCache?.secret === secret) return currentCache;
  const key = await crypto.subtle.importKey(
    "raw",
    new TextEncoder().encode(secret),
    { name: "HMAC", hash: "SHA-256" },
    false,
    ["sign", "verify"]
  );
  return { secret, key };
}

async function signValue(value, secret, cacheType) {
  if (cacheType === "jwt") {
    jwtKeyCache = await importHmacKey(secret, jwtKeyCache);
    return bytesToBase64Url(new Uint8Array(await crypto.subtle.sign("HMAC", jwtKeyCache.key, new TextEncoder().encode(value))));
  }
  downloadKeyCache = await importHmacKey(secret, downloadKeyCache);
  return bytesToBase64Url(new Uint8Array(await crypto.subtle.sign("HMAC", downloadKeyCache.key, new TextEncoder().encode(value))));
}

async function verifyValue(value, signature, secret, cacheType) {
  try {
    if (cacheType === "jwt") {
      jwtKeyCache = await importHmacKey(secret, jwtKeyCache);
      return crypto.subtle.verify("HMAC", jwtKeyCache.key, base64UrlToBytes(signature), new TextEncoder().encode(value));
    }
    downloadKeyCache = await importHmacKey(secret, downloadKeyCache);
    return crypto.subtle.verify("HMAC", downloadKeyCache.key, base64UrlToBytes(signature), new TextEncoder().encode(value));
  } catch (error) {
    if (error instanceof HttpError) throw error;
    return false;
  }
}

async function createDownloadToken(secret, fileKey, ttlSeconds) {
  const payload = encodeText(JSON.stringify({ key: fileKey, exp: Math.floor(Date.now() / 1000) + ttlSeconds }));
  return `${payload}.${await signValue(payload, secret, "download")}`;
}

async function verifyDownloadToken(token, secret) {
  const [payloadPart, signature, extra] = token.split(".");
  if (!payloadPart || !signature || extra) return null;
  if (!await verifyValue(payloadPart, signature, secret, "download")) return null;
  try {
    const payload = JSON.parse(decodeText(payloadPart));
    if (typeof payload.key !== "string" || !Number.isFinite(payload.exp) || payload.exp <= Math.floor(Date.now() / 1000)) return null;
    return payload;
  } catch {
    return null;
  }
}

function parseStoredSiteConfig(stored) {
  if (typeof stored === "number" && Number.isSafeInteger(stored) && stored >= 0) return { password: String(stored) };
  if (typeof stored !== "string") return stored;
  const value = stored.trim();
  if (!value) return { password: "" };
  try {
    const parsed = JSON.parse(value);
    return typeof parsed === "string" || (typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed >= 0)
      ? { password: String(parsed) }
      : parsed;
  } catch {
    return { password: value };
  }
}

async function readStoredSiteConfig(kv) {
  const stored = await kv.get("sys_config");
  return stored === null ? null : parseStoredSiteConfig(stored);
}

function readConfigPassword(raw, fields) {
  for (const field of fields) {
    if (!Object.prototype.hasOwnProperty.call(raw, field)) continue;
    const stored = raw[field];
    const value = typeof stored === "number" && Number.isSafeInteger(stored) && stored >= 0 ? String(stored) : stored;
    if (typeof value === "string" && value.length >= 6 && value.length <= 128) return value;
  }
  return null;
}

function normalizeSiteConfig(raw) {
  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new HttpError(503, "站点密码配置无效");

  // 短链接 Worker 使用 sys_config.password；优先读取它以保持双向改密同步。
  const admin = readConfigPassword(raw, ["password", "admin", "adminPassword", "admin_password", "sitePassword"]);
  const user = readConfigPassword(raw, ["user", "userPassword", "user_password"]);
  if (!admin) throw new HttpError(503, "站点密码配置无效");

  return { admin, user };
}

async function readD1SiteConfig(db) {
  const query = await db.prepare(
    "SELECT key, value FROM pan_config WHERE key IN ('admin_password', 'user_password')"
  ).all();
  const raw = {};
  for (const row of query.results || []) raw[row.key] = row.value;
  return Object.keys(raw).length ? raw : null;
}

async function getSiteConfig(env, forceRefresh = false) {
  const now = Date.now();
  const source = env.KV ? "kv" : "d1";
  if (!forceRefresh && configCache && configCacheSource === source && now - configCacheTime < CONFIG_CACHE_TTL) {
    return { ...configCache };
  }

  let raw;
  try {
    raw = env.KV ? await readStoredSiteConfig(env.KV) : await readD1SiteConfig(env.DB);
  } catch (error) {
    if (error instanceof HttpError) throw error;
    console.error(`${source.toUpperCase()} password config read failed:`, error.message);
    throw new HttpError(503, source === "kv" ? "KV 站点密码配置暂不可用" : "D1 站点密码配置暂不可用，请访问 /init");
  }

  if (!raw) {
    throw new HttpError(503, `${source === "kv" ? "KV" : "D1"} 站点密码尚未初始化，请访问 /init`);
  }

  let nextConfig;
  try {
    nextConfig = normalizeSiteConfig(raw);
  } catch {
    throw new HttpError(503, `${source === "kv" ? "KV 的 sys_config" : "D1 的 pan_config"} 没有有效管理员密码，请访问 /init 修复`);
  }
  configCache = nextConfig;
  configCacheTime = now;
  configCacheSource = source;
  return { ...nextConfig };
}

async function persistSiteConfig(env, changes) {
  if (!env.KV) {
    const stored = await readD1SiteConfig(env.DB);
    const nextStored = stored && typeof stored === "object" ? { ...stored } : {};
    if (Object.prototype.hasOwnProperty.call(changes, "admin")) nextStored.admin_password = changes.admin;
    if (Object.prototype.hasOwnProperty.call(changes, "user")) nextStored.user_password = changes.user;
    const normalized = normalizeSiteConfig(nextStored);
    const statements = [
      env.DB.prepare(
        "INSERT INTO pan_config (key, value, updated_at) VALUES ('admin_password', ?, CURRENT_TIMESTAMP) " +
        "ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP"
      ).bind(normalized.admin)
    ];
    if (normalized.user) {
      statements.push(env.DB.prepare(
        "INSERT INTO pan_config (key, value, updated_at) VALUES ('user_password', ?, CURRENT_TIMESTAMP) " +
        "ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP"
      ).bind(normalized.user));
    }
    await env.DB.batch(statements);
    configCache = normalized;
    configCacheTime = Date.now();
    configCacheSource = "d1";
    return;
  }

  const stored = await readStoredSiteConfig(env.KV);
  const nextStored = stored && typeof stored === "object" && !Array.isArray(stored) ? { ...stored } : {};

  if (Object.prototype.hasOwnProperty.call(changes, "admin")) {
    nextStored.password = changes.admin;
    nextStored.admin = changes.admin;
    if (Object.prototype.hasOwnProperty.call(nextStored, "adminPassword")) nextStored.adminPassword = changes.admin;
    if (Object.prototype.hasOwnProperty.call(nextStored, "admin_password")) nextStored.admin_password = changes.admin;
    if (Object.prototype.hasOwnProperty.call(nextStored, "sitePassword")) nextStored.sitePassword = changes.admin;
  }
  if (Object.prototype.hasOwnProperty.call(changes, "user")) {
    nextStored.user = changes.user;
    if (Object.prototype.hasOwnProperty.call(nextStored, "userPassword")) nextStored.userPassword = changes.user;
    if (Object.prototype.hasOwnProperty.call(nextStored, "user_password")) nextStored.user_password = changes.user;
  }
  if (Object.prototype.hasOwnProperty.call(changes, "siteName")) nextStored.siteName = changes.siteName;
  if (Object.prototype.hasOwnProperty.call(changes, "favicon")) nextStored.favicon = changes.favicon;

  await env.KV.put("sys_config", JSON.stringify(nextStored));
  configCache = normalizeSiteConfig(nextStored);
  configCacheTime = Date.now();
  configCacheSource = "kv";
}

async function getUsedStorage(db) {
  const row = await db.prepare("SELECT used_bytes FROM pan_storage_usage WHERE id = 1").first();
  if (!row) throw new HttpError(503, "存储计数器未初始化，请先执行数据库迁移");
  return Number(row.used_bytes) || 0;
}

async function checkLoginRateLimit(db, ip, now) {
  const row = await db.prepare("SELECT blocked_until FROM pan_login_attempts WHERE ip = ?").bind(ip).first();
  if (row && Number(row.blocked_until) > now) {
    throw new HttpError(429, `登录尝试过多，请在 ${Number(row.blocked_until) - now} 秒后重试`);
  }
}

async function recordLoginFailure(db, ip, now) {
  const cutoff = now - LOGIN_WINDOW_SECONDS;
  await db.prepare(
    `INSERT INTO pan_login_attempts (ip, failures, window_start, blocked_until) VALUES (?, 1, ?, 0)
     ON CONFLICT(ip) DO UPDATE SET
       failures = CASE WHEN window_start <= ? THEN 1 ELSE failures + 1 END,
       window_start = CASE WHEN window_start <= ? THEN ? ELSE window_start END,
       blocked_until = CASE WHEN window_start > ? AND failures + 1 >= ? THEN ? ELSE 0 END`
  ).bind(ip, now, cutoff, cutoff, now, cutoff, LOGIN_MAX_FAILURES, now + LOGIN_BLOCK_SECONDS).run();
}

async function clearLoginFailures(db, ip) {
  await db.prepare("DELETE FROM pan_login_attempts WHERE ip = ?").bind(ip).run();
}

// ========== JWT 工具 ==========
async function generateJWT(secret, role) {
  const header = encodeText(JSON.stringify({ alg: "HS256", typ: "JWT" }));
  const now = Math.floor(Date.now() / 1000);
  const payload = encodeText(JSON.stringify({ role, iat: now, exp: now + 7200 }));
  const unsigned = `${header}.${payload}`;
  return `${unsigned}.${await signValue(unsigned, secret, "jwt")}`;
}

async function verifyJWT(token, secret) {
  try {
    const [headerPart, payloadPart, signature, extra] = token.split(".");
    if (!headerPart || !payloadPart || !signature || extra) return null;
    const header = JSON.parse(decodeText(headerPart));
    if (header.alg !== "HS256" || header.typ !== "JWT") return null;
    if (!await verifyValue(`${headerPart}.${payloadPart}`, signature, secret, "jwt")) return null;
    const payload = JSON.parse(decodeText(payloadPart));
    if (!Number.isFinite(payload.exp) || payload.exp <= Math.floor(Date.now() / 1000)) return null;
    if (payload.role !== "admin" && payload.role !== "user") return null;
    return payload;
  } catch (error) {
    if (error instanceof HttpError) throw error;
    return null;
  }
}

async function extractTokenPayload(request, env) {
  const authHeader = request.headers.get("Authorization");
  if (!authHeader || !authHeader.startsWith("Bearer ")) return null;
  return verifyJWT(authHeader.slice(7), env.JWT_SECRET);
}

function normalizePreviewExtension(value) {
  const extension = String(value || "").trim().toLowerCase().replace(/^\.+/, "");
  return /^[\p{L}\p{N}][\p{L}\p{N}_+-]{0,63}$/u.test(extension) ? extension : "";
}

function parsePreviewExtensions(value) {
  const extensions = String(value || DEFAULT_PREVIEW_EXTENSIONS)
    .split(",")
    .map(normalizePreviewExtension)
    .filter(Boolean);
  return [...new Set(extensions.length ? extensions : DEFAULT_PREVIEW_EXTENSIONS.split(","))];
}

function parsePreviewMimeTypes(value, previewExtensions) {
  let input = value;
  if (typeof input === "string") {
    try { input = JSON.parse(input); } catch { return {}; }
  }
  if (!input || typeof input !== "object" || Array.isArray(input)) return {};
  const allowedExtensions = new Set(previewExtensions);
  const mimeTypes = {};
  for (const [key, rawContentType] of Object.entries(input)) {
    const extension = normalizePreviewExtension(key);
    const contentType = normalizeContentType(rawContentType);
    if (extension && allowedExtensions.has(extension) && contentType) mimeTypes[extension] = contentType;
  }
  return mimeTypes;
}

function normalizeAppConfig(values, downloadSecret) {
  const maxMultipartSize = parsePositiveInt(values.max_multipart_size, Number(DEFAULT_APP_CONFIG.max_multipart_size), MAX_MULTIPART_SIZE);
  const previewExtensions = parsePreviewExtensions(values.preview_extensions);
  return {
    SITE_NAME: typeof values.site_name === "string" && values.site_name.trim() ? values.site_name.trim() : DEFAULT_APP_CONFIG.site_name,
    FAVICON: normalizeFavicon(values.favicon || DEFAULT_APP_CONFIG.favicon),
    MAX_MULTIPART_SIZE: maxMultipartSize,
    MAX_TOTAL_SIZE: parsePositiveInt(values.max_total_size, Number(DEFAULT_APP_CONFIG.max_total_size)),
    DAILY_MAX_A_CLASS: parsePositiveInt(values.daily_max_a_class, Number(DEFAULT_APP_CONFIG.daily_max_a_class), 100000),
    USER_DOWNLOAD_TTL: parsePositiveInt(values.user_download_ttl, Number(DEFAULT_APP_CONFIG.user_download_ttl), 3600),
    DOWNLOAD_SECRET: downloadSecret,
    PREVIEW_EXTENSIONS: previewExtensions,
    PREVIEW_MIME_TYPES: parsePreviewMimeTypes(values.preview_mime_types, previewExtensions)
  };
}

async function getAppConfig(db, env, forceRefresh = false) {
  const now = Date.now();
  if (!forceRefresh && appConfigCache && now - appConfigCacheTime < CONFIG_CACHE_TTL) return { ...appConfigCache };

  let query;
  try {
    query = await db.prepare("SELECT key, value FROM pan_config").all();
  } catch {
    throw new HttpError(503, "数据库尚未初始化，请访问 /init");
  }
  if (!query.results?.length) throw new HttpError(503, "站点配置尚未初始化，请访问 /init");
  const values = { ...DEFAULT_APP_CONFIG };
  for (const row of query.results) {
    if (Object.prototype.hasOwnProperty.call(DEFAULT_APP_CONFIG, row.key)) values[row.key] = String(row.value);
  }
  appConfigCache = normalizeAppConfig(values, env.DOWNLOAD_SECRET);
  appConfigCacheTime = now;
  return { ...appConfigCache };
}

async function persistAppConfig(db, changes, env) {
  const entries = Object.entries(changes).filter(([key]) => Object.prototype.hasOwnProperty.call(DEFAULT_APP_CONFIG, key));
  if (!entries.length) return getAppConfig(db, env, true);
  await db.batch(entries.map(([key, value]) => db.prepare(
    `INSERT INTO pan_config (key, value, updated_at) VALUES (?, ?, datetime('now'))
     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
  ).bind(key, String(value))));
  appConfigCache = null;
  return getAppConfig(db, env, true);
}

function shouldSandboxPreview(contentType) {
  const mediaType = String(contentType || "").split(";", 1)[0].trim().toLowerCase();
  return mediaType === "text/html"
    || mediaType === "application/xhtml+xml"
    || mediaType === "image/svg+xml"
    || mediaType === "application/xml"
    || mediaType === "text/xml";
}

async function serveR2Object(request, r2, key, fileName, previewExts, previewMimeTypes) {
  const object = await r2.get(key, { range: request.headers, onlyIf: request.headers });
  if (!object) return textResponse("文件不存在", 404);

  const headers = new Headers({
    ...corsHeaders,
    "Accept-Ranges": "bytes",
    "Cache-Control": "private, no-store",
    "X-Content-Type-Options": "nosniff"
  });
  if (typeof object.writeHttpMetadata === "function") object.writeHttpMetadata(headers);
  const previewType = getPreviewType(fileName, previewExts, previewMimeTypes, headers.get("Content-Type") || "");
  headers.set("Content-Type", previewType || "application/octet-stream");
  headers.set("Content-Disposition", `${previewType ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(fileName)}`);
  if (previewType && shouldSandboxPreview(previewType)) headers.set("Content-Security-Policy", "sandbox");
  if (object.httpEtag) headers.set("ETag", object.httpEtag);

  if (!("body" in object)) {
    const notModified = request.headers.has("If-None-Match") || request.headers.has("If-Modified-Since");
    return new Response(null, { status: notModified ? 304 : 412, headers });
  }

  let status = 200;
  if (object.range && Number.isFinite(object.range.offset) && Number.isFinite(object.range.length)) {
    const start = object.range.offset;
    const end = start + object.range.length - 1;
    headers.set("Content-Range", `bytes ${start}-${end}/${object.size}`);
    headers.set("Content-Length", String(object.range.length));
    status = 206;
  } else if (Number.isFinite(object.size)) {
    headers.set("Content-Length", String(object.size));
  }

  return new Response(request.method === "HEAD" ? null : object.body, { status, headers });
}

// ========== D1 初始化与 v2 迁移 ==========
const PAN_SCHEMA_STATEMENTS = [
  `CREATE TABLE IF NOT EXISTS pan_daily_usage (
    date TEXT PRIMARY KEY,
    a_class INTEGER NOT NULL DEFAULT 0 CHECK (a_class >= 0)
  )`,
  `CREATE TABLE IF NOT EXISTS pan_files (
    key TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    size INTEGER NOT NULL CHECK (size >= 0),
    uploaded_at TEXT NOT NULL DEFAULT (datetime('now')),
    hidden INTEGER NOT NULL DEFAULT 0 CHECK (hidden IN (0, 1))
  )`,
  `CREATE TABLE IF NOT EXISTS pan_shares (
    token TEXT PRIMARY KEY,
    file_key TEXT NOT NULL,
    file_name TEXT NOT NULL,
    created_at TEXT NOT NULL DEFAULT (datetime('now')),
    hidden INTEGER NOT NULL DEFAULT 0 CHECK (hidden IN (0, 1))
  )`,
  `CREATE TABLE IF NOT EXISTS pan_storage_usage (
    id INTEGER PRIMARY KEY CHECK (id = 1),
    used_bytes INTEGER NOT NULL DEFAULT 0 CHECK (used_bytes >= 0)
  )`,
  `CREATE TABLE IF NOT EXISTS pan_login_attempts (
    ip TEXT PRIMARY KEY,
    failures INTEGER NOT NULL DEFAULT 0,
    window_start INTEGER NOT NULL DEFAULT 0,
    blocked_until INTEGER NOT NULL DEFAULT 0
  )`,
  `CREATE TABLE IF NOT EXISTS pan_sync_staging (
    run_id TEXT NOT NULL,
    key TEXT NOT NULL,
    name TEXT NOT NULL,
    size INTEGER NOT NULL CHECK (size >= 0),
    created_at TEXT NOT NULL DEFAULT (datetime('now')),
    PRIMARY KEY (run_id, key)
  )`,
  `CREATE TABLE IF NOT EXISTS pan_object_operations (
    id TEXT PRIMARY KEY,
    operation TEXT NOT NULL CHECK (operation IN ('delete')),
    file_key TEXT NOT NULL,
    size INTEGER NOT NULL CHECK (size >= 0),
    created_at TEXT NOT NULL DEFAULT (datetime('now'))
  )`,
  `CREATE TABLE IF NOT EXISTS pan_multipart_uploads (
    id TEXT PRIMARY KEY,
    upload_id TEXT NOT NULL,
    object_key TEXT NOT NULL UNIQUE,
    file_name TEXT NOT NULL,
    total_size INTEGER NOT NULL CHECK (total_size > 0),
    part_size INTEGER NOT NULL CHECK (part_size >= 5242880),
    total_parts INTEGER NOT NULL CHECK (total_parts BETWEEN 1 AND 10000),
    status TEXT NOT NULL DEFAULT 'uploading' CHECK (status IN ('uploading', 'completing')),
    created_at TEXT NOT NULL DEFAULT (datetime('now')),
    expires_at INTEGER NOT NULL
  )`,
  `CREATE TABLE IF NOT EXISTS pan_multipart_parts (
    session_id TEXT NOT NULL,
    part_number INTEGER NOT NULL CHECK (part_number BETWEEN 1 AND 10000),
    etag TEXT NOT NULL,
    size INTEGER NOT NULL CHECK (size > 0),
    uploaded_at TEXT NOT NULL DEFAULT (datetime('now')),
    PRIMARY KEY (session_id, part_number),
    FOREIGN KEY (session_id) REFERENCES pan_multipart_uploads(id) ON DELETE CASCADE
  )`,
  `CREATE TABLE IF NOT EXISTS pan_config (
    key TEXT PRIMARY KEY,
    value TEXT NOT NULL,
    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
  )`,
  `CREATE TABLE IF NOT EXISTS pan_schema_migrations (
    version INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
  )`,
  `CREATE TABLE IF NOT EXISTS pan_migration_lock (
    id INTEGER PRIMARY KEY CHECK (id = 1),
    owner TEXT NOT NULL,
    acquired_at TEXT NOT NULL DEFAULT (datetime('now'))
  )`
];

const PAN_INDEX_STATEMENTS = [
  "CREATE INDEX IF NOT EXISTS pan_idx_files_visibility_page ON pan_files (hidden, uploaded_at DESC, key DESC)",
  "CREATE INDEX IF NOT EXISTS pan_idx_shares_visibility_page ON pan_shares (hidden, created_at DESC, token DESC)",
  "CREATE INDEX IF NOT EXISTS pan_idx_shares_file_key ON pan_shares (file_key)",
  "CREATE INDEX IF NOT EXISTS pan_idx_sync_staging_created ON pan_sync_staging (created_at)",
  "CREATE UNIQUE INDEX IF NOT EXISTS pan_idx_object_operations_file ON pan_object_operations (file_key)",
  "CREATE INDEX IF NOT EXISTS pan_idx_object_operations_queue ON pan_object_operations (operation, created_at)",
  "CREATE INDEX IF NOT EXISTS pan_idx_multipart_uploads_expiry ON pan_multipart_uploads (expires_at)"
];

const PAN_REQUIRED_COLUMNS = {
  pan_daily_usage: ["date", "a_class"],
  pan_files: ["key", "name", "size", "uploaded_at", "hidden"],
  pan_shares: ["token", "file_key", "file_name", "created_at", "hidden"],
  pan_storage_usage: ["id", "used_bytes"],
  pan_login_attempts: ["ip", "failures", "window_start", "blocked_until"],
  pan_sync_staging: ["run_id", "key", "name", "size", "created_at"],
  pan_object_operations: ["id", "operation", "file_key", "size", "created_at"],
  pan_multipart_uploads: ["id", "upload_id", "object_key", "file_name", "total_size", "part_size", "total_parts", "status", "created_at", "expires_at"],
  pan_multipart_parts: ["session_id", "part_number", "etag", "size", "uploaded_at"],
  pan_config: ["key", "value", "updated_at"],
  pan_schema_migrations: ["version", "name", "applied_at"]
};

const LEGACY_TABLE_NAMES = [
  "daily_usage", "files", "shares", "storage_usage", "login_attempts", "sync_staging",
  "object_operations", "multipart_uploads", "multipart_parts"
];

function quoteIdentifier(value) {
  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) throw new Error("Unsafe SQL identifier");
  return `"${value}"`;
}

async function getDatabaseTables(db) {
  const query = await db.prepare(
    "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
  ).all();
  return new Set((query.results || []).map(row => String(row.name)));
}

async function getTableColumns(db, tableName) {
  const query = await db.prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`).all();
  return new Set((query.results || []).map(row => String(row.name)));
}

function findColumn(columns, aliases) {
  return aliases.find(alias => columns.has(alias)) || null;
}

function textColumnExpression(column, fallback) {
  return column
    ? `COALESCE(NULLIF(TRIM(CAST(${quoteIdentifier(column)} AS TEXT)), ''), ${fallback})`
    : fallback;
}

function integerColumnExpression(column, fallback = "0") {
  return column
    ? `MAX(0, COALESCE(CAST(${quoteIdentifier(column)} AS INTEGER), ${fallback}))`
    : fallback;
}

async function inspectPanDatabase(db) {
  const tables = await getDatabaseTables(db);
  const hasLegacy = LEGACY_TABLE_NAMES.some(name => tables.has(name));
  const hasPanCore = ["pan_files", "pan_shares", "pan_daily_usage"].some(name => tables.has(name));
  const missing = [];

  for (const [tableName, required] of Object.entries(PAN_REQUIRED_COLUMNS)) {
    if (!tables.has(tableName)) {
      missing.push(tableName);
      continue;
    }
    const columns = await getTableColumns(db, tableName);
    for (const column of required) {
      if (!columns.has(column)) missing.push(`${tableName}.${column}`);
    }
  }

  let state = "current";
  if (!hasLegacy && !hasPanCore) state = "empty";
  else if (hasLegacy || missing.length) state = "legacy_v2";
  const version = tables.has("pan_schema_migrations")
    ? Number((await db.prepare("SELECT MAX(version) AS version FROM pan_schema_migrations").first())?.version) || 0
    : 0;
  return { state, version, missing, tables: [...tables] };
}

async function runStatements(db, statements) {
  for (const sql of statements) await db.prepare(sql).run();
}

async function acquireMigrationLock(db) {
  await db.prepare(PAN_SCHEMA_STATEMENTS[PAN_SCHEMA_STATEMENTS.length - 1]).run();
  await db.prepare("DELETE FROM pan_migration_lock WHERE acquired_at < datetime('now', '-10 minutes')").run();
  const owner = crypto.randomUUID();
  await db.prepare("INSERT OR IGNORE INTO pan_migration_lock (id, owner) VALUES (1, ?)").bind(owner).run();
  const row = await db.prepare("SELECT owner FROM pan_migration_lock WHERE id = 1").first();
  if (!row || row.owner !== owner) throw new HttpError(409, "数据库正在初始化或迁移，请稍后重试");
  return owner;
}

async function releaseMigrationLock(db, owner) {
  try { await db.prepare("DELETE FROM pan_migration_lock WHERE id = 1 AND owner = ?").bind(owner).run(); } catch {}
}

async function renameLegacyTables(db, migrated) {
  const tables = await getDatabaseTables(db);
  for (const legacyName of LEGACY_TABLE_NAMES) {
    const panName = `pan_${legacyName}`;
    if (!tables.has(legacyName) || tables.has(panName)) continue;
    await db.prepare(`ALTER TABLE ${quoteIdentifier(legacyName)} RENAME TO ${quoteIdentifier(panName)}`).run();
    tables.delete(legacyName);
    tables.add(panName);
    migrated.push(`${legacyName} -> ${panName}`);
  }
}

async function rebuildPanFiles(db, columns, migrated) {
  const key = findColumn(columns, ["key", "file_key", "object_key", "r2_key"]);
  if (!key) throw new HttpError(409, "旧版 files 表缺少可识别的文件 key 列，已停止迁移");
  const name = findColumn(columns, ["name", "file_name", "filename"]);
  const size = findColumn(columns, ["size", "file_size", "bytes"]);
  const uploadedAt = findColumn(columns, ["uploaded_at", "created_at", "upload_time"]);
  const hidden = findColumn(columns, ["hidden", "is_hidden"]);
  const keyExpr = `CAST(${quoteIdentifier(key)} AS TEXT)`;
  const nameExpr = textColumnExpression(name, keyExpr);
  const dateExpr = textColumnExpression(uploadedAt, "datetime('now')");
  const hiddenExpr = hidden ? `CASE WHEN CAST(${quoteIdentifier(hidden)} AS INTEGER) = 1 THEN 1 ELSE 0 END` : "0";
  const backup = "pan_files_v2_backup";
  const tables = await getDatabaseTables(db);
  if (tables.has(backup)) throw new HttpError(409, `检测到未完成迁移表 ${backup}，请先人工确认后再重试`);

  await db.batch([
    db.prepare(`ALTER TABLE pan_files RENAME TO ${backup}`),
    db.prepare(PAN_SCHEMA_STATEMENTS[1]),
    db.prepare(
      `INSERT OR IGNORE INTO pan_files (key, name, size, uploaded_at, hidden)
       SELECT ${keyExpr}, ${nameExpr}, ${integerColumnExpression(size)}, ${dateExpr}, ${hiddenExpr}
       FROM ${backup} WHERE ${quoteIdentifier(key)} IS NOT NULL AND ${keyExpr} <> ''`
    ),
    db.prepare(`DROP TABLE ${backup}`)
  ]);
  migrated.push("pan_files 列结构升级");
}

async function rebuildPanShares(db, columns, migrated) {
  const token = findColumn(columns, ["token", "share_token", "short_key"]);
  const fileKey = findColumn(columns, ["file_key", "key", "object_key", "r2_key"]);
  if (!token || !fileKey) throw new HttpError(409, "旧版 shares 表缺少可识别的 token 或 file_key 列，已停止迁移");
  const fileName = findColumn(columns, ["file_name", "name", "filename"]);
  const createdAt = findColumn(columns, ["created_at", "uploaded_at", "create_time"]);
  const hidden = findColumn(columns, ["hidden", "is_hidden"]);
  const tokenExpr = `CAST(${quoteIdentifier(token)} AS TEXT)`;
  const fileKeyExpr = `CAST(${quoteIdentifier(fileKey)} AS TEXT)`;
  const fileNameExpr = textColumnExpression(fileName, fileKeyExpr);
  const dateExpr = textColumnExpression(createdAt, "datetime('now')");
  const hiddenExpr = hidden ? `CASE WHEN CAST(${quoteIdentifier(hidden)} AS INTEGER) = 1 THEN 1 ELSE 0 END` : "0";
  const backup = "pan_shares_v2_backup";
  const tables = await getDatabaseTables(db);
  if (tables.has(backup)) throw new HttpError(409, `检测到未完成迁移表 ${backup}，请先人工确认后再重试`);

  await db.batch([
    db.prepare(`ALTER TABLE pan_shares RENAME TO ${backup}`),
    db.prepare(PAN_SCHEMA_STATEMENTS[2]),
    db.prepare(
      `INSERT OR IGNORE INTO pan_shares (token, file_key, file_name, created_at, hidden)
       SELECT ${tokenExpr}, ${fileKeyExpr}, ${fileNameExpr}, ${dateExpr}, ${hiddenExpr}
       FROM ${backup} WHERE ${quoteIdentifier(token)} IS NOT NULL AND ${quoteIdentifier(fileKey)} IS NOT NULL`
    ),
    db.prepare(`DROP TABLE ${backup}`)
  ]);
  migrated.push("pan_shares 列结构升级");
}

async function rebuildPanDailyUsage(db, columns, migrated) {
  const date = findColumn(columns, ["date", "day", "usage_date"]);
  const usage = findColumn(columns, ["a_class", "count", "used", "usage"]);
  if (!date) throw new HttpError(409, "旧版 daily_usage 表缺少可识别的日期列，已停止迁移");
  const backup = "pan_daily_usage_v2_backup";
  const tables = await getDatabaseTables(db);
  if (tables.has(backup)) throw new HttpError(409, `检测到未完成迁移表 ${backup}，请先人工确认后再重试`);
  await db.batch([
    db.prepare(`ALTER TABLE pan_daily_usage RENAME TO ${backup}`),
    db.prepare(PAN_SCHEMA_STATEMENTS[0]),
    db.prepare(
      `INSERT OR REPLACE INTO pan_daily_usage (date, a_class)
       SELECT CAST(${quoteIdentifier(date)} AS TEXT), ${integerColumnExpression(usage)}
       FROM ${backup} WHERE ${quoteIdentifier(date)} IS NOT NULL`
    ),
    db.prepare(`DROP TABLE ${backup}`)
  ]);
  migrated.push("pan_daily_usage 列结构升级");
}

async function normalizeLegacyCoreTables(db, migrated) {
  const tables = await getDatabaseTables(db);
  if (tables.has("pan_files")) {
    const columns = await getTableColumns(db, "pan_files");
    if (["key", "name", "size", "uploaded_at"].some(column => !columns.has(column))) {
      await rebuildPanFiles(db, columns, migrated);
    } else if (!columns.has("hidden")) {
      await db.prepare("ALTER TABLE pan_files ADD COLUMN hidden INTEGER NOT NULL DEFAULT 0 CHECK (hidden IN (0, 1))").run();
      migrated.push("pan_files.hidden");
    }
  }
  if (tables.has("pan_shares")) {
    const columns = await getTableColumns(db, "pan_shares");
    if (["token", "file_key", "file_name", "created_at"].some(column => !columns.has(column))) {
      await rebuildPanShares(db, columns, migrated);
    } else if (!columns.has("hidden")) {
      await db.prepare("ALTER TABLE pan_shares ADD COLUMN hidden INTEGER NOT NULL DEFAULT 0 CHECK (hidden IN (0, 1))").run();
      migrated.push("pan_shares.hidden");
    }
  }
  if (tables.has("pan_daily_usage")) {
    const columns = await getTableColumns(db, "pan_daily_usage");
    if (!columns.has("date") || !columns.has("a_class")) await rebuildPanDailyUsage(db, columns, migrated);
  }
}

async function mergeRemainingLegacyCoreData(db, migrated) {
  const tables = await getDatabaseTables(db);
  if (tables.has("daily_usage") && tables.has("pan_daily_usage")) {
    const columns = await getTableColumns(db, "daily_usage");
    const date = findColumn(columns, ["date", "day", "usage_date"]);
    const usage = findColumn(columns, ["a_class", "count", "used", "usage"]);
    if (date) {
      await db.prepare(
        `INSERT INTO pan_daily_usage (date, a_class)
         SELECT CAST(${quoteIdentifier(date)} AS TEXT), ${integerColumnExpression(usage)}
         FROM daily_usage WHERE ${quoteIdentifier(date)} IS NOT NULL
         ON CONFLICT(date) DO UPDATE SET a_class = MAX(pan_daily_usage.a_class, excluded.a_class)`
      ).run();
      await db.prepare("DROP TABLE daily_usage").run();
      migrated.push("daily_usage 数据合并到 pan_daily_usage");
    }
  }
  if (tables.has("files") && tables.has("pan_files")) {
    const columns = await getTableColumns(db, "files");
    const key = findColumn(columns, ["key", "file_key", "object_key", "r2_key"]);
    if (key) {
      const name = findColumn(columns, ["name", "file_name", "filename"]);
      const size = findColumn(columns, ["size", "file_size", "bytes"]);
      const uploadedAt = findColumn(columns, ["uploaded_at", "created_at", "upload_time"]);
      const hidden = findColumn(columns, ["hidden", "is_hidden"]);
      const keyExpr = `CAST(${quoteIdentifier(key)} AS TEXT)`;
      await db.prepare(
        `INSERT OR IGNORE INTO pan_files (key, name, size, uploaded_at, hidden)
         SELECT ${keyExpr}, ${textColumnExpression(name, keyExpr)}, ${integerColumnExpression(size)},
           ${textColumnExpression(uploadedAt, "datetime('now')")},
           ${hidden ? `CASE WHEN CAST(${quoteIdentifier(hidden)} AS INTEGER) = 1 THEN 1 ELSE 0 END` : "0"}
         FROM files WHERE ${quoteIdentifier(key)} IS NOT NULL`
      ).run();
      await db.prepare("DROP TABLE files").run();
      migrated.push("files 数据合并到 pan_files");
    }
  }
  if (tables.has("shares") && tables.has("pan_shares")) {
    const columns = await getTableColumns(db, "shares");
    const token = findColumn(columns, ["token", "share_token", "short_key"]);
    const fileKey = findColumn(columns, ["file_key", "key", "object_key", "r2_key"]);
    if (token && fileKey) {
      const fileName = findColumn(columns, ["file_name", "name", "filename"]);
      const createdAt = findColumn(columns, ["created_at", "uploaded_at", "create_time"]);
      const hidden = findColumn(columns, ["hidden", "is_hidden"]);
      const fileKeyExpr = `CAST(${quoteIdentifier(fileKey)} AS TEXT)`;
      await db.prepare(
        `INSERT OR IGNORE INTO pan_shares (token, file_key, file_name, created_at, hidden)
         SELECT CAST(${quoteIdentifier(token)} AS TEXT), ${fileKeyExpr}, ${textColumnExpression(fileName, fileKeyExpr)},
           ${textColumnExpression(createdAt, "datetime('now')")},
           ${hidden ? `CASE WHEN CAST(${quoteIdentifier(hidden)} AS INTEGER) = 1 THEN 1 ELSE 0 END` : "0"}
         FROM shares WHERE ${quoteIdentifier(token)} IS NOT NULL AND ${quoteIdentifier(fileKey)} IS NOT NULL`
      ).run();
      await db.prepare("DROP TABLE shares").run();
      migrated.push("shares 数据合并到 pan_shares");
    }
  }
}

async function mergeRemainingLegacySupportData(db, migrated) {
  const tables = await getDatabaseTables(db);
  const mergeExact = async (legacyName, panName, columns, dropSource = true) => {
    if (!tables.has(legacyName) || !tables.has(panName)) return;
    const sourceColumns = await getTableColumns(db, legacyName);
    const missing = columns.filter(column => !sourceColumns.has(column));
    if (missing.length) throw new HttpError(409, `旧版 ${legacyName} 表缺少列：${missing.join(", ")}`);
    const columnList = columns.map(quoteIdentifier).join(", ");
    await db.prepare(`INSERT OR IGNORE INTO ${quoteIdentifier(panName)} (${columnList}) SELECT ${columnList} FROM ${quoteIdentifier(legacyName)}`).run();
    if (dropSource) await db.prepare(`DROP TABLE ${quoteIdentifier(legacyName)}`).run();
    migrated.push(`${legacyName} 数据合并到 ${panName}`);
    if (dropSource) tables.delete(legacyName);
  };

  await mergeExact("login_attempts", "pan_login_attempts", ["ip", "failures", "window_start", "blocked_until"]);
  await mergeExact("sync_staging", "pan_sync_staging", ["run_id", "key", "name", "size", "created_at"]);
  await mergeExact("object_operations", "pan_object_operations", ["id", "operation", "file_key", "size", "created_at"]);
  await mergeExact(
    "multipart_uploads", "pan_multipart_uploads",
    ["id", "upload_id", "object_key", "file_name", "total_size", "part_size", "total_parts", "status", "created_at", "expires_at"],
    false
  );
  await mergeExact("multipart_parts", "pan_multipart_parts", ["session_id", "part_number", "etag", "size", "uploaded_at"]);
  if (tables.has("multipart_uploads")) {
    await db.prepare("DROP TABLE multipart_uploads").run();
    tables.delete("multipart_uploads");
  }
  if (tables.has("storage_usage")) {
    await db.prepare("DROP TABLE storage_usage").run();
    migrated.push("storage_usage 已由 pan_storage_usage 重新统计");
  }
}

async function ensureDefaultAppConfig(db) {
  await db.batch(Object.entries(DEFAULT_APP_CONFIG).map(([key, value]) => db.prepare(
    "INSERT OR IGNORE INTO pan_config (key, value) VALUES (?, ?)"
  ).bind(key, value)));
}

function getProvidedPasswords(input) {
  const providedAdmin = typeof input.adminPassword === "string" ? input.adminPassword : "";
  const providedUser = typeof input.userPassword === "string" ? input.userPassword : "";
  if (providedAdmin && (providedAdmin.length < 6 || providedAdmin.length > 128)) {
    throw new HttpError(400, "管理员密码长度需为 6-128 位");
  }
  if (providedUser && (providedUser.length < 6 || providedUser.length > 128)) {
    throw new HttpError(400, "普通用户密码长度需为 6-128 位，或留空禁用普通用户登录");
  }
  return { providedAdmin, providedUser };
}

async function migrateKvSiteConfig(kv, db, input, env) {
  let raw = await readStoredSiteConfig(kv);
  let changed = false;
  const { providedAdmin, providedUser } = getProvidedPasswords(input);

  let normalized;
  try { normalized = raw ? normalizeSiteConfig(raw) : null; } catch { normalized = null; }
  if (!normalized) {
    if (!providedAdmin) {
      throw new HttpError(400, "KV 中没有有效共享密码，请在 /init 输入 6-128 位管理员密码");
    }
    raw = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
    raw.password = providedAdmin;
    raw.admin = providedAdmin;
    for (const alias of ["adminPassword", "admin_password", "sitePassword"]) {
      if (Object.prototype.hasOwnProperty.call(raw, alias)) raw[alias] = providedAdmin;
    }
    if (providedUser) raw.user = providedUser;
    for (const alias of ["userPassword", "user_password"]) {
      if (providedUser && Object.prototype.hasOwnProperty.call(raw, alias)) raw[alias] = providedUser;
    }
    normalized = normalizeSiteConfig(raw);
    changed = true;
  } else {
    raw = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
    if (providedAdmin) normalized.admin = providedAdmin;
    if (providedUser) normalized.user = providedUser;
    if (raw.password !== normalized.admin) { raw.password = normalized.admin; changed = true; }
    if (raw.admin !== normalized.admin) { raw.admin = normalized.admin; changed = true; }
    for (const alias of ["adminPassword", "admin_password", "sitePassword"]) {
      if (Object.prototype.hasOwnProperty.call(raw, alias) && raw[alias] !== normalized.admin) {
        raw[alias] = normalized.admin;
        changed = true;
      }
    }
    if (normalized.user && raw.user !== normalized.user) { raw.user = normalized.user; changed = true; }
    for (const alias of ["userPassword", "user_password"]) {
      if (normalized.user && Object.prototype.hasOwnProperty.call(raw, alias) && raw[alias] !== normalized.user) {
        raw[alias] = normalized.user;
        changed = true;
      }
    }
  }

  const appChanges = {};
  if (typeof raw.siteName === "string" && raw.siteName.trim()) appChanges.site_name = raw.siteName.trim();
  if (typeof raw.favicon === "string" && raw.favicon.trim()) appChanges.favicon = raw.favicon.trim();
  if (Object.keys(appChanges).length) await persistAppConfig(db, appChanges, env);
  if (changed) await kv.put("sys_config", JSON.stringify(raw));
  configCache = normalized;
  configCacheTime = Date.now();
  configCacheSource = "kv";
  return { source: "kv", changed, hasUserPassword: !!normalized.user };
}

async function initializeD1SiteConfig(db, input) {
  const { providedAdmin, providedUser } = getProvidedPasswords(input);
  const raw = await readD1SiteConfig(db);
  let normalized;
  try { normalized = raw ? normalizeSiteConfig(raw) : null; } catch { normalized = null; }
  if (!normalized && !providedAdmin) {
    throw new HttpError(400, "D1 中没有有效管理员密码，请在 /init 输入 6-128 位管理员密码");
  }

  const changes = {};
  if (providedAdmin || !normalized) changes.admin = providedAdmin;
  if (providedUser) changes.user = providedUser;
  if (Object.keys(changes).length) {
    await persistSiteConfig({ DB: db }, changes);
    normalized = await getSiteConfig({ DB: db }, true);
  } else {
    configCache = normalized;
    configCacheTime = Date.now();
    configCacheSource = "d1";
  }
  return { source: "d1", changed: !!Object.keys(changes).length, hasUserPassword: !!normalized.user };
}

async function initializeSiteConfig(env, input) {
  if (!env.KV) return initializeD1SiteConfig(env.DB, input);
  const result = await migrateKvSiteConfig(env.KV, env.DB, input, env);
  await env.DB.prepare("DELETE FROM pan_config WHERE key IN ('admin_password', 'user_password')").run();
  return result;
}

async function initializeOrMigrateDatabase(db) {
  const owner = await acquireMigrationLock(db);
  try {
    const before = await inspectPanDatabase(db);
    const migrated = [];
    await renameLegacyTables(db, migrated);
    await normalizeLegacyCoreTables(db, migrated);
    await runStatements(db, PAN_SCHEMA_STATEMENTS.slice(0, -1));
    await mergeRemainingLegacyCoreData(db, migrated);
    await mergeRemainingLegacySupportData(db, migrated);
    await runStatements(db, PAN_INDEX_STATEMENTS);
    await ensureDefaultAppConfig(db);
    const staleUploadConfig = await db.prepare("DELETE FROM pan_config WHERE key = 'max_size'").run();
    if (staleUploadConfig.meta.changes) migrated.push("移除旧版 max_size 单请求上传配置");
    await db.prepare("INSERT OR IGNORE INTO pan_storage_usage (id, used_bytes) VALUES (1, 0)").run();
    await db.prepare(
      `UPDATE pan_storage_usage SET used_bytes =
        (SELECT COALESCE(SUM(size), 0) FROM pan_files) +
        (SELECT COALESCE(SUM(m.total_size), 0) FROM pan_multipart_uploads m
         WHERE NOT EXISTS (SELECT 1 FROM pan_files f WHERE f.key = m.object_key))
       WHERE id = 1`
    ).run();
    await db.batch([
      db.prepare("INSERT OR IGNORE INTO pan_schema_migrations (version, name) VALUES (1, 'pan_v2_prefix_and_hardening')"),
      db.prepare("INSERT OR IGNORE INTO pan_schema_migrations (version, name) VALUES (2, 'pan_multipart_and_config')")
    ]);
    const after = await inspectPanDatabase(db);
    if (after.missing.length) throw new HttpError(500, `迁移后结构校验失败：${after.missing.join(", ")}`);
    const fileCount = Number((await db.prepare("SELECT COUNT(*) AS total FROM pan_files").first())?.total) || 0;
    const shareCount = Number((await db.prepare("SELECT COUNT(*) AS total FROM pan_shares").first())?.total) || 0;
    const usedBytes = Number((await db.prepare("SELECT used_bytes FROM pan_storage_usage WHERE id = 1").first())?.used_bytes) || 0;
    return {
      action: before.state === "empty" ? "initialized" : before.state === "current" && !migrated.length ? "verified" : "migrated",
      version: LATEST_SCHEMA_VERSION,
      migrated,
      fileCount,
      shareCount,
      usedBytes
    };
  } finally {
    await releaseMigrationLock(db, owner);
  }
}

async function getInitStatus(env) {
  const database = await inspectPanDatabase(env.DB);
  let password = "missing";
  let hasUserPassword = false;
  const passwordSource = env.KV ? "KV" : "D1 pan_config";
  try {
    const raw = env.KV
      ? await readStoredSiteConfig(env.KV)
      : database.tables.includes("pan_config") ? await readD1SiteConfig(env.DB) : null;
    const config = normalizeSiteConfig(raw);
    password = "ready";
    hasUserPassword = !!config.user;
  } catch {}
  return { database, password, hasUserPassword, passwordSource };
}

function getInitHtml(status) {
  const stateLabels = { empty: "等待初始化", legacy_v2: "检测到旧版 v2", current: "结构已是最新版" };
  const state = stateLabels[status.database.state] || "需要检查";
  const passwordState = status.password === "ready"
    ? `${status.passwordSource} 密码可用`
    : `${status.passwordSource} 需要设置管理员密码`;
  return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PanIndex 初始化</title>
<style>
:root { --accent:#176b5b; --accent-strong:#105448; --bg:#f3f6f5; --surface:#fff; --border:#dce4e1; --text:#17211f; --muted:#687572; --danger:#b42318; }
* { box-sizing:border-box; letter-spacing:0; }
body { margin:0; min-height:100vh; background:var(--bg); color:var(--text); font-family:ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif; padding:32px 16px; }
main { width:min(680px,100%); margin:0 auto; }
header { display:flex; align-items:center; gap:12px; margin-bottom:24px; }
header svg { width:32px; height:32px; color:var(--accent); }
h1 { font-size:24px; margin:0; }
.status { display:grid; grid-template-columns:1fr 1fr; border:1px solid var(--border); background:var(--surface); margin-bottom:16px; }
.status div { padding:16px; min-width:0; }
.status div + div { border-left:1px solid var(--border); }
.label { display:block; color:var(--muted); font-size:13px; margin-bottom:5px; }
.value { font-weight:650; overflow-wrap:anywhere; }
form { background:var(--surface); border:1px solid var(--border); padding:20px; }
.field { margin-bottom:15px; }
label { display:block; font-size:14px; font-weight:600; margin-bottom:6px; }
input { width:100%; border:1px solid #b9c7c3; padding:11px 12px; font:inherit; }
input:focus { outline:3px solid rgba(23,107,91,.18); border-color:var(--accent); }
button { width:100%; border:0; background:var(--accent); color:#fff; padding:12px 16px; font:inherit; font-weight:650; cursor:pointer; display:flex; align-items:center; justify-content:center; gap:8px; }
button:hover { background:var(--accent-strong); }
button:disabled { opacity:.55; cursor:wait; }
button svg { width:18px; height:18px; }
#result { margin-top:16px; padding:14px; border-left:4px solid var(--accent); background:#eaf4f1; white-space:pre-wrap; overflow-wrap:anywhere; display:none; }
#result.error { border-color:var(--danger); background:#fff0ee; }
@media(max-width:520px){ .status{grid-template-columns:1fr}.status div + div{border-left:0;border-top:1px solid var(--border)} }
</style>
</head>
<body>
<main>
  <header>
    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></svg>
    <h1>PanIndex 初始化与迁移</h1>
  </header>
  <section class="status" aria-label="当前状态">
    <div><span class="label">数据库</span><span class="value">${state}</span></div>
    <div><span class="label">站点密码</span><span class="value">${passwordState}</span></div>
  </section>
  <form id="initForm">
    <div class="field"><label for="initSecret">初始化口令</label><input id="initSecret" type="password" autocomplete="off" placeholder="填写 JWT_SECRET" required></div>
    <div class="field"><label for="adminPassword">管理员密码</label><input id="adminPassword" type="password" autocomplete="new-password" minlength="6" maxlength="128" placeholder="已有正确密码时留空，填写则覆盖"></div>
    <div class="field"><label for="userPassword">普通用户密码</label><input id="userPassword" type="password" autocomplete="new-password" minlength="6" maxlength="128" placeholder="可选，留空则只开放管理员登录"></div>
    <button id="runButton" type="submit"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 6 9 17l-5-5"/></svg><span>检查并执行</span></button>
  </form>
  <div id="result" role="status"></div>
</main>
<script>
const form=document.getElementById('initForm');
const button=document.getElementById('runButton');
const result=document.getElementById('result');
form.addEventListener('submit',async function(event){
  event.preventDefault(); button.disabled=true; result.style.display='block'; result.className=''; result.textContent='正在检查数据库结构';
  try {
    const response=await fetch('/init',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({
      initSecret:document.getElementById('initSecret').value,
      adminPassword:document.getElementById('adminPassword').value,
      userPassword:document.getElementById('userPassword').value
    })});
    const data=await response.json();
    if(!response.ok||data.code!==0) throw new Error(data.msg||'初始化失败');
    const detail=data.data;
    result.textContent=(detail.action==='initialized'?'初始化完成':detail.action==='migrated'?'旧版 v2 迁移完成':'数据库已是最新版')+'\\n文件 '+detail.fileCount+' 个，分享 '+detail.shareCount+' 个，schema v'+detail.version;
    window.setTimeout(function(){location.reload();},1200);
  } catch(error) { result.className='error'; result.textContent=error.message; }
  finally { button.disabled=false; }
});
</script>
</body>
</html>`;
}

function getNotFoundHtml(siteName) {
  return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>分享链接无效 | ${siteName}</title>
<link rel="icon" href="/app-icon.svg">
<style>
:root { color-scheme:light; --accent:#176b5b; --accent-strong:#105448; --accent-soft:#e5f2ef; --bg:#f3f6f5; --surface:#fff; --surface-muted:#f7f9f8; --border:#dce4e1; --text:#17211f; --muted:#687572; --radius:8px; }
* { box-sizing:border-box; }
html, body { margin:0; min-height:100%; }
body { min-height:100dvh; display:grid; place-items:center; background:var(--bg); color:var(--text); padding:24px 16px; font-family:ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif; }
main { width:min(760px,100%); }
.brand { min-height:40px; display:flex; align-items:center; gap:11px; margin-bottom:18px; font-size:16px; font-weight:700; }
.brand img { width:30px; height:30px; }
.panel { background:var(--surface); border:1px solid var(--border); border-radius:var(--radius); padding:clamp(22px,5vw,44px); }
.summary { display:grid; grid-template-columns:minmax(0,1fr) auto; align-items:end; gap:28px; }
.status-code { color:var(--accent); font:750 clamp(58px,12vw,96px)/.85 ui-monospace,SFMono-Regular,Consolas,monospace; letter-spacing:-.08em; }
h1 { margin:0 0 10px; font-size:clamp(25px,5vw,36px); line-height:1.2; }
.message { max-width:520px; margin:0; color:var(--muted); font-size:15px; line-height:1.75; }
.request { margin-top:30px; padding:15px 16px; border:1px solid var(--border); border-radius:var(--radius); background:var(--surface-muted); }
.request-label { display:block; margin-bottom:7px; color:var(--muted); font-size:12px; font-weight:650; }
#requestUrl { display:block; color:var(--accent-strong); font:13px/1.65 ui-monospace,SFMono-Regular,Consolas,monospace; overflow-wrap:anywhere; }
.actions { margin-top:22px; display:flex; }
.home-link { min-height:42px; display:inline-flex; align-items:center; justify-content:center; border:1px solid var(--accent); border-radius:6px; padding:10px 16px; background:var(--accent); color:#fff; font-size:14px; font-weight:650; text-decoration:none; transition:background-color .15s ease,transform .15s ease; }
.home-link:hover { background:var(--accent-strong); }
.home-link:active { transform:translateY(1px); }
.home-link:focus-visible { outline:3px solid rgba(23,107,91,.22); outline-offset:2px; }
@media(max-width:560px) { .summary { grid-template-columns:1fr; gap:20px; } .status-code { grid-row:1; } .request { margin-top:24px; } .home-link { width:100%; } }
@media(prefers-reduced-motion:reduce) { .home-link { transition:none; } }
</style>
</head>
<body>
<main>
  <div class="brand"><img src="/app-icon.svg" alt=""><span>${siteName}</span></div>
  <section class="panel" aria-labelledby="errorTitle">
    <div class="summary">
      <div>
        <h1 id="errorTitle">分享链接无效</h1>
        <p class="message">当前分享链接不存在、已失效或已过期，请检查链接后重试。</p>
      </div>
      <div class="status-code" aria-label="错误代码 404">404</div>
    </div>
    <div class="request">
      <span class="request-label">当前访问链接</span>
      <output id="requestUrl">正在读取当前链接</output>
    </div>
    <div class="actions"><a class="home-link" href="/">返回网盘首页</a></div>
  </section>
</main>
<script>document.getElementById('requestUrl').textContent=window.location.href;</script>
</body>
</html>`;
}

function notFoundResponse(request, runtime) {
  const html = getNotFoundHtml(escapeHtml(runtime.SITE_NAME));
  return new Response(request.method === "HEAD" ? null : html, {
    status: 404,
    headers: { "Content-Type": "text/html; charset=utf-8", ...corsHeaders, ...pageSecurityHeaders }
  });
}

async function handleInit(request, env) {
  if (request.method === "GET" || request.method === "HEAD") {
    const html = getInitHtml(await getInitStatus(env));
    return new Response(request.method === "HEAD" ? null : html, {
      headers: { "Content-Type": "text/html; charset=utf-8", ...pageSecurityHeaders }
    });
  }
  if (request.method !== "POST") return jsonResponse({ code: 405, msg: "Method not allowed" }, 405);
  const body = await readJson(request);
  if (typeof env.JWT_SECRET !== "string" || env.JWT_SECRET.length < 32 || typeof env.DOWNLOAD_SECRET !== "string" || env.DOWNLOAD_SECRET.length < 32) {
    throw new HttpError(503, "请先配置长度至少为 32 位的 JWT_SECRET 和 DOWNLOAD_SECRET");
  }
  if (typeof body.initSecret !== "string" || body.initSecret !== env.JWT_SECRET) {
    throw new HttpError(403, "初始化口令错误");
  }
  const database = await initializeOrMigrateDatabase(env.DB);
  const credentials = await initializeSiteConfig(env, body);
  appConfigCache = null;
  return jsonResponse({ code: 0, data: { ...database, credentials } });
}

// ========== 主 Worker ==========
export default {
  async fetch(request, env) {
    try {
      const url = new URL(request.url);
      const path = url.pathname;
      const DB = env.DB;
      const R2 = env.R2;
      const KV = env.KV;
      if (!DB || !R2) throw new HttpError(503, "缺少 DB 或 R2 绑定");

      if (request.method === "OPTIONS") return new Response(null, { status: 204, headers: corsHeaders });
      if (path === "/init") return await handleInit(request, env);
      if (path === "/app-icon.svg" || path === "/favicon.ico") {
        return new Response(APP_ICON_SVG, {
          headers: { "Content-Type": "image/svg+xml; charset=utf-8", "Cache-Control": "public, max-age=86400", "X-Content-Type-Options": "nosniff" }
        });
      }
      if (path === "/api/login") return await handleLogin(request, env);
      if (path === "/api/verify-token") return await handleVerifyToken(request, env);
      const runtime = await getAppConfig(DB, env);

      if (path.startsWith("/api/")) {
        const payload = await extractTokenPayload(request, env);
        if (!payload) return jsonResponse({ code: 401, msg: "未授权或令牌失效" }, 401);
        return await handleApi(path.slice(5), url, payload, R2, DB, KV, request, env, runtime);
      }

      const pathToken = getPathToken(path);
      if (pathToken && (request.method === "GET" || request.method === "HEAD")) {
        const shareRow = await DB.prepare(
          "SELECT file_key, file_name FROM pan_shares WHERE token = ?"
        ).bind(pathToken).first();
        if (shareRow) return await serveR2Object(
          request, R2, shareRow.file_key, shareRow.file_name, runtime.PREVIEW_EXTENSIONS, runtime.PREVIEW_MIME_TYPES
        );

        const downloadPayload = await verifyDownloadToken(pathToken, runtime.DOWNLOAD_SECRET);
        if (!downloadPayload) return notFoundResponse(request, runtime);
        const fileRow = await DB.prepare("SELECT name FROM pan_files WHERE key = ? AND hidden = 0").bind(downloadPayload.key).first();
        if (!fileRow) return notFoundResponse(request, runtime);
        return await serveR2Object(
          request, R2, downloadPayload.key, fileRow.name, runtime.PREVIEW_EXTENSIONS, runtime.PREVIEW_MIME_TYPES
        );
      }

      if (path !== "/") return notFoundResponse(request, runtime);
      await getSiteConfig(env);
      const usedSize = await getUsedStorage(DB);
      const day = new Date().toISOString().split("T")[0];
      const todayRow = await DB.prepare("SELECT a_class FROM pan_daily_usage WHERE date = ?").bind(day).first();
      const todayAclass = todayRow ? todayRow.a_class : 0;
      const pct = (usedSize / runtime.MAX_TOTAL_SIZE * 100).toFixed(1);
      return new Response(
        getHtml(
          todayAclass, usedSize, pct, escapeHtml(runtime.SITE_NAME), escapeHtml(runtime.FAVICON),
          runtime.MAX_MULTIPART_SIZE, runtime.MAX_TOTAL_SIZE, runtime.DAILY_MAX_A_CLASS,
          runtime.USER_DOWNLOAD_TTL, runtime.PREVIEW_EXTENSIONS.join(","), runtime.PREVIEW_MIME_TYPES
        ),
        { headers: { "Content-Type": "text/html; charset=utf-8", ...corsHeaders, ...pageSecurityHeaders } }
      );
    } catch (error) {
      const status = error instanceof HttpError ? error.status : 500;
      const message = error instanceof HttpError ? error.message : "服务异常";
      if (!(error instanceof HttpError)) console.error("Worker error:", error);
      const errorPath = new URL(request.url).pathname;
      return errorPath.startsWith("/api/") || (errorPath === "/init" && request.method === "POST")
        ? jsonResponse({ code: status, msg: message }, status)
        : textResponse(message, status);
    }
  }
};

// ========== 登录/验证接口 ==========
async function handleLogin(request, env) {
  if (request.method !== "POST") return jsonResponse({ code: 405, error: "Method not allowed" }, 405);
  const ip = request.headers.get("CF-Connecting-IP") || "unknown";
  const now = Math.floor(Date.now() / 1000);
  await checkLoginRateLimit(env.DB, ip, now);

  let body;
  try { body = await request.json(); } catch { throw new HttpError(400, "请求格式无效"); }
  const pass = typeof body.password === "string" ? body.password : "";
  const siteConfig = await getSiteConfig(env, true);
  let role = null;
  if (pass === siteConfig.admin) role = "admin";
  else if (pass === siteConfig.user) role = "user";

  if (!role) {
    await recordLoginFailure(env.DB, ip, now);
    return jsonResponse({ code: 403, msg: "密码错误" }, 403);
  }

  await clearLoginFailures(env.DB, ip);
  const token = await generateJWT(env.JWT_SECRET, role);
  return jsonResponse({ code: 0, token, role });
}

async function handleVerifyToken(request, env) {
  if (request.method !== "POST") return jsonResponse({ code: 405, error: "Method not allowed" }, 405);
  const payload = await extractTokenPayload(request, env);
  return jsonResponse({ code: 0, valid: !!payload, role: payload?.role });
}

// ========== API 业务处理 ==========
function requireMethod(request, method) {
  if (request.method !== method) throw new HttpError(405, "Method not allowed");
}

async function readJson(request) {
  try { return await request.json(); } catch { throw new HttpError(400, "请求格式无效"); }
}

async function consumeDailyOperation(db, day, maxOperations) {
  const result = await db.prepare(
    `INSERT INTO pan_daily_usage (date, a_class) VALUES (?, 1)
     ON CONFLICT(date) DO UPDATE SET a_class = a_class + 1 WHERE a_class < ?`
  ).bind(day, maxOperations).run();
  if (result.meta.changes === 0) throw new HttpError(429, "今日 A 类操作已达上限");
}

async function rollbackDailyOperation(db, day) {
  await db.prepare("UPDATE pan_daily_usage SET a_class = MAX(0, a_class - 1) WHERE date = ?").bind(day).run();
}

async function reserveStorage(db, size, maxTotalSize) {
  const result = await db.prepare(
    "UPDATE pan_storage_usage SET used_bytes = used_bytes + ? WHERE id = 1 AND used_bytes + ? <= ?"
  ).bind(size, size, maxTotalSize).run();
  if (result.meta.changes === 0) throw new HttpError(413, "存储空间已满");
}

async function releaseStorage(db, size) {
  await db.prepare("UPDATE pan_storage_usage SET used_bytes = MAX(0, used_bytes - ?) WHERE id = 1").bind(size).run();
}

async function listFilesPage(db, hidden, url) {
  const limit = parsePositiveInt(url.searchParams.get("limit"), DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
  const cursor = decodeCursor(url.searchParams.get("cursor"));
  let query;
  if (cursor) {
    query = await db.prepare(
      `SELECT key, name, size, hidden, uploaded_at FROM pan_files
       WHERE hidden = ? AND (uploaded_at < ? OR (uploaded_at = ? AND key < ?))
       ORDER BY uploaded_at DESC, key DESC LIMIT ?`
    ).bind(hidden, cursor.uploadedAt, cursor.uploadedAt, cursor.key, limit + 1).all();
  } else {
    query = await db.prepare(
      "SELECT key, name, size, hidden, uploaded_at FROM pan_files WHERE hidden = ? ORDER BY uploaded_at DESC, key DESC LIMIT ?"
    ).bind(hidden, limit + 1).all();
  }
  const hasMore = query.results.length > limit;
  const data = query.results.slice(0, limit);
  const last = data[data.length - 1];
  return { data, nextCursor: hasMore && last ? encodeCursor(last.uploaded_at, last.key) : null };
}

async function listSharesPage(db, hidden, url) {
  const limit = parsePositiveInt(url.searchParams.get("limit"), DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
  const cursor = decodeCursor(url.searchParams.get("cursor"));
  let query;
  if (cursor) {
    query = await db.prepare(
      `SELECT token, file_name, created_at FROM pan_shares
       WHERE hidden = ? AND (created_at < ? OR (created_at = ? AND token < ?))
       ORDER BY created_at DESC, token DESC LIMIT ?`
    ).bind(hidden, cursor.uploadedAt, cursor.uploadedAt, cursor.key, limit + 1).all();
  } else {
    query = await db.prepare(
      "SELECT token, file_name, created_at FROM pan_shares WHERE hidden = ? ORDER BY created_at DESC, token DESC LIMIT ?"
    ).bind(hidden, limit + 1).all();
  }
  const hasMore = query.results.length > limit;
  const data = query.results.slice(0, limit);
  const last = data[data.length - 1];
  return { data, nextCursor: hasMore && last ? encodeCursor(last.created_at, last.token) : null };
}

async function finalizePendingDelete(db, operation) {
  await db.batch([
    db.prepare("DELETE FROM pan_shares WHERE file_key = ?").bind(operation.file_key),
    db.prepare("DELETE FROM pan_files WHERE key = ?").bind(operation.file_key),
    db.prepare("UPDATE pan_storage_usage SET used_bytes = MAX(0, used_bytes - ?) WHERE id = 1").bind(operation.size),
    db.prepare("DELETE FROM pan_object_operations WHERE id = ?").bind(operation.id)
  ]);
}

async function drainPendingDeletes(r2, db, limit = 25) {
  const query = await db.prepare(
    "SELECT id, file_key, size FROM pan_object_operations WHERE operation = 'delete' ORDER BY created_at LIMIT ?"
  ).bind(limit).all();
  let completed = 0;
  for (const operation of query.results) {
    try {
      await r2.delete(operation.file_key);
      await finalizePendingDelete(db, operation);
      completed += 1;
    } catch (error) {
      console.error("Pending delete retry failed:", operation.file_key, error);
    }
  }
  return completed;
}

async function getMultipartSession(db, sessionId) {
  return db.prepare(
    `SELECT id, upload_id, object_key, file_name, total_size, part_size, total_parts, status, expires_at
     FROM pan_multipart_uploads WHERE id = ?`
  ).bind(sessionId).first();
}

function expectedMultipartPartSize(session, partNumber) {
  const totalParts = Number(session.total_parts);
  const totalSize = Number(session.total_size);
  const partSize = Number(session.part_size);
  return partNumber === totalParts
    ? totalSize - partSize * (totalParts - 1)
    : partSize;
}

async function finalizeMultipartSession(db, session) {
  await db.batch([
    db.prepare("INSERT OR IGNORE INTO pan_files (key, name, size) VALUES (?, ?, ?)")
      .bind(session.object_key, session.file_name, session.total_size),
    db.prepare("DELETE FROM pan_multipart_parts WHERE session_id = ?").bind(session.id),
    db.prepare("DELETE FROM pan_multipart_uploads WHERE id = ?").bind(session.id)
  ]);
}

async function discardMultipartSession(db, session) {
  await db.batch([
    db.prepare("DELETE FROM pan_multipart_parts WHERE session_id = ?").bind(session.id),
    db.prepare("DELETE FROM pan_multipart_uploads WHERE id = ?").bind(session.id),
    db.prepare("UPDATE pan_storage_usage SET used_bytes = MAX(0, used_bytes - ?) WHERE id = 1").bind(session.total_size)
  ]);
}

async function completeMultipartSession(r2, db, session, parts) {
  await db.prepare("UPDATE pan_multipart_uploads SET status = 'completing' WHERE id = ?").bind(session.id).run();
  const upload = r2.resumeMultipartUpload(session.object_key, session.upload_id);
  try {
    await upload.complete(parts);
  } catch (error) {
    const object = await r2.head(session.object_key).catch(() => null);
    if (!object || Number(object.size) !== Number(session.total_size)) {
      await db.prepare("UPDATE pan_multipart_uploads SET status = 'uploading' WHERE id = ?").bind(session.id).run();
      throw error;
    }
  }
  await finalizeMultipartSession(db, session);
}

async function cleanupExpiredMultipart(r2, db, limit = 10) {
  const now = Math.floor(Date.now() / 1000);
  const query = await db.prepare(
    `SELECT id, upload_id, object_key, file_name, total_size, part_size, total_parts, status, expires_at
     FROM pan_multipart_uploads WHERE expires_at <= ? ORDER BY expires_at LIMIT ?`
  ).bind(now, limit).all();

  let cleaned = 0;
  for (const session of query.results) {
    try {
      const object = await r2.head(session.object_key).catch(() => null);
      if (object && Number(object.size) === Number(session.total_size)) {
        await finalizeMultipartSession(db, session);
      } else {
        try { await r2.resumeMultipartUpload(session.object_key, session.upload_id).abort(); } catch {}
        await discardMultipartSession(db, session);
      }
      cleaned += 1;
    } catch (error) {
      console.error("Expired multipart cleanup failed:", session.id, error);
    }
  }
  return cleaned;
}

async function syncFiles(r2, db) {
  const runId = crypto.randomUUID();
  let cursor;
  let totalFiles = 0;
  await drainPendingDeletes(r2, db, 100);
  await cleanupExpiredMultipart(r2, db, 100);
  await db.prepare("DELETE FROM pan_sync_staging WHERE created_at < datetime('now', '-1 day')").run();

  try {
    do {
      const result = await r2.list(cursor ? { prefix: "pan/", limit: 500, cursor } : { prefix: "pan/", limit: 500 });
      totalFiles += result.objects.length;
      for (let index = 0; index < result.objects.length; index += 50) {
        const statements = result.objects.slice(index, index + 50).map(object => db.prepare(
          "INSERT OR REPLACE INTO pan_sync_staging (run_id, key, name, size) VALUES (?, ?, ?, ?)"
        ).bind(runId, object.key, parseFileNameFromKey(object.key), object.size));
        if (statements.length) await db.batch(statements);
      }
      cursor = result.truncated ? result.cursor : undefined;
    } while (cursor);

    const addedRow = await db.prepare(
      `SELECT COUNT(*) AS total FROM pan_sync_staging s
       LEFT JOIN pan_files f ON f.key = s.key WHERE s.run_id = ? AND f.key IS NULL`
    ).bind(runId).first();
    const deletedRow = await db.prepare(
      `SELECT COUNT(*) AS total FROM pan_files f
       LEFT JOIN pan_sync_staging s ON s.run_id = ? AND s.key = f.key
       WHERE f.key LIKE 'pan/%' AND s.key IS NULL`
    ).bind(runId).first();

    await db.batch([
      db.prepare(
        `INSERT OR IGNORE INTO pan_files (key, name, size)
         SELECT key, name, size FROM pan_sync_staging WHERE run_id = ?`
      ).bind(runId),
      db.prepare(
        `DELETE FROM pan_shares WHERE file_key IN (
           SELECT f.key FROM pan_files f LEFT JOIN pan_sync_staging s ON s.run_id = ? AND s.key = f.key
           WHERE f.key LIKE 'pan/%' AND s.key IS NULL
         )`
      ).bind(runId),
      db.prepare("DELETE FROM pan_files WHERE key LIKE 'pan/%' AND key NOT IN (SELECT key FROM pan_sync_staging WHERE run_id = ?)").bind(runId),
      db.prepare(
        `UPDATE pan_storage_usage SET used_bytes =
          (SELECT COALESCE(SUM(size), 0) FROM pan_files) +
          (SELECT COALESCE(SUM(m.total_size), 0) FROM pan_multipart_uploads m
           WHERE NOT EXISTS (SELECT 1 FROM pan_files f WHERE f.key = m.object_key))
         WHERE id = 1`
      ),
      db.prepare("DELETE FROM pan_sync_staging WHERE run_id = ?").bind(runId)
    ]);

    const totalRow = await db.prepare("SELECT used_bytes FROM pan_storage_usage WHERE id = 1").first();
    return {
      added: Number(addedRow?.total) || 0,
      deleted: Number(deletedRow?.total) || 0,
      totalFiles,
      totalSize: Number(totalRow?.used_bytes) || 0
    };
  } catch (error) {
    try { await db.prepare("DELETE FROM pan_sync_staging WHERE run_id = ?").bind(runId).run(); } catch {}
    throw error;
  }
}

async function handleApi(action, url, payload, R2, DB, KV, request, env, limits) {
  const fileKey = url.searchParams.get("key");
  const day = new Date().toISOString().split("T")[0];
  const isAdmin = payload.role === "admin";
  const requireAdminList = [
    "delete", "createShare", "listShares", "deleteShare", "updatePass", "updateSite", "updateShareToken", "syncFiles",
    "hideFile", "unhideFile", "listHidden", "hideShare", "unhideShare", "listHiddenShares"
  ];
  if (requireAdminList.includes(action) && !isAdmin) throw new HttpError(403, "需要管理员权限");

  switch (action) {
    case "multipart/create": {
      requireMethod(request, "POST");
      const body = await readJson(request);
      const fileName = normalizeFileName(body.name);
      const extension = getFileExtension(fileName);
      const uploadContentType = getMappedContentType(limits.PREVIEW_MIME_TYPES, extension)
        || normalizeContentType(body.type)
        || getMappedContentType(KNOWN_PREVIEW_TYPES, extension)
        || "application/octet-stream";
      const totalSize = Number(body.size);
      if (!Number.isSafeInteger(totalSize) || totalSize <= 0) throw new HttpError(400, "文件大小无效");
      if (totalSize > limits.MAX_MULTIPART_SIZE) {
        throw new HttpError(413, `分片上传文件不能超过 ${limits.MAX_MULTIPART_SIZE / 1024 / 1024 / 1024}GB`);
      }
      const totalParts = Math.ceil(totalSize / MULTIPART_PART_SIZE);
      if (totalParts > MAX_MULTIPART_PARTS) throw new HttpError(413, "文件分片数量过多");

      await cleanupExpiredMultipart(R2, DB);
      await reserveStorage(DB, totalSize, limits.MAX_TOTAL_SIZE);

      const sessionId = crypto.randomUUID();
      const objectKey = createObjectKey(fileName);
      const expiresAt = Math.floor(Date.now() / 1000) + MULTIPART_TTL_SECONDS;
      let multipartUpload = null;
      try {
        await consumeDailyOperation(DB, day, limits.DAILY_MAX_A_CLASS);
        multipartUpload = await R2.createMultipartUpload(objectKey, {
          httpMetadata: { contentType: uploadContentType }
        });
        await DB.prepare(
          `INSERT INTO pan_multipart_uploads
           (id, upload_id, object_key, file_name, total_size, part_size, total_parts, status, expires_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, 'uploading', ?)`
        ).bind(
          sessionId, multipartUpload.uploadId, objectKey, fileName, totalSize,
          MULTIPART_PART_SIZE, totalParts, expiresAt
        ).run();
        return jsonResponse({
          code: 0,
          data: { sessionId, partSize: MULTIPART_PART_SIZE, totalParts, uploadedParts: [], expiresAt }
        }, 201);
      } catch (error) {
        if (multipartUpload) {
          try { await multipartUpload.abort(); } catch (cleanupError) { console.error("Multipart create cleanup failed:", cleanupError); }
        }
        await releaseStorage(DB, totalSize);
        throw error;
      }
    }

    case "multipart/status": {
      requireMethod(request, "GET");
      const sessionId = url.searchParams.get("session");
      if (!sessionId || sessionId.length > 64) throw new HttpError(400, "上传会话无效");
      const session = await getMultipartSession(DB, sessionId);
      if (!session) throw new HttpError(404, "上传会话不存在或已结束");
      if (Number(session.expires_at) <= Math.floor(Date.now() / 1000)) throw new HttpError(410, "上传会话已过期");
      const parts = await DB.prepare(
        "SELECT part_number, size FROM pan_multipart_parts WHERE session_id = ? ORDER BY part_number"
      ).bind(sessionId).all();
      return jsonResponse({
        code: 0,
        data: {
          sessionId,
          name: session.file_name,
          size: Number(session.total_size),
          partSize: Number(session.part_size),
          totalParts: Number(session.total_parts),
          status: session.status,
          uploadedParts: parts.results.map(part => ({ partNumber: Number(part.part_number), size: Number(part.size) })),
          expiresAt: Number(session.expires_at)
        }
      });
    }

    case "multipart/part": {
      requireMethod(request, "PUT");
      const sessionId = url.searchParams.get("session");
      const partValue = url.searchParams.get("part");
      if (!sessionId || sessionId.length > 64 || !partValue || !/^\d+$/.test(partValue)) {
        throw new HttpError(400, "上传会话或分片编号无效");
      }
      const partNumber = Number(partValue);
      const session = await getMultipartSession(DB, sessionId);
      if (!session) throw new HttpError(404, "上传会话不存在或已结束");
      if (session.status !== "uploading") throw new HttpError(409, "上传会话正在完成中");
      if (Number(session.expires_at) <= Math.floor(Date.now() / 1000)) throw new HttpError(410, "上传会话已过期");
      if (!Number.isSafeInteger(partNumber) || partNumber < 1 || partNumber > Number(session.total_parts)) {
        throw new HttpError(400, "分片编号超出范围");
      }

      const lengthHeader = request.headers.get("Content-Length");
      if (!lengthHeader || !/^\d+$/.test(lengthHeader)) throw new HttpError(411, "分片请求必须包含 Content-Length");
      const contentLength = Number(lengthHeader);
      const expectedSize = expectedMultipartPartSize(session, partNumber);
      if (contentLength !== expectedSize) throw new HttpError(400, `第 ${partNumber} 片大小应为 ${expectedSize} 字节`);
      if (!request.body) throw new HttpError(400, "缺少分片内容");

      await consumeDailyOperation(DB, day, limits.DAILY_MAX_A_CLASS);
      const upload = R2.resumeMultipartUpload(session.object_key, session.upload_id);
      const uploadedPart = await upload.uploadPart(partNumber, request.body);
      await DB.prepare(
        `INSERT INTO pan_multipart_parts (session_id, part_number, etag, size) VALUES (?, ?, ?, ?)
         ON CONFLICT(session_id, part_number) DO UPDATE SET etag = excluded.etag, size = excluded.size,
           uploaded_at = datetime('now')`
      ).bind(sessionId, partNumber, uploadedPart.etag, contentLength).run();
      return jsonResponse({ code: 0, data: { partNumber, size: contentLength } });
    }

    case "multipart/complete": {
      requireMethod(request, "POST");
      const { sessionId } = await readJson(request);
      if (typeof sessionId !== "string" || !sessionId || sessionId.length > 64) throw new HttpError(400, "上传会话无效");
      const session = await getMultipartSession(DB, sessionId);
      if (!session) throw new HttpError(404, "上传会话不存在或已结束");
      if (Number(session.expires_at) <= Math.floor(Date.now() / 1000)) throw new HttpError(410, "上传会话已过期");
      const partQuery = await DB.prepare(
        "SELECT part_number, etag, size FROM pan_multipart_parts WHERE session_id = ? ORDER BY part_number"
      ).bind(sessionId).all();
      if (partQuery.results.length !== Number(session.total_parts)) throw new HttpError(409, "仍有分片未上传完成");

      const parts = partQuery.results.map(part => ({ partNumber: Number(part.part_number), etag: part.etag }));
      for (let index = 0; index < partQuery.results.length; index += 1) {
        const part = partQuery.results[index];
        const partNumber = index + 1;
        if (Number(part.part_number) !== partNumber || Number(part.size) !== expectedMultipartPartSize(session, partNumber)) {
          throw new HttpError(409, "分片记录不完整，请重传缺失分片");
        }
      }

      await consumeDailyOperation(DB, day, limits.DAILY_MAX_A_CLASS);
      try {
        await completeMultipartSession(R2, DB, session, parts);
      } catch (error) {
        console.error("Multipart complete failed:", sessionId, error);
        throw new HttpError(503, "合并分片失败，可稍后重试完成操作");
      }
      return jsonResponse({ code: 0, msg: "分片上传完成", data: { key: session.object_key } });
    }

    case "multipart/abort": {
      requireMethod(request, "POST");
      const { sessionId } = await readJson(request);
      if (typeof sessionId !== "string" || !sessionId || sessionId.length > 64) throw new HttpError(400, "上传会话无效");
      const session = await getMultipartSession(DB, sessionId);
      if (!session) return jsonResponse({ code: 0, msg: "上传会话已结束" });

      try { await consumeDailyOperation(DB, day, limits.DAILY_MAX_A_CLASS); }
      catch (error) { if (!(error instanceof HttpError) || error.status !== 429) throw error; }
      const object = await R2.head(session.object_key).catch(() => null);
      if (object && Number(object.size) === Number(session.total_size)) {
        await finalizeMultipartSession(DB, session);
        return jsonResponse({ code: 0, msg: "文件已完成上传", data: { completed: true } });
      }
      try {
        await R2.resumeMultipartUpload(session.object_key, session.upload_id).abort();
      } catch (error) {
        const completedObject = await R2.head(session.object_key).catch(() => null);
        if (completedObject && Number(completedObject.size) === Number(session.total_size)) {
          await finalizeMultipartSession(DB, session);
          return jsonResponse({ code: 0, msg: "文件已完成上传", data: { completed: true } });
        }
        console.error("Multipart abort failed:", sessionId, error);
        throw new HttpError(503, "取消上传失败，请稍后重试");
      }
      await discardMultipartSession(DB, session);
      return jsonResponse({ code: 0, msg: "分片上传已取消", data: { completed: false } });
    }

    case "list": {
      requireMethod(request, "GET");
      const page = await listFilesPage(DB, 0, url);
      return jsonResponse({ code: 0, data: page.data, isAdmin, pagination: { nextCursor: page.nextCursor } });
    }

    case "delete": {
      requireMethod(request, "POST");
      const { key } = await readJson(request);
      if (typeof key !== "string" || !key) throw new HttpError(400, "缺少 key");
      const file = await DB.prepare("SELECT size FROM pan_files WHERE key = ?").bind(key).first();
      if (!file) throw new HttpError(404, "文件不存在");
      await consumeDailyOperation(DB, day, limits.DAILY_MAX_A_CLASS);
      const operation = { id: crypto.randomUUID(), file_key: key, size: Number(file.size) || 0 };
      let staged = false;
      try {
        await DB.batch([
          DB.prepare(
            "INSERT INTO pan_object_operations (id, operation, file_key, size) VALUES (?, 'delete', ?, ?)"
          ).bind(operation.id, key, operation.size),
          DB.prepare("UPDATE pan_files SET hidden = 1 WHERE key = ?").bind(key),
          DB.prepare("DELETE FROM pan_shares WHERE file_key = ?").bind(key)
        ]);
        staged = true;
        await R2.delete(key);
        await finalizePendingDelete(DB, operation);
        return jsonResponse({ code: 0, msg: "文件已删除" });
      } catch (error) {
        if (!staged) await rollbackDailyOperation(DB, day);
        if (staged) throw new HttpError(503, "删除已进入重试队列，请稍后执行列表同步");
        throw error;
      }
    }

    case "getDownloadToken": {
      requireMethod(request, "GET");
      if (!fileKey) throw new HttpError(400, "缺少文件 key");
      const fileRow = await DB.prepare("SELECT name FROM pan_files WHERE key = ? AND hidden = 0").bind(fileKey).first();
      if (!fileRow) throw new HttpError(404, "文件不存在");
      const token = await createDownloadToken(limits.DOWNLOAD_SECRET, fileKey, limits.USER_DOWNLOAD_TTL);
      const previewable = isPreviewable(fileRow.name, limits.PREVIEW_EXTENSIONS);
      return jsonResponse({
        code: 0,
        token,
        url: `/${encodeURIComponent(token)}`,
        previewable
      });
    }

    case "createShare": {
      requireMethod(request, "POST");
      const { key } = await readJson(request);
      if (typeof key !== "string" || !key) throw new HttpError(400, "缺少 key");
      const fileRow = await DB.prepare("SELECT name FROM pan_files WHERE key = ? AND hidden = 0").bind(key).first();
      if (!fileRow) throw new HttpError(404, "文件不存在");
      const sharePath = randomToken();
      await DB.prepare("INSERT INTO pan_shares (token, file_key, file_name) VALUES (?, ?, ?)").bind(sharePath, key, fileRow.name).run();
      return jsonResponse({ code: 0, link: `${url.origin}/${sharePath}` }, 201);
    }

    case "listShares": {
      requireMethod(request, "GET");
      const page = await listSharesPage(DB, 0, url);
      return jsonResponse({
        code: 0,
        data: page.data.map(row => ({
          token: row.token,
          fileName: row.file_name,
          link: `${url.origin}/${encodeURIComponent(row.token)}`,
          expireTime: "永久"
        })),
        pagination: { nextCursor: page.nextCursor }
      });
    }

    case "deleteShare": {
      requireMethod(request, "POST");
      const { token } = await readJson(request);
      if (typeof token !== "string" || !token) throw new HttpError(400, "缺少分享路径");
      const result = await DB.prepare("DELETE FROM pan_shares WHERE token = ?").bind(token).run();
      if (result.meta.changes === 0) throw new HttpError(404, "分享不存在");
      return jsonResponse({ code: 0, msg: "分享已删除" });
    }

    case "updateShareToken": {
      requireMethod(request, "POST");
      const { oldToken, newToken } = await readJson(request);
      if (typeof oldToken !== "string" || !oldToken) throw new HttpError(400, "缺少原分享路径");
      const nextToken = validateSharePath(newToken);
      if (oldToken === nextToken) throw new HttpError(400, "新旧分享路径相同");
      const collision = await DB.prepare("SELECT 1 AS found FROM pan_shares WHERE token = ?").bind(nextToken).first();
      if (collision) throw new HttpError(409, "分享路径已被占用");
      const result = await DB.prepare("UPDATE pan_shares SET token = ? WHERE token = ?").bind(nextToken, oldToken).run();
      if (result.meta.changes === 0) throw new HttpError(404, "原分享不存在");
      return jsonResponse({ code: 0, msg: "修改成功", newToken: nextToken });
    }

    case "hideFile":
    case "unhideFile": {
      requireMethod(request, "POST");
      const { key } = await readJson(request);
      if (typeof key !== "string" || !key) throw new HttpError(400, "缺少 key");
      if (action === "unhideFile") {
        const pending = await DB.prepare("SELECT 1 AS found FROM pan_object_operations WHERE file_key = ?").bind(key).first();
        if (pending) throw new HttpError(409, "文件正在等待删除，暂时不能恢复");
      }
      const hidden = action === "hideFile" ? 1 : 0;
      const result = await DB.prepare("UPDATE pan_files SET hidden = ? WHERE key = ?").bind(hidden, key).run();
      if (result.meta.changes === 0) throw new HttpError(404, "文件不存在");
      return jsonResponse({ code: 0, msg: hidden ? "文件已隐藏" : "已取消隐藏" });
    }

    case "listHidden": {
      requireMethod(request, "GET");
      const page = await listFilesPage(DB, 1, url);
      return jsonResponse({ code: 0, data: page.data, pagination: { nextCursor: page.nextCursor } });
    }

    case "hideShare":
    case "unhideShare": {
      requireMethod(request, "POST");
      const { token } = await readJson(request);
      if (typeof token !== "string" || !token) throw new HttpError(400, "缺少分享路径");
      const hidden = action === "hideShare" ? 1 : 0;
      const result = await DB.prepare("UPDATE pan_shares SET hidden = ? WHERE token = ?").bind(hidden, token).run();
      if (result.meta.changes === 0) throw new HttpError(404, "分享不存在");
      return jsonResponse({ code: 0, msg: hidden ? "分享已移至隐藏列表，原链接仍可访问" : "分享已恢复到常规列表" });
    }

    case "listHiddenShares": {
      requireMethod(request, "GET");
      const page = await listSharesPage(DB, 1, url);
      return jsonResponse({
        code: 0,
        data: page.data.map(row => ({
          token: row.token,
          fileName: row.file_name,
          link: `${url.origin}/${encodeURIComponent(row.token)}`,
          expireTime: "永久"
        })),
        pagination: { nextCursor: page.nextCursor }
      });
    }

    case "updatePass": {
      requireMethod(request, "POST");
      const { type, old: oldPassword, new: newPassword } = await readJson(request);
      if (type !== "admin" && type !== "user") throw new HttpError(400, "密码类型无效");
      if (typeof newPassword !== "string" || newPassword.length < 6 || newPassword.length > 128) {
        throw new HttpError(400, "新密码长度需为 6-128 位");
      }
      const siteConfig = await getSiteConfig(env, true);
      const expectedOldPassword = type === "user" && !siteConfig.user ? siteConfig.admin : siteConfig[type];
      if (oldPassword !== expectedOldPassword) throw new HttpError(400, "原密码错误");
      await persistSiteConfig(env, { [type]: newPassword });
      return jsonResponse({ code: 0, msg: "修改成功，已有登录令牌将在到期后失效" });
    }

    case "updateSite": {
      requireMethod(request, "POST");
      const body = await readJson(request);
      const changes = {};
      if (body.siteName !== undefined && body.siteName !== "") {
        if (typeof body.siteName !== "string" || body.siteName.trim().length > 80) throw new HttpError(400, "网站名称不能超过 80 个字符");
        changes.site_name = body.siteName.trim();
      }
      if (body.favicon !== undefined && body.favicon !== "") changes.favicon = normalizeFavicon(body.favicon.trim());

      const readNumber = (field, min, max, label) => {
        if (body[field] === undefined || body[field] === "") return null;
        const value = Number(body[field]);
        if (!Number.isFinite(value) || value < min || value > max) throw new HttpError(400, `${label}需在 ${min}-${max} 之间`);
        return value;
      };
      const maxMultipartSizeMb = readNumber("maxMultipartSizeMb", 5, 1024, "分片上传上限(MiB)");
      const maxTotalSizeGb = readNumber("maxTotalSizeGb", 0.1, 10000, "总容量上限(GiB)");
      const dailyMaxAClass = readNumber("dailyMaxAClass", 1, 100000, "每日 A 类操作上限");
      const userDownloadTtl = readNumber("userDownloadTtl", 60, 3600, "普通用户下载有效期(秒)");
      if (maxMultipartSizeMb !== null) changes.max_multipart_size = String(Math.round(maxMultipartSizeMb * 1024 * 1024));
      if (maxTotalSizeGb !== null) changes.max_total_size = String(Math.round(maxTotalSizeGb * 1024 * 1024 * 1024));
      if (dailyMaxAClass !== null) changes.daily_max_a_class = String(Math.round(dailyMaxAClass));
      if (userDownloadTtl !== null) changes.user_download_ttl = String(Math.round(userDownloadTtl));
      if (body.previewExtensions !== undefined && body.previewExtensions !== "") {
        if (typeof body.previewExtensions !== "string") throw new HttpError(400, "预览扩展名格式无效");
        changes.preview_extensions = parsePreviewExtensions(body.previewExtensions).join(",");
      }
      if (body.previewMimeTypes !== undefined) {
        const previewExtensions = parsePreviewExtensions(changes.preview_extensions || limits.PREVIEW_EXTENSIONS.join(","));
        changes.preview_mime_types = JSON.stringify(parsePreviewMimeTypes(body.previewMimeTypes, previewExtensions));
      }
      const nextMultipartSize = Number(changes.max_multipart_size || limits.MAX_MULTIPART_SIZE);
      const nextTotalSize = Number(changes.max_total_size || limits.MAX_TOTAL_SIZE);
      if (nextTotalSize < nextMultipartSize) throw new HttpError(400, "总容量上限不能小于单文件分片上传上限");
      await persistAppConfig(DB, changes, env);
      return jsonResponse({ code: 0, msg: "配置已保存" });
    }

    case "syncFiles": {
      requireMethod(request, "POST");
      try {
        return jsonResponse({ code: 0, data: await syncFiles(R2, DB) });
      } catch (error) {
        console.error("File sync failed:", error);
        throw new HttpError(500, "同步失败，请稍后重试");
      }
    }

    default:
      throw new HttpError(404, "API 不存在");
  }
}

function getHtml(todayAclass, usedSize, storagePercent, siteName, faviconUrl, MAX_MULTIPART_SIZE, MAX_TOTAL_SIZE, DAILY_MAX_A_CLASS, USER_DOWNLOAD_TTL, PREVIEW_EXTENSIONS, PREVIEW_MIME_TYPES) {
  const formatSize = (s) => {
    if (s < 1024) return s + 'B';
    if (s < 1024 * 1024) return (s / 1024).toFixed(1) + 'KB';
    if (s < 1024 * 1024 * 1024) return (s / 1024 / 1024).toFixed(1) + 'MB';
    return (s / 1024 / 1024 / 1024).toFixed(1) + 'GB';
  };
  const maxMultipartSizeGB = MAX_MULTIPART_SIZE / 1024 / 1024 / 1024;

  return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<title>${siteName}</title>
<link rel="icon" href="${faviconUrl}">
<style>
:root { --accent: #176b5b; --accent-strong: #105448; --accent-soft: #e5f2ef; --bg: #f3f6f5; --surface: #ffffff; --surface-muted: #f7f9f8; --border: #dce4e1; --text: #17211f; --muted: #687572; --danger: #b42318; --danger-soft: #fef0ee; --warning: #8a5a00; --warning-soft: #fff7e0; --radius: 8px; }
* { margin: 0; padding: 0; box-sizing: border-box; letter-spacing: 0; }
html, body { overflow-x: hidden; width: 100%; min-height: 100%; }
body { background: var(--bg); color: var(--text); padding: 24px 16px 48px; font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; }
body > .card, body > #toast, body > .modal-overlay, body > input { max-width: 1040px; margin-left: auto; margin-right: auto; }
button, input, select { font: inherit; }
button { touch-action: manipulation; }
button:focus-visible, input:focus-visible, select:focus-visible, .upload-area:focus-visible { outline: 3px solid rgba(23,107,91,.22); outline-offset: 2px; }
.card { background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); padding: 20px; margin-bottom: 14px; width: 100%; }
.title { min-height: 36px; font-size: 17px; font-weight: 700; margin-bottom: 16px; display: flex; gap: 12px; justify-content: space-between; align-items: center; }
.brand { display: flex; align-items: center; gap: 10px; min-width: 0; }
.brand svg { width: 24px; height: 24px; color: var(--accent); flex: 0 0 auto; }
.brand span { overflow-wrap: anywhere; }
.info-bar { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); border: 1px solid var(--border); border-radius: var(--radius); margin-bottom: 14px; overflow: hidden; }
.info-item { padding: 10px 12px; font: 600 12px/1.35 ui-monospace, SFMono-Regular, Consolas, monospace; color: var(--muted); border-right: 1px solid var(--border); }
.info-item:last-child { border-right: 0; }
.btn-group { display: flex; gap: 8px; flex-wrap: wrap; }
.btn, .action-btn, .confirm-yes, .confirm-no, .btn-cancel { min-height: 40px; display: inline-flex; align-items: center; justify-content: center; gap: 7px; border: 1px solid transparent; border-radius: 6px; padding: 9px 13px; font-size: 14px; font-weight: 650; cursor: pointer; white-space: nowrap; transition: background-color .15s ease, border-color .15s ease, transform .15s ease; }
.btn:active, .action-btn:active, .confirm-yes:active, .confirm-no:active { transform: translateY(1px); }
.btn svg, .action-btn svg, .pagination svg { width: 17px; height: 17px; flex: 0 0 auto; }
.btn { background: var(--accent); color: #fff; flex: 0 0 auto; }
.btn:hover { background: var(--accent-strong); }
.btn-secondary { background: var(--surface); color: var(--text); border-color: var(--border); }
.btn-secondary:hover { background: var(--surface-muted); border-color: #b9c7c3; }
.btn-danger, .btn-cancel, .confirm-yes { background: var(--danger); color: #fff; }
.btn-cancel { width: 100%; margin-top: 12px; }
.modal-overlay { position: fixed; inset: 0; max-width: none !important; background: rgba(12,22,19,.56); display: none; align-items: flex-start; justify-content: center; z-index: 20; padding: 24px 12px; overflow-y: auto; }
.modal { background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); padding: 22px; width: 100%; max-width: 620px; margin-top: min(8vh, 60px); box-shadow: 0 18px 48px rgba(12,22,19,.18); }
#delModal { z-index: 100; align-items: center; }
#delModal .modal { max-width: 420px; margin-top: 0; }
.modal-header { display: flex; justify-content: space-between; align-items: center; gap: 16px; margin-bottom: 18px; }
.modal-header h3 { font-size: 17px; }
.modal-close { width: 36px; height: 36px; display: grid; place-items: center; background: transparent; border: 0; border-radius: 6px; cursor: pointer; color: var(--muted); font-size: 24px; }
.modal-close:hover { background: var(--surface-muted); color: var(--text); }
.upload-area { border: 1px dashed #9eb0ab; border-radius: var(--radius); padding: 32px 16px; text-align: center; cursor: pointer; width: 100%; color: var(--muted); background: var(--surface-muted); }
.upload-area:hover { border-color: var(--accent); color: var(--accent); }
#fileInput { display: none; }
#dropOverlay { position: fixed; inset: 0; z-index: 120; display: none; align-items: center; justify-content: center; padding: 18px; background: rgba(12,22,19,.72); color: #fff; pointer-events: none; }
#dropOverlay.active { display: flex; }
.drop-overlay-content { width: min(720px, 100%); min-height: min(420px, calc(100vh - 36px)); border: 2px dashed rgba(255,255,255,.72); display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 12px; text-align: center; padding: 28px; }
.drop-overlay-content svg { width: 48px; height: 48px; }
.drop-overlay-content strong { font-size: 20px; }
.drop-overlay-content span { color: rgba(255,255,255,.76); font-size: 13px; }
.progress-wrapper { margin-top: 16px; width: 100%; }
.progress-bar-container { height: 5px; background: #e5ebe9; border-radius: 3px; overflow: hidden; }
.progress-bar { height: 100%; background: var(--accent); width: 0%; }
.progress-text { margin-top: 8px; font: 12px/1.5 ui-monospace, SFMono-Regular, Consolas, monospace; color: var(--muted); text-align: center; }
.list-state { padding: 30px 12px; color: var(--muted); text-align: center; }
.skeleton-row { height: 64px; border-radius: var(--radius); background: #edf2f0; margin-bottom: 8px; animation: pulse 1.2s ease-in-out infinite alternate; }
@keyframes pulse { to { opacity: .48; } }
.file-item { display: grid; grid-template-columns: minmax(0, 1fr) auto; align-items: center; padding: 13px 14px; border-bottom: 1px solid var(--border); gap: 14px; }
.file-item:last-child { border-bottom: 0; }
.file-info { min-width: 0; }
.file-name, .share-filename { font-size: 14px; font-weight: 650; overflow-wrap: anywhere; white-space: pre-wrap; }
.file-size, .share-expire { margin-top: 3px; font: 12px/1.4 ui-monospace, SFMono-Regular, Consolas, monospace; color: var(--muted); }
.file-actions, .share-row { display: flex; gap: 6px; flex-wrap: wrap; justify-content: flex-end; }
.action-btn { min-height: 34px; padding: 7px 9px; font-size: 12px; background: var(--surface); border-color: var(--border); color: var(--text); }
.action-btn:hover { background: var(--surface-muted); border-color: #b9c7c3; }
.action-btn.primary, .share-copy-btn { background: var(--accent-soft); border-color: #c8e3dc; color: var(--accent-strong); }
.action-btn.danger, .share-del-btn { background: var(--danger-soft); border-color: #f3d1cc; color: var(--danger); }
.action-btn.warning, .share-hide-btn { background: var(--warning-soft); border-color: #ecdca9; color: var(--warning); }
.share-item { padding: 14px 2px; border-bottom: 1px solid var(--border); width: 100%; display: grid; gap: 9px; }
.share-item:last-child { border-bottom: 0; }
.share-token { font: 12px/1.55 ui-monospace, SFMono-Regular, Consolas, monospace; color: var(--accent-strong); overflow-wrap: anywhere; }
a.share-token:hover { color: var(--accent); text-decoration-thickness: 2px; }
.pagination { min-height: 45px; display: flex; justify-content: flex-end; align-items: center; gap: 8px; padding-top: 12px; border-top: 1px solid var(--border); }
.pagination[hidden] { display: none; }
.pagination button { width: 36px; height: 34px; display: grid; place-items: center; border: 1px solid var(--border); border-radius: 6px; background: var(--surface); color: var(--text); cursor: pointer; }
.pagination button:disabled { opacity: .38; cursor: not-allowed; }
.pagination span { min-width: 72px; text-align: center; font: 12px ui-monospace, SFMono-Regular, Consolas, monospace; color: var(--muted); }
.toast { position: fixed; bottom: 28px; left: 50%; transform: translateX(-50%); background: #25322f; color: #fff; padding: 10px 16px; border-radius: 6px; display: none; z-index: 30; white-space: pre-wrap; max-width: min(88vw, 520px); text-align: center; box-shadow: 0 12px 32px rgba(12,22,19,.2); }
.toast.error { background: var(--danger); }
.toast.success { background: var(--accent-strong); }
.toast.warn { background: var(--warning); }
.form-item { margin-bottom: 14px; width: 100%; }
.form-item label { display: block; margin-bottom: 6px; font-size: 13px; font-weight: 650; }
.form-item input, .form-item select { width: 100%; min-height: 42px; padding: 10px 11px; border-radius: 6px; border: 1px solid #b9c7c3; color: var(--text); background: var(--surface); }
.form-item input::placeholder { color: #778580; }
.extension-editor { min-height: 42px; display: flex; flex-wrap: wrap; align-items: center; gap: 7px; padding: 7px; border: 1px solid #b9c7c3; border-radius: 6px; background: var(--surface); }
.extension-editor:focus-within { border-color: var(--accent); outline: 3px solid rgba(39, 142, 116, .16); outline-offset: 1px; }
.extension-tags { display: contents; }
.extension-tag { min-height: 28px; display: inline-flex; align-items: center; gap: 5px; padding: 4px 7px; border: 1px solid #c8e3dc; border-radius: 6px; background: var(--accent-soft); color: var(--accent-strong); font-size: 12px; font-weight: 650; cursor: pointer; }
.extension-tag:hover { border-color: var(--accent); background: #d9eee8; }
.extension-tag svg { width: 13px; height: 13px; flex: 0 0 auto; }
.extension-mime { color: var(--muted); font-size: 11px; font-weight: 500; }
.form-item .extension-entry { flex: 1 1 130px; width: auto; min-width: 100px; min-height: 28px; padding: 3px 4px; border: 0; outline: 0; background: transparent; }
#previewExtensionsInput { display: none; }
.config-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 12px; }
.form-item-wide { grid-column: 1 / -1; }
.confirm-btns { display: flex; gap: 8px; justify-content: flex-end; margin-top: 20px; }
.confirm-no { background: var(--surface); color: var(--text); border-color: var(--border); }
.tab-bar { display: flex; overflow-x: auto; border-bottom: 1px solid var(--border); margin-bottom: 18px; gap: 2px; }
.tab-btn { flex: 0 0 auto; background: none; border: none; padding: 10px 12px; font-size: 13px; color: var(--muted); cursor: pointer; border-bottom: 2px solid transparent; margin-bottom: -1px; }
.tab-btn.active { color: var(--accent-strong); border-color: var(--accent); font-weight: 700; }
.tab-panel { display: none; }
.tab-panel.active { display: block; }
.sync-result { background: var(--surface-muted); border: 1px solid var(--border); border-radius: var(--radius); padding: 14px; margin-top: 14px; }
.sync-result p { margin: 4px 0; font-size: 13px; white-space: pre-line; }
#loginBar { display: flex; gap: 8px; flex: 0 0 auto; }
@media (max-width: 720px) { body { padding: 12px 10px 32px; } .card { padding: 15px; } .info-bar { grid-template-columns: repeat(2, minmax(0, 1fr)); } .info-item:nth-child(2) { border-right: 0; } .info-item:nth-child(-n+2) { border-bottom: 1px solid var(--border); } .btn-group > .btn { flex: 1 1 calc(50% - 4px); } .file-item { grid-template-columns: 1fr; } .file-actions { justify-content: flex-start; } .modal { padding: 18px; margin-top: 8px; } .config-grid { grid-template-columns: 1fr; } }
@media (prefers-reduced-motion: reduce) { *, *::before, *::after { scroll-behavior: auto !important; animation-duration: .01ms !important; transition-duration: .01ms !important; } }
</style>
</head>
<body>
<svg aria-hidden="true" style="display:none" xmlns="http://www.w3.org/2000/svg">
  <symbol id="cloud" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g></symbol>
  <symbol id="lock" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="11" rx="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></g></symbol>
  <symbol id="unlock" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="11" rx="2"/><path d="M7 11V7a5 5 0 0 1 9.9-1"/></g></symbol>
  <symbol id="arrows-expand" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></g></symbol>
  <symbol id="link" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/></g></symbol>
  <symbol id="settings" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-2.82 1.18V21a2 2 0 1 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 3.17 14H3a2 2 0 1 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 10 3.17V3a2 2 0 1 1 4 0v.09A1.65 1.65 0 0 0 15 4.6a1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 20.83 10H21a2 2 0 1 1 0 4h-.09A1.65 1.65 0 0 0 19.4 15Z"/></g></symbol>
  <symbol id="copy" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></g></symbol>
  <symbol id="arrow-left" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="19" y1="12" x2="5" y2="12"/><polyline points="12 19 5 12 12 5"/></g></symbol>
  <symbol id="flash" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/></g></symbol>
  <symbol id="external-link" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></g></symbol>
  <symbol id="edit" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3Z"/></g></symbol>
  <symbol id="delete" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></g></symbol>
  <symbol id="x" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M18 6 6 18M6 6l12 12"/></g></symbol>
</svg>
<div id="dropOverlay" aria-hidden="true">
  <div class="drop-overlay-content">
    <svg aria-hidden="true"><use href="#cloud"></use></svg>
    <strong>松开即可上传</strong>
    <span>文件将使用当前上传配置</span>
  </div>
</div>
<div class="card">
  <div class="title">
    <div class="brand"><svg aria-hidden="true"><use href="#cloud"></use></svg><span>${siteName}</span></div>
    <div id="loginBar">
      <button class="btn" id="loginBtn" onclick="toggleLogin()"><svg aria-hidden="true"><use href="#lock"></use></svg>登录</button>
      <button class="btn btn-secondary" id="logoutBtn" style="display:none" onclick="logout()"><svg aria-hidden="true"><use href="#unlock"></use></svg>退出</button>
    </div>
  </div>
  <div class="info-bar">
    <div class="info-item">存储：${formatSize(usedSize)} / ${formatSize(MAX_TOTAL_SIZE)} (${storagePercent}%)</div>
    <div class="info-item">A类：${todayAclass}/${DAILY_MAX_A_CLASS}</div>
    <div class="info-item">B类：按平台额度</div>
    <div class="info-item">单文件 ≤${maxMultipartSizeGB}GB</div>
  </div>
  <div class="btn-group">
    <button class="btn" onclick="openUpload()"><svg aria-hidden="true"><use href="#cloud"></use></svg>上传文件</button>
    <button class="btn btn-secondary" onclick="loadList()"><svg aria-hidden="true"><use href="#arrows-expand"></use></svg>刷新列表</button>
    <button class="btn btn-secondary" id="shareMgrBtn" style="display:none" onclick="openShareManager()"><svg aria-hidden="true"><use href="#link"></use></svg>分享管理</button>
    <button class="btn btn-secondary" id="setBtn" style="display:none" onclick="openAdminPanel()"><svg aria-hidden="true"><use href="#settings"></use></svg>管理面板</button>
  </div>
</div>
<div class="card">
  <div class="title">文件列表</div>
  <div id="fileList"><div class="list-state">请先登录</div></div>
  <div class="pagination" id="filePagination" hidden>
    <button id="filePrevBtn" type="button" title="上一页" aria-label="上一页"><svg aria-hidden="true"><use href="#arrow-left"></use></svg></button>
    <span id="filePageStatus">第 1 页</span>
    <button id="fileNextBtn" type="button" title="下一页" aria-label="下一页"><svg aria-hidden="true" style="transform:rotate(180deg)"><use href="#arrow-left"></use></svg></button>
  </div>
</div>

<!-- 登录模态框 -->
<div class="modal-overlay" id="loginModal">
  <div class="modal">
    <div class="modal-header">
      <h3>管理员验证</h3>
      <button class="modal-close" type="button" aria-label="关闭登录窗口" onclick="closeLoginModal()">×</button>
    </div>
    <p style="color:#666;margin-bottom:16px;">请输入密码（管理员或用户密码）</p>
    <input type="password" id="loginPassInput" aria-label="密码" placeholder="密码" style="width:100%;padding:12px;border-radius:6px;border:1px solid #b9c7c3;margin-bottom:16px;">
    <div class="btn-group">
      <button class="btn" onclick="submitLogin()">登录</button>
    </div>
  </div>
</div>

<!-- 上传模态框 -->
<div class="modal-overlay" id="uploadModal">
  <div class="modal">
    <div class="modal-header">
      <h3>上传文件</h3>
      <button class="modal-close" type="button" aria-label="关闭上传窗口" onclick="closeUpload()">×</button>
    </div>
    <div class="upload-area" id="uploadArea" role="button" tabindex="0">点击或拖拽上传（≤${maxMultipartSizeGB}GB）</div>
    <div class="progress-wrapper" id="progressWrapper" style="display:none">
      <div class="progress-bar-container">
        <div class="progress-bar" id="progressBar"></div>
      </div>
      <div class="progress-text" id="progressText"></div>
      <button class="btn-cancel" id="cancelUploadBtn" onclick="cancelUpload()">取消上传</button>
    </div>
  </div>
</div>

<!-- 删除确认 -->
<div class="modal-overlay" id="delModal">
  <div class="modal">
    <h3 id="deleteConfirmTitle">确认删除文件？</h3><p id="deleteConfirmMessage">文件及其全部分享将被永久删除，无法恢复。</p>
    <div class="confirm-btns">
      <button class="confirm-no" onclick="closeDel()">取消</button>
      <button class="confirm-yes" onclick="doDel()">确认删除</button>
    </div>
  </div>
</div>

<!-- 生成分享 -->
<div class="modal-overlay" id="shareModal">
  <div class="modal">
    <div class="modal-header">
      <h3>生成分享</h3>
      <button class="modal-close" type="button" aria-label="关闭分享窗口" onclick="closeShare()">×</button>
    </div>
    <div style="padding:10px 0;color:#666">分享链接永久有效</div>
    <div id="shareLink" class="share-token" style="padding:14px;background:var(--surface-muted);border:1px solid var(--border);border-radius:8px;word-break:break-all;margin:10px 0"></div>
    <button class="btn" onclick="copyShare()"><svg aria-hidden="true"><use href="#copy"></use></svg>复制完整链接</button>
  </div>
</div>

<!-- 分享管理 -->
<div class="modal-overlay" id="shareMgrModal">
  <div class="modal">
    <div class="modal-header">
      <h3>分享管理</h3>
      <button class="modal-close" type="button" aria-label="关闭分享管理" onclick="closeShareManager()">×</button>
    </div>
    <div id="shareList" style="max-height:400px;overflow-y:auto;padding-right:4px;"></div>
  </div>
</div>

<!-- 修改分享路径 -->
<div class="modal-overlay" id="tokenModal">
  <div class="modal">
    <div class="modal-header">
      <h3>修改分享路径</h3>
      <button class="modal-close" type="button" aria-label="关闭路径编辑" onclick="closeTokenModal()">×</button>
    </div>
    <div class="form-item">
      <label>分享路径</label>
      <input type="text" id="newTokenInput" minlength="1" maxlength="64" pattern="[A-Za-z0-9_-]{1,64}" placeholder="例如 project-release">
    </div>
    <div style="color:#86909c;font-size:13px;margin-bottom:14px;">修改后原分享链接将失效，请重新复制新链接</div>
    <button class="btn" style="width:100%" onclick="submitTokenUpdate()">确认修改</button>
  </div>
</div>

<!-- 管理面板 -->
<div class="modal-overlay" id="adminPanel">
  <div class="modal">
    <div class="modal-header">
      <h3>管理面板</h3>
      <button class="modal-close" type="button" aria-label="关闭管理面板" onclick="closeAdminPanel()">×</button>
    </div>
    <div class="tab-bar">
      <button class="tab-btn active" data-tab="tabPwd">修改密码</button>
      <button class="tab-btn" data-tab="tabSite">站点配置</button>
      <button class="tab-btn" data-tab="tabSync">列表同步</button>
      <button class="tab-btn" data-tab="tabHidden">隐藏列表</button>
      <button class="tab-btn" data-tab="tabHiddenShares">隐藏分享</button>
    </div>
    <div class="tab-panel active" id="tabPwd">
      <div class="form-item">
        <label>类型</label>
        <select id="pwdType"><option value="admin">管理员</option><option value="user">用户</option></select>
      </div>
      <div class="form-item"><label>原密码</label><input type="password" id="oldPwd"></div>
      <div class="form-item"><label>新密码</label><input type="password" id="newPwd" minlength="6" maxlength="128"></div>
      <button class="btn" style="width:100%" onclick="savePwd()">保存密码</button>
    </div>
    <div class="tab-panel" id="tabSite">
      <div class="config-grid">
        <div class="form-item">
          <label>网站名称</label>
          <input type="text" id="siteNameInput" value="${siteName}">
        </div>
        <div class="form-item">
          <label>图标链接(Favicon)</label>
          <input type="text" id="faviconInput" value="${faviconUrl}">
        </div>
        <div class="form-item">
          <label>分片上传上限(MiB)</label>
          <input type="number" id="maxMultipartSizeInput" min="5" max="1024" step="1" value="${MAX_MULTIPART_SIZE / 1024 / 1024}">
        </div>
        <div class="form-item">
          <label>总容量上限(GiB)</label>
          <input type="number" id="maxTotalSizeInput" min="0.1" max="10000" step="0.1" value="${Number((MAX_TOTAL_SIZE / 1024 / 1024 / 1024).toFixed(2))}">
        </div>
        <div class="form-item">
          <label>每日 A 类操作上限</label>
          <input type="number" id="dailyMaxInput" min="1" max="100000" step="1" value="${DAILY_MAX_A_CLASS}">
        </div>
        <div class="form-item">
          <label>普通用户下载有效期(秒)</label>
          <input type="number" id="downloadTtlInput" min="60" max="3600" step="1" value="${USER_DOWNLOAD_TTL}">
        </div>
        <div class="form-item form-item-wide">
          <label for="previewExtensionEntry">在线预览扩展名</label>
          <div class="extension-editor" id="previewExtensionEditor">
            <div class="extension-tags" id="previewExtensionTags"></div>
            <input type="text" class="extension-entry" id="previewExtensionEntry" autocomplete="off" spellcheck="false" placeholder="例如 mdx 或 mdx=text/markdown">
          </div>
          <input type="hidden" id="previewExtensionsInput" value="${PREVIEW_EXTENSIONS}">
        </div>
      </div>
      <button class="btn btn-secondary" style="width:100%;margin-top:12px" onclick="saveSite()">保存站点配置</button>
    </div>
    <div class="tab-panel" id="tabSync">
      <p style="margin-bottom:12px;color:#666">自动对比 R2 的 pan/ 目录与数据库记录，补全缺失文件并清理新目录中的无效元数据。</p>
      <button class="btn" onclick="startSync()"><svg aria-hidden="true"><use href="#flash"></use></svg>开始同步</button>
      <div class="sync-result" id="syncResult" style="display:none">
        <p id="syncStatus">同步中...</p>
        <p id="syncDetail"></p>
      </div>
    </div>
    <div class="tab-panel" id="tabHidden">
      <p style="margin-bottom:12px;color:#666">以下为已隐藏的文件，可在此处解除隐藏。</p>
      <div id="hiddenFileList" style="max-height:400px;overflow-y:auto;padding-right:4px;"></div>
    </div>
    <div class="tab-panel" id="tabHiddenShares">
      <p style="margin-bottom:12px;color:#666">以下分享仅从常规列表隐藏，原链接仍可访问或下载。</p>
      <div id="hiddenShareList" style="max-height:400px;overflow-y:auto;padding-right:4px;"></div>
    </div>
  </div>
</div>

<input type="file" id="fileInput">
<div class="toast" id="toast"></div>

<script>
const loginModal = document.getElementById('loginModal');
const loginPassInput = document.getElementById('loginPassInput');
const loginBtn = document.getElementById('loginBtn');
const logoutBtn = document.getElementById('logoutBtn');
const shareMgrBtn = document.getElementById('shareMgrBtn');
const setBtn = document.getElementById('setBtn');
const fileList = document.getElementById('fileList');
const filePagination = document.getElementById('filePagination');
const filePrevBtn = document.getElementById('filePrevBtn');
const fileNextBtn = document.getElementById('fileNextBtn');
const filePageStatus = document.getElementById('filePageStatus');
const toast = document.getElementById('toast');
const uploadModal = document.getElementById('uploadModal');
const uploadArea = document.getElementById('uploadArea');
const dropOverlay = document.getElementById('dropOverlay');
const progressBar = document.getElementById('progressBar');
const progressWrapper = document.getElementById('progressWrapper');
const progressText = document.getElementById('progressText');
const fileInput = document.getElementById('fileInput');
const delModal = document.getElementById('delModal');
const deleteConfirmTitle = document.getElementById('deleteConfirmTitle');
const deleteConfirmMessage = document.getElementById('deleteConfirmMessage');
const shareModal = document.getElementById('shareModal');
const shareLinkDiv = document.getElementById('shareLink');
const shareMgrModal = document.getElementById('shareMgrModal');
const shareList = document.getElementById('shareList');
const tokenModal = document.getElementById('tokenModal');
const newTokenInput = document.getElementById('newTokenInput');
const adminPanel = document.getElementById('adminPanel');
const syncResult = document.getElementById('syncResult');
const syncStatus = document.getElementById('syncStatus');
const syncDetail = document.getElementById('syncDetail');
const hiddenFileList = document.getElementById('hiddenFileList');
const hiddenShareList = document.getElementById('hiddenShareList');
const previewExtensionsInput = document.getElementById('previewExtensionsInput');
const previewExtensionEntry = document.getElementById('previewExtensionEntry');
const previewExtensionTags = document.getElementById('previewExtensionTags');
const PREVIEW_EXTENSION_PATTERN = /^[\\p{L}\\p{N}][\\p{L}\\p{N}_+-]{0,63}$/u;
const previewMimeTypes = Object.assign(Object.create(null), ${JSON.stringify(PREVIEW_MIME_TYPES)});
const MAX_LARGE_UPLOAD_SIZE = ${MAX_MULTIPART_SIZE};
const MULTIPART_CONCURRENCY = 3;

let isAdmin = false;
let delKey = '';
let delSource = 'visible';
let delType = 'file';
let shareUrl = '';
let currentMultipartSessionId = '';
let currentMultipartStorageKey = '';
let multipartStopped = false;
let uploadInProgress = false;
let pendingDroppedFile = null;
let fileDragDepth = 0;
const activePartXhrs = new Set();
let editingPath = '';
let toastTimer = 0;
let filePageIndex = 0;
let filePageCursors = [null];
let fileNextCursor = null;
let shareRows = [];
let shareNextCursor = null;
let hiddenFileRows = [];
let hiddenFileNextCursor = null;
let hiddenShareRows = [];
let hiddenShareNextCursor = null;
let previewExtensionValues = previewExtensionsInput.value
  .split(',')
  .map(function (value) { return value.trim().toLowerCase(); })
  .filter(function (value, index, values) { return PREVIEW_EXTENSION_PATTERN.test(value) && values.indexOf(value) === index; });

function showToast(message, type) {
  window.clearTimeout(toastTimer);
  toast.textContent = String(message || '操作失败');
  toast.className = 'toast ' + (type || 'info');
  toast.style.display = 'block';
  toastTimer = window.setTimeout(function () { toast.style.display = 'none'; }, 3200);
}

function getToken() {
  return sessionStorage.getItem('adminToken') || '';
}

function formatSize(size) {
  const value = Number(size) || 0;
  if (value < 1024) return value + 'B';
  if (value < 1024 * 1024) return (value / 1024).toFixed(1) + 'KB';
  if (value < 1024 * 1024 * 1024) return (value / 1024 / 1024).toFixed(1) + 'MB';
  return (value / 1024 / 1024 / 1024).toFixed(1) + 'GB';
}

function element(tagName, className, textValue) {
  const node = document.createElement(tagName);
  if (className) node.className = className;
  if (textValue !== undefined) node.textContent = String(textValue);
  return node;
}

function icon(name) {
  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
  const use = document.createElementNS('http://www.w3.org/2000/svg', 'use');
  svg.setAttribute('aria-hidden', 'true');
  use.setAttribute('href', '#' + name);
  svg.appendChild(use);
  return svg;
}

function actionButton(label, className, iconName, handler) {
  const button = element('button', 'action-btn ' + (className || ''));
  button.type = 'button';
  if (iconName) button.appendChild(icon(iconName));
  button.appendChild(document.createTextNode(label));
  button.addEventListener('click', handler);
  return button;
}

function syncPreviewExtensions() {
  previewExtensionsInput.value = previewExtensionValues.join(',');
}

function normalizePreviewMimeType(value) {
  const contentType = String(value || '').trim().toLowerCase();
  if (contentType.length > 127) return '';
  const parts = contentType.split('/');
  const tokenPattern = /^[a-z0-9!#$&^_.+-]+$/;
  return parts.length === 2 && tokenPattern.test(parts[0]) && tokenPattern.test(parts[1]) ? parts.join('/') : '';
}

function renderPreviewExtensionTags() {
  const fragment = document.createDocumentFragment();
  previewExtensionValues.forEach(function (value) {
    const button = element('button', 'extension-tag');
    button.type = 'button';
    button.title = '移除 ' + value;
    button.setAttribute('aria-label', '移除 ' + value);
    button.appendChild(document.createTextNode(value));
    if (Object.prototype.hasOwnProperty.call(previewMimeTypes, value)) {
      button.appendChild(element('span', 'extension-mime', previewMimeTypes[value]));
    }
    button.appendChild(icon('x'));
    button.addEventListener('click', function () { removePreviewExtension(value); });
    fragment.appendChild(button);
  });
  previewExtensionTags.replaceChildren(fragment);
  syncPreviewExtensions();
}

function removePreviewExtension(value) {
  if (previewExtensionValues.length <= 1) {
    showToast('至少保留一个预览格式', 'warn');
    return;
  }
  previewExtensionValues = previewExtensionValues.filter(function (item) { return item !== value; });
  delete previewMimeTypes[value];
  renderPreviewExtensionTags();
  previewExtensionEntry.focus();
}

function addPreviewExtensions(rawValue) {
  const candidates = String(rawValue || '').replaceAll('，', ',').split(',');
  let rejected = false;
  candidates.forEach(function (candidate) {
    const separatorIndex = candidate.indexOf('=');
    const rawExtension = separatorIndex === -1 ? candidate : candidate.slice(0, separatorIndex);
    const contentType = separatorIndex === -1 ? '' : normalizePreviewMimeType(candidate.slice(separatorIndex + 1));
    let value = rawExtension.trim().toLowerCase();
    while (value.startsWith('.')) value = value.slice(1);
    if (!value) return;
    if (!PREVIEW_EXTENSION_PATTERN.test(value) || (separatorIndex !== -1 && !contentType)) {
      rejected = true;
      return;
    }
    if (!previewExtensionValues.includes(value)) previewExtensionValues.push(value);
    if (contentType) previewMimeTypes[value] = contentType;
  });
  previewExtensionEntry.value = '';
  renderPreviewExtensionTags();
  if (rejected) showToast('扩展名或 MIME 格式无效', 'warn');
}

function setListState(container, message) {
  container.replaceChildren(element('div', 'list-state', message));
}

function showSkeleton(container) {
  const fragment = document.createDocumentFragment();
  for (let i = 0; i < 4; i += 1) fragment.appendChild(element('div', 'skeleton-row'));
  container.replaceChildren(fragment);
}

function appendLoadMore(container, handler) {
  const wrapper = element('div', 'pagination');
  const button = element('button', '', '更多');
  button.type = 'button';
  button.title = '加载下一页';
  button.style.width = 'auto';
  button.style.padding = '0 12px';
  button.addEventListener('click', handler);
  wrapper.appendChild(button);
  container.appendChild(wrapper);
}

async function apiFetch(path, options) {
  const requestOptions = options ? Object.assign({}, options) : {};
  const headers = new Headers(requestOptions.headers || {});
  headers.set('Authorization', 'Bearer ' + getToken());
  requestOptions.headers = headers;
  const response = await fetch(path, requestOptions);
  let data = null;
  try { data = await response.json(); } catch (_) {}
  if (!response.ok || !data || data.code !== 0) {
    if (response.status === 401) logout(false);
    throw new Error(data && data.msg ? data.msg : '请求失败（HTTP ' + response.status + '）');
  }
  return data;
}

function setLoggedIn(role) {
  isAdmin = role === 'admin';
  loginBtn.style.display = 'none';
  logoutBtn.style.display = 'inline-flex';
  shareMgrBtn.style.display = isAdmin ? 'inline-flex' : 'none';
  setBtn.style.display = isAdmin ? 'inline-flex' : 'none';
}

async function checkLoginStatus() {
  if (!getToken()) return;
  try {
    const response = await fetch('/api/verify-token', {
      method: 'POST',
      headers: { Authorization: 'Bearer ' + getToken() }
    });
    const data = await response.json();
    if (!response.ok || !data.valid) throw new Error('登录已失效');
    setLoggedIn(data.role);
    await loadList();
  } catch (_) {
    sessionStorage.removeItem('adminToken');
    setListState(fileList, '请先登录');
  }
}

function toggleLogin() {
  loginPassInput.value = '';
  loginModal.style.display = 'flex';
  window.setTimeout(function () { loginPassInput.focus(); }, 0);
}

function closeLoginModal() { loginModal.style.display = 'none'; pendingDroppedFile = null; }

function logout(showMessage) {
  sessionStorage.removeItem('adminToken');
  isAdmin = false;
  loginBtn.style.display = 'inline-flex';
  logoutBtn.style.display = 'none';
  shareMgrBtn.style.display = 'none';
  setBtn.style.display = 'none';
  filePagination.hidden = true;
  setListState(fileList, '请先登录');
  if (showMessage !== false) showToast('已退出登录', 'info');
}

async function submitLogin() {
  const password = loginPassInput.value;
  if (!password) return showToast('请输入密码', 'warn');
  try {
    const response = await fetch('/api/login', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ password: password })
    });
    const data = await response.json();
    if (!response.ok || data.code !== 0) throw new Error(data.msg || '登录失败');
    sessionStorage.setItem('adminToken', data.token);
    setLoggedIn(data.role);
    const droppedFile = pendingDroppedFile;
    pendingDroppedFile = null;
    closeLoginModal();
    showToast('登录成功', 'success');
    await loadList();
    if (droppedFile) startDroppedUpload(droppedFile);
  } catch (error) {
    showToast(error.message, 'error');
  }
}

function renderFiles(files) {
  if (!files.length) return setListState(fileList, '当前页没有文件');
  const fragment = document.createDocumentFragment();
  files.forEach(function (file) {
    const row = element('div', 'file-item');
    const info = element('div', 'file-info');
    info.appendChild(element('div', 'file-name', file.name));
    info.appendChild(element('div', 'file-size', formatSize(file.size)));
    const actions = element('div', 'file-actions');
    actions.appendChild(actionButton('打开', 'primary', 'external-link', function () { openFile(file.key); }));
    if (isAdmin) {
      actions.appendChild(actionButton('分享', '', 'link', function () { createShare(file.key); }));
      actions.appendChild(actionButton('隐藏', 'warning', 'lock', function () { hideFile(file.key); }));
      actions.appendChild(actionButton('删除', 'danger', 'delete', function () { openDel(file.key); }));
    }
    row.append(info, actions);
    fragment.appendChild(row);
  });
  fileList.replaceChildren(fragment);
}

async function loadList(reset) {
  if (!getToken()) return setListState(fileList, '请先登录');
  if (reset !== false) {
    filePageIndex = 0;
    filePageCursors = [null];
  }
  showSkeleton(fileList);
  try {
    const cursor = filePageCursors[filePageIndex];
    const query = cursor ? '?cursor=' + encodeURIComponent(cursor) : '';
    const data = await apiFetch('/api/list' + query);
    fileNextCursor = data.pagination && data.pagination.nextCursor;
    renderFiles(Array.isArray(data.data) ? data.data : []);
    filePagination.hidden = false;
    filePrevBtn.disabled = filePageIndex === 0;
    fileNextBtn.disabled = !fileNextCursor;
    filePageStatus.textContent = '第 ' + (filePageIndex + 1) + ' 页';
  } catch (error) {
    setListState(fileList, error.message);
    filePagination.hidden = true;
    showToast(error.message, 'error');
  }
}

filePrevBtn.addEventListener('click', function () {
  if (filePageIndex > 0) {
    filePageIndex -= 1;
    loadList(false);
  }
});

fileNextBtn.addEventListener('click', function () {
  if (!fileNextCursor) return;
  filePageIndex += 1;
  filePageCursors[filePageIndex] = fileNextCursor;
  loadList(false);
});

async function openFile(key) {
  try {
    const data = await apiFetch('/api/getDownloadToken?key=' + encodeURIComponent(key));
    const anchor = document.createElement('a');
    anchor.href = data.url;
    anchor.target = '_blank';
    anchor.rel = 'noopener';
    document.body.appendChild(anchor);
    anchor.click();
    anchor.remove();
  } catch (error) { showToast(error.message, 'error'); }
}

function openUpload() {
  if (!getToken()) return toggleLogin();
  prepareUploadModal();
}

function prepareUploadModal() {
  uploadModal.style.display = 'flex';
  progressWrapper.style.display = 'none';
  progressBar.style.width = '0%';
  progressText.textContent = '';
  fileInput.value = '';
}

function closeUpload() {
  cancelUpload(false);
}

function abortActivePartRequests() {
  activePartXhrs.forEach(function (xhr) { xhr.abort(); });
}

async function cancelUpload(showMessage) {
  multipartStopped = true;
  abortActivePartRequests();
  const sessionId = currentMultipartSessionId;
  const storageKey = currentMultipartStorageKey;
  if (sessionId) {
    try {
      await apiFetch('/api/multipart/abort', {
        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionId: sessionId })
      });
      if (storageKey) localStorage.removeItem(storageKey);
      currentMultipartSessionId = '';
      currentMultipartStorageKey = '';
    } catch (error) {
      uploadInProgress = false;
      showToast(error.message, 'error');
      return;
    }
  }
  uploadInProgress = false;
  uploadModal.style.display = 'none';
  if (showMessage !== false) showToast('上传已取消', 'info');
}

function multipartStorageKey(file) {
  return 'pan-multipart:' + file.name + ':' + file.size + ':' + file.lastModified;
}

function readStoredMultipartSession(key) {
  try { return localStorage.getItem(key) || ''; } catch (_) { return ''; }
}

function storeMultipartSession(key, sessionId) {
  try { localStorage.setItem(key, sessionId); } catch (_) {}
}

function removeStoredMultipartSession(key) {
  try { localStorage.removeItem(key); } catch (_) {}
}

function updateMultipartProgress(fileSize, completedSizes, activeProgress, totalParts) {
  let loaded = 0;
  completedSizes.forEach(function (size) { loaded += size; });
  activeProgress.forEach(function (size, partNumber) {
    if (!completedSizes.has(partNumber)) loaded += size;
  });
  loaded = Math.min(loaded, fileSize);
  const percent = Math.floor(loaded / fileSize * 100);
  progressBar.style.width = percent + '%';
  progressText.textContent = percent + '% · 分片 ' + completedSizes.size + '/' + totalParts + ' · ' + formatSize(loaded) + ' / ' + formatSize(fileSize);
}

async function getOrCreateMultipartSession(file, storageKey) {
  const storedSessionId = readStoredMultipartSession(storageKey);
  if (storedSessionId) {
    try {
      const status = await apiFetch('/api/multipart/status?session=' + encodeURIComponent(storedSessionId));
      if (status.data.name === file.name && Number(status.data.size) === file.size) return status.data;
    } catch (_) {}
    removeStoredMultipartSession(storageKey);
  }

  const created = await apiFetch('/api/multipart/create', {
    method: 'POST', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ name: file.name, size: file.size, type: file.type || '' })
  });
  storeMultipartSession(storageKey, created.data.sessionId);
  return created.data;
}

function uploadMultipartPart(file, session, partNumber, completedSizes, activeProgress) {
  return new Promise(function (resolve, reject) {
    if (multipartStopped) return reject(new Error('上传已暂停'));
    const start = (partNumber - 1) * session.partSize;
    const end = Math.min(start + session.partSize, file.size);
    const chunk = file.slice(start, end);
    const xhr = new XMLHttpRequest();
    activePartXhrs.add(xhr);
    xhr.open('PUT', '/api/multipart/part?session=' + encodeURIComponent(session.sessionId) + '&part=' + partNumber);
    xhr.setRequestHeader('Authorization', 'Bearer ' + getToken());
    xhr.upload.onprogress = function (event) {
      if (!event.lengthComputable) return;
      activeProgress.set(partNumber, event.loaded);
      updateMultipartProgress(file.size, completedSizes, activeProgress, session.totalParts);
    };
    xhr.onload = function () {
      activePartXhrs.delete(xhr);
      activeProgress.delete(partNumber);
      let data = null;
      try { data = JSON.parse(xhr.responseText); } catch (_) {}
      if (xhr.status >= 200 && xhr.status < 300 && data && data.code === 0) {
        completedSizes.set(partNumber, chunk.size);
        updateMultipartProgress(file.size, completedSizes, activeProgress, session.totalParts);
        resolve();
      } else {
        reject(new Error(data && data.msg ? data.msg : '第 ' + partNumber + ' 片上传失败（HTTP ' + xhr.status + '）'));
      }
    };
    xhr.onerror = function () {
      activePartXhrs.delete(xhr);
      activeProgress.delete(partNumber);
      reject(new Error('第 ' + partNumber + ' 片网络错误'));
    };
    xhr.onabort = function () {
      activePartXhrs.delete(xhr);
      activeProgress.delete(partNumber);
      reject(new Error('上传已暂停'));
    };
    xhr.send(chunk);
  });
}

async function startMultipartUpload(file) {
  progressWrapper.style.display = 'block';
  progressBar.style.width = '0%';
  progressText.textContent = '正在创建分片上传会话';
  multipartStopped = false;
  const storageKey = multipartStorageKey(file);
  currentMultipartStorageKey = storageKey;

  try {
    const session = await getOrCreateMultipartSession(file, storageKey);
    currentMultipartSessionId = session.sessionId;
    if (multipartStopped) {
      try {
        await apiFetch('/api/multipart/abort', {
          method: 'POST', headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ sessionId: session.sessionId })
        });
        removeStoredMultipartSession(storageKey);
        currentMultipartSessionId = '';
        currentMultipartStorageKey = '';
      } catch (_) {}
      uploadInProgress = false;
      return;
    }
    const completedSizes = new Map();
    (session.uploadedParts || []).forEach(function (part) {
      completedSizes.set(Number(part.partNumber), Number(part.size));
    });
    const activeProgress = new Map();
    const pendingParts = [];
    for (let partNumber = 1; partNumber <= session.totalParts; partNumber += 1) {
      if (!completedSizes.has(partNumber)) pendingParts.push(partNumber);
    }
    updateMultipartProgress(file.size, completedSizes, activeProgress, session.totalParts);

    let nextIndex = 0;
    async function uploadWorker() {
      while (!multipartStopped && nextIndex < pendingParts.length) {
        const partNumber = pendingParts[nextIndex];
        nextIndex += 1;
        await uploadMultipartPart(file, session, partNumber, completedSizes, activeProgress);
      }
    }
    const workers = [];
    const workerCount = Math.min(MULTIPART_CONCURRENCY, pendingParts.length);
    for (let index = 0; index < workerCount; index += 1) workers.push(uploadWorker());
    try {
      await Promise.all(workers);
    } catch (error) {
      multipartStopped = true;
      abortActivePartRequests();
      throw error;
    }
    if (multipartStopped) return;

    progressBar.style.width = '100%';
    progressText.textContent = '分片上传完成，正在合并文件';
    await apiFetch('/api/multipart/complete', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ sessionId: session.sessionId })
    });
    removeStoredMultipartSession(storageKey);
    currentMultipartSessionId = '';
    currentMultipartStorageKey = '';
    uploadModal.style.display = 'none';
    uploadInProgress = false;
    showToast('分片上传完成', 'success');
    loadList();
  } catch (error) {
    if (!multipartStopped) multipartStopped = true;
    uploadInProgress = false;
    progressText.textContent = '上传已暂停，重新选择同一文件可继续';
    showToast(error.message, 'error');
  }
}

function startUpload(file) {
  if (!file) return;
  if (uploadInProgress) return showToast('已有上传任务正在进行', 'warn');
  if (file.size <= 0) return showToast('不能上传空文件', 'warn');
  if (file.size > MAX_LARGE_UPLOAD_SIZE) return showToast('文件超过 1GB 上传上限', 'error');
  uploadInProgress = true;
  startMultipartUpload(file);
}

uploadArea.addEventListener('click', function () { fileInput.click(); });
uploadArea.addEventListener('keydown', function (event) {
  if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); fileInput.click(); }
});
fileInput.addEventListener('change', function () { startUpload(fileInput.files[0]); });

function isFileDrag(event) {
  if (!event.dataTransfer) return false;
  return Array.from(event.dataTransfer.types || []).includes('Files') || Boolean(event.dataTransfer.files && event.dataTransfer.files.length);
}

function resetFileDrag() {
  fileDragDepth = 0;
  dropOverlay.classList.remove('active');
}

function startDroppedUpload(file) {
  if (!file) return;
  if (uploadInProgress) return showToast('已有上传任务正在进行', 'warn');
  if (!getToken()) {
    pendingDroppedFile = file;
    toggleLogin();
    showToast('登录后将自动开始上传', 'info');
    return;
  }
  prepareUploadModal();
  startUpload(file);
}

document.addEventListener('dragenter', function (event) {
  if (!isFileDrag(event)) return;
  event.preventDefault();
  fileDragDepth += 1;
  dropOverlay.classList.add('active');
});

document.addEventListener('dragover', function (event) {
  if (!isFileDrag(event)) return;
  event.preventDefault();
  event.dataTransfer.dropEffect = 'copy';
});

document.addEventListener('dragleave', function (event) {
  if (fileDragDepth === 0) return;
  if (event.relatedTarget === null) return resetFileDrag();
  fileDragDepth = Math.max(0, fileDragDepth - 1);
  if (fileDragDepth === 0) dropOverlay.classList.remove('active');
});

document.addEventListener('drop', function (event) {
  if (!isFileDrag(event)) return;
  event.preventDefault();
  const files = event.dataTransfer.files;
  resetFileDrag();
  if (!files || files.length === 0) return;
  if (files.length > 1) return showToast('一次只能上传一个文件', 'warn');
  startDroppedUpload(files[0]);
});

window.addEventListener('blur', resetFileDrag);

function openDel(key, source, type) {
  delKey = key;
  delSource = source === 'hidden' ? 'hidden' : 'visible';
  delType = type === 'share' ? 'share' : 'file';
  deleteConfirmTitle.textContent = delType === 'share' ? '确认删除分享？' : '确认删除文件？';
  deleteConfirmMessage.textContent = delType === 'share'
    ? '分享链接将永久失效，无法恢复。'
    : '文件及其全部分享将被永久删除，无法恢复。';
  delModal.style.display = 'flex';
}
function closeDel() { delModal.style.display = 'none'; delKey = ''; delSource = 'visible'; delType = 'file'; }

async function doDel() {
  const key = delKey;
  const source = delSource;
  const type = delType;
  closeDel();
  try {
    if (type === 'share') {
      await apiFetch('/api/deleteShare', {
        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ token: key })
      });
      showToast('分享已删除', 'success');
      await loadShareList(null, false);
      return;
    }
    await apiFetch('/api/delete', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key: key })
    });
    showToast('文件已删除', 'success');
    if (source === 'hidden') await loadHiddenFiles(null, false);
    else await loadList(false);
  } catch (error) { showToast(error.message, 'error'); }
}

async function createShare(key) {
  try {
    const data = await apiFetch('/api/createShare', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key: key })
    });
    shareUrl = data.link;
    shareLinkDiv.textContent = shareUrl;
    shareModal.style.display = 'flex';
  } catch (error) { showToast(error.message, 'error'); }
}

function closeShare() { shareModal.style.display = 'none'; }

async function copyText(value) {
  if (navigator.clipboard && window.isSecureContext) return navigator.clipboard.writeText(value);
  const input = document.createElement('textarea');
  input.value = value;
  input.style.position = 'fixed';
  input.style.opacity = '0';
  document.body.appendChild(input);
  input.select();
  document.execCommand('copy');
  input.remove();
}

async function copyShare() {
  try { await copyText(shareUrl); showToast('完整链接已复制', 'success'); }
  catch (_) { showToast('复制失败，请手动复制', 'error'); }
}

function shareLinkFor(item) {
  try {
    const parsed = new URL(item.link, location.origin);
    if (parsed.origin === location.origin) return parsed.href;
  } catch (_) {}
  return location.origin + '/' + encodeURIComponent(item.token);
}

function renderShares() {
  if (!shareRows.length) return setListState(shareList, '暂无分享链接');
  const fragment = document.createDocumentFragment();
  shareRows.forEach(function (item) {
    const row = element('div', 'share-item');
    row.appendChild(element('div', 'share-filename', item.fileName));
    const fullLink = shareLinkFor(item);
    const link = element('a', 'share-token', fullLink);
    link.href = fullLink;
    link.target = '_blank';
    link.rel = 'noopener';
    row.appendChild(link);
    const actions = element('div', 'share-row');
    actions.appendChild(actionButton('复制', 'primary', 'copy', function () {
      copyText(fullLink).then(function () { showToast('完整链接已复制', 'success'); }).catch(function () { showToast('复制失败', 'error'); });
    }));
    actions.appendChild(actionButton('改路径', '', 'edit', function () { openTokenModal(item.token); }));
    actions.appendChild(actionButton('隐藏', 'warning', 'lock', function () { hideShare(item.token); }));
    actions.appendChild(actionButton('删除', 'danger', 'delete', function () { deleteShare(item.token); }));
    row.appendChild(actions);
    fragment.appendChild(row);
  });
  shareList.replaceChildren(fragment);
  if (shareNextCursor) appendLoadMore(shareList, function () { loadShareList(shareNextCursor, true); });
}

async function loadShareList(cursor, append) {
  if (!append) { shareRows = []; shareNextCursor = null; showSkeleton(shareList); }
  try {
    const query = cursor ? '?cursor=' + encodeURIComponent(cursor) : '';
    const data = await apiFetch('/api/listShares' + query);
    shareRows = append ? shareRows.concat(data.data || []) : (data.data || []);
    shareNextCursor = data.pagination && data.pagination.nextCursor;
    renderShares();
  } catch (error) { setListState(shareList, error.message); }
}

function openShareManager() { shareMgrModal.style.display = 'flex'; loadShareList(null, false); }
function closeShareManager() { shareMgrModal.style.display = 'none'; }

function deleteShare(path) { openDel(path, 'visible', 'share'); }

function openTokenModal(path) {
  editingPath = path;
  newTokenInput.value = path;
  tokenModal.style.display = 'flex';
  window.setTimeout(function () { newTokenInput.focus(); }, 0);
}
function closeTokenModal() { tokenModal.style.display = 'none'; editingPath = ''; }

async function submitTokenUpdate() {
  const nextPath = newTokenInput.value.trim();
  if (!/^[A-Za-z0-9_-]{1,64}$/.test(nextPath)) {
    showToast('分享路径需为 1-64 位字母、数字、下划线或连字符', 'error');
    return;
  }
  try {
    await apiFetch('/api/updateShareToken', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ oldToken: editingPath, newToken: nextPath })
    });
    closeTokenModal();
    showToast('分享路径修改成功', 'success');
    loadShareList(null, false);
  } catch (error) { showToast(error.message, 'error'); }
}

async function hideFile(key) {
  try {
    await apiFetch('/api/hideFile', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key: key })
    });
    showToast('文件已隐藏', 'success');
    loadList(false);
  } catch (error) { showToast(error.message, 'error'); }
}

async function hideShare(path) {
  try {
    await apiFetch('/api/hideShare', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ token: path })
    });
    showToast('分享已移至隐藏列表，原链接仍可访问', 'success');
    loadShareList(null, false);
  } catch (error) { showToast(error.message, 'error'); }
}

function renderHiddenFiles() {
  if (!hiddenFileRows.length) return setListState(hiddenFileList, '没有隐藏文件');
  const fragment = document.createDocumentFragment();
  hiddenFileRows.forEach(function (file) {
    const row = element('div', 'file-item');
    const info = element('div', 'file-info');
    info.appendChild(element('div', 'file-name', file.name));
    info.appendChild(element('div', 'file-size', formatSize(file.size)));
    const actions = element('div', 'file-actions');
    actions.appendChild(actionButton('恢复', 'primary', 'unlock', function () { unhideFile(file.key); }));
    actions.appendChild(actionButton('删除', 'danger', 'delete', function () { openDel(file.key, 'hidden'); }));
    row.append(info, actions);
    fragment.appendChild(row);
  });
  hiddenFileList.replaceChildren(fragment);
  if (hiddenFileNextCursor) appendLoadMore(hiddenFileList, function () { loadHiddenFiles(hiddenFileNextCursor, true); });
}

async function loadHiddenFiles(cursor, append) {
  if (!append) { hiddenFileRows = []; showSkeleton(hiddenFileList); }
  try {
    const query = cursor ? '?cursor=' + encodeURIComponent(cursor) : '';
    const data = await apiFetch('/api/listHidden' + query);
    hiddenFileRows = append ? hiddenFileRows.concat(data.data || []) : (data.data || []);
    hiddenFileNextCursor = data.pagination && data.pagination.nextCursor;
    renderHiddenFiles();
  } catch (error) { setListState(hiddenFileList, error.message); }
}

async function unhideFile(key) {
  try {
    await apiFetch('/api/unhideFile', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key: key })
    });
    showToast('文件已恢复', 'success');
    loadHiddenFiles(null, false);
    loadList();
  } catch (error) { showToast(error.message, 'error'); }
}

function renderHiddenShares() {
  if (!hiddenShareRows.length) return setListState(hiddenShareList, '没有隐藏分享');
  const fragment = document.createDocumentFragment();
  hiddenShareRows.forEach(function (item) {
    const row = element('div', 'share-item');
    row.appendChild(element('div', 'share-filename', item.fileName));
    const fullLink = shareLinkFor(item);
    row.appendChild(element('div', 'share-token', fullLink));
    const actions = element('div', 'share-row');
    actions.appendChild(actionButton('复制', 'primary', 'copy', function () {
      copyText(fullLink).then(function () { showToast('完整链接已复制', 'success'); }).catch(function () { showToast('复制失败', 'error'); });
    }));
    actions.appendChild(actionButton('恢复', '', 'unlock', function () { unhideShare(item.token); }));
    row.appendChild(actions);
    fragment.appendChild(row);
  });
  hiddenShareList.replaceChildren(fragment);
  if (hiddenShareNextCursor) appendLoadMore(hiddenShareList, function () { loadHiddenShares(hiddenShareNextCursor, true); });
}

async function loadHiddenShares(cursor, append) {
  if (!append) { hiddenShareRows = []; showSkeleton(hiddenShareList); }
  try {
    const query = cursor ? '?cursor=' + encodeURIComponent(cursor) : '';
    const data = await apiFetch('/api/listHiddenShares' + query);
    hiddenShareRows = append ? hiddenShareRows.concat(data.data || []) : (data.data || []);
    hiddenShareNextCursor = data.pagination && data.pagination.nextCursor;
    renderHiddenShares();
  } catch (error) { setListState(hiddenShareList, error.message); }
}

async function unhideShare(path) {
  try {
    await apiFetch('/api/unhideShare', {
      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ token: path })
    });
    showToast('分享已恢复', 'success');
    loadHiddenShares(null, false);
  } catch (error) { showToast(error.message, 'error'); }
}

function openAdminPanel() { adminPanel.style.display = 'flex'; }
function closeAdminPanel() { adminPanel.style.display = 'none'; }

document.querySelectorAll('.tab-btn').forEach(function (button) {
  button.addEventListener('click', function () {
    document.querySelectorAll('.tab-btn').forEach(function (item) { item.classList.remove('active'); });
    document.querySelectorAll('.tab-panel').forEach(function (item) { item.classList.remove('active'); });
    button.classList.add('active');
    document.getElementById(button.dataset.tab).classList.add('active');
    if (button.dataset.tab === 'tabHidden') loadHiddenFiles(null, false);
    if (button.dataset.tab === 'tabHiddenShares') loadHiddenShares(null, false);
  });
});

async function savePwd() {
  const type = document.getElementById('pwdType').value;
  const oldPassword = document.getElementById('oldPwd').value;
  const newPassword = document.getElementById('newPwd').value;
  try {
    const data = await apiFetch('/api/updatePass', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ type: type, old: oldPassword, new: newPassword })
    });
    showToast(data.msg, 'success');
    document.getElementById('oldPwd').value = '';
    document.getElementById('newPwd').value = '';
  } catch (error) { showToast(error.message, 'error'); }
}

async function saveSite() {
  const siteName = document.getElementById('siteNameInput').value.trim();
  const favicon = document.getElementById('faviconInput').value.trim();
  const maxMultipartSizeMb = document.getElementById('maxMultipartSizeInput').value;
  const maxTotalSizeGb = document.getElementById('maxTotalSizeInput').value;
  const dailyMaxAClass = document.getElementById('dailyMaxInput').value;
  const userDownloadTtl = document.getElementById('downloadTtlInput').value;
  if (previewExtensionEntry.value.trim()) addPreviewExtensions(previewExtensionEntry.value);
  const previewExtensions = previewExtensionsInput.value.trim();
  const activePreviewMimeTypes = {};
  previewExtensionValues.forEach(function (extension) {
    if (Object.prototype.hasOwnProperty.call(previewMimeTypes, extension)) {
      activePreviewMimeTypes[extension] = previewMimeTypes[extension];
    }
  });
  try {
    await apiFetch('/api/updateSite', {
      method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        siteName: siteName, favicon: favicon,
        maxMultipartSizeMb: maxMultipartSizeMb, maxTotalSizeGb: maxTotalSizeGb,
        dailyMaxAClass: dailyMaxAClass, userDownloadTtl: userDownloadTtl,
        previewExtensions: previewExtensions, previewMimeTypes: activePreviewMimeTypes
      })
    });
    showToast('站点配置已保存，即将刷新', 'success');
    window.setTimeout(function () { location.reload(); }, 900);
  } catch (error) { showToast(error.message, 'error'); }
}

async function startSync() {
  syncResult.style.display = 'block';
  syncStatus.textContent = '同步中，请勿重复操作';
  syncDetail.textContent = '';
  try {
    const data = await apiFetch('/api/syncFiles', { method: 'POST' });
    const result = data.data;
    syncStatus.textContent = '同步完成';
    syncDetail.textContent = '新增 ' + result.added + ' 个，清理 ' + result.deleted + ' 个\\n当前 ' + result.totalFiles + ' 个文件，共 ' + formatSize(result.totalSize);
    showToast('文件列表同步完成', 'success');
    loadList();
  } catch (error) {
    syncStatus.textContent = '同步失败';
    syncDetail.textContent = error.message;
    showToast(error.message, 'error');
  }
}

loginPassInput.addEventListener('keydown', function (event) {
  if (event.key === 'Enter') submitLogin();
});

previewExtensionEntry.addEventListener('keydown', function (event) {
  if (event.key === 'Enter' || event.key === ',') {
    event.preventDefault();
    addPreviewExtensions(previewExtensionEntry.value);
    return;
  }
  if (event.key === 'Backspace' && !previewExtensionEntry.value && previewExtensionValues.length > 1) {
    previewExtensionValues.pop();
    renderPreviewExtensionTags();
  }
});

previewExtensionEntry.addEventListener('blur', function () {
  if (previewExtensionEntry.value.trim()) addPreviewExtensions(previewExtensionEntry.value);
});

document.addEventListener('keydown', function (event) {
  if (event.key !== 'Escape') return;
  if (loginModal.style.display !== 'none') pendingDroppedFile = null;
  resetFileDrag();
  [loginModal, uploadModal, delModal, shareModal, shareMgrModal, tokenModal, adminPanel].forEach(function (modal) {
    modal.style.display = 'none';
  });
});

renderPreviewExtensionTags();
checkLoginStatus();
</script>

</body>
</html>`;
}