// src/lib/integrations/claude/ClaudeAnalysisService.ts

import Anthropic from '@anthropic-ai/sdk'

interface CommentAnalysis {
  sentiment: 'positive' | 'neutral' | 'negative' | 'question' | 'gratitude' | 'frustration'
  sentimentScore: number
  confidence: number
  topics: string[]
  language: string
  isMedicalQuestion: boolean
  requiresEscalation: boolean
  isSpam: boolean
  suggestedReply?: string
}

interface ReplyContext {
  videoTitle: string
  channelName: string
  isBusinessChannel: boolean
  template?: string
}

export class ClaudeAnalysisService {
  private client: Anthropic

  constructor() {
    this.client = new Anthropic({
      apiKey: process.env.ANTHROPIC_API_KEY,
    })
  }

  /**
   * Alias für analyzeComment (Konsistenz mit Prompt)
   */
  async analyzeInteraction(message: string): Promise<CommentAnalysis> {
    return this.analyzeComment(message)
  }

  /**
   * Kommentar analysieren
   */
  async analyzeComment(message: string): Promise<CommentAnalysis> {
    const systemPrompt = `Du bist ein Analyse-Assistent für YouTube-Kommentare eines deutschen Healthcare-Unternehmens (Medizinische Zweitmeinung) und eines Lifestyle-Kanals.

Analysiere den Kommentar und gib ein JSON-Objekt zurück mit:
- sentiment: "positive", "neutral", "negative", "question", "gratitude", "frustration"
- sentimentScore: Zahl von -1 (sehr negativ) bis 1 (sehr positiv)
- confidence: Konfidenz der Analyse 0-100
- topics: Array von erkannten Themen (max 3)
- language: ISO-639-1 Sprachcode (z.B. "de", "en")
- isMedicalQuestion: true wenn es um medizinische Fragen/Gesundheit geht
- requiresEscalation: true wenn dringend/kritisch/negativ oder Beschwerden
- isSpam: true wenn Spam/Werbung/Bot
- suggestedReply: Kurzer Antwortvorschlag auf Deutsch (optional, nur wenn sinnvoll)

WICHTIG für isMedicalQuestion:
- Fragen zu Intensivmedizin, Diagnosen, Behandlungen, Medikamenten = true
- Fragen zu Angehörigen von Patienten = true
- Allgemeine Lifestyle-Fragen (Mode, Zeitmanagement) = false

Antworte NUR mit dem JSON-Objekt, kein anderer Text.`

    try {
      const response = await this.client.messages.create({
        model: 'claude-3-5-haiku-20241022',
        max_tokens: 500,
        system: systemPrompt,
        messages: [
          {
            role: 'user',
            content: `Analysiere diesen Kommentar:\n\n"${message}"`,
          },
        ],
      })

      const content = response.content[0]
      if (content.type !== 'text') {
        throw new Error('Unexpected response type')
      }

      const analysis = JSON.parse(content.text) as CommentAnalysis
      return analysis
    } catch (error) {
      console.error('Claude analysis error:', error)

      // Fallback bei Fehler
      return {
        sentiment: 'neutral',
        sentimentScore: 0,
        confidence: 0,
        topics: [],
        language: 'de',
        isMedicalQuestion: false,
        requiresEscalation: false,
        isSpam: false,
      }
    }
  }

  /**
   * Antwort-Vorschlag generieren
   */
  async generateReply(comment: string, context: ReplyContext): Promise<string> {
    const systemPrompt = `Du bist ein Community-Manager für ${context.channelName}.
${
  context.isBusinessChannel
    ? 'Dies ist ein Healthcare-Kanal für medizinische Zweitmeinungen. Antworten müssen professionell sein und dürfen keine medizinischen Ratschläge geben. Bei medizinischen Fragen immer auf die Hotline verweisen.'
    : 'Dies ist ein Lifestyle-Kanal für berufstätige Mütter. Antworten sollten warm, persönlich und hilfreich sein.'
}

Erstelle eine passende, kurze Antwort auf den Kommentar.
- Maximal 2-3 Sätze
- Persönlich und authentisch
- Auf Deutsch
${context.template ? `\nVerwende dieses Template als Basis:\n${context.template}` : ''}

Antworte NUR mit dem Antworttext, kein anderer Text.`

    try {
      const response = await this.client.messages.create({
        model: 'claude-3-5-haiku-20241022',
        max_tokens: 200,
        system: systemPrompt,
        messages: [
          {
            role: 'user',
            content: `Video: "${context.videoTitle}"\n\nKommentar: "${comment}"\n\nErstelle eine Antwort:`,
          },
        ],
      })

      const content = response.content[0]
      if (content.type !== 'text') {
        throw new Error('Unexpected response type')
      }

      return content.text.trim()
    } catch (error) {
      console.error('Claude reply generation error:', error)
      throw error
    }
  }

  /**
   * Batch-Analyse mehrerer Kommentare
   */
  async analyzeCommentsBatch(
    messages: string[]
  ): Promise<Map<string, CommentAnalysis>> {
    const results = new Map<string, CommentAnalysis>()

    // Parallele Verarbeitung mit Rate-Limiting
    const batchSize = 5
    for (let i = 0; i < messages.length; i += batchSize) {
      const batch = messages.slice(i, i + batchSize)
      const analyses = await Promise.all(
        batch.map((msg) => this.analyzeComment(msg))
      )
      batch.forEach((msg, idx) => {
        results.set(msg, analyses[idx])
      })

      // Kurze Pause zwischen Batches
      if (i + batchSize < messages.length) {
        await new Promise((resolve) => setTimeout(resolve, 500))
      }
    }

    return results
  }
}

// Export types - AnalysisResult ist Alias für CommentAnalysis (Konsistenz mit Prompt)
export type { CommentAnalysis, CommentAnalysis as AnalysisResult, ReplyContext }
