// server/api/images/generate.post.ts - 图片生成接口：创建记录、流式调用上游生图、归档图床并返回图片地址。
import type {
  IImageGenerateData,
  IImageGenerateRequest
} from "#shared/types/openai";

type ApiLogger = ReturnType<typeof createApiLogger>;

/**
 * POST /api/images/generate
 *
 * 流程：
 * 1. 校验请求体和 prompt，空 prompt 不创建数据库记录。
 * 2. 从 httpOnly cookie 读取当前 NewAPI 用户 ID。
 * 3. 创建 RUNNING 生图记录，并递增全局请求/进行中统计。
 * 4. 在服务端确保并读取 AIArtStudio 完整 key，完整 key 不返回前端。
 * 5. 调用 Chat Completions 流式生图接口，累积 SSE delta content 并提取最终图片 URL。
 * 6. 尝试把上游图片下载后上传到 Lsky 图床；图床失败不阻断本次生图成功。
 * 7. 成功时写入上游 URL、图床 URL、完整上游响应、图床响应和耗时。
 * 8. 失败时把记录标记为 FAILED；鉴权失败会清理本地登录态并返回 401。
 */
export default defineEventHandler(async (event) => {
  const logger = createApiLogger("images.generate");
  let stage = "read_body";
  const requestBody = await readBody<Partial<IImageGenerateRequest> | null>(
    event
  );

  // 只接受 JSON 对象，避免数组、字符串等无效 body 被用于生成请求。
  if (
    requestBody !== null &&
    (typeof requestBody !== "object" || Array.isArray(requestBody))
  ) {
    logger.warn("请求体格式错误", {
      bodyType: Array.isArray(requestBody) ? "array" : typeof requestBody
    });
    return createErrorResponse(400, "请求体必须是 JSON 对象");
  }

  const prompt = requestBody?.prompt?.trim();
  if (!prompt) {
    logger.warn("缺少提示词");
    return createErrorResponse(400, "请输入图片描述");
  }

  // 不记录完整 prompt，日志只保留长度，避免把用户输入或潜在敏感内容写进日志。
  logger.info("开始", {
    promptLength: prompt.length
  });

  let record: { id: bigint; startedAt: Date } | null = null;

  try {
    stage = "read_user_id";
    // userId 来自服务端 httpOnly cookie，前端不能伪造请求体覆盖用户归属。
    const userId = getNewApiUserIdFromCookie(event);
    logger.info("读取用户成功", {
      userId
    });

    stage = "create_running_record";
    // 从这里开始才写数据库；参数错误和空 prompt 不会留下无效生图记录。
    record = await createRunningImageGeneration(userId, prompt);
    logger.info("创建生图记录成功", {
      recordId: record.id.toString()
    });

    stage = "get_api_key";
    // 完整 key 只在服务端内存中短暂使用，不写入响应、不写入日志。
    const apiKey = await getAiArtStudioTokenKey(event);
    logger.info("获取服务端 key 成功", {
      recordId: record.id.toString()
    });

    stage = "call_image_stream_api";
    // 上游通过 SSE 分段返回进度和最终 Markdown 图片链接，这里同步等待流结束。
    const result = await askImgStream({
      apiKey,
      prompt
    });
    logger.info("上游流式生图成功", {
      recordId: record.id.toString(),
      hasImageUrl: Boolean(result.imageUrl),
      contentLength: getStreamContentLength(result.upstreamResponse),
      hasUsage: hasStreamUsage(result.upstreamResponse)
    });

    stage = "upload_lsky";
    // 归档图床用于长期保存；失败时仍继续返回 NewAPI 上游图片 URL。
    const archiveResult = await archiveGeneratedImage({
      imageUrl: result.imageUrl,
      userId,
      recordId: record.id,
      createdAt: record.startedAt,
      logger
    });
    logger.info("图床归档完成", {
      recordId: record.id.toString(),
      hosted: Boolean(archiveResult.hostedImageUrl),
      mimeType: archiveResult.imageMimeType
    });

    stage = "finish_success_record";
    await finishImageGenerationSuccess(record.id, record.startedAt, {
      imageUrl: result.imageUrl,
      hostedImageUrl: archiveResult.hostedImageUrl,
      imageMimeType: archiveResult.imageMimeType,
      revisedPrompt: result.revisedPrompt,
      upstreamResponse: result.upstreamResponse,
      hostedResponse: archiveResult.hostedResponse,
      errorMessage: archiveResult.errorMessage
    });

    logger.done("成功", {
      recordId: record.id.toString(),
      hosted: Boolean(archiveResult.hostedImageUrl)
    });

    return createSuccessResponse<IImageGenerateData>(
      {
        imageUrl: result.imageUrl,
        hostedImageUrl: archiveResult.hostedImageUrl,
        revisedPrompt: result.revisedPrompt
      },
      "图片生成成功"
    );
  } catch (error) {
    logger.error("失败", {
      stage,
      recordId: record?.id.toString() ?? null,
      error: toSafeLogError(error)
    });

    if (record) {
      await finishImageGenerationFailed(
        record.id,
        record.startedAt,
        error
      ).catch((recordError) => {
        logger.error("更新失败记录失败", {
          recordId: record?.id.toString() ?? null,
          error: toSafeLogError(recordError)
        });
      });
    }

    if (isUnauthorizedError(error)) {
      clearNewApiAuthCookies(event);
      return createErrorResponse(401, "未登录");
    }

    // 统一把上游错误包成前端约定的响应结构，避免泄露 key/cookie。
    return createUpstreamErrorResponse(error, "图片生成失败");
  }
});

/** 将生成图上传到 Lsky，返回图床地址；归档失败时降级为空结果 */
const archiveGeneratedImage = async ({
  imageUrl,
  userId,
  recordId,
  createdAt,
  logger
}: {
  imageUrl: string;
  userId: number;
  recordId: bigint;
  createdAt: Date;
  logger: ApiLogger;
}): Promise<{
  hostedImageUrl: string | null;
  imageMimeType: string | null;
  hostedResponse: unknown;
  errorMessage: string | null;
}> => {
  try {
    // 图床归档失败不能阻断本次生成结果，前端仍可使用上游图片 URL。
    const identity = await getUserArchiveIdentity(userId);
    const uploaded = await uploadImageFromUrl({
      imageUrl,
      userId,
      username: identity.username,
      recordId,
      createdAt
    });

    return {
      hostedImageUrl: uploaded.publicUrl,
      imageMimeType: uploaded.mimetype,
      hostedResponse: uploaded.response,
      errorMessage: null
    };
  } catch (error) {
    logger.error("图床归档失败", {
      recordId: recordId.toString(),
      error: toSafeLogError(error)
    });

    return {
      hostedImageUrl: null,
      imageMimeType: null,
      hostedResponse: null,
      errorMessage: "图片生成成功，但图片归档失败"
    };
  }
};

// 日志只读取流式聚合结果的元信息，不记录完整提示词、key 或图片内容。
const getStreamContentLength = (upstreamResponse: unknown) => {
  if (
    upstreamResponse &&
    typeof upstreamResponse === "object" &&
    "content" in upstreamResponse &&
    typeof upstreamResponse.content === "string"
  ) {
    return upstreamResponse.content.length;
  }

  return 0;
};

/** 判断流式上游响应里是否包含 usage，用于日志确认上游是否正常结束 */
const hasStreamUsage = (upstreamResponse: unknown) => {
  return (
    upstreamResponse !== null &&
    typeof upstreamResponse === "object" &&
    "usage" in upstreamResponse &&
    Boolean(upstreamResponse.usage)
  );
};