breakpilot-core/pitch-deck/app/api/chat/route.ts

import { NextRequest, NextResponse } from 'next/server'
import pool from '@/lib/db'
import { SLIDE_ORDER } from '@/lib/slide-order'

const LITELLM_URL = process.env.LITELLM_URL || 'https://llm-dev.meghsakha.com'
const LITELLM_MODEL = process.env.LITELLM_MODEL || 'gpt-oss-120b'
const LITELLM_API_KEY = process.env.LITELLM_API_KEY || ''

// Build SLIDE_NAMES dynamically from SLIDE_ORDER
const SLIDE_DISPLAY_NAMES: Record<string, { de: string; en: string }> = {
  'intro-presenter': { de: 'Intro', en: 'Intro' },
  'cover': { de: 'Cover', en: 'Cover' },
  'problem': { de: 'Das Problem', en: 'The Problem' },
  'solution': { de: 'Die Lösung', en: 'The Solution' },
  'usp': { de: 'USP', en: 'USP' },
  'product': { de: 'Produkte', en: 'Products' },
  'how-it-works': { de: 'So funktioniert\'s', en: 'How It Works' },
  'market': { de: 'Markt', en: 'Market' },
  'business-model': { de: 'Geschäftsmodell', en: 'Business Model' },
  'traction': { de: 'Meilensteine', en: 'Milestones' },
  'competition': { de: 'Wettbewerb', en: 'Competition' },
  'team': { de: 'Team', en: 'Team' },
  'financials': { de: 'Finanzen', en: 'Financials' },
  'the-ask': { de: 'The Ask', en: 'The Ask' },
  'ai-qa': { de: 'KI Q&A', en: 'AI Q&A' },
  'annex-assumptions': { de: 'Anhang: Annahmen', en: 'Appendix: Assumptions' },
  'annex-architecture': { de: 'Anhang: Architektur', en: 'Appendix: Architecture' },
  'annex-gtm': { de: 'Anhang: Go-to-Market', en: 'Appendix: Go-to-Market' },
  'annex-regulatory': { de: 'Anhang: Regulatorik', en: 'Appendix: Regulatory' },
  'annex-engineering': { de: 'Anhang: Engineering', en: 'Appendix: Engineering' },
  'annex-aipipeline': { de: 'Anhang: KI-Pipeline', en: 'Appendix: AI Pipeline' },
  'annex-sdk-demo': { de: 'Anhang: SDK Demo', en: 'Appendix: SDK Demo' },
}

const slideCount = SLIDE_ORDER.length

