用户上传图像 + 输入提示词
   ↓
身份认证 (Better Auth)
   ↓
检查积分余额 (20 积分)
   ↓
创建生成记录 (generationHistory)
   ↓
扣除积分 + 记录账本
   ↓
调用火山引擎图像 API
   ↓
上传结果到 R2 存储
   ↓
更新生成记录 (completed)
   ↓
返回结果 URL

const model = volcanoEngineConfig.imageModel || 'doubao-seededit-3-0-i2i-250628';

// lib/volcano-engine/image.ts
const request: ImageGenerationRequest = {
  model,
  prompt,
  image: [referenceImageUrl],  // 参考图像
  response_format: 'url',
  size: '2K',                   // 使用 2K 分辨率
  watermark: false,             // 不添加水印
};

{
  "size": "2K",
  "watermark": false,
  "imageUrl": "https://example.com/reference.jpg"
}

// POST /api/image/generate
{
  "prompt": "将这张照片转换为水彩画风格",
  "imageUrl": "https://example.com/reference.jpg",
  "size": "2K",           // 可选, 默认 'adaptive'
  "watermark": false      // 可选, 默认 true
}

{
  "id": "uuid-xxx-xxx",
  "url": "https://your-r2-storage.com/images/user_123/image_xxx.png",
  "revisedPrompt": "将这张照片转换为水彩画风格",
  "remainingCredits": 280,
  "sourceImageUrl": "https://example.com/reference.jpg"
}

// 401 - 未登录
{
  "error": "Unauthorized"
}

// 400 - 缺少必需参数
{
  "error": "Prompt is required"
}

// 400 - 缺少参考图像
{
  "error": "Reference image is required"
}

// 402 - 积分不足
{
  "error": "Insufficient credits",
  "creditsNeeded": 20,
  "remainingCredits": 5
}

// 500 - 生成失败
{
  "error": "Failed to generate image"
}

// 1. 验证用户登录状态
const session = await auth.api.getSession({ headers: req.headers });
if (!session?.session?.userId) {
  return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}

const userId = session.session.userId;

// 2. 解析请求体
const { prompt, size, watermark, imageUrl } = await req.json();

// 3. 验证必需参数
if (!prompt) {
  return NextResponse.json({ error: "Prompt is required" }, { status: 400 });
}

if (!imageUrl) {
  return NextResponse.json({ error: "Reference image is required" }, { status: 400 });
}

// 4. 检查用户是否有足够积分 (20 积分)
const creditsNeeded = 20;
const hasCredits = await canUserAfford(userId, creditsNeeded);
if (!hasCredits) {
  return NextResponse.json({
    error: "Insufficient credits",
    creditsNeeded,
    remainingCredits: 0
  }, { status: 402 });
}

// 5. 创建生成历史记录
const historyId = randomUUID();
await db.insert(generationHistory).values({
  id: historyId,
  userId,
  type: "image",
  prompt,
  status: "processing",
  creditsUsed: creditsNeeded,
  metadata: JSON.stringify({ size, watermark, imageUrl }),
});

// 6. 扣除积分 (事务性操作)
const deductResult = await deductCredits(
  userId,
  creditsNeeded,
  "image_generation",
  historyId
);

if (!deductResult.success) {
  // 更新记录为失败状态
  await db.update(generationHistory)
    .set({ status: "failed", error: deductResult.error })
    .where(eq(generationHistory.id, historyId));

  return NextResponse.json({
    error: deductResult.error || "Failed to deduct credits",
    remainingCredits: deductResult.remainingCredits
  }, { status: 402 });
}

try {
  // 7. 生成图像
  const result = await volcanoEngine.generateImage(prompt, {
    size,
    inputImages: [imageUrl],  // 传入参考图像
    watermark,
  });

  if (!result.data || result.data.length === 0) {
    throw new Error('No image generated');
  }

  const imageData = result.data[0];
  // imageData.url: 火山引擎返回的图像 URL
  // imageData.revised_prompt: 优化后的提示词

  // 8. 上传图像到 R2 存储 (长期保存)
  const r2Url = await uploadImageFromUrl(imageData.url, userId, 'image');

  // 9. 更新记录为完成状态
  await db.update(generationHistory)
    .set({
      status: "completed",
      resultUrl: r2Url,
      updatedAt: new Date(),
    })
    .where(eq(generationHistory.id, historyId));

  // 10. 返回结果
  return NextResponse.json({
    id: historyId,
    url: r2Url,
    revisedPrompt: imageData.revised_prompt,
    remainingCredits: deductResult.remainingCredits,
    sourceImageUrl: imageUrl,
  });

} catch (genError: any) {
  // 11. 失败处理: 更新记录状态
  await db.update(generationHistory)
    .set({
      status: "failed",
      error: genError.message,
      updatedAt: new Date(),
    })
    .where(eq(generationHistory.id, historyId));

  throw genError;
}

catch (genError: any) {
  // 退还积分
  await refundCredits(userId, creditsNeeded, "refund", historyId);

  // 更新记录...
}

const creditsNeeded = 20; // 图像生成消耗 20 积分

// 根据分辨率动态定价
const creditsCost = {
  'adaptive': 20,
  '1K': 15,
  '2K': 25,
  '4K': 40,
};

const creditsNeeded = creditsCost[size] || 20;

import { useState } from "react";

