// AI内容分析服务
// filepath: h:\blews\akmon\uni_modules\ak-ai-news\services\ai-content-analysis-service.uts

import { AkReq } from '@/uni_modules/ak-req/index.uts'
import type { 
  ContentAnalysisResult, 
  EntityResult, 
  TopicResult, 
  CategoryResult,
  AIProvider, 
  AIResponse,
  AIServiceConfig,
  ContentInfo
} from '../types/ai-types.uts'

export class AIContentAnalysisService {
  private config: AIServiceConfig
  private req: AkReq
  private cache: Map<string, ContentAnalysisResult> = new Map()
  
  constructor(config: AIServiceConfig) {
    this.config = config
    this.req = new AkReq()
  }
  
  /**
   * 综合内容分析
   */
  async analyzeContent(
    content: ContentInfo,
    options?: {
      includeEntities?: boolean
      includeTopics?: boolean
      includeSentiment?: boolean
      includeReadability?: boolean
      includeCredibility?: boolean
      language?: string
    }
  ): Promise<AIResponse<ContentAnalysisResult>> {
    try {
      const startTime = Date.now()
      
      // 检查缓存
      const cacheKey = this.generateContentCacheKey(content.id, options)
      const cached = this.cache.get(cacheKey)
      if (cached) {
        return {
          success: true,
          data: cached,
          processingTimeMs: 0
        }
      }
      
      const analysisPromises: Promise<any>[] = []
      
      // 情感分析
      if (options?.includeSentiment !== false) {
        analysisPromises.push(this.analyzeSentiment(content.content, content.title))
      }
      
      // 实体识别
      if (options?.includeEntities !== false) {
        analysisPromises.push(this.extractEntities(content.content))
      }
      
      // 主题提取
      if (options?.includeTopics !== false) {
        analysisPromises.push(this.extractTopics(content.content))
      }
      
      // 可读性分析
      if (options?.includeReadability !== false) {
        analysisPromises.push(this.analyzeReadability(content.content))
      }
      
      // 可信度分析
      if (options?.includeCredibility !== false) {
        analysisPromises.push(this.analyzeCredibility(content))
      }
      
      // 并行执行所有分析
      const results = await Promise.all(analysisPromises)
      
      // 生成摘要
      const summary = await this.generateSummary(content.content)
      
      // 提取关键词
      const keywords = await this.extractKeywords(content.content)
      
      // 分类内容
      const categories = await this.classifyContent(content)
      
      const analysisResult: ContentAnalysisResult = {
        contentId: content.id,
        sentimentScore: results[0]?.score || 0,
        sentimentLabel: results[0]?.label || 'neutral',
        readabilityScore: results[3] || 0.5,
        credibilityScore: results[4] || 0.5,
        toxicityScore: 0, // 可以添加毒性检测
        keywords: keywords || [],
        entities: results[1] || [],
        topics: results[2] || [],
        categories: categories || [],
        summary: summary || '',
        keyPhrases: this.extractKeyPhrases(content.content),
        language: options?.language || content.originalLanguage,
        processingTimeMs: Date.now() - startTime,
        provider: 'openai'
      }
      
      // 缓存结果
      this.cache.set(cacheKey, analysisResult)
      
      return {
        success: true,
        data: analysisResult,
        processingTimeMs: analysisResult.processingTimeMs
      }
      
    } catch (error) {
      console.error('内容分析失败:', error)
      return {
        success: false,
        error: error instanceof Error ? error.message : '内容分析服务异常',
        errorCode: 'CONTENT_ANALYSIS_FAILED'
      }
    }
  }
  
  /**
   * 情感分析
   */
  private async analyzeSentiment(content: string, title?: string): Promise<{score: number, label: string}> {
    try {
      const openaiConfig = this.config.openai
      if (!openaiConfig) {
        throw new Error('OpenAI配置未找到')
      }
      
      const text = title ? `${title}\n\n${content}` : content
      const prompt = `请分析以下文本的情感倾向，返回一个-1到1之间的数值（-1表示非常负面，0表示中性，1表示非常正面）和对应的标签（positive/negative/neutral）。
      
文本：${text.substring(0, 2000)}

请以JSON格式返回：{"score": 数值, "label": "标签"}`
      
      const response = await this.req.post<any>({
        url: `${openaiConfig.baseURL || 'https://api.openai.com'}/v1/chat/completions`,
        headers: {
          'Authorization': `Bearer ${openaiConfig.apiKey}`,
          'Content-Type': 'application/json'
        },
        data: {
          model: openaiConfig.model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的文本情感分析助手。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          max_tokens: 100,
          temperature: 0.1
        }
      })
      
      if (!response.success || !response.data?.choices?.[0]) {
        throw new Error('情感分析API调用失败')
      }
      
      const result = JSON.parse(response.data.choices[0].message.content)
      return {
        score: Math.max(-1, Math.min(1, parseFloat(result.score) || 0)),
        label: result.label || 'neutral'
      }
      
    } catch (error) {
      console.error('情感分析失败:', error)
      return { score: 0, label: 'neutral' }
    }
  }
  
