"""Python FastAPI MCP Server Starter.

Main application entry point. Wires together FastAPI, the MCP SDK,
authentication middleware, and structured logging into a single server
that exposes three realistic tools over HTTP transport.
"""

from __future__ import annotations

import asyncio
import json
import platform
import re
import sys
import time
from collections import Counter
from datetime import datetime, timezone
from typing import Any

import uvicorn
from fastapi import FastAPI, Request, Response
from fastapi.responses import JSONResponse
from mcp.server import Server
from mcp.server.fastmcp import FastMCP
from mcp.types import TextContent, Tool
from pydantic import BaseModel, Field, field_validator

from auth import APIKeyMiddleware
from config import settings
from logger import get_logger, setup_logging, RequestLoggingMiddleware

# ---------------------------------------------------------------------------
# Logging
# ---------------------------------------------------------------------------

setup_logging()
log = get_logger(__name__)

# ---------------------------------------------------------------------------
# MCP Server
# ---------------------------------------------------------------------------

mcp = FastMCP(
    name=settings.server_name,
    version=settings.server_version,
)

# ---------------------------------------------------------------------------
# Input schemas
# ---------------------------------------------------------------------------


class AnalyzeTextInput(BaseModel):
    """Input schema for the analyze_text tool."""

    text: str = Field(
        ...,
        min_length=1,
        max_length=50_000,
        description="The text to analyse.",
    )
    include_word_frequency: bool = Field(
        default=False,
        description="Include a word frequency map in the response.",
    )
    top_n_words: int = Field(
        default=10,
        ge=1,
        le=100,
        description="Number of most-frequent words to return when include_word_frequency is true.",
    )


class TransformJsonInput(BaseModel):
    """Input schema for the transform_json tool."""

    data: dict[str, Any] = Field(
        ...,
        description="The JSON object to transform.",
    )
    operation: str = Field(
        ...,
        description=(
            "Transformation to apply. One of: "
            "'flatten_keys' (snake_case keys), "
            "'keys_to_uppercase', "
            "'remove_nulls', "
            "'sort_keys'."
        ),
    )

    @field_validator("operation")
    @classmethod
    def validate_operation(cls, v: str) -> str:
        allowed = {"flatten_keys", "keys_to_uppercase", "remove_nulls", "sort_keys"}
        if v not in allowed:
            raise ValueError(f"operation must be one of {sorted(allowed)}, got '{v}'")
        return v


class SystemInfoInput(BaseModel):
    """Input schema for the system_info tool (no required fields)."""

    include_environment: bool = Field(
        default=False,
        description="Include non-sensitive environment metadata (Python path, prefix).",
    )


# ---------------------------------------------------------------------------
# Tool implementations
# ---------------------------------------------------------------------------


@mcp.tool()
async def analyze_text(
    text: str,
    include_word_frequency: bool = False,
    top_n_words: int = 10,
) -> str:
    """Analyse a block of text and return statistics.

    Returns character count, word count, sentence count, average word
    length, reading time estimate, and optionally a word frequency map.
    """
    tool_log = get_logger("tool.analyze_text")
    tool_log.info("analyze_text called", text_length=len(text))

    # Validate via Pydantic
    try:
        params = AnalyzeTextInput(
            text=text,
            include_word_frequency=include_word_frequency,
            top_n_words=top_n_words,
        )
    except Exception as exc:
        tool_log.warning("validation error", error=str(exc))
        return json.dumps({"error": f"Validation failed: {exc}"})

    t = params.text

    # Character stats
    char_count = len(t)
    char_count_no_spaces = len(t.replace(" ", ""))

    # Word stats
    words_raw = t.split()
    word_count = len(words_raw)
    avg_word_length = (
        round(sum(len(w.strip(".,!?;:\"'")) for w in words_raw) / word_count, 2)
        if word_count
        else 0
    )

    # Sentence stats (split on . ! ?)
    sentences = [s.strip() for s in re.split(r"[.!?]+", t) if s.strip()]
    sentence_count = len(sentences)

    # Reading time (average adult reads ~238 wpm)
    reading_time_seconds = round((word_count / 238) * 60, 1)

    # Paragraph count
    paragraphs = [p.strip() for p in t.split("\n\n") if p.strip()]
    paragraph_count = len(paragraphs)

    result: dict[str, Any] = {
        "character_count": char_count,
        "character_count_no_spaces": char_count_no_spaces,
        "word_count": word_count,
        "sentence_count": sentence_count,
        "paragraph_count": paragraph_count,
        "average_word_length": avg_word_length,
        "estimated_reading_time_seconds": reading_time_seconds,
    }

    if params.include_word_frequency:
        # Normalise: lowercase, strip punctuation
        normalised = [
            re.sub(r"[^\w]", "", w.lower()) for w in words_raw
        ]
        normalised = [w for w in normalised if w]
        frequency = Counter(normalised).most_common(params.top_n_words)
        result["word_frequency"] = [
            {"word": word, "count": count} for word, count in frequency
        ]

    tool_log.info("analyze_text completed", word_count=word_count)
    return json.dumps(result, indent=2)