export function ImageGeneratorComponent() {
  const [prompt, setPrompt] = useState("");
  const [imageUrl, setImageUrl] = useState("");
  const [resultUrl, setResultUrl] = useState<string | null>(null);
  const [isLoading, setIsLoading] = useState(false);
  const [credits, setCredits] = useState<number>(0);

  const handleGenerate = async () => {
    if (!prompt || !imageUrl) {
      alert("请输入提示词和参考图像 URL");
      return;
    }

    setIsLoading(true);
    setResultUrl(null);

    try {
      const response = await fetch("/api/image/generate", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          prompt,
          imageUrl,
          size: "2K",
          watermark: false,
        }),
      });

      if (!response.ok) {
        const error = await response.json();

        if (response.status === 402) {
          alert(`积分不足!需要 ${error.creditsNeeded} 积分,当前余额 ${error.remainingCredits}`);
          return;
        }

        throw new Error(error.error || "Failed to generate image");
      }

      const result = await response.json();
      setResultUrl(result.url);
      setCredits(result.remainingCredits);

      console.log("生成记录 ID:", result.id);
      console.log("优化后的提示词:", result.revisedPrompt);

    } catch (error: any) {
      console.error("Image generation error:", error);
      alert(error.message);
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <div>
      {/* 积分显示 */}
      <div>剩余积分: {credits}</div>

      {/* 输入区域 */}
      <div>
        <label>参考图像 URL:</label>
        <input
          type="text"
          value={imageUrl}
          onChange={(e) => setImageUrl(e.target.value)}
          placeholder="https://example.com/image.jpg"
          disabled={isLoading}
        />
      </div>

      <div>
        <label>提示词:</label>
        <textarea
          value={prompt}
          onChange={(e) => setPrompt(e.target.value)}
          placeholder="将这张照片转换为水彩画风格"
          disabled={isLoading}
        />
      </div>

      <button onClick={handleGenerate} disabled={isLoading || !prompt || !imageUrl}>
        {isLoading ? "生成中..." : "生成图像 (20 积分)"}
      </button>

      {/* 结果显示 */}
      {resultUrl && (
        <div>
          <h3>生成结果:</h3>
          <img src={resultUrl} alt="Generated" style={{ maxWidth: "100%" }} />
          <a href={resultUrl} download>下载图像</a>
        </div>
      )}
    </div>
  );
}

const handleFileUpload = async (file: File) => {
  const formData = new FormData();
  formData.append("file", file);

  const response = await fetch("/api/upload", {
    method: "POST",
    body: formData,
  });

  const { url } = await response.json();
  setImageUrl(url);
};

async function generateImage(prompt, imageUrl, options = {}) {
  const response = await fetch('/api/image/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      prompt,
      imageUrl,
      size: options.size || '2K',
      watermark: options.watermark !== undefined ? options.watermark : false,
    }),
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error);
  }

  return response.json();
}

// 使用示例
generateImage(
  '将这张照片转换为水彩画风格',
  'https://example.com/photo.jpg',
  { size: '2K', watermark: false }
)
  .then(result => {
    console.log('生成成功!');
    console.log('结果 URL:', result.url);
    console.log('剩余积分:', result.remainingCredits);
  })
  .catch(error => console.error('生成失败:', error.message));

✅ "将这张照片转换为水彩画风格,保留人物特征"
✅ "在图像中添加夕阳光效,色调偏暖"
✅ "移除背景,替换为纯白色"
✅ "将照片风格改为赛博朋克,增强霓虹灯效果"

❌ "好看" (太模糊)
❌ "修改" (没有明确指示)
❌ "画一只猫" (应该使用文生图,而非图生图)

async function batchGenerateImages(prompts: string[], imageUrl: string) {
  const results = [];

  for (const prompt of prompts) {
    const result = await fetch('/api/image/generate', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ prompt, imageUrl }),
    }).then(r => r.json());

    results.push(result);

    // 添加延迟避免频繁调用
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  return results;
}

// 使用
const prompts = [
  '转换为水彩画风格',
  '转换为油画风格',
  '转换为素描风格',
];

batchGenerateImages(prompts, 'https://example.com/photo.jpg')
  .then(results => console.log('批量生成完成:', results));

// API 端点 (需要自己实现)
// GET /api/image/history?limit=10

async function getImageHistory(limit = 10) {
  const response = await fetch(`/api/image/history?limit=${limit}`);
  return response.json();
}

// 返回格式
/*
[
  {
    id: "uuid-xxx",
    prompt: "转换为水彩画风格",
    imageUrl: "https://...",
    resultUrl: "https://...",
    status: "completed",
    createdAt: "2025-10-15T10:30:00Z"
  },
  ...
]
*/

// app/api/image/generate/route.ts
const { prompt, imageUrl, size = 'adaptive', watermark } = await req.json();

// 根据分辨率计算积分
const creditsCostMap = {
  'adaptive': 20,
  '1K': 15,
  '2K': 25,
  '4K': 40,
};

const creditsNeeded = creditsCostMap[size] || 20;

// 检查余额
const hasCredits = await canUserAfford(userId, creditsNeeded);
// ... 后续逻辑

const preloadImage = (url: string): Promise<void> => {
  return new Promise((resolve, reject) => {
    const img = new Image();
    img.onload = () => resolve();
    img.onerror = () => reject(new Error('Failed to load image'));
    img.src = url;
  });
};

// 在提交前验证
await preloadImage(imageUrl);

const uploadPromises = imageUrls.map(url =>
  uploadImageFromUrl(url, userId, 'image')
);

const r2Urls = await Promise.all(uploadPromises);

let cachedToken: string | null = null;
let tokenExpiry: number = 0;

async function getVolcanoToken() {
  if (cachedToken && Date.now() < tokenExpiry) {
    return cachedToken;
  }

  // 获取新 Token
  const response = await fetch('https://api.volcengine.com/auth/token', { ... });
  const { token, expires_in } = await response.json();

  cachedToken = token;
  tokenExpiry = Date.now() + expires_in * 1000;

  return token;
}