// src/config/prompts.ts

const RELEVANCE_RUBRIC = `
TASK RELEVANCE (INTEGER 0–100, NO %):
- 55–65 = Basis/ok
- 66–75 = Gut geeignet
- 76–85 = Sehr gut geeignet
- >85   = Nur bei nahezu perfekter Übereinstimmung
`.trim();

const STRICTNESS = `
STRICTNESS:
- Output MUST be pure JSON (no prose, no code fences, no trailing commas).
- Use EXACT item names as provided (casing/spelling must match).
- Do NOT invent items or fields. If unsure, select fewer.
`.trim();

export const AI_PROMPTS = {
  enhancementQuestions: (input: string) => {
    return `Sie sind DFIR-Experte. Ein Nutzer beschreibt unten ein Szenario/Problem.

ZIEL:
- Stellen Sie NUR dann 1–3 präzise Rückfragen, wenn entscheidende forensische Lücken die weitere Analyse/Toolauswahl PHASENREIHENFOLGE oder EVIDENCE-STRATEGIE wesentlich beeinflussen würden.
- Wenn ausreichend abgedeckt: Geben Sie eine leere Liste [] zurück.

PRIORITÄT DER THEMEN (in dieser Reihenfolge prüfen):
1) Available Evidence & Artefakte (z.B. RAM-Dump, Disk-Image, Logs, PCAP, Registry, Cloud/Audit-Logs)
2) Scope/Systems (konkrete Plattformen/Assets/Identitäten/Netzsegmente)
3) Investigation Objectives (Ziele: IOC-Extraktion, Timeline, Impact, Attribution)
4) Timeline/Timeframe (kritische Zeitfenster, Erhalt flüchtiger Daten)
5) Legal & Compliance (Chain of Custody, Aufbewahrung, DSGVO/Branchenvorgaben)
6) Technical Constraints (Ressourcen, Zugriffsrechte, Tooling/EDR)

FRAGEN-QUALITÄT:
- Forensisch spezifisch und entscheidungsrelevant (keine Allgemeinplätze).
- Eine Frage pro Thema, keine Dopplungen.
- Antwortbar vom Nutzer (keine Spekulation, keine “Beweise senden”-Aufforderungen).
- Maximal 18 Wörter, endet mit "?".

VALIDIERUNG:
- Stellen Sie NUR Fragen zu Themen, die im Nutzertext NICHT hinreichend konkret beantwortet sind (keine Wiederholung bereits gegebener Details).
- Wenn alle priorisierten Themen ausreichend sind → [].

ANTWORTFORMAT (NUR JSON, KEIN ZUSÄTZLICHER TEXT):
[
  "präzise Frage 1?",
  "präzise Frage 2?",
  "präzise Frage 3?"
]

NUTZER-EINGABE:
${input}`.trim();
  },
  toolSelection: (mode: string, userQuery: string, maxSelectedItems: number) => {
    const modeInstruction =
      mode === 'workflow'
        ? 'Workflow mit 15–25 Items über alle Phasen. Pflicht: ~40% Methoden, Rest Software/Konzepte (falls verfügbar).'
        : 'Spezifische Lösung mit 4–10 Items. Pflicht: ≥30% Methoden (falls verfügbar).';

    return `Du bist DFIR-Experte. Wähle die BESTEN Items aus dem bereits semantisch vorgefilterten Set für die konkrete Aufgabe.

${modeInstruction}

ANFRAGE: "${userQuery}"

ITEM-TYPEN:
- TOOLS (type: "software" | "method")
- KONZEPTE (type: "concept")

AUSWAHLPRINZIPIEN:
1) Relevanz zur Anfrage (direkt anwendbar, adressiert Kernproblem)
2) Ausgewogene Mischung (Praxis: selectedTools; Methodik: selectedConcepts)
3) Qualität > Quantität (lieber weniger, dafür passgenau)
4) Keine Erfindungen. Wenn etwas nicht passt, wähle weniger.

AUSWAHLREGELN:
- Wähle ${mode === 'workflow' ? '15–25' : '4–10'} Items total (max ${maxSelectedItems})
- Fülle BEIDE Arrays: selectedTools UND selectedConcepts
- Mindestens 1–2 Konzepte (falls verfügbar)
- Bevorzugt ~40% Methoden (Workflow) bzw. ≥30% Methoden (Tool-Modus), sofern vorhanden
- Sortiere selectedTools grob nach Eignung (bestes zuerst)

Skalenhinweis (für spätere Schritte – einheitlich):
${RELEVANCE_RUBRIC}

${STRICTNESS}

ANTWORT (NUR JSON):
{
  "selectedTools": ["ToolName1", "MethodName1", "..."],
  "selectedConcepts": ["ConceptName1", "ConceptName2", "..."],
  "reasoning": "Sehr kurz: Balance/Abdeckung begründen"
}`;
  },

  toolSelectionWithData: (basePrompt: string, toolsToSend: any[], conceptsToSend: any[]) => {
    return `${basePrompt}

VERFÜGBARE TOOLS (${toolsToSend.length}):
${JSON.stringify(toolsToSend, null, 2)}

VERFÜGBARE KONZEPTE (${conceptsToSend.length}):
${JSON.stringify(conceptsToSend, null, 2)}

WICHTIG:
- Wähle nur aus obigen Listen. Keine neuen Namen.
- Nutze exakte Namen. Keine Synonyme/Varianten.

Hinweis zur einheitlichen Relevanz-Skala:
${RELEVANCE_RUBRIC}

${STRICTNESS}`;
  },

  scenarioAnalysis: (isWorkflow: boolean, userQuery: string) => {
    const analysisType = isWorkflow ? 'Szenario' : 'Problem';
    const focus = isWorkflow
      ? 'Angriffsvektoren, betroffene Systeme, Zeitkritikalität'
      : 'Kernherausforderung, verfügbare Daten, methodische Anforderungen';

    return `DFIR-Experte: Analysiere das ${analysisType}.

${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
Fokus: ${focus}

Antwort: Fließtext, max 100 Wörter. Keine Liste, keine Einleitung.`;
  },

  investigationApproach: (isWorkflow: boolean, userQuery: string) => {
    const approachType = isWorkflow ? 'Untersuchungsansatz' : 'Lösungsansatz';
    const focus = isWorkflow
      ? 'Triage-Prioritäten, Phasenabfolge, Kontaminationsvermeidung'
      : 'Methodenauswahl, Validierung, Integration';

    return `Entwickle einen ${approachType}.

${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
Fokus: ${focus}

Antwort: Fließtext, max 100 Wörter.`;
  },

  criticalConsiderations: (isWorkflow: boolean, userQuery: string) => {
    const focus = isWorkflow
      ? 'Beweissicherung vs. Gründlichkeit, Chain of Custody'
      : 'Tool-Validierung, False Positives/Negatives, Qualifikationen';

    return `Identifiziere kritische Überlegungen.

${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
Fokus: ${focus}

Antwort: Fließtext, max 100 Wörter.`;
  },

  phaseToolSelection: (userQuery: string, phase: any, phaseTools: any[]) => {
    const methods = phaseTools.filter(t => t.type === 'method');
    const tools = phaseTools.filter(t => t.type === 'software');

    if (phaseTools.length === 0) {
      return `Keine Methoden/Tools für Phase "${phase.name}" verfügbar. Antworte mit leerem Array: []`;
    }

    return `Wähle die 2–3 BESTEN Items für Phase "${phase.name}".

SZENARIO: "${userQuery}"
PHASE: ${phase.name} — ${phase.description || ''}

VERFÜGBARE ITEMS:
${methods.length > 0 ? `
METHODEN (${methods.length}):
${methods.map((m: any) =>
  `- ${m.name}
  Typ: ${m.type}
  Beschreibung: ${m.description}
  Domains: ${m.domains?.join(', ') || 'N/A'}
  Skill Level: ${m.skillLevel}`
).join('\n\n')}
` : 'Keine Methoden verfügbar'}

${tools.length > 0 ? `
SOFTWARE (${tools.length}):
${tools.map((t: any) =>
  `- ${t.name}
  Typ: ${t.type}
  Beschreibung: ${t.description}
  Plattformen: ${t.platforms?.join(', ') || 'N/A'}
  Skill Level: ${t.skillLevel}`
).join('\n\n')}
` : 'Keine Software-Tools verfügbar'}

REGELN:
1) 2–3 Items, direkt phasenrelevant; mind. 1 Methode, falls verfügbar
2) Begründung pro Item (präzise, anwendungsbezogen)
3) Verwende EXAKTE Namen aus den Listen. Keine Erfindungen.

${RELEVANCE_RUBRIC}

${STRICTNESS}

ANTWORT (NUR JSON):
[
  {
    "toolName": "Exakter Name",
    "taskRelevance": 0,
    "justification": "60–80 Wörter zur phasenspezifischen Eignung",
    "limitations": ["Optionale spezifische Einschränkung"]
  }
]`;
  },

  toolEvaluation: (userQuery: string, tool: any, rank: number) => {
    const itemType = tool.type === 'method' ? 'Methode' : 'Tool';

    return `Bewerte diese/diesen ${itemType} ausschließlich bzgl. des PROBLEMS.

PROBLEM: "${userQuery}"
${itemType.toUpperCase()}: ${tool.name}
TYP: ${tool.type}

ANWEISUNGEN:
- Nur vorhandene Metadaten nutzen (keine Annahmen, keine Websuche).
- "taskRelevance" als GANZZAHL 0–100 nach einheitlicher Skala vergeben.
- Realistische Scores i.d.R. 60–80, >85 nur bei nahezu perfektem Fit.
- Keine Texte außerhalb des JSON.

${RELEVANCE_RUBRIC}
${STRICTNESS}

ANTWORT (NUR JSON):
{
  "detailed_explanation": "Warum und wie einsetzen",
  "implementation_approach": "Konkrete Schritte",
  "pros": ["Vorteil 1", "Vorteil 2"],
  "limitations": ["Einschränkung 1"],
  "alternatives": "Kurz zu sinnvollen Alternativen",
  "taskRelevance": 0
}`;
  },

  backgroundKnowledgeSelection: (userQuery: string, mode: string, selectedToolNames: string[], availableConcepts: any[]) => {
    return `Wähle 2–4 Konzepte, die das Verständnis/den Einsatz der ausgewählten Tools verbessern.

${mode === 'workflow' ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
AUSGEWÄHLTE TOOLS: ${selectedToolNames.join(', ')}

VERFÜGBARE KONZEPTE (${availableConcepts.length}):
${availableConcepts.map((c: any) => `- ${c.name}: ${c.description}...`).join('\n')}

REGELN:
- Nur Konzepte aus obiger Liste wählen.
- Relevanz kurz und konkret begründen.

${STRICTNESS}

ANTWORT (NUR JSON):
[
  {
    "conceptName": "Exakter Name",
    "relevance": "Warum dieses Konzept hier methodisch wichtig ist"
  }
]`;
  },

  phaseCompletionReasoning: (
    originalQuery: string,
    phase: any,
    selectedToolName: string,
    tool: any,
    completionContext: string
  ) => {
    return `Begründe knapp die Nachergänzung für Phase "${phase.name}".

URSPRÜNGLICHE ANFRAGE: "${originalQuery}"
PHASE: ${phase.name} — ${phase.description || ''}
HINZUGEFÜGTES TOOL: ${selectedToolName} (${tool.type})
KONTEXT: ${completionContext}

Antwort: Prägnanter Fließtext, max 40 Wörter, keine Einleitung, keine Liste.`;
  },

  generatePhaseCompletionPrompt(
    originalQuery: string,
    phase: any,
    candidateTools: any[],
    candidateConcepts: any[]
  ): string {
    return `Unterrepräsentierte Phase: "${phase.name}". Ergänze 1–2 passende Items aus der semantischen Nachsuche.

ORIGINALANFRAGE: "${originalQuery}"
PHASE: ${phase.name} — ${phase.description || ''}

KANDIDATEN — TOOLS (${candidateTools.length}):
${candidateTools.map((t: any) => `
- ${t.name} (${t.type})
  Beschreibung: ${t.description}
  Skill Level: ${t.skillLevel}
`).join('')}

${candidateConcepts.length > 0 ? `
KANDIDATEN — KONZEPTE (${candidateConcepts.length}):
${candidateConcepts.map((c: any) => `
- ${c.name}
  Beschreibung: ${c.description}
`).join('')}
` : ''}

REGELN:
- Wähle 1–2 Tools/Methoden, die ${phase.name} sinnvoll ergänzen (keine Ersetzung).
- Nur aus obigen Kandidaten wählen; exakte Namen verwenden.
- Kurze Begründung, warum diese Ergänzung nötig ist.

Skalenhinweis (einheitlich):
${RELEVANCE_RUBRIC}

${STRICTNESS}

ANTWORT (NUR JSON):
{
  "selectedTools": ["ToolName1", "ToolName2"],
  "selectedConcepts": ["ConceptName1"],
  "completionReasoning": "Kurze Erklärung zur Ergänzung der ${phase.name}-Phase"
}`;
  },

  finalRecommendations: (isWorkflow: boolean, userQuery: string, selectedToolNames: string[]) => {
    const focus = isWorkflow
      ? 'Knappe Workflow-Schritte & Best Practices; neutral formulieren'
      : 'Methodische Überlegungen, Validierung, Qualitätssicherung';

    return `Erstelle ${isWorkflow ? 'Workflow-Empfehlung' : 'methodische Überlegungen'}.

${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
AUSGEWÄHLT: ${selectedToolNames.join(', ')}${selectedToolNames.length > 5 ? '...' : ''}

Fokus: ${focus}
Antwort: Fließtext, max ${isWorkflow ? '100' : '80'} Wörter. Keine Liste.`;
  }
} as const;

