"""
Code Handlers - команды для работы с кодом
"""

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

class CodeHandlers(BaseHandler):
    """Обработчик команд для работы с кодом"""
    
    def register_tools(self):
        """Регистрация всех Code инструментов"""
        
        # Code Error Save
        self.register_tool(
            "mcp_nmp_code_error_save",
            "Save code error + solution",
            self.code_error_save,
            {
                "type": "object",
                "properties": {
                    "error": {"type": "string", "description": "Error description"},
                    "solution": {"type": "string", "description": "Solution description"},
                    "context": {"type": "string", "description": "Error context"},
                    "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags"}
                },
                "required": ["error", "solution"]
            }
        )
        
        # Code Pattern Save
        self.register_tool(
            "mcp_nmp_code_pattern_save",
            "Save code pattern",
            self.code_pattern_save,
            {
                "type": "object",
                "properties": {
                    "pattern": {"type": "string", "description": "Code pattern"},
                    "description": {"type": "string", "description": "Pattern description"},
                    "language": {"type": "string", "description": "Programming language"}
                },
                "required": ["pattern"]
            }
        )
        
        # Refactor Track
        self.register_tool(
            "mcp_nmp_refactor_track",
            "Track refactoring",
            self.refactor_track,
            {
                "type": "object",
                "properties": {
                    "before": {"type": "string", "description": "Code before refactoring"},
                    "after": {"type": "string", "description": "Code after refactoring"},
                    "reason": {"type": "string", "description": "Refactoring reason"}
                },
                "required": ["before", "after"]
            }
        )
        
        # Solution Pattern
        self.register_tool(
            "mcp_nmp_solution_pattern",
            "Solution patterns",
            self.solution_pattern,
            {
                "type": "object",
                "properties": {
                    "problem": {"type": "string", "description": "Problem description"},
                    "solution": {"type": "string", "description": "Solution pattern"}
                },
                "required": ["problem", "solution"]
            }
        )
        
        # Debug Journey
        self.register_tool(
            "mcp_nmp_debug_journey",
            "Debug journey history",
            self.debug_journey,
            {
                "type": "object",
                "properties": {
                    "steps": {"type": "string", "description": "Debug steps"},
                    "outcome": {"type": "string", "description": "Debug outcome"}
                },
                "required": ["steps"]
            }
        )
        
        # Code Snippet Save
        self.register_tool(
            "mcp_nmp_code_snippet_save",
            "Save useful code snippet",
            self.code_snippet_save,
            {
                "type": "object",
                "properties": {
                    "code": {"type": "string", "description": "Code snippet"},
                    "description": {"type": "string", "description": "What this code does"},
                    "language": {"type": "string", "description": "Programming language"}
                },
                "required": ["code"]
            }
        )
        
        logging.info("✅ Зарегистрированы Code handlers (6 команд)")
    
    # Реализация методов
    async def code_error_save(self, error: str, solution: str, context: str = "", tags: List[str] = None) -> str:
        """Сохранение ошибки + решения"""
        try:
            data = {
                "error": error,
                "solution": solution,
                "context": context,
                "tags": tags or []
            }
            response = self.make_request("api/code/error/save", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "code_error_save")
            return ResponseFormatter.format_error(error_response)
    
    async def code_pattern_save(self, pattern: str, description: str = "", language: str = "") -> str:
        """Сохранение паттерна кода"""
        try:
            data = {
                "pattern": pattern,
                "description": description,
                "language": language
            }
            response = self.make_request("api/code/pattern/save", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "code_pattern_save")
            return ResponseFormatter.format_error(error_response)
    
    async def refactor_track(self, before: str, after: str, reason: str = "") -> str:
        """Отслеживание рефакторинга"""
        try:
            data = {
                "before": before,
                "after": after,
                "reason": reason
            }
            response = self.make_request("api/code/refactor/track", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "refactor_track")
            return ResponseFormatter.format_error(error_response)
    
    async def solution_pattern(self, problem: str, solution: str) -> str:
        """Паттерны решений"""
        try:
            data = {
                "problem": problem,
                "solution": solution
            }
            response = self.make_request("api/code/solution/pattern", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "solution_pattern")
            return ResponseFormatter.format_error(error_response)
    
    async def debug_journey(self, steps: str, outcome: str = "") -> str:
        """История отладки"""
        try:
            data = {
                "steps": steps,
                "outcome": outcome
            }
            response = self.make_request("api/code/debug/journey", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "debug_journey")
            return ResponseFormatter.format_error(error_response)
    
    async def code_snippet_save(self, code: str, description: str = "", language: str = "") -> str:
        """Сохранение полезного кода"""
        try:
            data = {
                "code": code,
                "description": description,
                "language": language
            }
            response = self.make_request("api/code/snippet/save", data)
            return ResponseFormatter.format_memory(response)
        except Exception as e:
            error_response = await self.handle_error(e, "code_snippet_save")
            return ResponseFormatter.format_error(error_response)