"""
Architecture Handlers - команды для архитектурных решений
"""

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

class ArchitectureHandlers(BaseHandler):
    """Обработчик архитектурных команд"""
    
    def register_tools(self):
        """Регистрация всех Architecture инструментов"""
        
        # Architecture Decision
        self.register_tool(
            "mcp_nmp_architecture_decision",
            "Architecture decisions",
            self.architecture_decision,
            {
                "type": "object",
                "properties": {
                    "decision": {"type": "string", "description": "Architecture decision"},
                    "rationale": {"type": "string", "description": "Decision rationale"},
                    "alternatives": {"type": "string", "description": "Alternatives considered"}
                },
                "required": ["decision"]
            }
        )
        
        # Dependency Map
        self.register_tool(
            "mcp_nmp_dependency_map",
            "Dependency mapping",
            self.dependency_map,
            {
                "type": "object",
                "properties": {
                    "component": {"type": "string", "description": "Component name"},
                    "dependencies": {"type": "string", "description": "Dependencies list"}
                },
                "required": ["component"]
            }
        )
        
        # Config Snapshot
        self.register_tool(
            "mcp_nmp_config_snapshot",
            "Configuration snapshot",
            self.config_snapshot,
            {
                "type": "object",
                "properties": {
                    "config": {"type": "string", "description": "Configuration data"},
                    "environment": {"type": "string", "description": "Environment"}
                },
                "required": ["config"]
            }
        )
        
        # Tech Choice Log
        self.register_tool(
            "mcp_nmp_tech_choice_log",
            "Technology choice logging",
            self.tech_choice_log,
            {
                "type": "object",
                "properties": {
                    "technology": {"type": "string", "description": "Technology chosen"},
                    "reason": {"type": "string", "description": "Choice reason"}
                },
                "required": ["technology"]
            }
        )
        
        # Design Pattern
        self.register_tool(
            "mcp_nmp_design_pattern",
            "Design patterns",
            self.design_pattern,
            {
                "type": "object",
                "properties": {
                    "pattern": {"type": "string", "description": "Pattern name"},
                    "usage": {"type": "string", "description": "How it's used"}
                },
                "required": ["pattern"]
            }
        )
        
        logging.info("✅ Зарегистрированы Architecture handlers (5 команд)")
    
    # Реализация методов
    async def architecture_decision(self, decision: str, rationale: str = "", alternatives: str = "") -> str:
        """Архитектурные решения"""
        try:
            data = {
                "decision": decision,
                "rationale": rationale,
                "alternatives": alternatives
            }
            response = self.make_request("api/architecture/decision", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "architecture_decision")
            return ResponseFormatter.format_error(error_response)
    
    async def dependency_map(self, component: str, dependencies: str = "") -> str:
        """Карта зависимостей"""
        try:
            data = {
                "component": component,
                "dependencies": dependencies
            }
            response = self.make_request("api/architecture/dependency/map", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "dependency_map")
            return ResponseFormatter.format_error(error_response)
    
    async def config_snapshot(self, config: str, environment: str = "") -> str:
        """Снимок конфигурации"""
        try:
            data = {
                "config": config,
                "environment": environment
            }
            response = self.make_request("api/architecture/config/snapshot", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "config_snapshot")
            return ResponseFormatter.format_error(error_response)
    
    async def tech_choice_log(self, technology: str, reason: str = "") -> str:
        """Логирование выбора технологий"""
        try:
            data = {
                "technology": technology,
                "reason": reason
            }
            response = self.make_request("api/architecture/tech/choice/log", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "tech_choice_log")
            return ResponseFormatter.format_error(error_response)
    
    async def design_pattern(self, pattern: str, usage: str = "") -> str:
        """Паттерны проектирования"""
        try:
            data = {
                "pattern": pattern,
                "usage": usage
            }
            response = self.make_request("api/architecture/design/pattern", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "design_pattern")
            return ResponseFormatter.format_error(error_response)