"use strict";

const crypto = require("node:crypto");
const { requireAuth, keyManager, preauthorizeCall, pool, withTransaction, deductImageGenerationCredits } = require("./context");
const { putObject, isOssConfigured } = require("../ossClient");
const { buildImageProviderDebug, resolveImageProviderCandidates, resolveVideoProvider, resolveTextProvider, getPostUrl } = require("../aiProviderRouter");
const { shouldSkipProvider, recordProviderSuccess, recordProviderFailure } = require("../providerCircuitBreaker");
const {
  isEnterpriseVideoBillingUser,
  markEnterpriseVideoCreditsAccepted,
  prepareEnterpriseVideoBilling,
  refundEnterpriseVideoCredits,
  reserveEnterpriseVideoCredits,
  calculateEnterpriseVideoCredits,
  getEnterpriseVideoCreditRate,
} = require("../enterpriseVideoBilling");
const {
  startPolling,
  updateTaskInDb,
  extractProviderTaskId,
  extractImageUrl,
  extractGeminiImageUrl,
  extractVideoUrl,
  parseKlingCredential,
  createKlingJwt,
  taskEvents,
} = require("../aiTaskWorker");
const {
  buildDashscopeImageSuperResolveBody,
  buildDashscopeVideoStyleTransformBody,
  normalizeImageUpscaleFactor,
  normalizeVideoStyleTransformOptions,
} = require("../aiUpscaleHelpers");

const GRSAI_IMAGE_QUALITY_MODEL_OVERRIDES = new Map([
  ["gpt-image-2", "1K"],
]);

const GRSAI_IMAGE_MAX_QUALITY = new Map([
  ["gpt-image-2", "2K"],
]);

const DASHSCOPE_IMAGE_MAX_QUALITY = new Map([
  ["wan2.7-image", "2K"],
]);

const ALIYUN_VIDEOENHAN_ENDPOINT = "https://videoenhan.cn-shanghai.aliyuncs.com/";
const ALIYUN_VIDEOENHAN_VERSION = "2020-03-20";

function toViapiAccessibleUrl(url) {
  if (!url) return url;
  const match = url.match(/^(https?:\/\/)([^.]+)\.oss-cn-(?!shanghai)[^.]+(\.aliyuncs\.com\/.*)$/i);
  if (match) {
    return `${match[1]}${match[2]}.oss-accelerate${match[3]}`;
  }
  return url;
}

const SUPER_RESOLVE_POLL_INTERVAL_MS = 3000;
const SUPER_RESOLVE_MAX_POLL_ATTEMPTS = 200;
const IMAGE_PROVIDER_SUBMIT_TIMEOUT_MS = 90_000;
const GEMINI_IMAGE_SUBMIT_TIMEOUT_MS = 180_000;
const DASHSCOPE_VIDEO_STYLE_ENDPOINT = "https://dashscope.aliyuncs.com/api/v1/services/aigc/video-generation/video-synthesis";
const DASHSCOPE_IMAGE_EDIT_ENDPOINT = "https://dashscope.aliyuncs.com/api/v1/services/aigc/image2image/image-synthesis";
const MAX_USER_ACTIVE_GENERATION_TASKS = 3;
const GENERATION_CONCURRENCY_LIMIT_MESSAGE = "最多只能同时进行3个任务";

const GPT_IMAGE_ASPECT_RATIO_TO_PIXELS = {
  "1:1": { "1K": "1024x1024", "2K": "2048x2048", "4K": "2880x2880" },
  "16:9": { "1K": "1774x887", "2K": "2048x1152", "4K": "3840x2160" },
  "9:16": { "1K": "887x1774", "2K": "1152x2048", "4K": "2160x3840" },
  "4:3": { "1K": "1536x1152", "2K": "2048x1536", "4K": "3072x2304" },
  "3:4": { "1K": "1152x1536", "2K": "1536x2048", "4K": "2304x3072" },
};

function mapAspectRatioToPixels(ratio, quality) {
  const q = String(quality || "1K").toUpperCase();
  const map = GPT_IMAGE_ASPECT_RATIO_TO_PIXELS[ratio || "1:1"];
  return map ? (map[q] || map["1K"]) : "1024x1024";
}

function mapAspectRatioToDashscopeSize(ratio, quality) {
  return mapAspectRatioToPixels(ratio, quality).replace("x", "*");
}

function normalizeQuality(value, fallback = "1K") {
  const q = String(value || fallback).trim().toUpperCase();
  if (q === "4K" || q === "2K" || q === "1K") return q;
  return fallback;
}

function clampImageQualityForModel(model, quality) {
  const normalized = normalizeQuality(quality, "2K");
  const maxQuality = DASHSCOPE_IMAGE_MAX_QUALITY.get(String(model || "").toLowerCase());
  if (maxQuality === "2K" && normalized === "4K") return "2K";
  if (maxQuality === "1K" && normalized !== "1K") return "1K";
  return normalized;
}

function clampGrsaiImageQualityForModel(model, quality) {
  const normalized = normalizeQuality(quality, "1K");
  const maxQuality = GRSAI_IMAGE_MAX_QUALITY.get(String(model || "").toLowerCase());
  if (maxQuality === "2K" && normalized === "4K") return "2K";
  if (maxQuality === "1K" && normalized !== "1K") return "1K";
  return normalized;
}

function normalizeDuration(value, min = 4, max = 15, fallback = 5) {
  const numeric = Number(value);
  if (!Number.isFinite(numeric)) return fallback;
  return Math.max(min, Math.min(max, Math.round(numeric)));
}

function normalizeRatio(value, fallback = "16:9") {
  const ratio = String(value || fallback).trim();
  return ratio === "auto" ? "adaptive" : ratio;
}

function normalizeVideoResolution(value, allowed, fallback = "720p") {
  const resolution = String(value || "").trim().toLowerCase();
  return allowed.includes(resolution) ? resolution : fallback;
}

function normalizeS2vResolution(value) {
  const resolution = String(value || "").trim().toLowerCase();
  return resolution === "480p" ? "480P" : "720P";
}

function normalizeS2vStyle(value) {
  const style = String(value || "").trim().toLowerCase();
  return ["speech", "sing", "performance"].includes(style) ? style : "speech";
}

function normalizePublicHttpUrl(value) {
  const url = String(value || "").trim();
  return /^https?:\/\//i.test(url) ? url : "";
}