  /**
   * 实体识别
   */
  private async extractEntities(content: string): Promise<EntityResult[]> {
    try {
      const openaiConfig = this.config.openai
      if (!openaiConfig) {
        return []
      }
      
      const prompt = `请从以下文本中识别出人名、地名、机构名、日期、金额等实体。
      
文本：${content.substring(0, 2000)}

请以JSON数组格式返回，每个实体包含：text(实体文本)、type(类型：person/location/organization/date/money/other)、confidence(置信度0-1)。`
      
      const response = await this.req.post<any>({
        url: `${openaiConfig.baseURL || 'https://api.openai.com'}/v1/chat/completions`,
        headers: {
          'Authorization': `Bearer ${openaiConfig.apiKey}`,
          'Content-Type': 'application/json'
        },
        data: {
          model: openaiConfig.model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的命名实体识别助手。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          max_tokens: 500,
          temperature: 0.1
        }
      })
      
      if (!response.success || !response.data?.choices?.[0]) {
        return []
      }
      
      const entities = JSON.parse(response.data.choices[0].message.content)
      return entities.map((entity: any, index: number) => ({
        text: entity.text || '',
        type: entity.type || 'other',
        confidence: entity.confidence || 0.8,
        startPosition: 0, // 简化处理
        endPosition: entity.text?.length || 0
      })) as EntityResult[]
      
    } catch (error) {
      console.error('实体识别失败:', error)
      return []
    }
  }
  
  /**
   * 主题提取
   */
  private async extractTopics(content: string): Promise<TopicResult[]> {
    try {
      const openaiConfig = this.config.openai
      if (!openaiConfig) {
        return []
      }
      
      const prompt = `请分析以下文本的主要主题，提取3-5个核心主题。
      
文本：${content.substring(0, 2000)}

请以JSON数组格式返回，每个主题包含：name(主题名称)、confidence(置信度0-1)、keywords(相关关键词数组)。`
      
      const response = await this.req.post<any>({
        url: `${openaiConfig.baseURL || 'https://api.openai.com'}/v1/chat/completions`,
        headers: {
          'Authorization': `Bearer ${openaiConfig.apiKey}`,
          'Content-Type': 'application/json'
        },
        data: {
          model: openaiConfig.model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的文本主题分析助手。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          max_tokens: 400,
          temperature: 0.2
        }
      })
      
      if (!response.success || !response.data?.choices?.[0]) {
        return []
      }
      
      const topics = JSON.parse(response.data.choices[0].message.content)
      return topics.map((topic: any) => ({
        name: topic.name || '',
        confidence: topic.confidence || 0.8,
        keywords: topic.keywords || []
      })) as TopicResult[]
      
    } catch (error) {
      console.error('主题提取失败:', error)
      return []
    }
  }
  
  /**
   * 可读性分析
   */
  private async analyzeReadability(content: string): Promise<number> {
    try {
      // 简化的可读性计算
      const sentences = content.split(/[.!?。！？]/).length
      const words = content.split(/\s+/).length
      const avgWordsPerSentence = words / sentences
      
      // 基于平均句长计算可读性分数
      let score = 1.0
      if (avgWordsPerSentence > 30) score = 0.3
      else if (avgWordsPerSentence > 20) score = 0.5
      else if (avgWordsPerSentence > 15) score = 0.7
      else if (avgWordsPerSentence > 10) score = 0.9
      
      return score
      
    } catch (error) {
      console.error('可读性分析失败:', error)
      return 0.5
    }
  }
  
  /**
   * 可信度分析
   */
  private async analyzeCredibility(content: ContentInfo): Promise<number> {
    try {
      let score = 0.5 // 基础分数
      
      // 来源可信度
      if (content.sourceUrl) {
        const domain = this.extractDomain(content.sourceUrl)
        const credibleDomains = ['reuters.com', 'bbc.com', 'xinhuanet.com', 'nhk.or.jp']
        if (credibleDomains.some(d => domain.includes(d))) {
          score += 0.2
        }
      }
      
      // 作者信息
      if (content.author && content.author.length > 0) {
        score += 0.1
      }
      
      // 内容长度和结构
      if (content.content.length > 500) {
        score += 0.1
      }
      
      // 时效性
      const daysSincePublished = (Date.now() - content.publishedAt) / (1000 * 60 * 60 * 24)
      if (daysSincePublished < 1) {
        score += 0.1
      }
      
      return Math.min(1.0, score)
      
    } catch (error) {
      console.error('可信度分析失败:', error)
      return 0.5
    }
  }
  
