breakpilot-pwa/admin-v2/ai-compliance-sdk/internal/api/generate.go

package api

import (
	"net/http"

	"github.com/breakpilot/ai-compliance-sdk/internal/llm"
	"github.com/breakpilot/ai-compliance-sdk/internal/rag"
	"github.com/gin-gonic/gin"
)

// GenerateHandler handles document generation requests
type GenerateHandler struct {
	llmService *llm.Service
	ragService *rag.Service
}

// NewGenerateHandler creates a new generate handler
func NewGenerateHandler(llmService *llm.Service, ragService *rag.Service) *GenerateHandler {
	return &GenerateHandler{
		llmService: llmService,
		ragService: ragService,
	}
}

// GenerateDSFA generates a Data Protection Impact Assessment
func (h *GenerateHandler) GenerateDSFA(c *gin.Context) {
	var req GenerateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ErrorResponse(c, http.StatusBadRequest, err.Error(), "INVALID_REQUEST")
		return
	}

	// Get RAG context if requested
	var ragSources []llm.SearchResult
	if req.UseRAG && h.ragService != nil {
		query := req.RAGQuery
		if query == "" {
			query = "DSFA Datenschutz-Folgenabschaetzung Anforderungen"
		}
		results, _ := h.ragService.Search(c.Request.Context(), query, 5, "legal_corpus", "regulation:DSGVO")
		for _, r := range results {
			ragSources = append(ragSources, llm.SearchResult{
				ID:       r.ID,
				Content:  r.Content,
				Source:   r.Source,
				Score:    r.Score,
				Metadata: r.Metadata,
			})
		}
	}

	// Generate DSFA content
	content, tokensUsed, err := h.llmService.GenerateDSFA(c.Request.Context(), req.Context, ragSources)
	if err != nil {
		// Return mock content if LLM fails
		content = h.getMockDSFA(req.Context)
		tokensUsed = 0
	}

	SuccessResponse(c, GenerateResponse{
		Content:     content,
		GeneratedAt: now(),
		Model:       h.llmService.GetModel(),
		TokensUsed:  tokensUsed,
		RAGSources:  convertLLMSources(ragSources),
		Confidence:  0.85,
	})
}

// GenerateTOM generates Technical and Organizational Measures
func (h *GenerateHandler) GenerateTOM(c *gin.Context) {
	var req GenerateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ErrorResponse(c, http.StatusBadRequest, err.Error(), "INVALID_REQUEST")
		return
	}

	// Get RAG context if requested
	var llmRagSources []llm.SearchResult
	if req.UseRAG && h.ragService != nil {
		query := req.RAGQuery
		if query == "" {
			query = "technische organisatorische Massnahmen TOM Datenschutz"
		}
		results, _ := h.ragService.Search(c.Request.Context(), query, 5, "legal_corpus", "")
		for _, r := range results {
			llmRagSources = append(llmRagSources, llm.SearchResult{
				ID:       r.ID,
				Content:  r.Content,
				Source:   r.Source,
				Score:    r.Score,
				Metadata: r.Metadata,
			})
		}
	}

	// Generate TOM content
	content, tokensUsed, err := h.llmService.GenerateTOM(c.Request.Context(), req.Context, llmRagSources)
	if err != nil {
		content = h.getMockTOM(req.Context)
		tokensUsed = 0
	}

	SuccessResponse(c, GenerateResponse{
		Content:     content,
		GeneratedAt: now(),
		Model:       h.llmService.GetModel(),
		TokensUsed:  tokensUsed,
		RAGSources:  convertLLMSources(llmRagSources),
		Confidence:  0.82,
	})
}

// GenerateVVT generates Processing Activity Register
func (h *GenerateHandler) GenerateVVT(c *gin.Context) {
	var req GenerateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ErrorResponse(c, http.StatusBadRequest, err.Error(), "INVALID_REQUEST")
		return
	}

	// Get RAG context if requested
	var llmRagSources []llm.SearchResult
	if req.UseRAG && h.ragService != nil {
		query := req.RAGQuery
		if query == "" {
			query = "Verarbeitungsverzeichnis Art. 30 DSGVO"
		}
		results, _ := h.ragService.Search(c.Request.Context(), query, 5, "legal_corpus", "regulation:DSGVO")
		for _, r := range results {
			llmRagSources = append(llmRagSources, llm.SearchResult{
				ID:       r.ID,
				Content:  r.Content,
				Source:   r.Source,
				Score:    r.Score,
				Metadata: r.Metadata,
			})
		}
	}

	// Generate VVT content
	content, tokensUsed, err := h.llmService.GenerateVVT(c.Request.Context(), req.Context, llmRagSources)
	if err != nil {
		content = h.getMockVVT(req.Context)
		tokensUsed = 0
	}

	SuccessResponse(c, GenerateResponse{
		Content:     content,
		GeneratedAt: now(),
		Model:       h.llmService.GetModel(),
		TokensUsed:  tokensUsed,
		RAGSources:  convertLLMSources(llmRagSources),
		Confidence:  0.88,
	})
}