export function getPrompt(key: 'enhancementQuestions', input: string): string;
export function getPrompt(key: 'toolSelection', mode: string, userQuery: string, maxSelectedItems: number): string;
export function getPrompt(key: 'toolSelectionWithData', basePrompt: string, toolsToSend: any[], conceptsToSend: any[]): string;
export function getPrompt(key: 'scenarioAnalysis', isWorkflow: boolean, userQuery: string): string;
export function getPrompt(key: 'investigationApproach', isWorkflow: boolean, userQuery: string): string;
export function getPrompt(key: 'criticalConsiderations', isWorkflow: boolean, userQuery: string): string;
export function getPrompt(key: 'phaseToolSelection', userQuery: string, phase: any, phaseTools: any[]): string;
export function getPrompt(key: 'toolEvaluation', userQuery: string, tool: any, rank: number): string;
export function getPrompt(key: 'backgroundKnowledgeSelection', userQuery: string, mode: string, selectedToolNames: string[], availableConcepts: any[]): string;
export function getPrompt(key: 'phaseCompletionReasoning', originalQuery: string, phase: any, selectedToolName: string, tool: any, completionContext: string): string;
export function getPrompt(key: 'finalRecommendations', isWorkflow: boolean, userQuery: string, selectedToolNames: string[]): string;
export function getPrompt(key: 'generatePhaseCompletionPrompt', originalQuery: string, phase: any, candidateTools: any[], candidateConcepts: any[]): string;

export function getPrompt(promptKey: keyof typeof AI_PROMPTS, ...args: any[]): string {
  try {
    const f = AI_PROMPTS[promptKey];
    if (typeof f === 'function') return (f as (...a: any[]) => string)(...args);
    console.error(`[PROMPTS] Invalid prompt key: ${promptKey}`);
    return 'Error: Invalid prompt configuration';
  } catch (err) {
    console.error(`[PROMPTS] Error generating prompt ${promptKey}:`, err);
    return 'Error: Failed to generate prompt';
  }
}