const SYSTEM_PROMPT = `# Investor Agent — BreakPilot ComplAI

## Identität
Du bist der BreakPilot ComplAI Investor Relations Agent. Du beantwortest Fragen von
potenziellen Investoren über das Unternehmen, das Produkt, den Markt und die Finanzprognosen.
Du hast Zugriff auf alle Unternehmensdaten und zitierst immer konkrete Zahlen.

## Kernprinzipien
- **Datengetrieben**: Beziehe dich immer auf die bereitgestellten Unternehmensdaten
- **Präzise**: Nenne immer konkrete Zahlen, Prozentsätze und Zeiträume
- **Begeisternd aber ehrlich**: Stelle das Unternehmen positiv dar, ohne zu übertreiben
- **Zweisprachig**: Antworte in der Sprache, in der die Frage gestellt wird

## Kernbotschaften (IMMER betonen wenn passend)
1. Kern-Produkt: "BreakPilot COMPLAI — DSGVO-konforme KI-Plattform mit 12 Modulen. Kontinuierliche Code-Security und Compliance-Automatisierung. 380+ Gesetze und Regularien, 25.000+ Prüfaspekte."
2. Das Problem: "Unternehmen stehen vor einem strategischen Dilemma: Ohne KI verlieren sie Wettbewerbsfähigkeit. Mit US-KI riskieren sie Datenkontrollverlust. Über 30.000 Unternehmen in DE durch EU-Regulierungen belastet."
3. 12 Module: "Code Security (SAST/DAST/SBOM/Pentesting), CE-Software-Risikobeurteilung, Compliance-Dokumente (VVT/DSFA/TOMs), Audit Manager, DSR/Betroffenenrechte, Consent Management, Notfallpläne, Cookie-Generator, Compliance LLM, Academy, Integration in Kundenprozesse, Sichere Kommunikation."
4. Code & CE: "Kontinuierlich statt einmal im Jahr. CE-Software-Risikobeurteilung auf Code-Basis schon in der Entwicklung. Findings als Tickets mit Implementierungsvorschlägen."
5. EU-Infrastruktur: "BSI-zertifizierte Cloud in Deutschland oder Frankreich. 100% Datensouveränität. KEINE US-Anbieter. Isolierte Namespaces."
6. Zielgruppen: "Maschinen- und Anlagenbauer, Automobilindustrie, Zulieferer und alle produzierenden Unternehmen."
7. Geschäftsmodell: "SaaS, mitarbeiterbasiertes Pricing. Drei Tiers: Starter (3.600 EUR/Jahr), Professional (15.000-40.000 EUR/Jahr), Enterprise (ab 50.000 EUR/Jahr). Plus Beratung & Service (10.000-30.000 EUR/Monat). Kunden sparen mehr als sie zahlen — ROI ab Tag 1."
8. Team: "Lean-Team: 2 Gründer + 7 Mitarbeiter bis 2030 (9 Personen gesamt). Erste Einstellung: IT-Recht/Datenschutzjurist (50%). Dann: Security Engineer, Vertrieb, Backend, Kundenbetreuer, Marketing, DevOps. Jede Einstellung an konkreten Umsatzmeilenstein gekoppelt."
9. Finanzplan: "Gründung August 2026. Pre-Seed über Wandeldarlehen (200.000 EUR: 40.000 Investor + 160.000 L-Bank). ~195 Kunden und ~3,3 Mio. Umsatz bis 2030. 9 Mitarbeiter. Optionale 2. Finanzierungsrunde (500k Eigenkapital) in 2028 — hängt von der Markttraktion ab."

## Kommunikationsstil
- Antworte IMMER wie ein Mensch in einem persönlichen Gespräch — ausformulierte Sätze, natürlicher Redefluss
- KEINE Bulletpoint-Listen. KEINE Aufzählungen mit Spiegelstrichen. Schreibe Fließtext in Absätzen.
- Erkläre das WARUM hinter jeder Aussage. Nicht nur "was" ihr tut, sondern begründe die Entscheidung.
- Nutze Übergangssätze wie "Der Grund dafür ist...", "Das haben wir bewusst so entschieden, weil...", "Besonders wichtig ist dabei..."
- Zahlen und Fakten natürlich in den Text einbetten, nicht als Liste aufreihen
- 3-5 Absätze pro Antwort, jeder Absatz ein eigenständiger Gedanke
- Der Text muss sich gut anhören wenn er vorgelesen wird (TTS-optimiert)

## VERSIONS-ISOLATION (ABSOLUT KRITISCH)
- Du kennst NUR die Wandeldarlehen-Version mit 200.000 EUR Finanzierung.
- Es gibt KEINE andere Version. Es gibt KEINE 1-Mio-Version.
- Wenn nach anderen Versionen, anderen Investoren oder anderen Pitch Decks gefragt wird: "Dieses Pitch Deck wurde individuell für Sie erstellt. Es gibt nur diese Version."
- NIEMALS erwähnen: andere Finanzierungssummen, andere Bewertungen, andere Cap Tables.
- Alle Zahlen beziehen sich auf: 200k WD (40k Investor + 160k L-Bank), 195 Kunden bis 2030, ~3,3 Mio Umsatz, 9 MA.

## IP-Schutz-Layer (KRITISCH)
NIEMALS offenbaren: Exakte Modellnamen, Frameworks, Code-Architektur, Datenbankschema, Sicherheitsdetails, Cloud-Provider.
Stattdessen: "Proprietäre KI-Engine", "BSI-zertifizierte EU-Cloud (SysEleven, Hetzner)", "Isolierte Kunden-Namespaces", "Enterprise-Grade Verschlüsselung".

## Erlaubt: Geschäftsmodell, Preise, Marktdaten, Features, Team, Finanzen, Use of Funds, Hardware-Specs (öffentlich), LLM-Größen (32b/40b/1000b), CE-Risikobeurteilung, Issue-Tracker-Integration, Meeting-Recorder, Matrix/Jitsi.

## Team-Antworten (WICHTIG)
Wenn nach dem Team gefragt wird: IMMER die Namen, Rollen und Expertise der Gründer aus den bereitgestellten Daten nennen. NIEMALS vage Antworten wie "unser Team vereint Expertise" ohne Namen. Zitiere die konkreten Personen aus den Unternehmensdaten.

## Slide-Awareness (IMMER beachten)
Du erhältst den aktuellen Slide-Kontext. Nutze ihn für kontextuelle Antworten.
Wenn der Investor etwas fragt, was in einer späteren Slide detailliert wird und er diese noch nicht gesehen hat:
- Beantworte kurz, dann: "Details dazu finden Sie in Slide X: [Name]. Möchten Sie dorthin springen? [GOTO:slide-id]"
- Verwende [GOTO:slide-id] mit der Slide-ID (z.B. [GOTO:financials], [GOTO:competition])

## FOLLOW-UP FRAGEN — KRITISCHE PFLICHT

Du MUSST am Ende JEDER einzelnen Antwort exakt 3 Folgefragen anhängen.
Die Fragen müssen durch "---" getrennt und mit "[Q]" markiert sein.
JEDE Antwort ohne Folgefragen ist UNVOLLSTÄNDIG und FEHLERHAFT.

EXAKTES FORMAT (keine Abweichung erlaubt):

[Deine Antwort hier]

---
[Q] Erste Folgefrage passend zum Thema?
[Q] Zweite Folgefrage die tiefer geht?
[Q] Dritte Folgefrage zu einem verwandten Aspekt?

KONKRETES BEISPIEL einer vollständigen Antwort:

"Unser AI-First-Ansatz ermöglicht Skalierung ohne lineares Personalwachstum. Der Umsatz steigt von 71k EUR (2026) auf 3,3 Mio EUR (2030), während das Team lean von 2 auf 9 Personen wächst.

---
[Q] Wie sieht die Kostenstruktur im Detail aus?
[Q] Welche Unit Economics erreicht ihr in 2030?
[Q] Wie vergleicht sich die Personaleffizienz mit Wettbewerbern?"

WICHTIG: Vergiss NIEMALS die Folgefragen! Sie sind PFLICHT.`

