"""
TesterAgent - задаёт вопросы ученику и оценивает ответы.
"""

import logging
from typing import List, Any
from .base_agent import BaseAgent, AgentState, AgentResponse
from deepseek_handler import get_mcp_tools, get_mcp_tools_openai, get_mcp_tools_anthropic

logger = logging.getLogger(__name__)

class TesterAgent(BaseAgent):
    def __init__(self):
        system_prompt = (
            f"Когда отвечаешь, первым словом пиши tester "
            f"Ты – Tester Agent. Твоя задача – выбирать вопросы из базы данных, задавать их ученику и оценивать ответ. "
            f"Используй функции БД, чтобы получить следующий вопрос (llm_get_question_from_db). "
            f"Subject_id: {{subject_id}} "
            f"Автоматически получай вопросы по предмету (subject_id: {{subject_id}}) и классу, который выбрал ученик в системе. "
            f"Сразу начинай с получения первого вопроса из базы данных. "
            f"После получения ответа ученика, скажи верный ответ или нет. Хвали ученика, если он отвечает правильно. "
            f"Если ученик ответил неверно, объясни ему в чем ошибка и почему другой ответ верный. "
            f"Не пиши ученику, чтобы он взял следующий вопрос. "
            f"Подбадривай ученика, если он отвечает правильно или неверно. "
            
        )
        super().__init__("Tester", system_prompt, mode=0)

    def _get_tools(self) -> List[Any]:
        """Compatibility method - not used"""
        return []

    def _get_gemini_tools(self) -> List[Any]:
        """Get MCP tools in Gemini format"""
        try:
            return get_mcp_tools_gemini()
        except Exception as e:
            logger.error(f"Tester: Error getting Gemini MCP tools: {e}")
            return []

    def _get_openai_tools(self) -> List[Any]:
        """Get MCP tools in OpenAI format"""
        try:
            return get_mcp_tools_openai()
        except Exception as e:
            logger.error(f"Tester: Error getting OpenAI MCP tools: {e}")
            return []

    def _get_anthropic_tools(self) -> List[Any]:
        """Get MCP tools in Anthropic format"""
        try:
            return get_mcp_tools_anthropic()
        except Exception as e:
            logger.error(f"Tester: Error getting Anthropic MCP tools: {e}")
            return []

    def _process_function_call(self, function_call, state: AgentState) -> Any:
        """Process MCP function calls"""
        try:
            from mcpserver.mcp_client import llm_get_question_from_db, llm_save_paragraph_progress, llm_list_available_questions
            
            func_name = function_call.name
            
            # Handle Gemini, OpenAI and Anthropic function call formats
            if hasattr(function_call, 'args'):
                # Gemini format
                args = dict(function_call.args)
            elif hasattr(function_call, 'input'):
                # Anthropic format
                args = function_call.input
            else:
                # OpenAI format (already converted in base class)
                args = function_call.args
            
            if func_name == "llm_get_question_from_db":
                subject_id = int(args.get("subject_id", state.subject_id))
                grade = int(args.get("grade", state.grade))
                question_order = int(args.get("question_order", 1))
                result = llm_get_question_from_db(subject_id, grade, question_order)
                return result
                
            elif func_name == "llm_save_paragraph_progress":
                seq_number = args.get("seq_number", "auto")
                progress = args.get("progress", "Test completed")
                result = llm_save_paragraph_progress(seq_number, progress)
                return result
                
            elif func_name == "llm_list_available_questions":
                subject_id = int(args.get("subject_id", state.subject_id))
                grade = int(args.get("grade", state.grade))
                result = llm_list_available_questions(subject_id, grade)
                return result
                
        except Exception as e:
            logger.error(f"Tester: Error processing function call {function_call.name}: {e}")
            return f"Error: {str(e)}"
        
        return None

    def process_message(
        self,
        message: str,
        state: AgentState
    ) -> AgentResponse:
        """Dynamically update system prompt and process message"""
        logger.info(f"Tester: Processing message for subject_id: {state.subject_id}")

        # Dynamically update the system prompt with the correct subject_id from the state
        dynamic_system_prompt = self.system_prompt.format(subject_id=state.subject_id)
        
        # Temporarily update the system prompt for this call
        original_system_prompt = self.system_prompt
        self.system_prompt = dynamic_system_prompt
        
        # Call the parent's process_message to handle the LLM call
        response = super().process_message(message, state)
        
        # Restore the original system prompt
        self.system_prompt = original_system_prompt
        
        return response