function percentEncodeRpc(value) {
  return encodeURIComponent(String(value))
    .replace(/!/g, "%21")
    .replace(/'/g, "%27")
    .replace(/\(/g, "%28")
    .replace(/\)/g, "%29")
    .replace(/\*/g, "%2A");
}

function signAliyunRpcParams(method, params, accessKeySecret) {
  const canonicalQuery = Object.keys(params)
    .sort()
    .map((key) => `${percentEncodeRpc(key)}=${percentEncodeRpc(params[key])}`)
    .join("&");
  const stringToSign = `${method.toUpperCase()}&${percentEncodeRpc("/")}&${percentEncodeRpc(canonicalQuery)}`;
  return crypto.createHmac("sha1", `${accessKeySecret}&`).update(stringToSign).digest("base64");
}

function getAliyunVideoEnhanCredentials() {
  const accessKeyId =
    process.env.ALIYUN_VIDEOENHAN_ACCESS_KEY_ID ||
    process.env.ALIYUN_ACCESS_KEY_ID ||
    process.env.STS_ACCESS_KEY_ID ||
    "";
  const accessKeySecret =
    process.env.ALIYUN_VIDEOENHAN_ACCESS_KEY_SECRET ||
    process.env.ALIYUN_ACCESS_KEY_SECRET ||
    process.env.STS_ACCESS_KEY_SECRET ||
    "";
  return { accessKeyId, accessKeySecret };
}

function buildAliyunRpcRequest(action, actionParams = {}, method = "GET") {
  const { accessKeyId, accessKeySecret } = getAliyunVideoEnhanCredentials();
  if (!accessKeyId || !accessKeySecret) {
    const error = new Error("Aliyun video super-resolution is not configured");
    error.status = 501;
    throw error;
  }

  const params = {
    Action: action,
    Version: ALIYUN_VIDEOENHAN_VERSION,
    Format: "JSON",
    AccessKeyId: accessKeyId,
    SignatureMethod: "HMAC-SHA1",
    SignatureVersion: "1.0",
    SignatureNonce: crypto.randomUUID(),
    Timestamp: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
    ...actionParams,
  };
  params.Signature = signAliyunRpcParams(method.toUpperCase(), params, accessKeySecret);

  const encoded = Object.entries(params)
    .map(([key, value]) => `${percentEncodeRpc(key)}=${percentEncodeRpc(value)}`)
    .join("&");

  if (method.toUpperCase() === "POST") {
    return { url: ALIYUN_VIDEOENHAN_ENDPOINT, body: encoded, method: "POST" };
  }
  return { url: `${ALIYUN_VIDEOENHAN_ENDPOINT}?${encoded}`, method: "GET" };
}

function buildAliyunRpcUrl(action, actionParams = {}) {
  const { url } = buildAliyunRpcRequest(action, actionParams, "GET");
  return url;
}

function parseAliyunJsonResult(value) {
  if (!value) return null;
  if (typeof value === "object") return value;
  if (typeof value !== "string") return null;
  try {
    return JSON.parse(value);
  } catch {
    return null;
  }
}

async function callAliyunRpc(action, params, method = "GET") {
  const request = buildAliyunRpcRequest(action, params, method);
  const fetchOptions = { method: request.method };
  if (request.body) {
    fetchOptions.headers = { "Content-Type": "application/x-www-form-urlencoded" };
    fetchOptions.body = request.body;
  }
  const response = await fetch(request.url, fetchOptions);
  const text = await response.text().catch(() => "");
  let json = {};
  try {
    json = text ? JSON.parse(text) : {};
  } catch {
    throw new Error(`Aliyun ${action} returned non-JSON response (${response.status})`);
  }

  if (!response.ok || json.Code || json.code) {
    throw new Error(json.Message || json.message || `Aliyun ${action} returned ${response.status}`);
  }

  return json;
}

function normalizeSuperResolveBitRate(value) {
  const numeric = Number(value);
  if (!Number.isFinite(numeric)) return 10;
  return Math.max(1, Math.min(20, Math.round(numeric)));
}

function normalizeAliyunJobStatus(value) {
  return String(value || "").trim().toUpperCase();
}

async function ensureDefaultProject(userId) {
  const projectId = `web-default-${userId}`;
  const { rows } = await pool.query("SELECT id FROM projects WHERE id = $1 AND user_id = $2", [projectId, userId]);
  if (rows.length === 0) {
    const safeUserId = String(userId).replace(/[^a-zA-Z0-9_-]/g, "");
    await pool.query(
      `INSERT INTO projects (
        id,
        user_id,
        name,
        description,
        oss_key,
        storyboard_count,
        image_count,
        video_count,
        file_size,
        current_revision,
        updated_by_device_id,
        created_at,
        updated_at
      )
       VALUES ($1, $2, $3, $4, $5, 0, 0, 0, 0, 1, 'web', NOW(), NOW())
       ON CONFLICT (id) DO NOTHING`,
      [
        projectId,
        userId,
        "Default workbench",
        "Web fallback project for legacy generation requests",
        `users/${safeUserId}/projects/${projectId}/current/project.json`,
      ],
    );
  }
  return projectId;
}

async function resolveTaskProject(userId, requestedProjectId) {
  const projectId = String(requestedProjectId || "").trim().slice(0, 64);
  if (!projectId) {
    return ensureDefaultProject(userId);
  }

  const { rows } = await pool.query("SELECT id FROM projects WHERE id = $1 AND user_id = $2", [
    projectId,
    userId,
  ]);
  if (rows.length === 0) {
    const error = new Error("Project not found");
    error.status = 404;
    throw error;
  }
  return projectId;
}

async function insertTask(userId, projectId, type, params, conversationId = null, client = null) {
  if (!client) {
    return withTransaction((tx) => insertTask(userId, projectId, type, params, conversationId, tx));
  }

  await assertUserGenerationConcurrencyLimit(userId, client);
  const clientQueueId = `web-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
  const { rows: [row] } = await client.query(
    `INSERT INTO generation_tasks (user_id, project_id, conversation_id, client_queue_id, type, status, params_json, progress, created_at, updated_at)
     VALUES ($1, $2, $3, $4, $5, 'pending', $6, 0, NOW(), NOW()) RETURNING *`,
    [userId, projectId, conversationId, clientQueueId, type, JSON.stringify(params)],
  );
  return row;
}

async function assertUserGenerationConcurrencyLimit(userId, client = pool) {
  await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [`generation-tasks:${userId}`]);

  // Expire stale tasks using heartbeat-aware detection.
  // A task is considered stale if neither the server nor the client has touched it
  // in the last 10 minutes.  This is much faster than the old 30/60-minute window
  // because: if a client is actively polling, `last_poll_at` keeps the task alive;
  // if the client navigated away (or crashed), `last_poll_at` stops updating and
  // the task is freed after 10 minutes.
  await client.query(
    `UPDATE generation_tasks
     SET status = 'failed', error = '任务超时自动释放', updated_at = NOW()
     WHERE user_id = $1
       AND status IN ('pending', 'running')
       AND GREATEST(updated_at, COALESCE(last_poll_at, created_at)) < NOW() - INTERVAL '10 minutes'`,
    [userId],
  );

  const { rows } = await client.query(
    "SELECT COUNT(*)::int AS active_count FROM generation_tasks WHERE user_id = $1 AND status IN ('pending', 'running')",
    [userId],
  );
  const activeCount = Number(rows[0]?.active_count ?? rows[0]?.count ?? 0);
  if (activeCount < MAX_USER_ACTIVE_GENERATION_TASKS) return;

  const error = new Error(GENERATION_CONCURRENCY_LIMIT_MESSAGE);
  error.status = 429;
  error.code = "GENERATION_CONCURRENCY_LIMIT";
  error.activeCount = activeCount;
  error.maxActiveTasks = MAX_USER_ACTIVE_GENERATION_TASKS;
  throw error;
}

async function providerPoolExists(provider) {
  if (!provider) return false;
  const { rows } = await pool.query(
    "SELECT 1 FROM api_keys WHERE provider = $1 AND enabled = 1 LIMIT 1",
    [provider],
  );
  return rows.length > 0;
}

function releaseLease(slotResult) {
  if (slotResult?.leaseToken) keyManager.releaseKey(slotResult.leaseToken).catch(() => {});
}

function sendAiRouteError(res, err) {
  res.status(err.status || 500).json({
    error: err.message,
    code: err.code,
    activeCount: err.activeCount,
    maxActiveTasks: err.maxActiveTasks,
  });
}

async function fetchWithTimeout(url, options = {}, timeoutMs = IMAGE_PROVIDER_SUBMIT_TIMEOUT_MS) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);
  try {
    return await fetch(url, { ...options, signal: controller.signal });
  } catch (err) {
    if (err?.name === "AbortError") {
      throw new Error(`Provider request timed out after ${Math.round(timeoutMs / 1000)}s`);
    }
    throw err;
  } finally {
    clearTimeout(timer);
  }
}

function sanitizeUpstreamError(value, fallback = "上游服务暂时不可用，请稍后重试") {
  const raw = String(value || "").trim();
  if (!raw) return fallback;

  let message = raw;
  try {
    const parsed = JSON.parse(raw);
    message =
      parsed?.error?.message ||
      parsed?.error_description ||
      parsed?.message ||
      parsed?.error ||
      raw;
  } catch {}

  const compact = String(message).replace(/\s+/g, " ").trim();
  const looksLikeMarkup =
    /^<!doctype\s/i.test(compact) ||
    /^<html[\s>]/i.test(compact) ||
    /^<\?xml/i.test(compact) ||
    /<\/?[a-z][^>]*>/i.test(compact);

  if (looksLikeMarkup) return fallback;
  return compact.slice(0, 320);
}

function parseTaskParams(value) {
  if (!value || typeof value !== "string") return {};
  try {
    return JSON.parse(value);
  } catch {
    return {};
  }
}

function formatAiTaskRow(row) {
  return {
    taskId: String(row.id),
    projectId: row.project_id,
    conversationId: row.conversation_id,
    clientQueueId: row.client_queue_id || null,
    type: row.type,
    status: row.status,
    progress: Number(row.progress || 0),
    resultUrl: row.result_url || null,
    error: row.error || null,
    params: parseTaskParams(row.params_json),
    createdAt: row.created_at,
    updatedAt: row.updated_at,
    completedAt: row.completed_at || null,
  };
}

function extensionFromContentType(contentType, fallbackType) {
  const mime = String(contentType || "").split(";")[0].trim().toLowerCase();
  if (mime === "image/jpeg") return "jpg";
  if (mime === "image/png") return "png";
  if (mime === "image/webp") return "webp";
  if (mime === "image/gif") return "gif";
  if (mime === "video/webm") return "webm";
  if (mime === "video/quicktime") return "mov";
  if (mime === "video/mp4") return "mp4";
  return fallbackType === "video" ? "mp4" : "png";
}

function contentDispositionFilename(value) {
  return String(value || "generated")
    .replace(/[\\/:*?"<>|]+/g, "-")
    .replace(/[^\x20-\x7e]/g, "")
    .trim()
    .slice(0, 120) || "generated";
}

function isErrorContentType(contentType) {
  return /(?:application|text)\/(?:json|xml|html|plain)|\+xml/i.test(String(contentType || ""));
}

function buildDashscopeImageBody(params) {
  const content = [];
  for (const url of params.referenceUrls || []) {
    if (url) content.push({ image: url });
  }
  content.push({ text: params.prompt });
  const quality = clampImageQualityForModel(params.model, params.quality);
  return {
    model: params.model,
    input: {
      messages: [{ role: "user", content }],
    },
    parameters: {
      size: mapAspectRatioToDashscopeSize(params.ratio, quality),
      n: params.gridMode === "grid-4" ? 4 : params.gridMode === "grid-9" ? 9 : 1,
      watermark: false,
    },
  };
}

function buildGrsaiImageBody(params) {
  const isGptImage = String(params.model || "").startsWith("gpt-image");
  const modelKey = String(params.model || "").toLowerCase();
  const quality = GRSAI_IMAGE_QUALITY_MODEL_OVERRIDES.get(modelKey) || clampGrsaiImageQualityForModel(params.model, params.quality);
  return isGptImage
    ? {
        model: params.model,
        prompt: params.prompt,
        images: params.referenceUrls || [],
        aspectRatio: mapAspectRatioToPixels(params.ratio, quality),
        replyType: "json",
      }
    : {
        model: params.model,
        prompt: params.prompt,
        images: params.referenceUrls || [],
        aspectRatio: params.ratio || "auto",
        imageSize: quality,
        replyType: "json",
      };
}

function buildRightcodeImageBody(providerConfig, params) {
  const referenceUrls = Array.isArray(params.referenceUrls) ? params.referenceUrls.filter(Boolean) : [];
  const quality = normalizeQuality(params.quality, "1K");

  return {
    model: providerConfig.model || params.model,
    prompt: params.prompt,
    image: referenceUrls,
    size: mapAspectRatioToPixels(params.ratio, quality),
    response_format: "url",
  };
}

function getGridCount(gridMode) {
  if (gridMode === "grid-4") return 4;
  if (gridMode === "grid-9") return 9;
  if (gridMode === "grid-25") return 25;
  return 1;
}

function buildGeminiImageBody(params) {
  const parts = [{ text: String(params.prompt || "").trim() }];
  const refs = (params.referenceUrls || []).filter(Boolean);
  for (const url of refs) {
    parts.push({
      fileData: { fileUri: url, mimeType: "image/png" },
    });
  }
  const generationConfig = { responseModalities: ["IMAGE", "TEXT"] };
  const count = getGridCount(params.gridMode);
  if (count > 1) generationConfig.candidateCount = count;
  return {
    contents: [{ parts }],
    generationConfig,
  };
}

function buildOpenAIImageBody(providerConfig, params) {
  const userContent = [];
  const prompt = String(params.prompt || "").trim();
  if (prompt) userContent.push({ type: "text", text: prompt });
  const refs = (params.referenceUrls || []).filter(Boolean);
  for (const url of refs) {
    userContent.push({ type: "image_url", image_url: { url } });
  }
  const body = {
    model: providerConfig.model || params.model,
    messages: [{ role: "user", content: userContent.length > 1 ? userContent : (prompt || "generate an image") }],
  };
  const count = getGridCount(params.gridMode);
  if (count > 1) body.n = count;
  return body;
}

function buildImageRequest(providerConfig, params, apiKey) {
  const effectiveParams = providerConfig.model ? { ...params, model: providerConfig.model } : params;
  if (providerConfig.transport === "dashscope-image") {
    return { headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` }, body: buildDashscopeImageBody(effectiveParams) };
  }
  if (providerConfig.transport === "rightcode-image") {
    return { headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` }, body: buildRightcodeImageBody(providerConfig, effectiveParams) };
  }
  if (providerConfig.transport === "gemini-image") {
    return { headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` }, body: buildGeminiImageBody(effectiveParams) };
  }
  if (providerConfig.transport === "openai-image") {
    return { headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` }, body: buildOpenAIImageBody(providerConfig, effectiveParams) };
  }
  return { headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` }, body: buildGrsaiImageBody(effectiveParams) };
}