  /**
   * 生成摘要
   */
  private async generateSummary(content: string): Promise<string> {
    try {
      const openaiConfig = this.config.openai
      if (!openaiConfig) {
        return ''
      }
      
      if (content.length < 200) {
        return content
      }
      
      const prompt = `请为以下文本生成一个简洁的摘要（100字以内）：\n\n${content.substring(0, 2000)}`
      
      const response = await this.req.post<any>({
        url: `${openaiConfig.baseURL || 'https://api.openai.com'}/v1/chat/completions`,
        headers: {
          'Authorization': `Bearer ${openaiConfig.apiKey}`,
          'Content-Type': 'application/json'
        },
        data: {
          model: openaiConfig.model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的文本摘要助手。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          max_tokens: 200,
          temperature: 0.3
        }
      })
      
      if (!response.success || !response.data?.choices?.[0]) {
        return ''
      }
      
      return response.data.choices[0].message.content.trim()
      
    } catch (error) {
      console.error('摘要生成失败:', error)
      return ''
    }
  }
  
  /**
   * 提取关键词
   */
  private async extractKeywords(content: string): Promise<string[]> {
    try {
      const openaiConfig = this.config.openai
      if (!openaiConfig) {
        return []
      }
      
      const prompt = `请从以下文本中提取5-10个关键词：\n\n${content.substring(0, 1500)}\n\n请以JSON数组格式返回关键词。`
      
      const response = await this.req.post<any>({
        url: `${openaiConfig.baseURL || 'https://api.openai.com'}/v1/chat/completions`,
        headers: {
          'Authorization': `Bearer ${openaiConfig.apiKey}`,
          'Content-Type': 'application/json'
        },
        data: {
          model: openaiConfig.model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的关键词提取助手。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          max_tokens: 200,
          temperature: 0.1
        }
      })
      
      if (!response.success || !response.data?.choices?.[0]) {
        return []
      }
      
      const keywords = JSON.parse(response.data.choices[0].message.content)
      return Array.isArray(keywords) ? keywords : []
      
    } catch (error) {
      console.error('关键词提取失败:', error)
      return []
    }
  }
  
  /**
   * 内容分类
   */
  private async classifyContent(content: ContentInfo): Promise<CategoryResult[]> {
    try {
      // 预定义分类
      const categories = [
        { id: 'politics', name: '政治', keywords: ['政治', '政府', '选举', '政策', 'politics', 'government'] },
        { id: 'technology', name: '科技', keywords: ['科技', '技术', '人工智能', 'AI', 'technology', 'tech'] },
        { id: 'business', name: '商业', keywords: ['商业', '经济', '金融', '市场', 'business', 'economy'] },
        { id: 'sports', name: '体育', keywords: ['体育', '运动', '比赛', '足球', 'sports', 'game'] },
        { id: 'entertainment', name: '娱乐', keywords: ['娱乐', '电影', '音乐', '明星', 'entertainment', 'movie'] },
        { id: 'health', name: '健康', keywords: ['健康', '医疗', '疾病', '医院', 'health', 'medical'] }
      ]
      
      const text = `${content.title} ${content.content}`.toLowerCase()
      const results: CategoryResult[] = []
      
      for (const category of categories) {
        let score = 0
        for (const keyword of category.keywords) {
          const matches = (text.match(new RegExp(keyword.toLowerCase(), 'g')) || []).length
          score += matches
        }
        
        if (score > 0) {
          results.push({
            categoryId: category.id,
            categoryName: category.name,
            confidence: Math.min(1.0, score / 10),
            level: 1
          })
        }
      }
      
      return results.sort((a, b) => b.confidence - a.confidence).slice(0, 3)
      
    } catch (error) {
      console.error('内容分类失败:', error)
      return []
    }
  }
  
  /**
   * 提取关键短语
   */
  private extractKeyPhrases(content: string): string[] {
    try {
      // 简单的关键短语提取
      const sentences = content.split(/[.!?。！？]/)
      const phrases: string[] = []
      
      for (const sentence of sentences) {
        const words = sentence.trim().split(/\s+/)
        if (words.length >= 2 && words.length <= 5) {
          phrases.push(sentence.trim())
        }
      }
      
      return phrases.slice(0, 10)
      
    } catch (error) {
      console.error('关键短语提取失败:', error)
      return []
    }
  }
  
  /**
   * 提取域名
   */
  private extractDomain(url: string): string {
    try {
      const matches = url.match(/https?:\/\/([^\/]+)/)
      return matches ? matches[1] : ''
    } catch (error) {
      return ''
    }
  }
  
  /**
   * 生成缓存键
   */
  private generateContentCacheKey(contentId: string, options?: any): string {
    const optionsStr = JSON.stringify(options || {})
    return `content-${contentId}-${this.simpleHash(optionsStr)}`
  }
  
  /**
   * 简单哈希函数
   */
  private simpleHash(str: string): string {
    let hash = 0
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i)
      hash = ((hash << 5) - hash) + char
      hash = hash & hash
    }
    return Math.abs(hash).toString(36)
  }
}