"""
No Memory Baseline (T1)

A simple agent that has no memory of previous sessions.
Only sees the current conversation history within a session.
"""

from typing import List, Dict, Any, Optional
import os

from .base import BaselineAgent, AgentResponse


# System prompt for the agent
AGENT_SYSTEM_PROMPT = """You are a helpful AI assistant helping users solve problems.

Guidelines:
- If the user's request is unclear, ask for clarification
- Provide clear, well-structured answers
- Adapt to user feedback and preferences expressed in the conversation
- Be helpful and do your best to solve the user's problem

Your output should be a direct response to the user."""


class NoMemoryAgent(BaselineAgent):
    """
    T1: Base model with no memory.
    
    This agent:
    - Has no memory across sessions
    - Only uses current conversation context
    - Represents the baseline "no personalization" case
    """
    
    def __init__(
        self,
        model_name: str = "llama-8b",
        api_base: Optional[str] = None,
        api_key: Optional[str] = None,
        max_new_tokens: int = 512,
        temperature: float = 0.7,
        **kwargs
    ):
        super().__init__(model_name, **kwargs)
        
        self.api_base = api_base or os.getenv("OPENAI_API_BASE", "http://localhost:8003/v1")
        self.api_key = api_key or os.getenv("OPENAI_API_KEY", "EMPTY")
        self.max_new_tokens = max_new_tokens
        self.temperature = temperature
        
        # Initialize client
        self._init_client()
    
    def _init_client(self):
        """Initialize the LLM client."""
        try:
            import openai
            self.client = openai.OpenAI(
                base_url=self.api_base,
                api_key=self.api_key,
            )
        except Exception as e:
            print(f"Warning: Could not initialize OpenAI client: {e}")
            self.client = None
    
    def _build_messages(
        self,
        conversation_history: List[Dict[str, str]],
        query: str,
    ) -> List[Dict[str, str]]:
        """Build messages for the LLM."""
        messages = [{"role": "system", "content": AGENT_SYSTEM_PROMPT}]
        
        # Add conversation history
        for msg in conversation_history:
            messages.append({
                "role": msg["role"],
                "content": msg["content"],
            })
        
        # Add current query if not already in history
        if not conversation_history or conversation_history[-1]["content"] != query:
            messages.append({"role": "user", "content": query})
        
        return messages
    
    def respond(
        self,
        user_id: str,
        query: str,
        conversation_history: List[Dict[str, str]],
        **kwargs
    ) -> AgentResponse:
        """Generate response using only current conversation context."""
        
        messages = self._build_messages(conversation_history, query)
        
        if self.client is None:
            # Fallback for testing without LLM
            return AgentResponse(
                answer=f"[NoMemoryAgent] Response to: {query[:50]}...",
                debug_info={"mode": "fallback", "num_messages": len(messages)},
            )
        
        try:
            response = self.client.chat.completions.create(
                model=self.model_name,
                messages=messages,
                max_tokens=self.max_new_tokens,
                temperature=self.temperature,
            )
            
            answer = response.choices[0].message.content
            
            return AgentResponse(
                answer=answer,
                debug_info={
                    "num_messages": len(messages),
                    "prompt_tokens": response.usage.prompt_tokens if response.usage else 0,
                    "completion_tokens": response.usage.completion_tokens if response.usage else 0,
                },
            )
            
        except Exception as e:
            print(f"Error calling LLM: {e}")
            return AgentResponse(
                answer=f"I apologize, but I encountered an error. Let me try again: {query[:100]}",
                debug_info={"error": str(e)},
            )
    
    def end_session(self, user_id: str, conversation: List[Dict[str, str]]):
        """No-op for no-memory agent."""
        pass
    
    def reset_user(self, user_id: str):
        """No-op for no-memory agent."""
        pass
    
    def get_name(self) -> str:
        return f"NoMemory({self.model_name})"