function buildSeedVideoBody(params) {
  const resolution = normalizeVideoResolution(params.quality, ["480p", "720p"]);
  const metadata = {
    generate_audio: true,
    watermark: false,
    ratio: normalizeRatio(params.ratio),
    duration: normalizeDuration(params.duration, 4, 15, 5),
    resolution,
  };
  const body = {
    model: params.model,
    prompt: params.prompt,
    metadata,
  };
  const refs = params.referenceUrls || [];
  if (params.frameMode === "start-end" && refs.length >= 2) {
    metadata.first_frame_image = refs[0];
    metadata.last_frame_image = refs[refs.length - 1];
  } else if (refs.length === 1) {
    body.image = refs[0];
  } else if (refs.length > 1) {
    metadata.reference_images = refs;
  }
  return body;
}

function buildArkSeedVideoBody(params) {
  const content = [];
  if (params.prompt) content.push({ type: "text", text: params.prompt });

  const refs = params.referenceUrls || [];
  if (params.frameMode === "start-end" && refs.length >= 2) {
    content.push({ type: "image_url", image_url: { url: refs[0] }, role: "first_frame" });
    content.push({ type: "image_url", image_url: { url: refs[refs.length - 1] }, role: "last_frame" });
  } else {
    refs.forEach((url, index) => {
      content.push({
        type: "image_url",
        image_url: { url },
        role: index === 0 ? "first_frame" : "reference_image",
      });
    });
  }

  const body = {
    model: params.model,
    content,
    ratio: normalizeRatio(params.ratio),
    duration: normalizeDuration(params.duration, 4, 15, 5),
    generate_audio: true,
    watermark: false,
  };
  body.resolution = normalizeVideoResolution(params.quality, ["480p", "720p", "1080p"]);
  return body;
}

function buildWanT2vBody(params) {
  const requestedResolution = String(params.quality || "").toUpperCase();
  const parameters = {
    resolution: requestedResolution === "720P" ? "720P" : "1080P",
    ratio: normalizeRatio(params.ratio),
    duration: normalizeDuration(params.duration, 3, 15, 5),
    watermark: false,
    prompt_extend: true,
  };
  return {
    model: params.model,
    input: { prompt: params.prompt },
    parameters,
  };
}

function buildWanI2vBody(params) {
  const refs = params.referenceUrls || [];
  const media = [];
  if (params.frameMode === "start-end" && refs.length >= 2) {
    media.push({ type: "first_frame", url: refs[0] });
    media.push({ type: "last_frame", url: refs[refs.length - 1] });
  } else if (refs[0]) {
    media.push({ type: "first_frame", url: refs[0] });
  }

  if (!media.length) {
    throw createMissingReferenceError("wan2.7-i2v 需要提供至少一张参考图片作为首帧");
  }

  const input = { prompt: params.prompt, media };
  const requestedResolution = String(params.quality || "").toUpperCase();
  const parameters = {
    resolution: requestedResolution === "720P" ? "720P" : "1080P",
    ratio: normalizeRatio(params.ratio),
    duration: normalizeDuration(params.duration, 3, 15, 5),
    watermark: false,
  };
  parameters.prompt_extend = true;

  return {
    model: params.model,
    input,
    parameters,
  };
}

function normalizeHappyHorseResolution(value) {
  return String(value || "").toUpperCase() === "720P" ? "720P" : "1080P";
}

function getReferenceImageUrls(params, limit = 9) {
  return (Array.isArray(params.referenceUrls) ? params.referenceUrls : [])
    .map((url) => normalizePublicHttpUrl(url))
    .filter(Boolean)
    .slice(0, limit);
}

function buildHappyHorseBaseParameters(params, { includeRatio }) {
  const parameters = {
    resolution: normalizeHappyHorseResolution(params.quality),
    duration: normalizeDuration(params.duration, 3, 15, 5),
    watermark: false,
  };
  if (includeRatio) parameters.ratio = normalizeRatio(params.ratio);
  return parameters;
}

function createMissingReferenceError(message) {
  const error = new Error(message);
  error.status = 400;
  return error;
}

function buildHappyHorseT2vBody(params) {
  return {
    model: params.model,
    input: {
      prompt: params.prompt,
    },
    parameters: buildHappyHorseBaseParameters(params, { includeRatio: true }),
  };
}

function buildHappyHorseI2vBody(params) {
  const [firstFrame] = getReferenceImageUrls(params, 1);
  if (!firstFrame) {
    throw createMissingReferenceError("HappyHorse I2V requires one first-frame image.");
  }

  return {
    model: params.model,
    input: {
      prompt: params.prompt,
      media: [{ type: "first_frame", url: firstFrame }],
    },
    parameters: buildHappyHorseBaseParameters(params, { includeRatio: false }),
  };
}

function buildHappyHorseR2vBody(params) {
  const refs = getReferenceImageUrls(params, 9);
  if (!refs.length) {
    throw createMissingReferenceError("HappyHorse R2V requires 1 to 9 reference images.");
  }

  return {
    model: params.model,
    input: {
      prompt: params.prompt,
      media: refs.map((url) => ({ type: "reference_image", url })),
    },
    parameters: buildHappyHorseBaseParameters(params, { includeRatio: true }),
  };
}

function getHappyHorseReferenceError(protocol, referenceUrls) {
  if (protocol === "happyhorse-i2v" && !getReferenceImageUrls({ referenceUrls }, 1).length) {
    return "HappyHorse I2V requires one first-frame image.";
  }
  if (protocol === "happyhorse-r2v" && !getReferenceImageUrls({ referenceUrls }, 9).length) {
    return "HappyHorse R2V requires 1 to 9 reference images.";
  }
  return "";
}

async function assertWanS2vImageDetected(providerConfig, params, apiKey) {
  const imageUrl = normalizePublicHttpUrl(params.imageUrl || (params.referenceUrls || [])[0]);
  if (!imageUrl) {
    const error = new Error("Missing imageUrl");
    error.status = 400;
    throw error;
  }

  const response = await fetch(`${providerConfig.baseUrl}${providerConfig.detectEndpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify({
      model: providerConfig.detectModel || "wan2.2-s2v-detect",
      input: { image_url: imageUrl },
    }),
  });

  const text = await response.text();
  let json = null;
  try {
    json = text ? JSON.parse(text) : null;
  } catch {}

  if (!response.ok) {
    throw new Error(sanitizeUpstreamError(text, `数字人人像检测返回 HTTP ${response.status}`));
  }

  const output = json && typeof json === "object" ? json.output || json.data || json : {};
  const pass =
    output.check_pass === true ||
    output.checkPass === true ||
    output.passed === true ||
    output.pass === true ||
    String(output.code || "").toLowerCase() === "success";

  if (!pass) {
    const message = extractProviderDetectMessage(output) || "人像检测未通过，请换一张清晰、单人、正面的人物图。";
    const error = new Error(message);
    error.status = 400;
    throw error;
  }
}

function extractProviderDetectMessage(output) {
  if (!output || typeof output !== "object") return "";
  return String(
    output.message ||
      output.reason ||
      output.failure_reason ||
      output.description ||
      output.error ||
      "",
  ).trim();
}

function buildWanS2vBody(params) {
  const imageUrl = normalizePublicHttpUrl(params.imageUrl || (params.referenceUrls || [])[0]);
  const audioUrl = normalizePublicHttpUrl(params.audioUrl);
  if (!imageUrl) {
    const error = new Error("Missing imageUrl");
    error.status = 400;
    throw error;
  }
  if (!audioUrl) {
    const error = new Error("Missing audioUrl");
    error.status = 400;
    throw error;
  }

  const parameters = {
    resolution: normalizeS2vResolution(params.quality),
    style: normalizeS2vStyle(params.style),
  };

  return {
    model: params.model,
    input: {
      image_url: imageUrl,
      audio_url: audioUrl,
    },
    parameters,
  };
}

function buildWanAnimateMixBody(params) {
  const imageUrl = normalizePublicHttpUrl(params.imageUrl);
  const videoUrl = normalizePublicHttpUrl((params.referenceUrls || [])[0]);
  if (!imageUrl) {
    const error = new Error("Missing imageUrl");
    error.status = 400;
    throw error;
  }
  if (!videoUrl) {
    const error = new Error("Missing videoUrl");
    error.status = 400;
    throw error;
  }

  const mode = "wan-pro";
  const watermark = params.muted === false;

  return {
    model: params.model,
    input: {
      image_url: imageUrl,
      video_url: videoUrl,
      watermark,
    },
    parameters: {
      mode,
    },
  };
}

function buildDashscopeKlingBody(params) {
  const refs = params.referenceUrls || [];
  const media = [];
  if (params.frameMode === "start-end" && refs.length >= 2) {
    media.push({ type: "first_frame", url: refs[0] });
    media.push({ type: "last_frame", url: refs[refs.length - 1] });
  } else if (refs[0]) {
    media.push({ type: "first_frame", url: refs[0] });
  }

  const input = { prompt: params.prompt };
  if (media.length) input.media = media;
  const parameters = {
    mode: params.quality === "std" ? "std" : "pro",
    duration: normalizeDuration(params.duration, 5, 10, 5),
    audio: false,
    watermark: false,
  };
  if (!media.length) parameters.aspect_ratio = normalizeRatio(params.ratio);

  return { model: params.model, input, parameters };
}

function buildKlingOmniBody(params) {
  const refs = params.referenceUrls || [];
  const imageList = [];
  if (params.frameMode === "start-end" && refs.length >= 2) {
    imageList.push({ image_url: refs[0], type: "first_frame" });
    imageList.push({ image_url: refs[refs.length - 1], type: "end_frame" });
  } else if (refs[0]) {
    imageList.push({ image_url: refs[0], type: "first_frame" });
  }

  const body = {
    model_name: "kling-v3-omni",
    mode: params.quality === "std" ? "std" : "pro",
    sound: "off",
    duration: String(normalizeDuration(params.duration, 3, 15, 5)),
    watermark_info: { enabled: false },
    prompt: params.prompt,
  };
  if (imageList.length) body.image_list = imageList;
  else body.aspect_ratio = normalizeRatio(params.ratio);
  return body;
}

function buildViduT2vBody(params) {
  const requestedRes = String(params.quality || "").toUpperCase();
  const resolution = requestedRes === "720P" ? "720P" : "1080P";
  const sizeMap = { "720P": "1280*720", "1080P": "1920*1080" };
  return { model: params.model, input: { prompt: params.prompt }, parameters: { resolution, size: sizeMap[resolution], duration: normalizeDuration(params.duration, 1, 16, 5), watermark: false } };
}

function buildViduI2vBody(params) {
  const [img] = getReferenceImageUrls(params, 1);
  if (!img) throw createMissingReferenceError("Vidu I2V 需要提供一张参考图片");
  const requestedRes = String(params.quality || "").toUpperCase();
  const resolution = requestedRes === "720P" ? "720P" : "1080P";
  return { model: params.model, input: { prompt: params.prompt || "", media: [{ type: "image", url: img }] }, parameters: { resolution, duration: normalizeDuration(params.duration, 1, 16, 5), watermark: false } };
}

function buildPixverseT2vBody(params) {
  const requestedRes = String(params.quality || "").toUpperCase();
  const sizeMap = { "720P": "1280*720", "1080P": "1920*1080" };
  const size = sizeMap[requestedRes] || "1280*720";
  return { model: params.model, input: { prompt: params.prompt }, parameters: { size, duration: normalizeDuration(params.duration, 1, 15, 5), watermark: false, audio: false } };
}

function buildPixverseI2vBody(params) {
  const [img] = getReferenceImageUrls(params, 1);
  if (!img) throw createMissingReferenceError("PixVerse I2V 需要提供一张参考图片");
  const requestedRes = String(params.quality || "").toUpperCase();
  const resolution = (requestedRes === "720P" || requestedRes === "1080P") ? requestedRes : "720P";
  return { model: params.model, input: { prompt: params.prompt || "", media: [{ type: "image_url", url: img }] }, parameters: { resolution, duration: normalizeDuration(params.duration, 1, 15, 5), watermark: false, audio: false } };
}

function buildVideoRequest(providerConfig, params, apiKey) {
  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` };
  let body;

  if (providerConfig.protocol === "seed-video-ark") {
    body = buildArkSeedVideoBody(params);
  } else if (providerConfig.protocol === "happyhorse-t2v") {
    body = buildHappyHorseT2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "happyhorse-i2v") {
    body = buildHappyHorseI2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "happyhorse-r2v") {
    body = buildHappyHorseR2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "wan-i2v") {
    body = buildWanI2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "wan-t2v") {
    body = buildWanT2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "wan-s2v") {
    body = buildWanS2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "wan-animate-mix") {
    body = buildWanAnimateMixBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "kling-dashscope") {
    body = buildDashscopeKlingBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "vidu-t2v") {
    body = buildViduT2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "vidu-i2v") {
    body = buildViduI2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "pixverse-t2v") {
    body = buildPixverseT2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "pixverse-i2v") {
    body = buildPixverseI2vBody(params);
    headers["X-DashScope-Async"] = "enable";
  } else if (providerConfig.protocol === "kling-omni") {
    body = buildKlingOmniBody(params);
    const credential = parseKlingCredential(apiKey);
    if (credential) {
      headers.Authorization = `Bearer ${createKlingJwt(credential.accessKey, credential.secretKey)}`;
    }
  } else {
    body = buildSeedVideoBody(params);
  }

  return { headers, body };
}

