"""
Workflow Handlers - команды для рабочих процессов
"""

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

class WorkflowHandlers(BaseHandler):
    """Обработчик команд рабочих процессов"""
    
    def register_tools(self):
        """Регистрация всех Workflow инструментов"""
        
        # Workflow Discover
        self.register_tool(
            "mcp_nmp_workflow_discover",
            "Analyze project + find similar solutions",
            self.workflow_discover,
            {
                "type": "object",
                "properties": {
                    "project_data": {"type": "string", "description": "Project data for analysis"}
                },
                "required": []
            }
        )
        
        # Workflow Plan
        self.register_tool(
            "mcp_nmp_workflow_plan",
            "Planning with experience usage",
            self.workflow_plan,
            {
                "type": "object",
                "properties": {
                    "goal": {"type": "string", "description": "Planning goal"}
                },
                "required": []
            }
        )
        
        # Session Context
        self.register_tool(
            "mcp_nmp_session_context",
            "Work session context",
            self.session_context,
            {
                "type": "object",
                "properties": {
                    "session": {"type": "string", "description": "Session description"},
                    "context": {"type": "string", "description": "Session context"}
                },
                "required": ["session"]
            }
        )
        
        # File Relations
        self.register_tool(
            "mcp_nmp_file_relations",
            "File relations",
            self.file_relations,
            {
                "type": "object",
                "properties": {
                    "file": {"type": "string", "description": "File path"},
                    "relations": {"type": "string", "description": "Related files"}
                },
                "required": ["file"]
            }
        )
        
        # TODO Extract
        self.register_tool(
            "mcp_nmp_todo_extract",
            "Extract TODO items",
            self.todo_extract,
            {
                "type": "object",
                "properties": {
                    "content": {"type": "string", "description": "Content to extract TODOs from"}
                },
                "required": ["content"]
            }
        )
        
        # Project Context Restore
        self.register_tool(
            "mcp_nmp_project_context_restore",
            "Restore full project context",
            self.project_context_restore,
            {
                "type": "object",
                "properties": {
                    "data": {"type": "string", "description": "Data for analysis"}
                },
                "required": ["data"]
            }
        )
        
        # Productivity Track
        self.register_tool(
            "mcp_nmp_productivity_track",
            "Track productivity",
            self.productivity_track,
            {
                "type": "object",
                "properties": {
                    "activity": {"type": "string", "description": "Activity description"},
                    "time": {"type": "string", "description": "Time spent"}
                },
                "required": ["activity"]
            }
        )
        
        # Task Completion
        self.register_tool(
            "mcp_nmp_task_completion",
            "Task completion",
            self.task_completion,
            {
                "type": "object",
                "properties": {
                    "task": {"type": "string", "description": "Task description"},
                    "status": {"type": "string", "description": "Completion status"}
                },
                "required": ["task"]
            }
        )
        
        logging.info("✅ Зарегистрированы Workflow handlers (8 команд)")
    
    # Реализация методов
    async def workflow_discover(self, project_data: str = "") -> str:
        """Анализ проекта и поиск похожих решений"""
        try:
            data = {"project_data": project_data}
            response = self.make_request("api/workflow/discover", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "workflow_discover")
            return ResponseFormatter.format_error(error_response)
    
    async def workflow_plan(self, goal: str = "") -> str:
        """Планирование с использованием опыта"""
        try:
            data = {"goal": goal}
            response = self.make_request("api/workflow/plan", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "workflow_plan")
            return ResponseFormatter.format_error(error_response)
    
    async def session_context(self, session: str, context: str = "") -> str:
        """Контекст рабочей сессии"""
        try:
            data = {
                "session": session,
                "context": context
            }
            response = self.make_request("api/workflow/session/context", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "session_context")
            return ResponseFormatter.format_error(error_response)
    
    async def file_relations(self, file: str, relations: str = "") -> str:
        """Связи файлов"""
        try:
            data = {
                "file": file,
                "relations": relations
            }
            response = self.make_request("api/workflow/file/relations", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "file_relations")
            return ResponseFormatter.format_error(error_response)
    
    async def todo_extract(self, content: str) -> str:
        """Извлечение TODO элементов"""
        try:
            data = {"content": content}
            response = self.make_request("api/workflow/todo/extract", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "todo_extract")
            return ResponseFormatter.format_error(error_response)
    
    async def project_context_restore(self, data: str) -> str:
        """Восстановление контекста проекта"""
        try:
            request_data = {"data": data}
            response = self.make_request("api/workflow/project/context/restore", request_data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "project_context_restore")
            return ResponseFormatter.format_error(error_response)
    
    async def productivity_track(self, activity: str, time: str = "") -> str:
        """Отслеживание продуктивности"""
        try:
            data = {
                "activity": activity,
                "time": time
            }
            response = self.make_request("api/workflow/productivity/track", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "productivity_track")
            return ResponseFormatter.format_error(error_response)
    
    async def task_completion(self, task: str, status: str = "") -> str:
        """Завершение задач"""
        try:
            data = {
                "task": task,
                "status": status
            }
            response = self.make_request("api/workflow/task/completion", data)
            return ResponseFormatter.format_generic(response)
        except Exception as e:
            error_response = await self.handle_error(e, "task_completion")
            return ResponseFormatter.format_error(error_response)