"""
MCP (Model Context Protocol) API endpoints for CQA Test Application
Using flask-mcp-server package for standard MCP implementation
"""

import logging
from flask_mcp_server import Mcp
from common.context import api_function
from flask_restful import reqparse

logger = logging.getLogger(__name__)


@Mcp.tool(name="jira_list_projects")
def jira_list_projects() -> dict:
    """List all accessible Jira projects"""
    try:
        return jira_client.list_projects()
    except Exception as e:
        logger.error(f"Error listing Jira projects: {e}")
        return {"error": str(e)}


@Mcp.tool(name="jira_search_issues")
def jira_search_issues(jql: str, max_results: int = 50) -> dict:
    """Search Jira issues using JQL query
    
    Args:
        jql: JQL (Jira Query Language) query string
        max_results: Maximum number of results to return (default: 50)
    """
    try:
        return jira_client.search_issues(jql, max_results)
    except Exception as e:
        logger.error(f"Error searching Jira issues: {e}")
        return {"error": str(e)}


@Mcp.tool(name="jira_get_issue")
def jira_get_issue(issue_key: str) -> dict:
    """Get detailed information about a specific Jira issue
    
    Args:
        issue_key: Jira issue key (e.g., PROJ-123)
    """
    try:
        return jira_client.get_issue(issue_key)
    except Exception as e:
        logger.error(f"Error getting Jira issue: {e}")
        return {"error": str(e)}


@Mcp.tool(name="jira_get_comments")
def jira_get_comments(issue_key: str) -> dict:
    """Get comments for a specific Jira issue
    
    Args:
        issue_key: Jira issue key (e.g., PROJ-123)
    """
    try:
        return jira_client.get_issue_comments(issue_key)
    except Exception as e:
        logger.error(f"Error getting Jira comments: {e}")
        return {"error": str(e)}


@Mcp.tool(name="jira_create_issue")
def jira_create_issue(
    project_key: str, 
    summary: str, 
    description: str, 
    issue_type: str = "Task", 
    priority: str = "Medium"
) -> dict:
    """Create a new Jira issue
    
    Args:
        project_key: Jira project key
        summary: Issue summary/title
        description: Issue description
        issue_type: Issue type (e.g., Task, Bug, Story) (default: Task)
        priority: Issue priority (e.g., High, Medium, Low) (default: Medium)
    """
    try:
        return jira_client.create_issue(
            project_key, summary, description, issue_type, priority
        )
    except Exception as e:
        logger.error(f"Error creating Jira issue: {e}")
        return {"error": str(e)}


@Mcp.tool(name="run_command")
def run_command(command: str) -> dict:
    """Execute a system command
    
    Args:
        command: Command to execute
    """
    try:
        # Create mock request for existing API function
        mock_request = type('MockRequest', (), {
            'get_json': lambda: {'cmd': command},
            'method': 'POST',
            'url': '/mcp/execute',
            'headers': {}
        })()
        
        result = api_function.run_cmd(reqparse=reqparse, request=mock_request)
        return result
    except Exception as e:
        logger.error(f"Error executing command: {e}")
        return {"error": str(e)}


@Mcp.tool(name="network_test")
def network_test(server: str, port: int = 5201, duration: int = 10) -> dict:
    """Run network performance test using iperf3
    
    Args:
        server: Target server for iperf test
        port: Port number (default: 5201)
        duration: Test duration in seconds (default: 10)
    """
    try:
        # Create mock request for existing API function
        mock_request = type('MockRequest', (), {
            'get_json': lambda: {
                'server': server,
                'port': port,
                'duration': duration
            },
            'method': 'POST',
            'url': '/mcp/execute',
            'headers': {}
        })()
        
        result = api_function.run_iperf(reqparse=reqparse, request=mock_request)
        return result
    except Exception as e:
        logger.error(f"Error running network test: {e}")
        return {"error": str(e)}


def get_mcp_server_info() -> dict:
    """Get MCP server information for compatibility"""
    return {
        "server_name": "cqa-test-app",
        "server_version": "1.0.0",
        "capabilities": {
            "tools": True,
            "resources": False,
            "prompts": False
        },
        "jira_connected": jira_client.is_connected()
    }