// GenerateGutachten generates an expert opinion/assessment
func (h *GenerateHandler) GenerateGutachten(c *gin.Context) {
	var req GenerateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ErrorResponse(c, http.StatusBadRequest, err.Error(), "INVALID_REQUEST")
		return
	}

	// Get RAG context if requested
	var llmRagSources []llm.SearchResult
	if req.UseRAG && h.ragService != nil {
		query := req.RAGQuery
		if query == "" {
			query = "Compliance Bewertung Gutachten"
		}
		results, _ := h.ragService.Search(c.Request.Context(), query, 5, "legal_corpus", "")
		for _, r := range results {
			llmRagSources = append(llmRagSources, llm.SearchResult{
				ID:       r.ID,
				Content:  r.Content,
				Source:   r.Source,
				Score:    r.Score,
				Metadata: r.Metadata,
			})
		}
	}

	// Generate Gutachten content
	content, tokensUsed, err := h.llmService.GenerateGutachten(c.Request.Context(), req.Context, llmRagSources)
	if err != nil {
		content = h.getMockGutachten(req.Context)
		tokensUsed = 0
	}

	SuccessResponse(c, GenerateResponse{
		Content:     content,
		GeneratedAt: now(),
		Model:       h.llmService.GetModel(),
		TokensUsed:  tokensUsed,
		RAGSources:  convertLLMSources(llmRagSources),
		Confidence:  0.80,
	})
}

// Mock content generators for when LLM is not available
func (h *GenerateHandler) getMockDSFA(context map[string]interface{}) string {
	return `# Datenschutz-Folgenabschätzung (DSFA)

## 1. Systematische Beschreibung der Verarbeitungsvorgänge

Die geplante Verarbeitung umfasst die Analyse von Kundendaten mittels KI-gestützter Systeme zur Verbesserung der Servicequalität und Personalisierung von Angeboten.

### Verarbeitungszwecke:
- Kundensegmentierung und Analyse des Nutzerverhaltens
- Personalisierte Empfehlungen
- Optimierung von Geschäftsprozessen

### Rechtsgrundlage:
- Art. 6 Abs. 1 lit. f DSGVO (berechtigtes Interesse)
- Alternativ: Art. 6 Abs. 1 lit. a DSGVO (Einwilligung)

## 2. Bewertung der Notwendigkeit und Verhältnismäßigkeit

Die Verarbeitung ist für die genannten Zwecke erforderlich und verhältnismäßig. Alternative Maßnahmen wurden geprüft, jedoch sind diese weniger effektiv.

## 3. Risikobewertung

### Identifizierte Risiken:
| Risiko | Eintrittswahrscheinlichkeit | Schwere | Maßnahmen |
|--------|---------------------------|---------|-----------|
| Unbefugter Zugriff | Mittel | Hoch | Verschlüsselung, Zugangskontrolle |
| Profilbildung | Hoch | Mittel | Anonymisierung, Einwilligung |
| Datenverlust | Niedrig | Hoch | Backup, Redundanz |

## 4. Maßnahmen zur Risikominderung

- Implementierung von Verschlüsselung (AES-256)
- Strenge Zugriffskontrollen nach dem Least-Privilege-Prinzip
- Regelmäßige Datenschutz-Schulungen
- Audit-Logging aller Zugriffe

## 5. Stellungnahme des Datenschutzbeauftragten

[Hier Stellungnahme einfügen]

## 6. Dokumentation der Konsultation

Erstellt am: ${new Date().toISOString()}
Status: ENTWURF
`
}

