// 对话历史管理 - 章节内容作为系统上下文
const conversationHistory = [
  { role: 'system', content: chapterContext },
  ...messages.map(msg => ({
    role: msg.role,
    content: msg.content
  }))
];

// 直接调用Gemini API，无需后端
const response = await fetch(
  `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
  { method: 'POST', body: JSON.stringify({ contents: conversationHistory }) }
);

// Next.js API路由 - 豆包API适配
export async function POST(request: Request) {
  const encoder = new TextEncoder();
  const stream = new TransformStream();
  const writer = stream.writable.getWriter();
  
  // SSE流式推送
  writer.write(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
  
  return new Response(stream.readable, {
    headers: { 'Content-Type': 'text/event-stream' }
  });
}

// 分级缓存系统
const CACHE_DURATIONS = {
  hot: 30 * 60 * 1000,      // 热门书籍：30分钟
  categories: 60 * 60 * 1000, // 分类列表：1小时
  search: 15 * 60 * 1000,     // 搜索结果：15分钟
  category: 20 * 60 * 1000,   // 分类页面：20分钟
  book: 30 * 60 * 1000,       // 书籍详情：30分钟
};

// 自动过期检测和清理
const cached = localStorage.getItem(cacheKey);
if (cached && Date.now() < cached.timestamp + cached.expiry) {
  return cached.data; // 命中缓存
}

// 逆向分析的API端点
const AILV_API_URL = 'https://a.ailv.run/analyze';

// 精心构造的请求头，绕过反爬虫
headers: {
  'Content-Type': 'application/json',
  'Origin': 'https://www.ailv.run',
  'Referer': 'https://www.ailv.run/',
  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
}

// 返回原始检测结果
{
  avgAiProbability: 0.85,      // AI生成概率
  avgHumanProbability: 0.15    // 人类创作概率
}

// SSE流式接收
const eventSource = new EventSource('/api/ai-image/generate');
eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
  if (data.type === 'progress') {
    updateProgress(data.progress);
  } else if (data.type === 'image') {
    displayImage(data.url);
  }
};

interface Chapter {
  id: string;
  title: string;
  content: string;
  draft?: string;      // 草稿版本
  wordCount: number;
  createdAt: Date;
  updatedAt: Date;
}

interface Character {
  id: string;
  name: string;
  avatar?: string;
  description: string;
  personality: string[];
  background: string;
  relationships: Relationship[];
}

interface WorldBook {
  id: string;
  category: string;    // 地理、历史、魔法体系等
  name: string;
  description: string;
  tags: string[];
  relatedChapters: string[];
}

// 统一的AI提供商接口
export interface AIProvider {
  readonly id: string;
  readonly type: 'openai' | 'gemini' | 'claude' | 'custom';
  readonly apiUrl: string;
  readonly apiKey: string;
  
  // 统一的调用方法
  generateContent(modelId: string, prompt: string, options?: GenerateOptions): Promise<string>;
  generateContentStream(modelId: string, prompt: string, options?: GenerateOptions): AsyncGenerator<string>;
  listModels(): Promise<AIModel[]>;
  testConnection(): Promise<ConnectionTestResult>;
}

export class UnifiedAIClient {
  private providers = new Map<string, AIProvider>();
  
  // 生成内容 - 统一入口
  async generateContent(
    providerId: string,
    modelId: string,
    prompt: string,
    options?: GenerateOptions
  ): Promise<string> {
    const provider = this.ensureProviderForCall(
      this.getProvider(providerId)
    );
    return provider.generateContent(modelId, prompt, options);
  }
  
  // 自动选择最佳提供商
  async selectBestProvider(): Promise<{ providerId: string; modelId: string }> {
    // 优先级：Gemini > OpenAI > Claude > Custom
    const enabledProviders = this.getEnabledProviders();
    // ... 智能选择逻辑
  }
  
  // 获取使用统计
  getStatsSummary(): {
    totalRequests: number;
    totalTokens: number;
    averageResponseTime: number;
    providerUsage: Record<string, number>;
  }
}

export class AIConfigManager {
  // CRUD操作
  static addProvider(provider: Omit<AIProviderConfig, 'createdAt' | 'updatedAt'>)
  static updateProvider(providerId: string, updates: Partial<AIProviderConfig>)
  static removeProvider(providerId: string)
  static getProviders(): AIProviderConfig[]
  
  // 导入导出
  static exportConfig(): string  // 导出JSON配置
  static importConfig(configJson: string, options: {
    overwrite?: boolean;    // 是否覆盖现有配置
    skipInvalid?: boolean;  // 跳过无效配置
  }): { success: boolean; imported: number; skipped: number; errors: string[] }
  
  // 验证
  static validateProvider(provider: AIProviderConfig): ConfigValidationResult
  
  // 健康检查
  static checkHealth(): { healthy: boolean; issues: Array<{ type: 'error' | 'warning'; message: string }> }
  
  // 配置变更监听
  static onConfigChange(callback: (event: ConfigChangeEvent) => void): () => void
}

import { getUnifiedAIClient } from '@/lib/ai/unified-client';

const client = getUnifiedAIClient();

// 使用指定提供商和模型
const result = await client.generateContent(
  'gemini-main',
  'gemini-2.5-flash',
  '写一个科幻故事开头',
  { temperature: 0.9 }
);

// 流式生成
for await (const chunk of client.generateContentStream(
  'deepseek-backup',
  'deepseek-chat',
  '继续故事情节'
)) {
  console.log(chunk);
}

import { autoGenerateContent } from '@/lib/ai/unified-client';

// 自动选择最优Provider（Gemini优先）
const result = await autoGenerateContent(
  '分析这段小说的写作手法',
  { temperature: 0.7 }
);

const client = getUnifiedAIClient();
const stats = client.getStatsSummary();

console.log(`总请求: ${stats.totalRequests}`);
console.log(`总Token: ${stats.totalTokens}`);
console.log(`平均响应时间: ${stats.averageResponseTime}ms`);
console.log('提供商使用情况:', stats.providerUsage);
// 输出: { 'gemini-main': 45, 'deepseek-backup': 12 }

// src/lib/gemini-client.ts

export async function callGeminiAPI(
  conversationHistory: ChatMessage[],
  chapterContext: string,
  apiKey: string,
  model: string = 'gemini-2.5-flash'
) {
  // 构建完整对话历史
  const contents = [
    {
      role: 'system',
      parts: [{ text: chapterContext }]
    },
    ...conversationHistory.map(msg => ({
      role: msg.role === 'user' ? 'user' : 'model',
      parts: [{ text: msg.content }]
    }))
  ];

  // 直接调用Google API
  const response = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        contents,
        generationConfig: {
          temperature: 0.9,
          maxOutputTokens: 8192,
        }
      })
    }
  );

  const data = await response.json();
  return data.candidates[0].content.parts[0].text;
}

// src/lib/book-source-rule-parser.ts

export function parseRule(
  html: string,
  rule: string,
  context: ParseContext
): string | string[] {
  // 1. 处理JavaScript代码块
  if (rule.includes('<js>')) {
    const jsCode = extractJsCode(rule);
    return executeInSandbox(jsCode, context);
  }

  // 2. 处理混合规则 @css + @js
  if (rule.includes('@css') && rule.includes('@js')) {
    const cssResult = parseCssSelector(html, rule);
    const jsResult = executeJs(cssResult, rule);
    return jsResult;
  }

  // 3. 处理JSONPath
  if (rule.startsWith('$.')) {
    return parseJsonPath(html, rule);
  }

  // 4. 处理占位符
  const processed = replacePlaceholders(rule, context);

  // 5. 标准CSS选择器
  return parseCssSelector(html, processed);
}

const PLACEHOLDERS = {
  '{{page}}': () => currentPage.toString(),
  '{{host()}}': () => new URL(baseUrl).origin,
  '{{source.bookUrl}}': () => context.bookUrl,
  '{{source.chapterUrl}}': () => context.chapterUrl,
};

// src/lib/cache-manager.ts

interface CacheEntry<T> {
  data: T;
  timestamp: number;
  expiry: number;
}

class CacheManager {
  private prefix = 'bookstore_cache_';

  // 存储缓存
  set<T>(key: string, data: T, duration: number): void {
    const entry: CacheEntry<T> = {
      data,
      timestamp: Date.now(),
      expiry: duration
    };
    localStorage.setItem(
      `${this.prefix}${this.hashKey(key)}`,
      JSON.stringify(entry)
    );
  }

  // 读取缓存
  get<T>(key: string): T | null {
    const item = localStorage.getItem(`${this.prefix}${this.hashKey(key)}`);
    if (!item) return null;

    const entry: CacheEntry<T> = JSON.parse(item);
    
    // 检查是否过期
    if (Date.now() > entry.timestamp + entry.expiry) {
      this.delete(key);
      return null;
    }

    return entry.data;
  }

  // 清理所有过期缓存
  cleanExpired(): void {
    Object.keys(localStorage)
      .filter(key => key.startsWith(this.prefix))
      .forEach(key => {
        const entry = JSON.parse(localStorage.getItem(key)!);
        if (Date.now() > entry.timestamp + entry.expiry) {
          localStorage.removeItem(key);
        }
      });
  }

  // 生成缓存键
  private hashKey(key: string): string {
    return btoa(encodeURIComponent(key)).substring(0, 32);
  }
}

export const cacheManager = new CacheManager();

// 先查缓存
const cached = cacheManager.get<Book[]>('hot_books');
if (cached) {
  setBooks(cached);
  return;
}

// 缓存未命中，请求API
const response = await fetch('/api/bookstore/hot');
const data = await response.json();

// 存入缓存（30分钟）
cacheManager.set('hot_books', data, 30 * 60 * 1000);
setBooks(data);

// src/app/api/ai-image/generate/route.ts

export async function POST(request: Request) {
  const { prompt, count } = await request.json();

  // 创建SSE流
  const encoder = new TextEncoder();
  const stream = new TransformStream();
  const writer = stream.writable.getWriter();

  // 异步处理
  (async () => {
    try {
      // 1. 提交任务
      writer.write(encoder.encode(
        `data: ${JSON.stringify({ type: 'progress', message: '提交生成任务...' })}\n\n`
      ));

      const taskResponse = await fetch(DOUBAO_API_URL, {
        method: 'POST',
        headers: { 'Authorization': `Bearer ${DOUBAO_API_KEY}` },
        body: JSON.stringify({ prompt, num_images: count })
      });

      const { task_id } = await taskResponse.json();

      // 2. 轮询结果
      let completed = false;
      while (!completed) {
        await new Promise(resolve => setTimeout(resolve, 2000));

        const statusResponse = await fetch(`${DOUBAO_API_URL}/${task_id}`);
        const status = await statusResponse.json();

        // 推送进度
        writer.write(encoder.encode(
          `data: ${JSON.stringify({
            type: 'progress',
            progress: status.progress
          })}\n\n`
        ));

        if (status.status === 'completed') {
          // 推送图片
          status.images.forEach((url: string) => {
            writer.write(encoder.encode(
              `data: ${JSON.stringify({ type: 'image', url })}\n\n`
            ));
          });
          completed = true;
        }
      }

      writer.write(encoder.encode(`data: ${JSON.stringify({ type: 'done' })}\n\n`));
    } catch (error) {
      writer.write(encoder.encode(
        `data: ${JSON.stringify({ type: 'error', message: error.message })}\n\n`
      ));
    } finally {
      writer.close();
    }
  })();

  return new Response(stream.readable, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive'
    }
  });
}

const eventSource = new EventSource('/api/ai-image/generate', {
  method: 'POST',
  body: JSON.stringify({ prompt, count: 4 })
});

eventSource.addEventListener('message', (event) => {
  const data = JSON.parse(event.data);
  
  switch (data.type) {
    case 'progress':
      setProgress(data.progress);
      break;
    case 'image':
      setImages(prev => [...prev, data.url]);
      break;
    case 'done':
      eventSource.close();
      break;
    case 'error':
      showError(data.message);
      eventSource.close();
      break;
  }
});

// src/app/bookstore/read/page.tsx

// 方案1：基于书籍章节列表（优先）
async function navigateByChapterList(direction: 'prev' | 'next') {
  // 获取完整章节列表
  const chaptersResponse = await fetch(`/api/bookstore/book?url=${bookUrl}`);
  const { chapters } = await chaptersResponse.json();

  // 定位当前章节
  const currentIndex = chapters.findIndex(ch => ch.url === currentChapterUrl);
  
  // 计算目标章节
  const targetIndex = direction === 'next' ? currentIndex + 1 : currentIndex - 1;
  
  if (targetIndex >= 0 && targetIndex < chapters.length) {
    const targetChapter = chapters[targetIndex];
    router.push(`/bookstore/read?url=${encodeURIComponent(targetChapter.url)}&bookUrl=${encodeURIComponent(bookUrl)}`);
    return true;
  }
  
  return false;
}

// 方案2：基于HTML提取（备用）
async function navigateByHtmlExtraction(direction: 'prev' | 'next') {
  const response = await fetch(`/api/bookstore/chapter?url=${currentChapterUrl}`);
  const { navigation } = await response.json();
  
  // 严格区分"下一章"和"下一页"
  const targetUrl = direction === 'next' 
    ? navigation.nextChapter  // 不是nextPage！
    : navigation.prevChapter;
  
  if (targetUrl) {
    router.push(`/bookstore/read?url=${encodeURIComponent(targetUrl)}`);
    return true;
  }
  
  return false;
}

// 智能导航函数
async function smartNavigate(direction: 'prev' | 'next') {
  // 优先使用章节列表导航
  if (bookUrl) {
    const success = await navigateByChapterList(direction);
    if (success) return;
  }
  
  // 降级到HTML提取
  await navigateByHtmlExtraction(direction);
}

// src/lib/book-source-utils.ts

function extractNavigation(html: string): Navigation {
  const $ = cheerio.load(html);
  
  // 查找导航链接
  const links = $('a').toArray();
  
  let prevChapter = null;
  let nextChapter = null;
  
  links.forEach(link => {
    const text = $(link).text().trim();
    const href = $(link).attr('href');
    
    // 严格匹配"上一章"
    if (/上一章|上一节|上一回/.test(text)) {
      prevChapter = resolveUrl(href, baseUrl);
    }
    
    // 严格匹配"下一章"，排除"下一页"
    if (/下一章|下一节|下一回/.test(text) && !/下一页/.test(text)) {
      nextChapter = resolveUrl(href, baseUrl);
    }
  });
  
  return { prevChapter, nextChapter };
}