"""
LessonPlannerAgent - планирует занятия, используя данные о прогрессе.
"""

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

logger = logging.getLogger(__name__)


class LessonPlannerAgent(BaseAgent):
    """Agent responsible for creating personalized study plans"""

    def __init__(self):
        system_prompt = (
            "Ты – Lesson Planner Agent. Анализируй, какие темы уже изучены, какие вызывают затруднения, "
            "и предлагай план урока. При необходимости используй функции БД, чтобы получить информацию о вопросах "
            "или сохранить прогресс."
        )
        super().__init__("LessonPlanner", 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"LessonPlanner: 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"LessonPlanner: 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"LessonPlanner: 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", "Lesson planned")
                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"LessonPlanner: Error processing function call {function_call.name}: {e}")
            return f"Error: {str(e)}"
        
        return None