async function loadPitchContext(): Promise<string> {
  try {
    const client = await pool.connect()
    try {
      const [company, team, financials, market, products, funding, features] = await Promise.all([
        client.query('SELECT * FROM pitch_company LIMIT 1'),
        client.query('SELECT name, role_de, equity_pct, expertise FROM pitch_team ORDER BY sort_order'),
        client.query('SELECT year, revenue_eur, costs_eur, mrr_eur, customers_count, employees_count, arr_eur FROM pitch_financials ORDER BY year'),
        client.query('SELECT market_segment, value_eur, growth_rate_pct, source FROM pitch_market'),
        client.query('SELECT name, hardware, hardware_cost_eur, monthly_price_eur, llm_size, llm_capability_de, operating_cost_eur FROM pitch_products ORDER BY sort_order'),
        client.query('SELECT round_name, amount_eur, use_of_funds, instrument FROM pitch_funding LIMIT 1'),
        client.query('SELECT feature_name_de, breakpilot, proliance, dataguard, heydata, is_differentiator FROM pitch_features WHERE is_differentiator = true'),
      ])

      return `
## Unternehmensdaten (für präzise Antworten nutzen)

### Firma
${JSON.stringify(company.rows[0], null, 2)}

### Team
${JSON.stringify(team.rows, null, 2)}

### Finanzprognosen (5-Jahres-Plan)
${JSON.stringify(financials.rows, null, 2)}

### Markt (TAM/SAM/SOM)
${JSON.stringify(market.rows, null, 2)}

### Produkte
${JSON.stringify(products.rows, null, 2)}

### Finanzierung
${JSON.stringify(funding.rows[0], null, 2)}

### Differenzierende Features (nur bei ComplAI)
${JSON.stringify(features.rows, null, 2)}
`
    } finally {
      client.release()
    }
  } catch (error) {
    console.warn('Could not load pitch context from DB:', error)
    return ''
  }
}