function registerAiRoutes(router) {
  router.post("/ai/image", requireAuth, async (req, res) => {
    const { model, prompt, ratio, quality, gridMode, referenceUrls, projectId: requestedProjectId, conversationId } = req.body;
    if (!prompt) return res.status(400).json({ error: "Missing prompt" });

    try {
      const allCandidates = resolveImageProviderCandidates(model);
      const providerCandidates = allCandidates.filter(c => !shouldSkipProvider(c.provider));
      if (!providerCandidates.length) providerCandidates.push(...allCandidates);
      const primaryProviderConfig = providerCandidates[0];
      const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
      const params = {
        model: primaryProviderConfig.model,
        requestedModel: primaryProviderConfig.requestedModel,
        prompt,
        ratio,
        quality,
        gridMode,
        referenceUrls,
      };
      const { taskRow, imageBilling } = await withTransaction(async (client) => {
        const nextTaskRow = await insertTask(
          req.user.id,
          projectId,
          "image",
          params,
          Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
          client,
        );
        const billingResult = await deductImageGenerationCredits(req.user.id, client, {
          taskId: nextTaskRow.id,
          model: params.requestedModel || params.model || model,
          resolution: [ratio, quality].filter(Boolean).join(" / "),
        });
        if (!billingResult.success) {
          const error = new Error(billingResult.message || "账户积分不足");
          error.status = 402;
          error.code = "INSUFFICIENT_BALANCE";
          error.costCents = billingResult.costCents;
          throw error;
        }
        return { taskRow: nextTaskRow, imageBilling: billingResult };
      });
      const preauth = { authorized: true, estimatedCostCents: 0, billingMode: imageBilling.deductionType };

      res.status(202).json({
        taskId: String(taskRow.id),
        status: "pending",
        imageBilling: {
          costCents: imageBilling.costCents,
          deductionType: imageBilling.deductionType,
          balanceAfterCents: imageBilling.balanceAfterCents,
        },
        providerDebug: buildImageProviderDebug(model),
      });
      submitImageWithProviderFallback(taskRow.id, providerCandidates, req.user, preauth, params).catch((err) => {
        console.error("[ai/image] submit error:", err.message);
        updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
      });
    } catch (err) {
      console.error("[ai/image] error:", err.message);
      sendAiRouteError(res, err);
    }
  });

  router.post("/ai/video", requireAuth, async (req, res) => {
    const {
      model,
      prompt,
      ratio,
      duration,
      quality,
      frameMode,
      referenceUrls,
      imageUrl,
      audioUrl,
      resolution,
      muted,
      hasReferenceVideo,
      style,
      projectId: requestedProjectId,
      conversationId,
    } = req.body;
    let providerConfig;
    try {
      providerConfig = resolveVideoProvider(model);
    } catch (err) {
      return res.status(err.status || 400).json({ error: err.message });
    }
    const provider = providerConfig.provider;
    const isWanS2v = providerConfig.protocol === "wan-s2v";
    const isWanAnimateMix = providerConfig.protocol === "wan-animate-mix";
    const happyHorseReferenceError = getHappyHorseReferenceError(providerConfig.protocol, referenceUrls);

    if (!isWanS2v && !isWanAnimateMix && !prompt) return res.status(400).json({ error: "Missing prompt" });
    if (happyHorseReferenceError) return res.status(400).json({ error: happyHorseReferenceError });
    if (isWanS2v) {
      if (!normalizePublicHttpUrl(imageUrl || (Array.isArray(referenceUrls) ? referenceUrls[0] : ""))) {
        return res.status(400).json({ error: "Missing imageUrl" });
      }
      if (!normalizePublicHttpUrl(audioUrl)) {
        return res.status(400).json({ error: "Missing audioUrl" });
      }
    }
    if (isWanAnimateMix) {
      if (!normalizePublicHttpUrl(imageUrl)) {
        return res.status(400).json({ error: "Missing imageUrl" });
      }
      if (!normalizePublicHttpUrl((Array.isArray(referenceUrls) ? referenceUrls[0] : ""))) {
        return res.status(400).json({ error: "Missing reference videoUrl" });
      }
    }

    let slotResult = null;
    try {
      const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
      const params = {
        model: providerConfig.model,
        requestedModel: providerConfig.requestedModel,
        prompt: prompt || "数字人口播视频",
        ratio,
        duration,
        quality: quality || resolution,
        resolution: resolution || quality,
        frameMode,
        referenceUrls,
        imageUrl,
        audioUrl,
        muted: Boolean(muted),
        hasReferenceVideo: Boolean(hasReferenceVideo),
        style,
      };

      let enterpriseBilling = null;
      let preauth = null;
      if (isEnterpriseVideoBillingUser(req.user)) {
        enterpriseBilling = prepareEnterpriseVideoBilling({ user: req.user, providerConfig, params });
        preauth = {
          authorized: true,
          estimatedCostCents: enterpriseBilling.amountCents,
          billingMode: "enterprise",
        };
      } else {
        preauth = await preauthorizeCall(req.user.id, provider);
        if (!preauth.authorized) {
          return res.status(402).json({ error: preauth.message, code: "INSUFFICIENT_BALANCE" });
        }
      }

      await assertUserGenerationConcurrencyLimit(req.user.id);
      slotResult = await keyManager.acquireKey(provider, req.user, preauth, { waitTimeoutMs: 15000 });
      if (!slotResult) {
        return res.status(429).json({ error: `${provider} concurrency pool is full, please retry later` });
      }

      const { taskRow, reservedBilling, regularBilling } = await withTransaction(async (client) => {
        const nextTaskRow = await insertTask(
          req.user.id,
          projectId,
          "video",
          params,
          Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
          client,
        );
        if (enterpriseBilling) {
          const nextBilling = await reserveEnterpriseVideoCredits(client, {
            ...enterpriseBilling,
            taskId: nextTaskRow.id,
          });
          return { taskRow: nextTaskRow, reservedBilling: nextBilling, regularBilling: null };
        }
        // Regular user: deduct from personal balance
        const credits = calculateEnterpriseVideoCredits({
          model: params.model,
          resolution: params.resolution || params.quality,
          durationSeconds: params.duration,
          muted: params.muted,
          hasReferenceVideo: params.hasReferenceVideo,
        });
        const costCents = Math.ceil(credits * 100);
        const { rows: [deducted] } = await client.query(
          "UPDATE users SET balance_cents = balance_cents - $1, updated_at = NOW() WHERE id = $2 AND balance_cents >= $1 RETURNING balance_cents",
          [costCents, req.user.id],
        );
        if (!deducted) {
          throw Object.assign(new Error("账户积分不足，请充值"), { status: 402, code: "INSUFFICIENT_BALANCE" });
        }
        await client.query(
          "INSERT INTO transactions (user_id, type, amount_cents, balance_after_cents, description) VALUES ($1, 'deduct', $2, $3, $4)",
          [req.user.id, -costCents, deducted.balance_cents, `视频生成扣费 ${credits} 积分`],
        );
        return { taskRow: nextTaskRow, reservedBilling: null, regularBilling: { costCents, balanceAfterCents: deducted.balance_cents, credits } };
      });

      if (reservedBilling) {
        params.enterpriseBilling = {
          creditLedgerId: reservedBilling.creditLedgerId,
          amountCents: reservedBilling.amountCents,
          resolution: reservedBilling.resolution,
          durationSeconds: reservedBilling.durationSeconds,
          rateCentsPerSecond: reservedBilling.rateCentsPerSecond,
        };
        await pool.query("UPDATE generation_tasks SET params_json = $1, updated_at = NOW() WHERE id = $2", [
          JSON.stringify(params),
          taskRow.id,
        ]);
      }

      res.status(202).json({
        taskId: String(taskRow.id),
        status: "pending",
        enterpriseBilling: reservedBilling
          ? {
              creditLedgerId: reservedBilling.creditLedgerId,
              amountCents: reservedBilling.amountCents,
              enterpriseBalanceCents: reservedBilling.enterpriseBalanceCents,
            }
          : undefined,
      });
      const activeSlotResult = slotResult;
      slotResult = null;
      submitVideoToProvider(taskRow.id, providerConfig, activeSlotResult, params)
        .then(async () => {
          try {
            await markEnterpriseVideoCreditsAccepted(pool, reservedBilling?.creditLedgerId);
          } catch (settlementError) {
            console.error("[ai/video] enterprise ledger settle error:", settlementError.message);
          }
        })
        .catch(async (err) => {
          console.error("[ai/video] submit error:", err.message);
          await updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
          await refundEnterpriseVideoCredits(pool, reservedBilling, err.message);
          releaseLease(activeSlotResult);
        });
    } catch (err) {
      releaseLease(slotResult);
      console.error("[ai/video] error:", err.message);
      if (err.code === "INSUFFICIENT_ENTERPRISE_BALANCE") {
        return res.status(err.status || 402).json({
          error: err.message,
          code: "INSUFFICIENT_ENTERPRISE_BALANCE",
        });
      }
      sendAiRouteError(res, err);
    }
  });

  router.post("/ai/image/super-resolve", requireAuth, async (req, res) => {
    const imageUrl = normalizePublicHttpUrl(req.body?.imageUrl);
    const scale = normalizeImageUpscaleFactor(req.body?.scale ?? req.body?.upscaleFactor);
    const { projectId: requestedProjectId, conversationId } = req.body || {};

    if (!imageUrl) return res.status(400).json({ error: "Missing imageUrl" });

    const provider = "dashscope";
    let slotResult;
    try {
      const preauth = await preauthorizeCall(req.user.id, provider);
      if (!preauth.authorized) {
        return res.status(402).json({ error: preauth.message, code: "INSUFFICIENT_BALANCE" });
      }

      await assertUserGenerationConcurrencyLimit(req.user.id);
      slotResult = await keyManager.acquireKey(provider, req.user, preauth, { waitTimeoutMs: 15000 });
      if (!slotResult) {
        return res.status(429).json({ error: `${provider} concurrency pool is full, please retry later` });
      }

      const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
      const params = {
        model: "wanx2.1-imageedit",
        operation: "image-super-resolution",
        imageUrl,
        scale,
      };
      const taskRow = await insertTask(
        req.user.id,
        projectId,
        "image",
        params,
        Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
      );

      res.status(202).json({ taskId: String(taskRow.id), status: "pending" });
      submitDashscopeImageSuperResolveTask(taskRow.id, slotResult, params).catch((err) => {
        console.error("[ai/image/super-resolve] submit error:", err.message);
        updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
        releaseLease(slotResult);
      });
    } catch (err) {
      if (slotResult) releaseLease(slotResult);
      console.error("[ai/image/super-resolve] error:", err.message);
      sendAiRouteError(res, err);
    }
  });

  router.post("/ai/video/super-resolve", requireAuth, async (req, res) => {
    const videoUrl = String(req.body?.videoUrl || "").trim();
    const bitRate = normalizeSuperResolveBitRate(req.body?.bitRate);
    const providerMode = String(req.body?.provider || req.body?.model || "").trim();
    const shouldUseDashscopeStyle =
      providerMode === "dashscope-style-transform" || providerMode === "video-style-transform";
    const { projectId: requestedProjectId, conversationId } = req.body || {};

    if (!videoUrl) return res.status(400).json({ error: "Missing videoUrl" });
    if (!/^https?:\/\//i.test(videoUrl)) {
      return res.status(400).json({ error: "videoUrl must be an HTTP URL" });
    }

    let dashscopeSlotResult;
    try {
      if (shouldUseDashscopeStyle) {
        const provider = "dashscope";
        const preauth = await preauthorizeCall(req.user.id, provider);
        if (!preauth.authorized) {
          return res.status(402).json({ error: preauth.message, code: "INSUFFICIENT_BALANCE" });
        }

        await assertUserGenerationConcurrencyLimit(req.user.id);
        dashscopeSlotResult = await keyManager.acquireKey(provider, req.user, preauth, { waitTimeoutMs: 15000 });
        if (!dashscopeSlotResult) {
          return res.status(429).json({ error: `${provider} concurrency pool is full, please retry later` });
        }

        const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
        const styleOptions = normalizeVideoStyleTransformOptions(req.body);
        const params = {
          model: "video-style-transform",
          operation: "video-style-super-resolution",
          videoUrl,
          ...styleOptions,
        };
        const taskRow = await insertTask(
          req.user.id,
          projectId,
          "video",
          params,
          Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
        );

        res.status(202).json({ taskId: String(taskRow.id), status: "pending" });
        submitDashscopeVideoStyleTransformTask(taskRow.id, dashscopeSlotResult, params).catch((err) => {
          console.error("[ai/video/super-resolve] dashscope submit error:", err.message);
          updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
          releaseLease(dashscopeSlotResult);
        });
        return;
      }

      const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
      const params = { model: "aliyun-video-super-resolve", videoUrl, bitRate };
      const taskRow = await insertTask(
        req.user.id,
        projectId,
        "video",
        params,
        Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
      );

      res.status(202).json({ taskId: String(taskRow.id), status: "pending" });
      submitVideoSuperResolveTask(taskRow.id, params).catch((err) => {
        console.error("[ai/video/super-resolve] submit error:", err.message);
        updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
      });
    } catch (err) {
      if (dashscopeSlotResult) releaseLease(dashscopeSlotResult);
      console.error("[ai/video/super-resolve] error:", err.message);
      sendAiRouteError(res, err);
    }
  });

  router.post("/ai/video/erase-subtitles", requireAuth, async (req, res) => {
    const videoUrl = normalizePublicHttpUrl(req.body?.videoUrl);
    const { projectId: requestedProjectId, conversationId } = req.body || {};
    if (!videoUrl) return res.status(400).json({ error: "Missing videoUrl" });

    try {
      await assertUserGenerationConcurrencyLimit(req.user.id);
      const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
      const bx = Number(req.body?.bx) || 0;
      const by = Number(req.body?.by) || 0;
      const bw = Number(req.body?.bw) || 0;
      const bh = Number(req.body?.bh) || 0;
      const params = { model: "aliyun-erase-subtitles", videoUrl, bx, by, bw, bh };
      const taskRow = await insertTask(
        req.user.id,
        projectId,
        "video",
        params,
        Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
      );

      res.status(202).json({ taskId: String(taskRow.id), status: "pending" });
      submitEraseSubtitlesTask(taskRow.id, params).catch((err) => {
        console.error("[ai/video/erase-subtitles] submit error:", err.message);
        updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
      });
    } catch (err) {
      console.error("[ai/video/erase-subtitles] error:", err.message);
      sendAiRouteError(res, err);
    }
  });

  router.post("/ai/image/edit", requireAuth, async (req, res) => {
    const imageUrl = normalizePublicHttpUrl(req.body?.imageUrl);
    const editFunction = String(req.body?.function || "description_edit").trim();
    const prompt = String(req.body?.prompt || "").trim();
    const n = Math.max(1, Math.min(4, Number(req.body?.n) || 1));
    const { projectId: requestedProjectId, conversationId } = req.body || {};

    if (!imageUrl) return res.status(400).json({ error: "Missing imageUrl" });

    const provider = "dashscope";
    let slotResult;
    try {
      const preauth = await preauthorizeCall(req.user.id, provider);
      if (!preauth.authorized) {
        return res.status(402).json({ error: preauth.message, code: "INSUFFICIENT_BALANCE" });
      }

      await assertUserGenerationConcurrencyLimit(req.user.id);
      slotResult = await keyManager.acquireKey(provider, req.user, preauth, { waitTimeoutMs: 15000 });
      if (!slotResult) {
        return res.status(429).json({ error: `${provider} concurrency pool is full, please retry later` });
      }

      const projectId = requestedProjectId ? await resolveTaskProject(req.user.id, requestedProjectId) : null;
      const params = { model: "wanx2.1-imageedit", operation: "image-edit", imageUrl, function: editFunction, prompt, n };
      const taskRow = await insertTask(
        req.user.id,
        projectId,
        "image",
        params,
        Number.isFinite(Number(conversationId)) ? Number(conversationId) : null,
      );

      res.status(202).json({ taskId: String(taskRow.id), status: "pending" });
      submitDashscopeImageEditTask(taskRow.id, slotResult, params).catch((err) => {
        console.error("[ai/image/edit] submit error:", err.message);
        updateTaskInDb(taskRow.id, { status: "failed", error: err.message });
        releaseLease(slotResult);
      });
    } catch (err) {
      if (slotResult) releaseLease(slotResult);
      console.error("[ai/image/edit] error:", err.message);
      sendAiRouteError(res, err);
    }
  });

  router.post("/ai/chat", requireAuth, async (req, res) => {
    const { model, messages, stream = true, temperature } = req.body;
    if (!messages || !messages.length) return res.status(400).json({ error: "Missing messages" });

    const providerConfig = resolveTextProvider(model);
    const provider = providerConfig.provider;
    let slotResult;
    try {
      const preauth = await preauthorizeCall(req.user.id, provider);
      if (!preauth.authorized) {
        return res.status(402).json({ error: preauth.message, code: "INSUFFICIENT_BALANCE" });
      }

      slotResult = await keyManager.acquireKey(provider, req.user, preauth, { waitTimeoutMs: 15000 });
      if (!slotResult) {
        return res.status(429).json({ error: `${provider} concurrency pool is full, please retry later` });
      }

      const url = `${providerConfig.baseUrl}${providerConfig.endpoint}`;
      const reqHeaders = {
        "Content-Type": "application/json",
        Authorization: `Bearer ${slotResult.apiKey}`,
      };
      const reqBody = JSON.stringify({
        model: providerConfig.model,
        messages,
        stream,
        temperature: temperature || 0.7,
        max_tokens: 4096,
        enable_thinking: false,
      });

      if (stream) {
        res.setHeader("Content-Type", "text/event-stream");
        res.setHeader("Cache-Control", "no-cache");
        res.setHeader("Connection", "keep-alive");
        res.flushHeaders();

        const abortController = new AbortController();
        const streamTimer = setTimeout(() => abortController.abort(), 120000);
        req.on("close", () => { clearTimeout(streamTimer); abortController.abort(); });

        try {
          const upstream = await fetch(url, { method: "POST", headers: reqHeaders, body: reqBody, signal: abortController.signal });
          if (!upstream.ok) {
            const errText = await upstream.text().catch(() => "upstream error");
            res.write(
              `data: ${JSON.stringify({
                error: sanitizeUpstreamError(errText, `文本服务返回 HTTP ${upstream.status}`),
                done: true,
              })}\n\n`,
            );
            res.end();
            releaseLease(slotResult);
            return;
          }

          const reader = upstream.body.getReader();
          const decoder = new TextDecoder();
          let buffer = "";
          while (true) {
            const { done, value } = await reader.read();
            if (done) break;
            buffer += decoder.decode(value, { stream: true });
            const lines = buffer.split("\n");
            buffer = lines.pop() || "";
            for (const line of lines) {
              if (!line.startsWith("data: ")) continue;
              const payload = line.slice(6).trim();
              if (payload === "[DONE]") {
                res.write(`data: ${JSON.stringify({ delta: "", done: true })}\n\n`);
                continue;
              }
              try {
                const chunk = JSON.parse(payload);
                const delta = chunk.choices?.[0]?.delta?.content || "";
                if (delta) res.write(`data: ${JSON.stringify({ delta, done: false })}\n\n`);
              } catch {}
            }
          }

          res.write(`data: ${JSON.stringify({ delta: "", done: true })}\n\n`);
          res.end();
          releaseLease(slotResult);
        } catch (streamErr) {
          if (streamErr.name !== "AbortError") {
            res.write(
              `data: ${JSON.stringify({
                error: sanitizeUpstreamError(streamErr.message),
                done: true,
              })}\n\n`,
            );
          }
          res.end();
          releaseLease(slotResult);
        }
      } else {
        const nonStreamAbort = new AbortController();
        const nonStreamTimer = setTimeout(() => nonStreamAbort.abort(), 120000);
        const upstream = await fetch(url, { method: "POST", headers: reqHeaders, body: reqBody, signal: nonStreamAbort.signal });
        clearTimeout(nonStreamTimer);
        const text = await upstream.text().catch(() => "");
        releaseLease(slotResult);

        let json = {};
        try {
          json = text ? JSON.parse(text) : {};
        } catch {
          return res.status(502).json({
            error: sanitizeUpstreamError(text, `文本服务返回 HTTP ${upstream.status}`),
          });
        }

        if (!upstream.ok || json.error) {
          console.error("[ai/chat] upstream error:", upstream.status, JSON.stringify(json.error || json.message || "").slice(0, 500), "model:", providerConfig.model, "provider:", providerConfig.provider);
          if (upstream.status >= 500 && providerConfig.provider && providerConfig.provider.startsWith("dashscope")) {
            try {
              const fallbackConfig = resolveTextProvider("gemini-3.1-pro");
              const fallbackUrl = fallbackConfig.baseUrl + fallbackConfig.endpoint;
              const fallbackHeaders = { "Content-Type": "application/json", Authorization: "Bearer " + slotResult.apiKey };
              const fallbackBody = JSON.stringify({ model: fallbackConfig.model, messages, stream: false, temperature: temperature || 0.7, max_tokens: 4096 });
              const fbAbort = new AbortController();
              const fbTimer = setTimeout(() => fbAbort.abort(), 90000);
              const fbUpstream = await fetch(fallbackUrl, { method: "POST", headers: fallbackHeaders, body: fallbackBody, signal: fbAbort.signal });
              clearTimeout(fbTimer);
              const fbText = await fbUpstream.text().catch(() => "");
              if (fbUpstream.ok) {
                const fbJson = fbText ? JSON.parse(fbText) : {};
                const fbContent = fbJson.choices?.[0]?.message?.content || "";
                if (fbContent) {
                  const fbUsage = fbJson.usage || {};
                  return res.json({ content: fbContent, usage: { promptTokens: fbUsage.prompt_tokens, completionTokens: fbUsage.completion_tokens } });
                }
              }
            } catch (fbErr) {
              console.error("[ai/chat] fallback also failed:", fbErr.message);
            }
          }
          return res.status(502).json({
            error: sanitizeUpstreamError(
              json.error?.message || json.message || json.error || text,
              `文本服务返回 HTTP ${upstream.status}`,
            ),
          });
        }

        const content = json.choices?.[0]?.message?.content || "";
        const usage = json.usage || {};
        res.json({ content, usage: { promptTokens: usage.prompt_tokens, completionTokens: usage.completion_tokens } });
      }
    } catch (err) {
      releaseLease(slotResult);
      console.error("[ai/chat] error:", err.message);
      res.status(err.name === "AbortError" ? 504 : 500).json({ error: err.name === "AbortError" ? "AI 上游响应超时，请重试" : err.message });
    }
  });

  router.get("/ai/tasks", requireAuth, async (req, res) => {
    try {
      const limit = Math.min(Math.max(Number(req.query.limit) || 100, 1), 200);
      const offset = Math.min(Math.max(Number(req.query.offset) || 0, 0), 5000);
      const status = String(req.query.status || "").trim();
      const type = String(req.query.type || "").trim();
      const projectId = String(req.query.projectId || req.query.project_id || "").trim();
      const params = [req.user.id];
      const where = ["user_id = $1"];

      if (["pending", "running", "completed", "failed", "cancelled"].includes(status)) {
        params.push(status);
        where.push(`status = $${params.length}`);
      }
      if (["image", "video"].includes(type)) {
        params.push(type);
        where.push(`type = $${params.length}`);
      }
      const source = String(req.query.source || "").trim();
      if (source) {
        params.push(source);
        where.push(`params_json->>'source' = $${params.length}`);
      }
      if (projectId) {
        params.push(projectId);
        where.push(`project_id = $${params.length}`);
      }

      params.push(limit, offset);
      const { rows } = await pool.query(
        `
        SELECT *
        FROM generation_tasks
        WHERE ${where.join(" AND ")}
        ORDER BY updated_at DESC
        LIMIT $${params.length - 1}
        OFFSET $${params.length}
      `,
        params,
      );
      res.json({ tasks: rows.map(formatAiTaskRow) });
    } catch (err) {
      console.error("[ai/tasks] list failed:", err.message);
      res.status(500).json({ error: "Failed to load task history" });
    }
  });

  router.patch("/ai/tasks/:taskId/conversation", requireAuth, async (req, res) => {
    const taskId = Number(req.params.taskId);
    const conversationId = Number(req.body?.conversationId);

    if (!Number.isFinite(taskId) || !Number.isFinite(conversationId)) {
      return res.status(400).json({ error: "Invalid task or conversation id" });
    }

    try {
      const { rows: conversationRows } = await pool.query(
        "SELECT id FROM conversations WHERE id = $1 AND user_id = $2",
        [conversationId, req.user.id],
      );
      if (conversationRows.length === 0) {
        return res.status(404).json({ error: "Conversation not found" });
      }

      const { rows } = await pool.query(
        `UPDATE generation_tasks
         SET conversation_id = $1, updated_at = NOW()
         WHERE id = $2 AND user_id = $3
         RETURNING id, conversation_id`,
        [conversationId, taskId, req.user.id],
      );
      if (rows.length === 0) {
        return res.status(404).json({ error: "Task not found" });
      }

      res.json({ taskId: String(rows[0].id), conversationId: rows[0].conversation_id });
    } catch (err) {
      res.status(err.name === "AbortError" ? 504 : 500).json({ error: err.name === "AbortError" ? "AI 上游响应超时，请重试" : err.message });
    }
  });

  router.get("/ai/tasks/:taskId", requireAuth, async (req, res) => {
    const { taskId } = req.params;
    try {
      const { rows } = await pool.query(
        "SELECT * FROM generation_tasks WHERE id = $1 AND user_id = $2",
        [taskId, req.user.id],
      );
      if (rows.length === 0) return res.status(404).json({ error: "Task not found" });

      // Heartbeat: track that the client is still polling this task.
      // Only update for active tasks to avoid unnecessary writes on completed/failed rows.
      if (rows[0].status === "pending" || rows[0].status === "running") {
        pool.query(
          "UPDATE generation_tasks SET last_poll_at = NOW() WHERE id = $1",
          [taskId],
        ).catch(() => {});
      }

      res.json(formatAiTaskRow(rows[0]));
    } catch (err) {
      res.status(err.name === "AbortError" ? 504 : 500).json({ error: err.name === "AbortError" ? "AI 上游响应超时，请重试" : err.message });
    }
  });

  router.get("/ai/tasks/:taskId/stream", requireAuth, async (req, res) => {
    const { taskId } = req.params;
    try {
      const { rows } = await pool.query(
        "SELECT * FROM generation_tasks WHERE id = $1 AND user_id = $2",
        [taskId, req.user.id],
      );
      if (rows.length === 0) return res.status(404).json({ error: "Task not found" });

      res.writeHead(200, {
        "Content-Type": "text/event-stream",
        "Cache-Control": "no-cache",
        Connection: "keep-alive",
        "X-Accel-Buffering": "no",
      });

      const row = rows[0];
      const initial = {
        taskId: row.id,
        status: row.status,
        progress: row.progress,
        resultUrl: row.result_url || null,
        error: row.error || null,
      };
      res.write(`data: ${JSON.stringify(initial)}\n\n`);

      if (["completed", "failed", "cancelled"].includes(row.status)) {
        res.end();
        return;
      }

      const onUpdate = (evt) => {
        res.write(`data: ${JSON.stringify(evt)}\n\n`);
        if (["completed", "failed", "cancelled"].includes(evt.status)) {
          res.end();
        }
      };
      taskEvents.on(`task:${taskId}`, onUpdate);

      req.on("close", () => {
        taskEvents.off(`task:${taskId}`, onUpdate);
      });
    } catch (err) {
      if (!res.headersSent) res.status(err.name === "AbortError" ? 504 : 500).json({ error: err.name === "AbortError" ? "AI 上游响应超时，请重试" : err.message });
    }
  });

  router.patch("/ai/tasks/:taskId/cancel", requireAuth, async (req, res) => {
    const taskId = Number(req.params.taskId);
    if (!Number.isFinite(taskId)) return res.status(400).json({ error: "Invalid task id" });

    try {
      const { rows } = await pool.query(
        "UPDATE generation_tasks SET status = 'cancelled', updated_at = NOW() WHERE id = $1 AND user_id = $2 AND status IN ('pending', 'running') RETURNING id, status",
        [taskId, req.user.id],
      );
      if (rows.length === 0) return res.status(404).json({ error: "Task not found or not in active state" });
      res.json({ id: rows[0].id, status: rows[0].status });
    } catch (err) {
      console.error("[ai/task-cancel] error:", err.message);
      res.status(500).json({ error: "取消任务失败" });
    }
  });

  router.get("/ai/tasks/:taskId/download", requireAuth, async (req, res) => {
    const { taskId } = req.params;
    try {
      const { rows } = await pool.query(
        "SELECT id, type, result_url FROM generation_tasks WHERE id = $1 AND user_id = $2",
        [taskId, req.user.id],
      );
      if (rows.length === 0) return res.status(404).json({ error: "Task not found" });

      const task = rows[0];
      const resultUrl = String(task.result_url || "").trim();
      if (!/^https?:\/\//i.test(resultUrl)) {
        return res.status(400).json({ error: "Task result is not downloadable" });
      }

      const upstream = await fetch(resultUrl, { method: "GET" });
      if (!upstream.ok || !upstream.body) {
        return res.status(upstream.status || 502).json({ error: `Result download failed (${upstream.status})` });
      }

      const contentType = upstream.headers.get("content-type") || (task.type === "video" ? "video/mp4" : "image/png");
      if (isErrorContentType(contentType)) {
        const text = await upstream.text().catch(() => "");
        return res.status(502).json({
          error: text.includes("Expired") || text.includes("AccessDenied")
            ? "结果链接已过期，请重新生成后再下载"
            : "结果链接返回了错误内容，请重新生成后再下载",
        });
      }
      const buffer = Buffer.from(await upstream.arrayBuffer());
      if (!buffer.length) {
        return res.status(502).json({ error: "Result download returned empty content" });
      }

      const extension = extensionFromContentType(contentType, task.type);
      const filename = contentDispositionFilename(`generated-${task.type}-${task.id}.${extension}`);

      res.setHeader("Content-Type", contentType);
      res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
      res.setHeader("Content-Length", String(buffer.length));
      res.setHeader("Cache-Control", "no-store");
      res.end(buffer);
    } catch (err) {
      console.error("[ai/tasks/download] failed:", err.message);
      if (!res.headersSent) res.status(err.name === "AbortError" ? 504 : 500).json({ error: err.name === "AbortError" ? "AI 上游响应超时，请重试" : err.message });
    }
  });

  router.get("/ai/proxy-download", requireAuth, async (req, res) => {
    const url = String(req.query.url || "").trim();
    if (!url || !/^https?:\/\//i.test(url)) {
      return res.status(400).json({ error: "Invalid URL" });
    }
    if (!/aliyuncs\.com/i.test(url)) {
      return res.status(403).json({ error: "Only OSS URLs can be proxied" });
    }
    try {
      const upstream = await fetch(url, { method: "GET" });
      if (!upstream.ok || !upstream.body) {
        return res.status(upstream.status || 502).json({ error: `Proxy download failed (${upstream.status})` });
      }
      const contentType = upstream.headers.get("content-type") || "application/octet-stream";
      const buffer = Buffer.from(await upstream.arrayBuffer());
      if (!buffer.length) {
        return res.status(502).json({ error: "Proxy download returned empty content" });
      }
      res.setHeader("Content-Type", contentType);
      res.setHeader("Content-Length", String(buffer.length));
      res.setHeader("Cache-Control", "no-store");
      res.end(buffer);
    } catch (err) {
      console.error("[ai/proxy-download] failed:", err.message);
      if (!res.headersSent) res.status(err.name === "AbortError" ? 504 : 500).json({ error: err.name === "AbortError" ? "AI 上游响应超时，请重试" : err.message });
    }
  });
}

