"""
Core Handlers - основные команды памяти и поиска
"""

import logging
from typing import Dict, List, Any
from .base_handler import BaseHandler
from .response_formatter import ResponseFormatter

class CoreHandlers(BaseHandler):
    """Обработчик основных команд памяти"""
    
    def register_tools(self):
        """Регистрация всех Core инструментов"""
        
        # Memory Save
        self.register_tool(
            "mcp_nmp_memory_save",
            "Save information to NMP memory",
            self.memory_save,
            {
                "type": "object",
                "properties": {
                    "content": {"type": "string", "description": "Content to save"},
                    "collection": {"type": "string", "description": "Collection name"},
                    "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags"}
                },
                "required": ["content", "collection"]
            }
        )
        
        # Memory Search
        self.register_tool(
            "mcp_nmp_memory_search",
            "Search in NMP memory",
            self.memory_search,
            {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "collection": {"type": "string", "description": "Collection name"},
                    "limit": {"type": "number", "description": "Max results"},
                    "bypass_qwen": {"type": "boolean", "description": "Bypass QWEN control for direct search"}
                },
                "required": ["query", "collection"]
            }
        )
        
        # Memory List
        self.register_tool(
            "mcp_nmp_memory_list",
            "List NMP collections",
            self.memory_list,
            {
                "type": "object",
                "properties": {},
                "required": []
            }
        )
        
        # Memory Create
        self.register_tool(
            "mcp_nmp_memory_create",
            "Create NMP collection",
            self.memory_create,
            {
                "type": "object",
                "properties": {
                    "name": {"type": "string", "description": "Collection name"}
                },
                "required": ["name"]
            }
        )
        
        # Memory Delete
        self.register_tool(
            "mcp_nmp_memory_delete",
            "Delete NMP collection",
            self.memory_delete,
            {
                "type": "object",
                "properties": {
                    "name": {"type": "string", "description": "Collection name"}
                },
                "required": ["name"]
            }
        )
        
        # Memory Stats
        self.register_tool(
            "mcp_nmp_memory_stats",
            "NMP system statistics",
            self.memory_stats,
            {
                "type": "object",
                "properties": {},
                "required": []
            }
        )
        
        # Status
        self.register_tool(
            "mcp_nmp_status",
            "NMP system status",
            self.status,
            {
                "type": "object",
                "properties": {},
                "required": []
            }
        )
        
        # Direct Search (без QWEN)
        self.register_tool(
            "mcp_nmp_memory_search_direct",
            "Direct search in NMP memory bypassing QWEN",
            self.memory_search_direct,
            {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "collection": {"type": "string", "description": "Collection name"},
                    "limit": {"type": "number", "description": "Max results"}
                },
                "required": ["query", "collection"]
            }
        )
        
        logging.info("✅ Зарегистрированы Core handlers (8 команд)")
    
    # Реализация методов
    async def memory_save(self, content: str, collection: str, tags: List[str] = None) -> str:
        """Сохранение информации в память"""
        try:
            data = {
                "content": content,
                "collection": collection,
                "tags": tags or []
            }
            response = self.make_request("api/memory/save", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_save")
            return ResponseFormatter.format_error(error_response)
    
    async def memory_search(self, query: str, collection: str, limit: int = 5, bypass_qwen: bool = False) -> str:
        """Поиск в памяти"""
        try:
            data = {
                "query": query,
                "collection": collection,
                "limit": limit,
                "bypass_qwen": bypass_qwen
            }
            response = self.make_request("api/memory/search", data)
            return ResponseFormatter.format_search(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_search")
            return ResponseFormatter.format_error(error_response)
    
    async def memory_list(self, random_string: str = "") -> str:
        """Список коллекций"""
        try:
            response = self.make_request("api/memory/list", {})
            return ResponseFormatter.format_list(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_list")
            return ResponseFormatter.format_error(error_response)
    
    async def memory_create(self, name: str) -> str:
        """Создание коллекции"""
        try:
            data = {"name": name}
            response = self.make_request("api/memory/create", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_create")
            return ResponseFormatter.format_error(error_response)
    
    async def memory_delete(self, name: str) -> str:
        """Удаление коллекции"""
        try:
            data = {"name": name}
            response = self.make_request("api/memory/delete", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_delete")
            return ResponseFormatter.format_error(error_response)
    
    async def memory_stats(self, random_string: str = "") -> str:
        """Статистика системы"""
        try:
            response = self.make_request("api/memory/stats", {})
            return ResponseFormatter.format_stats(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_stats")
            return ResponseFormatter.format_error(error_response)
    
    async def status(self, random_string: str = "") -> str:
        """Статус системы"""
        try:
            response = self.make_request("api/status", {})
            return ResponseFormatter.format_stats(response)
        except Exception as e:
            error_response = await self.handle_error(e, "status")
            return ResponseFormatter.format_error(error_response)
    
    async def memory_search_direct(self, query: str, collection: str, limit: int = 5) -> str:
        """Прямой поиск в памяти без QWEN контроля"""
        try:
            data = {
                "query": query,
                "collection": collection,
                "limit": limit,
                "bypass_qwen": True  # Принудительно отключаем QWEN
            }
            response = self.make_request("api/memory/search", data)
            return ResponseFormatter.format_search(response)
        except Exception as e:
            error_response = await self.handle_error(e, "memory_search_direct")
            return ResponseFormatter.format_error(error_response)