"""
Basisklasse für Agenten im Agentservice.
Dieser Modul stellt eine Basis-Agent-Klasse für spezialisierte Agenten zur Verfügung.
"""

import logging
from typing import List, Dict, Any, Optional, Tuple

logger = logging.getLogger(__name__)

class BaseAgent:
    """Basisklasse für alle Agenten im System"""
    
    def __init__(self):
        """Initialisiert den Basis-Agenten"""
        self.id = "base_agent"
        self.name = "Base Agent"
        self.type = "base"
        self.description = "Basisagent als Vorlage für spezialisierte Agenten"
        self.capabilities = "Grundlegende Agentenoperationen"
        self.instructions = """
        Als Basis-Agent kannst du grundlegende Aufgaben erledigen.
        Diese Anweisungen sollten von spezialisierten Agenten überschrieben werden.
        """
    
    def get_agent_info(self) -> Dict[str, Any]:
        """
        Gibt Informationen über den Agenten zurück.
        
        Returns:
            Dict mit Agenten-Informationen
        """
        return {
            "id": self.id,
            "name": self.name,
            "type": self.type,
            "description": self.description,
            "capabilities": self.capabilities,
            "instructions": self.instructions,
            "used": False,  # Wird zur Laufzeit aktualisiert
            "last_result_status": None  # Wird zur Laufzeit aktualisiert
        }
    
    def get_prompt(self, message_context: Dict[str, Any]) -> str:
        """
        Generiert einen an den Agenten angepassten Prompt basierend auf Kontext.
        
        Args:
            message_context: Kontext der Nachricht
            
        Returns:
            Formatierter Prompt für den Agenten
        """
        # Basis-Prompt, der von spezialisierten Agenten überschrieben werden kann
        base_prompt = f"""
        Du bist {self.name}, ein {self.type} Agent.
        
        {self.description}
        
        Deine Fähigkeiten: {self.capabilities}
        
        {self.instructions}
        
        Formatiere deine Antwort klar und strukturiert. Beantworte alle Aspekte der Anfrage.
        Deklariere am Ende deiner Antwort den Status deines Ergebnisses:
        [STATUS: ERGEBNIS] - Wenn du ein vollständiges, konkretes Ergebnis geliefert hast
        [STATUS: TEILWEISE] - Wenn du ein teilweises Ergebnis geliefert hast
        [STATUS: PLAN] - Wenn du nur einen Plan vorgeschlagen hast
        """
        
        return base_prompt.strip()
    
    async def process_message(self, message: Dict[str, Any], context: Dict[str, Any] = None) -> Dict[str, Any]:
        """
        Verarbeitet eine Nachricht und generiert eine Antwort.
        Sollte von spezialisierten Agenten überschrieben werden.
        
        Args:
            message: Die zu verarbeitende Nachricht
            context: Zusätzlicher Kontext (optional)
            
        Returns:
            Die generierte Antwort
        """
        # Basis-Implementierung, die einfach eine Standardantwort zurückgibt
        return {
            "role": "assistant",
            "content": f"Ich bin {self.name} und habe deine Anfrage erhalten. Allerdings bin ich nur eine Basisimplementierung ohne spezifische Funktionalität. [STATUS: PLAN]",
            "agent_type": self.type
        }
    
    def extract_status(self, content: str) -> Tuple[str, str]:
        """
        Extrahiert den Status aus dem Inhalt der Antwort.
        
        Args:
            content: Inhalt der Antwort
            
        Returns:
            Tuple mit (bereinigter Text, Status)
        """
        import re
        
        # Standard-Status, falls keine Deklaration gefunden wird
        status = "UNBEKANNT"
        
        # Suche nach Status-Deklaration
        status_pattern = r'\[STATUS:\s*(ERGEBNIS|TEILWEISE|PLAN)\]'
        match = re.search(status_pattern, content, re.IGNORECASE)
        
        if match:
            # Extrahiere den Status
            status = match.group(1).upper()
            
            # Entferne die Status-Deklaration aus dem Text
            content = re.sub(status_pattern, '', content, flags=re.IGNORECASE).strip()
        
        return content, status