async function submitImageWithProviderFallback(taskDbId, providerCandidates, user, preauth, params, previousErrors = []) {
  const errors = [...previousErrors];
  const candidates = Array.isArray(providerCandidates) ? providerCandidates : [];

  for (let index = 0; index < candidates.length; index += 1) {
    const providerConfig = candidates[index];
    const provider = providerConfig?.provider;
    let slotResult = null;

    if (!provider) continue;

    try {
      if (index > 0 && !(await providerPoolExists(provider))) {
        throw new Error(`${provider} provider pool is not configured`);
      }

      slotResult = await keyManager.acquireKey(provider, user, preauth, { waitTimeoutMs: 15000 });
      if (!slotResult) {
        throw new Error(`${provider} concurrency pool is full`);
      }

      await submitImageToProvider(taskDbId, providerConfig, slotResult, params, {
        onTaskFailed: async (failureMessage) => {
          recordProviderFailure(provider);
          const providerError = `${provider}: ${failureMessage}`;
          const remainingCandidates = candidates.slice(index + 1);
          if (remainingCandidates.length === 0) {
            await updateTaskInDb(taskDbId, {
              status: "failed",
              error: `All image providers failed: ${[...errors, providerError].join(" | ")}`,
            });
            return true;
          }

          console.warn(`[ai/image] provider ${provider} failed during polling for task ${taskDbId}: ${failureMessage}`);
          await updateTaskInDb(taskDbId, { status: "pending", progress: 5, providerTaskId: null, error: null });
          try {
            await submitImageWithProviderFallback(taskDbId, remainingCandidates, user, preauth, params, [
              ...errors,
              providerError,
            ]);
            return true;
          } catch (fallbackErr) {
            await updateTaskInDb(taskDbId, { status: "failed", error: fallbackErr.message });
            return true;
          }
        },
      });
      recordProviderSuccess(provider, 0);
      if (index > 0) {
        console.info(`[ai/image] task ${taskDbId} switched provider to ${provider}`);
      }
      return;
    } catch (err) {
      const message = err?.message || String(err);
      errors.push(`${provider}: ${message}`);
      console.warn(`[ai/image] provider ${provider} failed for task ${taskDbId}: ${message}`);
      recordProviderFailure(provider);
      releaseLease(slotResult);

      if (index < candidates.length - 1) {
        await updateTaskInDb(taskDbId, { status: "pending", progress: 5, providerTaskId: null, error: null });
      }
    }
  }

  throw new Error(errors.length ? `All image providers failed: ${errors.join(" | ")}` : "No image provider available");
}

