"""RollCalc's minimal stdio MCP server."""

from __future__ import annotations

from typing import Any

from rollcalc_mcp_tools import (
    analyze_transport_capacity_result,
    calculate_roll_diameter_result,
    get_article_result,
)


def create_server() -> Any:
    """Create the stdio-only MCP server after the SDK is installed."""
    from mcp.server.fastmcp import FastMCP

    server = FastMCP("RollCalc")

    @server.tool()
    def get_article(
        article_number: str | None = None,
        article_name_hint: str | None = None,
    ) -> dict[str, Any]:
        """Resolve RollCalc article master data. article_number is text (including leading zeroes); optional article_name_hint preserves existing conflict and ambiguity checks."""
        return get_article_result(article_number, article_name_hint)

    @server.tool()
    def calculate_roll_diameter(
        roll_length_m: float | None = None,
        core_diameter_mm: float | None = None,
        thickness_mm: float | None = None,
        thickness_stddev_mm: float | None = None,
        article_number: str | None = None,
        article_name_hint: str | None = None,
        core_type: str | None = None,
        width_m: float | None = None,
        area_weight_g_m2: float | None = None,
        include_roll_weight: bool = False,
        category: str | None = None,
        production_site: str | None = None,
    ) -> dict[str, Any]:
        """Calculate roll diameter. roll_length_m is the material length on one roll in m; core_diameter_mm, thickness_mm, and thickness_stddev_mm are mm; width_m is m; and area_weight_g_m2 is g/m². Resolve an article or provide applicable manual material inputs. Set include_roll_weight only to request the existing optional roll_weight_kg result."""
        return calculate_roll_diameter_result(
            article_number=article_number,
            article_name_hint=article_name_hint,
            roll_length_m=roll_length_m,
            width_m=width_m,
            thickness_mm=thickness_mm,
            thickness_stddev_mm=thickness_stddev_mm,
            area_weight_g_m2=area_weight_g_m2,
            core_diameter_mm=core_diameter_mm,
            core_type=core_type,
            category=category,
            production_site=production_site,
            include_roll_weight=include_roll_weight,
        )

    @server.tool()
    def analyze_transport_capacity(
        roll_diameter_mm: float | None = None,
        core_diameter_mm: float | None = None,
        roll_width_m: float | None = None,
        roll_weight_kg: float | None = None,
        product_length_m: float | None = None,
        transport_preset: str | None = None,
        length_m: float | None = None,
        width_m: float | None = None,
        height_m: float | None = None,
        max_weight_kg: float | None = None,
        margin_side_m: float | None = None,
        margin_ceiling_m: float | None = None,
    ) -> dict[str, Any]:
        """Analyze transport capacity. roll_diameter_mm and core_diameter_mm are mm; roll_width_m and product_length_m are m; roll_weight_kg and max_weight_kg are kg. product_length_m is the material length represented by one roll and is used for reported m², not placement geometry. Use a shared transport_preset or supply all custom transport dimensions in m and max_weight_kg. roll_weight_kg is consumed exactly as supplied."""
        return analyze_transport_capacity_result(
            transport_preset=transport_preset,
            length_m=length_m,
            width_m=width_m,
            height_m=height_m,
            max_weight_kg=max_weight_kg,
            margin_side_m=margin_side_m,
            margin_ceiling_m=margin_ceiling_m,
            roll_diameter_mm=roll_diameter_mm,
            core_diameter_mm=core_diameter_mm,
            roll_width_m=roll_width_m,
            roll_weight_kg=roll_weight_kg,
            product_length_m=product_length_m,
        )

    return server


if __name__ == "__main__":
    create_server().run(transport="stdio")