@mcp.tool()
async def transform_json(
    data: dict[str, Any],
    operation: str,
) -> str:
    """Apply a named transformation to a JSON object.

    Supported operations:
    - flatten_keys: convert all keys to snake_case
    - keys_to_uppercase: convert all keys to UPPER_CASE
    - remove_nulls: recursively remove keys whose value is null/None
    - sort_keys: return the object with keys sorted alphabetically
    """
    tool_log = get_logger("tool.transform_json")
    tool_log.info("transform_json called", operation=operation, key_count=len(data))

    try:
        params = TransformJsonInput(data=data, operation=operation)
    except Exception as exc:
        tool_log.warning("validation error", error=str(exc))
        return json.dumps({"error": f"Validation failed: {exc}"})

    def to_snake_case(name: str) -> str:
        # Insert underscore before uppercase letters, then lowercase
        s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
        return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower()

    def flatten_keys(obj: Any) -> Any:
        if isinstance(obj, dict):
            return {to_snake_case(k): flatten_keys(v) for k, v in obj.items()}
        if isinstance(obj, list):
            return [flatten_keys(item) for item in obj]
        return obj

    def keys_to_uppercase(obj: Any) -> Any:
        if isinstance(obj, dict):
            return {k.upper(): keys_to_uppercase(v) for k, v in obj.items()}
        if isinstance(obj, list):
            return [keys_to_uppercase(item) for item in obj]
        return obj

    def remove_nulls(obj: Any) -> Any:
        if isinstance(obj, dict):
            return {
                k: remove_nulls(v)
                for k, v in obj.items()
                if v is not None
            }
        if isinstance(obj, list):
            return [remove_nulls(item) for item in obj if item is not None]
        return obj

    def sort_keys(obj: Any) -> Any:
        if isinstance(obj, dict):
            return {k: sort_keys(v) for k in sorted(obj.keys()) for _ in [None] if (v := obj[k]) is not None or True}
        if isinstance(obj, list):
            return [sort_keys(item) for item in obj]
        return obj

    ops = {
        "flatten_keys": flatten_keys,
        "keys_to_uppercase": keys_to_uppercase,
        "remove_nulls": remove_nulls,
        "sort_keys": sort_keys,
    }

    transformed = ops[params.operation](params.data)
    tool_log.info("transform_json completed", operation=params.operation)
    return json.dumps(
        {"operation": params.operation, "result": transformed},
        indent=2,
    )


@mcp.tool()
async def system_info(include_environment: bool = False) -> str:
    """Return metadata about the MCP server runtime environment.

    Useful for debugging connectivity, verifying the deployed version,
    and understanding the execution context.
    """
    tool_log = get_logger("tool.system_info")
    tool_log.info("system_info called")

    try:
        params = SystemInfoInput(include_environment=include_environment)
    except Exception as exc:
        return json.dumps({"error": f"Validation failed: {exc}"})

    info: dict[str, Any] = {
        "server_name": settings.server_name,
        "server_version": settings.server_version,
        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
        "python_version": sys.version,
        "platform": {
            "system": platform.system(),
            "release": platform.release(),
            "machine": platform.machine(),
            "processor": platform.processor() or "unknown",
        },
        "uptime_seconds": round(time.monotonic() - _start_time, 2),
    }

    if params.include_environment:
        info["environment"] = {
            "python_executable": sys.executable,
            "python_prefix": sys.prefix,
            "log_level": settings.log_level,
            "log_format": settings.log_format,
        }

    tool_log.info("system_info completed")
    return json.dumps(info, indent=2)


# ---------------------------------------------------------------------------
# FastAPI application
# ---------------------------------------------------------------------------

_start_time = time.monotonic()

app = FastAPI(
    title=settings.server_name,
    version=settings.server_version,
    docs_url=None,   # Disable Swagger UI in production
    redoc_url=None,
)

# Register middleware (order matters — outermost first)
app.add_middleware(RequestLoggingMiddleware)
app.add_middleware(APIKeyMiddleware, api_key=settings.mcp_api_key)

# Mount the MCP HTTP app under /mcp
app.mount("/mcp", mcp.streamable_http_app())


@app.get("/health", include_in_schema=False)
async def health_check() -> JSONResponse:
    """Liveness probe for load balancers and container orchestrators."""
    return JSONResponse(
        content={
            "status": "ok",
            "server": settings.server_name,
            "version": settings.server_version,
            "uptime_seconds": round(time.monotonic() - _start_time, 2),
            "timestamp_utc": datetime.now(timezone.utc).isoformat(),
        }
    )


@app.on_event("startup")
async def on_startup() -> None:
    log.info(
        "MCP server starting",
        name=settings.server_name,
        version=settings.server_version,
        host=settings.host,
        port=settings.port,
        log_level=settings.log_level,
    )


@app.on_event("shutdown")
async def on_shutdown() -> None:
    log.info("MCP server shutting down", name=settings.server_name)


# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------

if __name__ == "__main__":
    uvicorn.run(
        "server:app",
        host=settings.host,
        port=settings.port,
        log_level=settings.log_level.lower(),
        reload=settings.log_format == "console",  # Enable reload in dev mode
        access_log=False,  # structlog handles request logging
    )