async function submitImageToProvider(taskDbId, providerConfig, slotResult, params, options = {}) {
  const url = getPostUrl(providerConfig);
  const { headers, body } = buildImageRequest(providerConfig, params, slotResult.apiKey);

  await updateTaskInDb(taskDbId, { status: "running", progress: 10 });
  const submitTimeout = providerConfig.transport === "gemini-image" ? GEMINI_IMAGE_SUBMIT_TIMEOUT_MS : IMAGE_PROVIDER_SUBMIT_TIMEOUT_MS;
  const response = await fetchWithTimeout(url, { method: "POST", headers, body: JSON.stringify(body) }, submitTimeout);
  if (!response.ok) {
    const errText = await response.text().catch(() => "provider error");
    throw new Error(sanitizeUpstreamError(errText, `图片服务返回 HTTP ${response.status}`));
  }

  const json = await response.json();

  // Synchronous transports — extract image URL directly, no polling
  if (providerConfig.transport === "rightcode-image" || providerConfig.transport === "gemini-image" || providerConfig.transport === "openai-image") {
    let directUrl = extractImageUrl(json) || extractGeminiImageUrl(json);
    const tag = providerConfig.transport === "rightcode-image" ? "rightcode" : "kuaikuai";
    console.info(
      `[ai/image/${tag}] task ${taskDbId} direct result ${directUrl ? "parsed" : "missing"} for model ${providerConfig.model || params.model}`,
    );
    if (!directUrl) throw new Error(`${tag} did not return an image url`);

    // Gemini may return base64 data URL — too large for DB, upload to OSS first
    if (directUrl.startsWith("data:") && isOssConfigured()) {
      const match = directUrl.match(/^data:([^;,]+);base64,(.+)$/);
      if (match) {
        const mimeType = match[1];
        const buffer = Buffer.from(match[2], "base64");
        const ext = mimeType.split("/")[1] || "png";
        const ossKey = `tmp/${String(params.userId || "gen").replace(/[^a-zA-Z0-9_-]/g, "")}/generation-results/${Date.now()}_${crypto.randomUUID()}.${ext}`;
        await putObject(ossKey, buffer, mimeType, { "x-oss-object-acl": "public-read" });
        const bucket = process.env.OSS_BUCKET || "";
        const region = (process.env.OSS_REGION || "").replace(/^oss-/, "");
        directUrl = process.env.OSS_PUBLIC_BASE_URL
          ? `${process.env.OSS_PUBLIC_BASE_URL.replace(/\/+$/, "")}/${ossKey}`
          : `https://${bucket}.oss-${region}.aliyuncs.com/${ossKey}`;
        console.info(`[ai/image/${tag}] task ${taskDbId} base64 result uploaded to OSS: ${ossKey}`);
      }
    }

    await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: directUrl });
    console.info(`[ai/image/${tag}] task ${taskDbId} completed with direct image result`);
    releaseLease(slotResult);
    return;
  }

  const directUrl = extractImageUrl(json);

  const providerTaskId = extractProviderTaskId(json);
  if (directUrl) {
    console.info(`[ai/image/grsai] task ${taskDbId} completed with direct result from submit response`);
    await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: directUrl });
    releaseLease(slotResult);
    return;
  }
  if (!providerTaskId) throw new Error("Provider did not return taskId");

  await updateTaskInDb(taskDbId, { providerTaskId, status: "running", progress: 20 });
  startPolling(taskDbId, {
    providerTaskId,
    apiKey: slotResult.apiKey,
    type: "image",
    providerConfig,
    leaseToken: slotResult.leaseToken,
    keyManager,
    onTaskFailed: options.onTaskFailed,
  });
}

