// src/lib/integrations/claude/ClaudeReplyService.ts

import Anthropic from '@anthropic-ai/sdk'
import type { ReplyContext, GeneratedReply } from '@/types/youtube'

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
})

export class ClaudeReplyService {
  private model: string

  constructor(model?: string) {
    this.model = model || 'claude-3-5-haiku-20241022'
  }

  /**
   * Generiere Antwortvorschlag basierend auf Kontext
   */
  async generateReply(context: ReplyContext): Promise<GeneratedReply> {
    const systemPrompt = this.buildSystemPrompt(context)
    const userPrompt = this.buildUserPrompt(context)

    try {
      const response = await anthropic.messages.create({
        model: this.model,
        max_tokens: 500,
        system: systemPrompt,
        messages: [{ role: 'user', content: userPrompt }],
      })

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

      return this.parseReplyResponse(content.text, context)
    } catch (error: unknown) {
      console.error('[ClaudeReply] Generation failed:', error)
      throw error
    }
  }

  /**
   * Generiere mehrere Varianten für A/B-Testing
   */
  async generateReplyVariants(
    context: ReplyContext,
    count: number = 3
  ): Promise<GeneratedReply[]> {
    const variants: GeneratedReply[] = []
    const tones = ['freundlich', 'professionell', 'empathisch']

    for (let i = 0; i < Math.min(count, tones.length); i++) {
      const contextWithTone = {
        ...context,
        requestedTone: tones[i],
      } as ReplyContext & { requestedTone: string }

      const reply = await this.generateReplyWithTone(contextWithTone, tones[i])
      reply.tone = tones[i]
      variants.push(reply)

      // Rate limiting
      await this.sleep(100)
    }

    return variants
  }

  private async generateReplyWithTone(
    context: ReplyContext & { requestedTone?: string },
    tone: string
  ): Promise<GeneratedReply> {
    const systemPrompt = this.buildSystemPrompt(context, tone)
    const userPrompt = this.buildUserPrompt(context)

    const response = await anthropic.messages.create({
      model: this.model,
      max_tokens: 500,
      system: systemPrompt,
      messages: [{ role: 'user', content: userPrompt }],
    })

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

    return this.parseReplyResponse(content.text, context)
  }

  private buildSystemPrompt(context: ReplyContext, requestedTone?: string): string {
    const basePrompt = `Du bist der Community Manager für "${context.channelName}", einen deutschen YouTube-Kanal.

KANAL-KONTEXT:
${this.getChannelContext(context.channelType)}

WICHTIGE REGELN:
1. Antworte IMMER auf Deutsch
2. Verwende "Du" (nicht "Sie")
3. Halte Antworten kurz (max. 2-3 Sätze für normale Kommentare)
4. Unterschreibe mit "— ${this.getSignature(context.channelType)}"
5. Sei authentisch, nicht roboterhaft
6. Verwende KEINE Emojis außer: (sparsam)

${context.isMedicalQuestion ? this.getMedicalWarning() : ''}

TONALITÄT:
${this.getToneGuidelines(context.channelType, context.commentSentiment, requestedTone)}`

    return basePrompt
  }

  private buildUserPrompt(context: ReplyContext): string {
    return `KOMMENTAR VON "${context.authorName}":
"${context.commentText}"

VIDEO: "${context.videoTitle}"
SENTIMENT: ${context.commentSentiment}
${context.isMedicalQuestion ? 'MEDIZINISCHE FRAGE ERKANNT' : ''}

Generiere eine passende Antwort. Antworte NUR mit dem Antworttext, keine Erklärungen.`
  }