func (h *GenerateHandler) getMockTOM(context map[string]interface{}) string {
	return `# Technische und Organisatorische Maßnahmen (TOMs)

## 1. Vertraulichkeit (Art. 32 Abs. 1 lit. b DSGVO)

### 1.1 Zutrittskontrolle
- Alarmanlage
- Chipkarten-/Transponder-System
- Videoüberwachung der Eingänge
- Besuchererfassung und -begleitung

### 1.2 Zugangskontrolle
- Passwort-Richtlinie (min. 12 Zeichen, Komplexitätsanforderungen)
- Multi-Faktor-Authentifizierung
- Automatische Bildschirmsperre
- VPN für Remote-Zugriffe

### 1.3 Zugriffskontrolle
- Rollenbasiertes Berechtigungskonzept
- Need-to-know-Prinzip
- Regelmäßige Überprüfung der Zugriffsrechte
- Protokollierung aller Zugriffe

## 2. Integrität (Art. 32 Abs. 1 lit. b DSGVO)

### 2.1 Weitergabekontrolle
- Transportverschlüsselung (TLS 1.3)
- Ende-zu-Ende-Verschlüsselung für sensible Daten
- Sichere E-Mail-Kommunikation (S/MIME)

### 2.2 Eingabekontrolle
- Protokollierung aller Datenänderungen
- Benutzeridentifikation bei Änderungen
- Audit-Trail für alle Transaktionen

## 3. Verfügbarkeit (Art. 32 Abs. 1 lit. c DSGVO)

### 3.1 Verfügbarkeitskontrolle
- Tägliche Backups
- Georedundante Datenspeicherung
- USV-Anlage
- Notfallplan

### 3.2 Wiederherstellung
- Dokumentierte Wiederherstellungsverfahren
- Regelmäßige Backup-Tests
- Maximale Wiederherstellungszeit: 4 Stunden

## 4. Belastbarkeit (Art. 32 Abs. 1 lit. b DSGVO)

- Lastverteilung
- DDoS-Schutz
- Skalierbare Infrastruktur
`
}

func (h *GenerateHandler) getMockVVT(context map[string]interface{}) string {
	return `# Verzeichnis der Verarbeitungstätigkeiten (Art. 30 DSGVO)

## Verarbeitungstätigkeit: Kundenanalyse und Personalisierung

### Angaben nach Art. 30 Abs. 1 DSGVO:

| Feld | Inhalt |
|------|--------|
| **Name des Verantwortlichen** | [Unternehmensname] |
| **Kontaktdaten** | [Adresse, E-Mail, Telefon] |
| **Datenschutzbeauftragter** | [Name, Kontakt] |
| **Zweck der Verarbeitung** | Kundensegmentierung, Personalisierung, Serviceoptimierung |
| **Kategorien betroffener Personen** | Kunden, Interessenten |
| **Kategorien personenbezogener Daten** | Kontaktdaten, Nutzungsdaten, Transaktionsdaten |
| **Kategorien von Empfängern** | Interne Abteilungen, IT-Dienstleister |
| **Drittlandtransfer** | Nein / Ja (mit Angabe der Garantien) |
| **Löschfristen** | 3 Jahre nach letzter Aktivität |
| **TOM-Referenz** | Siehe TOM-Dokument v1.0 |

### Rechtsgrundlage:
Art. 6 Abs. 1 lit. f DSGVO - Berechtigtes Interesse

### Dokumentation:
- Erstellt: ${new Date().toISOString()}
- Letzte Aktualisierung: ${new Date().toISOString()}
- Version: 1.0
`
}

func (h *GenerateHandler) getMockGutachten(context map[string]interface{}) string {
	return `# Compliance-Gutachten

## Zusammenfassung

Das geprüfte KI-System erfüllt die wesentlichen Anforderungen der DSGVO und des AI Acts. Es wurden jedoch Optimierungspotenziale identifiziert.

## Prüfungsumfang

- DSGVO-Konformität
- AI Act Compliance
- NIS2-Anforderungen

## Bewertungsergebnis

| Bereich | Bewertung | Handlungsbedarf |
|---------|-----------|-----------------|
| Datenschutz | Gut | Gering |
| KI-Risikoeinstufung | Erfüllt | Keiner |
| Cybersicherheit | Befriedigend | Mittel |

## Empfehlungen

1. Verstärkung der Dokumentation
2. Regelmäßige Audits einplanen
3. Schulungsmaßnahmen erweitern

Erstellt am: ${new Date().toISOString()}
`
}

// convertLLMSources converts llm.SearchResult to api.SearchResult for the response
func convertLLMSources(sources []llm.SearchResult) []SearchResult {
	if sources == nil {
		return nil
	}
	result := make([]SearchResult, len(sources))
	for i, s := range sources {
		result[i] = SearchResult{
			ID:       s.ID,
			Content:  s.Content,
			Source:   s.Source,
			Score:    s.Score,
			Metadata: s.Metadata,
		}
	}
	return result
}