async function submitVideoToProvider(taskDbId, providerConfig, slotResult, params) {
  const url = `${providerConfig.baseUrl}${providerConfig.endpoint}`;
  const { headers, body } = buildVideoRequest(providerConfig, params, slotResult.apiKey);

  await updateTaskInDb(taskDbId, { status: "running", progress: 10 });
  if (providerConfig.protocol === "wan-s2v") {
    await assertWanS2vImageDetected(providerConfig, params, slotResult.apiKey);
    await updateTaskInDb(taskDbId, { status: "running", progress: 16 });
  }
  const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(body) });
  if (!response.ok) {
    const errText = await response.text().catch(() => "provider error");
    throw new Error(sanitizeUpstreamError(errText, `视频服务返回 HTTP ${response.status}`));
  }

  const json = await response.json();
  const directUrl = extractVideoUrl(json);
  const providerTaskId = extractProviderTaskId(json);
  if (directUrl && !providerTaskId) {
    await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: directUrl });
    releaseLease(slotResult);
    return;
  }
  if (!providerTaskId) throw new Error("Video provider did not return taskId");

  await updateTaskInDb(taskDbId, { providerTaskId, status: "running", progress: 20 });
  startPolling(taskDbId, {
    providerTaskId,
    apiKey: slotResult.apiKey,
    type: "video",
    providerConfig,
    leaseToken: slotResult.leaseToken,
    keyManager,
  });
}