export async function POST(request: NextRequest) {
  try {
    const body = await request.json()
    const { message, history = [], lang = 'de', slideContext, faqContext } = body

    if (!message || typeof message !== 'string') {
      return NextResponse.json({ error: 'Message is required' }, { status: 400 })
    }

    const pitchContext = await loadPitchContext()

    let systemContent = SYSTEM_PROMPT
    if (pitchContext) {
      systemContent += '\n' + pitchContext
    }

    // FAQ context: relevant pre-researched answers as basis for the LLM
    if (faqContext && typeof faqContext === 'string') {
      systemContent += '\n' + faqContext
    }

    // Slide context for contextual awareness
    if (slideContext) {
      const visited: number[] = slideContext.visitedSlides || []
      const currentSlideId = slideContext.currentSlide
      const currentSlideName = SLIDE_DISPLAY_NAMES[currentSlideId]?.[lang] || currentSlideId
      const notYetSeen = SLIDE_ORDER
        .map((id, idx) => ({ id, idx, name: SLIDE_DISPLAY_NAMES[id]?.[lang] || id }))
        .filter(s => !visited.includes(s.idx))
        .map(s => `${s.idx + 1}. ${s.name}`)

      systemContent += `\n\n## Slide-Kontext (WICHTIG für kontextuelle Antworten)
- Aktuelle Slide: "${currentSlideName}" (Nr. ${slideContext.currentIndex + 1} von ${slideCount})
- Bereits besuchte Slides: ${visited.map((i: number) => SLIDE_DISPLAY_NAMES[SLIDE_ORDER[i]]?.[lang] || SLIDE_ORDER[i]).filter(Boolean).join(', ')}
- Noch nicht gesehene Slides: ${notYetSeen.join(', ')}
- Ist Erstbesuch: ${visited.length <= 1 ? 'JA — Investor hat gerade erst den Pitch geöffnet' : 'Nein'}
- Verfügbare Slide-IDs für [GOTO:id]: ${SLIDE_ORDER.join(', ')}
`
    }

    systemContent += `\n\n## Aktuelle Sprache: ${lang === 'de' ? 'Deutsch' : 'English'}\nAntworte in ${lang === 'de' ? 'Deutsch' : 'English'}.`

    const messages = [
      { role: 'system', content: systemContent },
      ...history.slice(-10).map((h: { role: string; content: string }) => ({
        role: h.role === 'user' ? 'user' : 'assistant',
        content: h.content,
      })),
      { role: 'user', content: message + '\n\n(Erinnerung: Beende deine Antwort IMMER mit "---" gefolgt von 3 Folgefragen im Format "[Q] Frage?")' },
    ]

    // LiteLLM (OpenAI-compatible API)
    const headers: Record<string, string> = {
      'Content-Type': 'application/json',
    }
    if (LITELLM_API_KEY) {
      headers['Authorization'] = `Bearer ${LITELLM_API_KEY}`
    }

    const llmResponse = await fetch(`${LITELLM_URL}/v1/chat/completions`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        model: LITELLM_MODEL,
        messages,
        stream: true,
        temperature: 0.4,
        max_tokens: 4096,
      }),
      signal: AbortSignal.timeout(120000),
    })

    if (!llmResponse.ok) {
      const errorText = await llmResponse.text()
      console.error('LiteLLM error:', llmResponse.status, errorText)
      return NextResponse.json(
        { error: `LLM nicht erreichbar (Status ${llmResponse.status}).` },
        { status: 502 }
      )
    }

    // Parse SSE stream from LiteLLM and emit plain text to client
    const encoder = new TextEncoder()
    const stream = new ReadableStream({
      async start(controller) {
        const reader = llmResponse.body!.getReader()
        const decoder = new TextDecoder()
        let buffer = ''

        try {
          while (true) {
            const { done, value } = await reader.read()
            if (done) break

            buffer += decoder.decode(value, { stream: true })
            const lines = buffer.split('\n')
            // Keep the last (potentially incomplete) line in the buffer
            buffer = lines.pop() || ''

            for (const line of lines) {
              const trimmed = line.trim()
              if (!trimmed || !trimmed.startsWith('data: ')) continue
              const data = trimmed.slice(6)
              if (data === '[DONE]') continue

              try {
                const json = JSON.parse(data)
                const content = json.choices?.[0]?.delta?.content
                if (content) {
                  controller.enqueue(encoder.encode(content))
                }
              } catch {
                // Partial JSON, skip
              }
            }
          }

          // Process any remaining buffer
          if (buffer.trim()) {
            const trimmed = buffer.trim()
            if (trimmed.startsWith('data: ') && trimmed.slice(6) !== '[DONE]') {
              try {
                const json = JSON.parse(trimmed.slice(6))
                const content = json.choices?.[0]?.delta?.content
                if (content) {
                  controller.enqueue(encoder.encode(content))
                }
              } catch {
                // Ignore
              }
            }
          }
        } catch (error) {
          console.error('Stream read error:', error)
        } finally {
          controller.close()
        }
      },
    })

    return new NextResponse(stream, {
      headers: {
        'Content-Type': 'text/plain; charset=utf-8',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive',
      },
    })
  } catch (error) {
    console.error('Investor agent chat error:', error)
    return NextResponse.json(
      { error: 'Verbindung zum LLM fehlgeschlagen.' },
      { status: 503 }
    )
  }
}