// src/config/prompts.ts - Enhanced with phase completion reasoning

export const AI_PROMPTS = {
  
  toolSelection: (mode: string, userQuery: string, selectionMethod: string, maxSelectedItems: number) => {
    const modeInstruction = mode === 'workflow' 
      ? 'Workflow mit 15-25 Items über alle Phasen. PFLICHT: Mindestens 40% Methoden, Rest Tools/Konzepte.'
      : 'Spezifische Lösung mit 4-10 Items. PFLICHT: Mindestens 30% Methoden wenn verfügbar.';

    return `Du bist ein DFIR-Experte. Wähle die BESTEN Items aus dem vorgefilterten Set.

AUSWAHLMETHODE: ${selectionMethod}
${selectionMethod === 'embeddings_candidates' ? 
  '✓ Semantisch relevante Items bereits vorgefiltert\n✓ Wähle die BESTEN für die konkrete Aufgabe' :
  '✓ Vollständige Datenbank verfügbar\n✓ Wähle die relevantesten Items'}

${modeInstruction}

ANFRAGE: "${userQuery}"

VERFÜGBARE ITEM-TYPEN:
- TOOLS (type: "software"/"method") → praktische Anwendungen und Vorgehensweisen  
- KONZEPTE (type: "concept") → theoretisches Wissen und Methodiken

AUSWAHLSTRATEGIE:
1. **ERSTE PRIORITÄT: Relevanz zur Anfrage**
  - Direkt anwendbar auf das Problem
  - Löst die Kernherausforderung

2. **ZWEITE PRIORITÄT: Ausgewogene Mischung**
  - Tools/Methoden für praktische Umsetzung → selectedTools
  - Konzepte für methodisches Verständnis → selectedConcepts
  - WICHTIG: Auch Konzepte auswählen, nicht nur Tools!

3. **QUALITÄT > QUANTITÄT**
  - Lieber weniger perfekte Items als viele mittelmäßige
  - Jedes Item muss begründbar sein

AUSWAHLREGELN:
- Wähle ${mode === 'workflow' ? '15-25' : '4-10'} Items total, max ${maxSelectedItems}
- BEIDE Arrays füllen: selectedTools UND selectedConcepts
- Mindestens 1-2 Konzepte auswählen für methodische Fundierung
- Tools: 40% Methoden (type="method"), Rest Software (type="software")

ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT:
{
  "selectedTools": ["ToolName1", "MethodName1", ...],
  "selectedConcepts": ["ConceptName1", "ConceptName2", ...],
  "reasoning": "Kurze Begründung mit Erwähnung der Tool/Konzept-Balance"
}`;
  },

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

VERFÜGBARE TOOLS (${toolsToSend.length} Items - Methoden und Software):
${JSON.stringify(toolsToSend, null, 2)}

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

WICHTIGER HINWEIS: Wähle sowohl aus TOOLS als auch aus KONZEPTEN aus! Konzepte sind essentiell für methodische Fundierung.`;
  },

  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 ohne Listen, max 100 Wörter.`;
  },

  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 ohne Listen, 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 ohne Listen, 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 `Du bist ein DFIR-Experte. Wähle die 2-3 BESTEN Items für Phase "${phase.name}".

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

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

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

AUSWAHLREGELN FÜR PHASE "${phase.name}":
1. Wähle die 2-3 BESTEN Items für diese spezifische Phase
2. Priorisiere Items, die DIREKT für "${phase.name}" relevant sind
3. Mindestens 1 Methode wenn verfügbar, Rest Software-Tools
4. Begründe WARUM jedes Item für diese Phase optimal ist

WICHTIG: Verwende EXAKT die Namen wie oben aufgelistet (ohne Präfixe wie M1./T2.)!

ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB:
[
  {
    "toolName": "Exakter Name aus der Liste oben",
    "taskRelevance": 85,
    "justification": "Detaillierte Begründung (60-80 Wörter) warum optimal für ${phase.name} - erkläre Anwendung, Vorteile und spezifische Relevanz",
    "limitations": ["Mögliche Einschränkung für diese Phase"]
  }
]`;
  },

  toolEvaluation: (userQuery: string, tool: any, rank: number, taskRelevance: number) => {
    const itemType = tool.type === 'method' ? 'Methode' : 'Tool';
    
    return `Erkläre die Anwendung dieser/dieses ${itemType}.

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

Bereits als Rang ${rank} bewertet.

ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB DER JSON-STRUKTUR:
{
  "detailed_explanation": "Warum und wie einsetzen",
  "implementation_approach": "Konkrete Schritte",
  "pros": ["Vorteil 1", "Vorteil 2"],
  "limitations": ["Einschränkung 1"],
  "alternatives": "Alternative Ansätze"
}`;
  },

  backgroundKnowledgeSelection: (userQuery: string, mode: string, selectedToolNames: string[], availableConcepts: any[]) => {
    return `Wähle 2-4 relevante Konzepte.

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

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

ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB DER JSON-STRUKTUR:
[
  {
    "conceptName": "Name",
    "relevance": "Warum kritisch für Methodik"
  }
]`;
  },

  phaseCompletionReasoning: (
    originalQuery: string,
    phase: any,
    selectedToolName: string,
    tool: any,
    completionContext: string
  ) => {
    return `Du bist ein DFIR-Experte. Erkläre warum dieses Tool nachträglich zur Vervollständigung hinzugefügt wurde.

KONTEXT DER NACHTRÄGLICHEN ERGÄNZUNG:
- Ursprüngliche KI-Auswahl war zu spezifisch/eng gefasst
- Phase "${phase.name}" war unterrepräsentiert in der initialen Auswahl
- Semantische Suche fand zusätzlich relevante Tools für diese Phase
- Tool wird nachträglich hinzugefügt um Vollständigkeit zu gewährleisten

URSPRÜNGLICHE ANFRAGE: "${originalQuery}"
PHASE ZU VERVOLLSTÄNDIGEN: ${phase.name} - ${phase.description || ''}
HINZUGEFÜGTES TOOL: ${selectedToolName} (${tool.type})
TOOL-BESCHREIBUNG: ${tool.description}

BEGRÜNDUNGSKONTEXT: ${completionContext}

Erstelle eine präzise Begründung (max. 40 Wörter), die erklärt:
1. WARUM dieses Tool nachträglich hinzugefügt wurde
2. WIE es die ${phase.name}-Phase ergänzt
3. DASS es die ursprünglich zu spezifische Auswahl erweitert

Antwort: Prägnanter Fließtext, knappe Begründung für Nachergänzung. Vermeide Begriffe wie "Das Tool" und gib keinen einleitenden Text wie "Begründung (40 Wörter):" an.`;
  },

  generatePhaseCompletionPrompt(
    originalQuery: string,
    phase: any,
    candidateTools: any[],
    candidateConcepts: any[]
  ): string {
    return `Du bist ein DFIR-Experte. Die initiale KI-Auswahl war zu spezifisch - die Phase "${phase.name}" ist unterrepräsentiert.

KONTEXT: Die Hauptauswahl hat zu wenige Tools für "${phase.name}" identifiziert. Wähle jetzt ergänzende Tools aus semantischer Nachsuche.

ORIGINAL ANFRAGE: "${originalQuery}"
UNTERREPRÄSENTIERTE PHASE: ${phase.name} - ${phase.description || ''}

SEMANTISCH GEFUNDENE KANDIDATEN für Nachergänzung:

VERFÜGBARE TOOLS (${candidateTools.length}):
${candidateTools.map((tool: any) => `
- ${tool.name} (${tool.type})
  Beschreibung: ${tool.description}
  Skill Level: ${tool.skillLevel}
`).join('')}

${candidateConcepts.length > 0 ? `
VERFÜGBARE KONZEPTE (${candidateConcepts.length}):
${candidateConcepts.map((concept: any) => `
- ${concept.name}
  Beschreibung: ${concept.description}
`).join('')}
` : ''}

AUSWAHLREGELN FÜR NACHERGÄNZUNG:
1. Wähle 1-2 BESTE Methoden/Tools die die ${phase.name}-Phase optimal ergänzen
2. Methoden/Tools müssen für die ursprüngliche Anfrage relevant sein
3. Ergänzen, nicht ersetzen - erweitere die zu spezifische Erstauswahl

ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT:
{
  "selectedTools": ["ToolName1", "ToolName2"],
  "selectedConcepts": ["ConceptName1"],
  "completionReasoning": "Kurze Erklärung warum diese Nachergänzung für ${phase.name} notwendig war"
}`;
  },

  finalRecommendations: (isWorkflow: boolean, userQuery: string, selectedToolNames: string[]) => {
    const focus = isWorkflow ? 
      'Workflow-Schritte, Best Practices, Objektivität' :
      '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 ohne Listen, max ${isWorkflow ? '100' : '80'} Wörter.`;
  }
} as const;

export function getPrompt(key: 'toolSelection', mode: string, userQuery: string, selectionMethod: 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, taskRelevance: 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 promptFunction = AI_PROMPTS[promptKey];
    if (typeof promptFunction === 'function') {
      return (promptFunction as (...args: any[]) => string)(...args);
    } else {
      console.error(`[PROMPTS] Invalid prompt key: ${promptKey}`);
      return 'Error: Invalid prompt configuration';
    }
  } catch (error) {
    console.error(`[PROMPTS] Error generating prompt ${promptKey}:`, error);
    return 'Error: Failed to generate prompt';
  }
}