async function submitDashscopeImageSuperResolveTask(taskDbId, slotResult, params) {
  await updateTaskInDb(taskDbId, { status: "running", progress: 10 });
  const body = buildDashscopeImageSuperResolveBody(params);
  const response = await fetch(DASHSCOPE_IMAGE_EDIT_ENDPOINT, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-DashScope-Async": "enable",
      Authorization: `Bearer ${slotResult.apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!response.ok) {
    const errText = await response.text().catch(() => "provider error");
    throw new Error(sanitizeUpstreamError(errText, `图片超分服务返回 HTTP ${response.status}`));
  }

  const json = await response.json();
  const directUrl = extractImageUrl(json);
  const providerTaskId = extractProviderTaskId(json);
  if (directUrl && !providerTaskId) {
    await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: directUrl });
    releaseLease(slotResult);
    return;
  }
  if (!providerTaskId) throw new Error("DashScope image super-resolution did not return taskId");

  await updateTaskInDb(taskDbId, { providerTaskId, status: "running", progress: 20 });
  startPolling(taskDbId, {
    providerTaskId,
    apiKey: slotResult.apiKey,
    type: "image",
    providerConfig: { transport: "dashscope-image" },
    leaseToken: slotResult.leaseToken,
    keyManager,
  });
}

async function submitDashscopeVideoStyleTransformTask(taskDbId, slotResult, params) {
  await updateTaskInDb(taskDbId, { status: "running", progress: 10 });
  const body = buildDashscopeVideoStyleTransformBody(params);
  const response = await fetch(DASHSCOPE_VIDEO_STYLE_ENDPOINT, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-DashScope-Async": "enable",
      Authorization: `Bearer ${slotResult.apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!response.ok) {
    const errText = await response.text().catch(() => "provider error");
    throw new Error(sanitizeUpstreamError(errText, `视频风格重绘超分服务返回 HTTP ${response.status}`));
  }

  const json = await response.json();
  const directUrl = extractVideoUrl(json);
  const providerTaskId = extractProviderTaskId(json);
  if (directUrl && !providerTaskId) {
    await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: directUrl });
    releaseLease(slotResult);
    return;
  }
  if (!providerTaskId) throw new Error("DashScope video style transform did not return taskId");

  await updateTaskInDb(taskDbId, { providerTaskId, status: "running", progress: 20 });
  startPolling(taskDbId, {
    providerTaskId,
    apiKey: slotResult.apiKey,
    type: "video",
    providerConfig: {
      protocol: "wan-i2v",
      baseUrl: "https://dashscope.aliyuncs.com",
    },
    leaseToken: slotResult.leaseToken,
    keyManager,
  });
}

async function submitVideoSuperResolveTask(taskDbId, params) {
  await updateTaskInDb(taskDbId, { status: "running", progress: 8 });
  const submitResult = await callAliyunRpc("SuperResolveVideo", {
    VideoUrl: toViapiAccessibleUrl(params.videoUrl),
    BitRate: String(params.bitRate || 10),
  });
  const jobId = submitResult.RequestId || submitResult.requestId || submitResult.JobId || submitResult.jobId;
  if (!jobId) {
    throw new Error("Aliyun SuperResolveVideo did not return a job id");
  }

  await updateTaskInDb(taskDbId, { providerTaskId: jobId, status: "running", progress: 18 });

  for (let attempt = 0; attempt < SUPER_RESOLVE_MAX_POLL_ATTEMPTS; attempt += 1) {
    if (attempt > 0) {
      await new Promise((resolve) => setTimeout(resolve, SUPER_RESOLVE_POLL_INTERVAL_MS));
    }

    const result = await callAliyunRpc("GetAsyncJobResult", { JobId: jobId });
    const data = result.Data || result.data || {};
    const status = normalizeAliyunJobStatus(data.Status || data.status);
    const progress = Math.min(96, 18 + Math.round((attempt / SUPER_RESOLVE_MAX_POLL_ATTEMPTS) * 76));

    if (status === "PROCESS_SUCCESS" || status === "SUCCESS" || status === "SUCCEEDED") {
      const resultPayload = parseAliyunJsonResult(data.Result || data.result) || data;
      const videoUrl = resultPayload.VideoUrl || resultPayload.videoUrl || resultPayload.video_url;
      if (!videoUrl) {
        throw new Error("Aliyun super-resolution completed without a video url");
      }
      await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: videoUrl });
      return;
    }

    if (
      status === "PROCESS_FAILED" ||
      status === "FAIL" ||
      status === "FAILED" ||
      status === "TIMEOUT_FAILED" ||
      status === "LIMIT_RETRY_FAILED"
    ) {
      throw new Error(data.Message || data.MessageDetail || data.ErrorMessage || "Aliyun video super-resolution failed");
    }

    await updateTaskInDb(taskDbId, { status: "running", progress });
  }

  throw new Error("Aliyun video super-resolution timed out");
}

async function submitEraseSubtitlesTask(taskDbId, params) {
  await updateTaskInDb(taskDbId, { status: "running", progress: 8 });
  const rpcParams = { VideoUrl: toViapiAccessibleUrl(params.videoUrl) };
  if (params.bx || params.by || params.bw || params.bh) {
    rpcParams.BX = String(params.bx || 0);
    rpcParams.BY = String(params.by || 0);
    rpcParams.BW = String(params.bw || 0);
    rpcParams.BH = String(params.bh || 0);
  }
  const submitResult = await callAliyunRpc("EraseVideoSubtitles", rpcParams);
  const jobId = submitResult.RequestId || submitResult.requestId || submitResult.JobId || submitResult.jobId;
  if (!jobId) {
    throw new Error("Aliyun EraseVideoSubtitles did not return a job id");
  }

  await updateTaskInDb(taskDbId, { providerTaskId: jobId, status: "running", progress: 18 });

  for (let attempt = 0; attempt < SUPER_RESOLVE_MAX_POLL_ATTEMPTS; attempt += 1) {
    if (attempt > 0) {
      await new Promise((resolve) => setTimeout(resolve, SUPER_RESOLVE_POLL_INTERVAL_MS));
    }

    const result = await callAliyunRpc("GetAsyncJobResult", { JobId: jobId });
    const data = result.Data || result.data || {};
    const status = normalizeAliyunJobStatus(data.Status || data.status);
    const progress = Math.min(96, 18 + Math.round((attempt / SUPER_RESOLVE_MAX_POLL_ATTEMPTS) * 76));

    if (status === "PROCESS_SUCCESS" || status === "SUCCESS" || status === "SUCCEEDED") {
      const resultPayload = parseAliyunJsonResult(data.Result || data.result) || data;
      const videoUrl = resultPayload.VideoUrl || resultPayload.videoUrl || resultPayload.video_url;
      if (!videoUrl) {
        throw new Error("Aliyun subtitle erasure completed without a video url");
      }
      await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: videoUrl });
      return;
    }

    if (
      status === "PROCESS_FAILED" ||
      status === "FAIL" ||
      status === "FAILED" ||
      status === "TIMEOUT_FAILED" ||
      status === "LIMIT_RETRY_FAILED"
    ) {
      throw new Error(data.Message || data.MessageDetail || data.ErrorMessage || "字幕去除失败");
    }

    await updateTaskInDb(taskDbId, { status: "running", progress });
  }

  throw new Error("字幕去除超时");
}

async function submitDashscopeImageEditTask(taskDbId, slotResult, params) {
  await updateTaskInDb(taskDbId, { status: "running", progress: 10 });
  const WAN27_IMAGE_EDIT_ENDPOINT = "https://dashscope.aliyuncs.com/api/v1/services/aigc/image-generation/generation";
  const body = {
    model: "wan2.7-image-pro",
    input: {
      messages: [{
        role: "user",
        content: [
          { image: params.imageUrl },
          { text: params.prompt || "去除图像中的水印和文字" },
        ],
      }],
    },
    parameters: {
      size: "2K",
      n: params.n || 1,
      watermark: false,
    },
  };
  const response = await fetch(WAN27_IMAGE_EDIT_ENDPOINT, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-DashScope-Async": "enable",
      Authorization: `Bearer ${slotResult.apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!response.ok) {
    const errText = await response.text().catch(() => "provider error");
    throw new Error(sanitizeUpstreamError(errText, `图片编辑服务返回 HTTP ${response.status}`));
  }

  const json = await response.json();
  const directUrl = extractImageUrl(json);
  const providerTaskId = extractProviderTaskId(json);
  if (directUrl && !providerTaskId) {
    await updateTaskInDb(taskDbId, { status: "completed", progress: 100, resultUrl: directUrl });
    releaseLease(slotResult);
    return;
  }
  if (!providerTaskId) throw new Error("DashScope image edit did not return taskId");

  await updateTaskInDb(taskDbId, { providerTaskId, status: "running", progress: 20 });
  startPolling(taskDbId, {
    providerTaskId,
    apiKey: slotResult.apiKey,
    type: "image",
    providerConfig: { transport: "dashscope-image" },
    leaseToken: slotResult.leaseToken,
    keyManager,
  });
}

module.exports = { registerAiRoutes };