  private getChannelContext(channelType: string): string {
    switch (channelType) {
      case 'corporate':
        return `Kanal: zweitmeinu.ng (Complex Care Solutions)
Thema: Medizinische Zweitmeinungen, Patientenrechte, Gesundheitsentscheidungen
Zielgruppe: Patienten, Angehörige, Krankenkassen
Persona: Dr. Caroline Porwoll (Gesundheitsberaterin, NICHT Ärztin)
Wichtig: Keine medizinische Beratung geben, auf Hotline verweisen`

      case 'lifestyle':
        return `Kanal: BlogWoman by Caroline Porwoll
Thema: Premium-Lifestyle für Karrierefrauen (Mode, Systeme, Regeneration)
Zielgruppe: Berufstätige Mütter 35-45
Persona: Caroline Porwoll (Unternehmerin, Mutter, Stilexpertin)
Wichtig: Editorial-Premium-Ton, keine Influencer-Sprache`

      case 'business':
        return `Kanal: CCS Business (English)
Thema: B2B Second Opinion Programs, ROI, Healthcare Governance
Zielgruppe: International Healthcare Decision-Makers
Persona: Dr. Caroline Porwoll (CEO, Healthcare Expert)
Wichtig: Professionell, faktenbasiert, auf Demo/Whitepaper verweisen`

      default:
        return 'Allgemeiner YouTube-Kanal'
    }
  }

  private getToneGuidelines(
    channelType: string,
    sentiment: string,
    requestedTone?: string
  ): string {
    const baseGuidelines: Record<string, string> = {
      corporate: 'Warm, empathisch, ermutigend, professionell',
      lifestyle: 'Editorial Premium, systemorientiert, "Performance & Pleasure"',
      business: 'Professional, fact-based, ROI-oriented',
    }

    const sentimentAdjustments: Record<string, string> = {
      positive: 'Teile die Freude, bedanke dich herzlich',
      negative: 'Zeige Verständnis, biete Hilfe an, eskaliere nicht',
      question: 'Beantworte klar und hilfreich, verweise auf Ressourcen',
      gratitude: 'Bedanke dich aufrichtig, zeige dass es geschätzt wird',
      frustration: 'Validiere Gefühle, biete konkrete Lösung, bleib ruhig',
      neutral: 'Freundlich und hilfsbereit',
    }

    let guidelines = `Grundton: ${baseGuidelines[channelType] || 'Freundlich'}
Bei ${sentiment}: ${sentimentAdjustments[sentiment] || sentimentAdjustments['neutral']}`

    if (requestedTone) {
      guidelines += `\nAngeforderter Ton: ${requestedTone}`
    }

    return guidelines
  }

  private getMedicalWarning(): string {
    return `
MEDIZINISCHE FRAGE - BESONDERE VORSICHT:
- Gib KEINE medizinische Beratung
- Gib KEINE Diagnosen oder Behandlungsempfehlungen
- Verweise IMMER auf professionelle Beratung
- Standardformulierung: "Für eine persönliche Einschätzung Ihrer Situation empfehlen wir ein Gespräch mit unserem Beratungsteam unter 0800-XXX oder auf unserer Website."
`
  }

  private getSignature(channelType: string): string {
    switch (channelType) {
      case 'corporate':
        return 'Caroline'
      case 'lifestyle':
        return 'Caroline'
      case 'business':
        return 'The CCS Team'
      default:
        return 'Das Team'
    }
  }

  private parseReplyResponse(text: string, context: ReplyContext): GeneratedReply {
    // Bereinige die Antwort
    let cleanedText = text.trim()

    // Entferne mögliche Anführungszeichen am Anfang/Ende
    cleanedText = cleanedText.replace(/^["']|["']$/g, '')

    const warnings: string[] = []

    // Prüfe auf potenzielle Probleme
    if (context.isMedicalQuestion && !cleanedText.toLowerCase().includes('beratung')) {
      warnings.push('Medizinische Frage: Verweis auf Beratung fehlt möglicherweise')
    }

    if (cleanedText.length > 500) {
      warnings.push('Antwort ist möglicherweise zu lang')
    }

    if (cleanedText.length < 20) {
      warnings.push('Antwort ist sehr kurz')
    }

    return {
      text: cleanedText,
      tone: 'standard',
      confidence: 85,
      alternatives: [],
      warnings,
    }
  }

  private sleep(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms))
  }
}

export default ClaudeReplyService
