"""
Command router for the MiniMax Code CLI.

Routes commands to their appropriate handlers based on the parsed arguments.
"""

import logging
from typing import Any

from huggingface_hub import InferenceClient
from ..config import Configuration
from ..presentation.base import BasePresenter

from .analyze import AnalyzeCommands
from .generate import GenerateCommands
from .edit import EditCommands
from .chat import ChatCommands
from .project import ProjectCommands


class CommandRouter:
    """Routes CLI commands to their appropriate handlers."""
    
    def __init__(self, client: InferenceClient, config: Configuration, presenter: BasePresenter):
        self.client = client
        self.config = config
        self.presenter = presenter
        self.logger = logging.getLogger(__name__)
        
        # Initialize command handlers
        self.analyze = AnalyzeCommands(client, config, presenter)
        self.generate = GenerateCommands(client, config, presenter)
        self.edit = EditCommands(client, config, presenter)
        self.chat = ChatCommands(client, config, presenter)
        self.project = ProjectCommands(client, config, presenter)
    
    def route(self, args: Any) -> bool:
        """Route the command to the appropriate handler."""
        try:
            command = args.command
            
            if command == 'analyze':
                return self._route_analyze(args)
            elif command == 'generate':
                return self._route_generate(args)
            elif command == 'edit':
                return self._route_edit(args)
            elif command == 'chat':
                return self._route_chat(args)
            elif command == 'project':
                return self._route_project(args)
            else:
                error_msg = f"Unknown command: {command}"
                self.logger.error(error_msg)
                self.presenter.show_error(error_msg)
                return False
                
        except Exception as e:
            error_msg = f"Error routing command: {e}"
            self.logger.error(error_msg)
            self.presenter.show_error(error_msg)
            return False
    
    def _route_analyze(self, args: Any) -> bool:
        """Route analyze subcommands."""
        action = getattr(args, 'analyze_action', None)
        
        if action == 'review':
            return self.analyze.review(args)
        elif action == 'explain':
            return self.analyze.explain(args)
        elif action == 'debug':
            return self.analyze.debug(args)
        elif action == 'optimize':
            return self.analyze.optimize(args)
        else:
            error_msg = "No analyze action specified"
            self.logger.error(error_msg)
            self.presenter.show_error(error_msg)
            return False
    
    def _route_generate(self, args: Any) -> bool:
        """Route generate subcommands."""
        action = getattr(args, 'generate_action', None)
        
        if action == 'function':
            return self.generate.function(args)
        elif action == 'class':
            return self.generate.class_code(args)
        elif action == 'test':
            return self.generate.test(args)
        elif action == 'project':
            return self.generate.project(args)
        else:
            error_msg = "No generate action specified"
            self.logger.error(error_msg)
            self.presenter.show_error(error_msg)
            return False
    
    def _route_edit(self, args: Any) -> bool:
        """Route edit subcommands."""
        action = getattr(args, 'edit_action', None)
        
        if action == 'modify':
            return self.edit.modify(args)
        elif action == 'refactor':
            return self.edit.refactor(args)
        elif action == 'format':
            return self.edit.format_code(args)
        else:
            error_msg = "No edit action specified"
            self.logger.error(error_msg)
            self.presenter.show_error(error_msg)
            return False
    
    def _route_chat(self, args: Any) -> bool:
        """Route chat subcommands."""
        action = getattr(args, 'chat_action', None)
        
        if action == 'start':
            return self.chat.start(args)
        elif action == 'context':
            return self.chat.context(args)
        else:
            error_msg = "No chat action specified"
            self.logger.error(error_msg)
            self.presenter.show_error(error_msg)
            return False
    
    def _route_project(self, args: Any) -> bool:
        """Route project subcommands."""
        action = getattr(args, 'project_action', None)
        
        if action == 'init':
            return self.project.init(args)
        elif action == 'scan':
            return self.project.scan(args)
        elif action == 'summary':
            return self.project.summary(args)
        else:
            error_msg = "No project action specified"
            self.logger.error(error_msg)
            self.presenter.show_error(error_msg)
            return False