#!/usr/bin/env python3
"""
Hotel MCP Server - Main FastMCP server implementation.

This is the main entry point for the Hotel MCP server. It provides read-only
access to hotel information including rooms, activities, facilities, menus,
and galleries with rich multimedia content and multilingual support.

Usage:
    python hotel_mcp.py                    # Run with stdio transport
    fastmcp run hotel_mcp.py:mcp          # Run with FastMCP CLI
    fastmcp install hotel_mcp.py          # Install in Claude Desktop
"""

import logging
import os
from datetime import datetime
from typing import Optional

from dotenv import load_dotenv
from fastmcp import FastMCP

# Import our custom modules
from src.cache import get_cache_summary
from src.database import DatabaseError, get_database_client
from src.media import ImageSize, MediaFormat, get_media_optimizer
from src.monitoring import get_monitoring_summary
from src.resources import (
    get_category_resource,
    get_hotel_general_info,
    get_search_resource,
)
from src.tools import activities, facilities, galleries, menu, rooms, url_builder
from src.translations import get_translation_engine

# Load environment variables
load_dotenv()

# Configure logging
log_level = os.getenv("LOG_LEVEL", "INFO").upper()
logging.basicConfig(
    level=getattr(logging, log_level),
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger(__name__)

# Initialize FastMCP server
mcp = FastMCP(
    name="Hotel Information Server",
    dependencies=[
        "supabase>=2.0.0",
        "python-dotenv>=1.0.0",
        "pydantic>=2.0.0",
        "httpx>=0.25.0",
    ],
)

# Global configuration
SUPABASE_URL = os.getenv("SUPABASE_URL")
SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
DEFAULT_SITE_ID = os.getenv("DEFAULT_SITE_ID")
DEFAULT_LANGUAGE = os.getenv("DEFAULT_LANGUAGE", "es")
DEBUG = os.getenv("DEBUG", "false").lower() == "true"

# Validate required environment variables
if not SUPABASE_URL:
    raise ValueError("SUPABASE_URL environment variable is required")
if not SUPABASE_ANON_KEY:
    raise ValueError("SUPABASE_ANON_KEY environment variable is required")
if not DEFAULT_SITE_ID:
    raise ValueError("DEFAULT_SITE_ID environment variable is required")

logger.info(f"Hotel MCP Server starting with site_id: {DEFAULT_SITE_ID}")
logger.info(f"Default language: {DEFAULT_LANGUAGE}")
logger.info(f"Debug mode: {DEBUG}")

# Initialize global components
db_client = get_database_client()
translation_engine = get_translation_engine()
media_optimizer = get_media_optimizer()


# Placeholder tools - will be implemented in Phase 2+
@mcp.tool()
def get_server_info() -> dict:
    """Get basic information about the Hotel MCP server."""
    return {
        "name": "Hotel Information Server",
        "version": "0.1.0",
        "description": "Read-only access to hotel information with rich media",
        "site_id": DEFAULT_SITE_ID,
        "default_language": DEFAULT_LANGUAGE,
        "supported_languages": ["es", "en", "fr", "ca"],
        "available_tools": [
            "get_server_info",
            "health_check",
            "test_database_connection",
            "get_translation_info",
            "get_media_optimization_info",
            # Phase 3: Room tools
            "list_rooms",
            "get_room_details",
            "search_rooms",
            # Phase 4: Activity tools
            "list_activities",
            "get_activity_details",
            "search_activities",
            # Phase 5: Facility tools
            "list_facilities",
            "get_facility_details",
            "search_facilities",
            # Phase 6: Menu tools
            "list_menu_items",
            "get_menu_item_details",
            "search_menu_items",
            # Phase 7: Gallery tools
            "list_galleries",
            "get_gallery_details",
            "search_galleries",
            # Phase 8: Intelligent URL Builder tools
            "build_url",
            "parse_url",
            "encode_url_component",
            "decode_url_component",
            "build_url_from_template",
            "validate_url",
            # Intelligent hotel-specific tools
            "build_hotel_reservation_url",
            "build_room_reservation_url_from_search",
            "build_multiple_reservation_urls",
            # More tools will be added in subsequent phases
        ],
        "status": "Phase 8 - Intelligent URL Builder Tools Complete",
    }


@mcp.tool()
def health_check() -> dict:
    """Check the health status of the server and its connections."""
    try:
        from datetime import datetime

        # Test database connection
        db_status = "unknown"
        db_error = None
        try:
            db_client.test_connection()
            db_status = "connected"
        except Exception as e:
            db_status = "error"
            db_error = str(e)

        # Check component status
        components_status = {
            "database": db_status,
            "translation_engine": "initialized",
            "media_optimizer": "initialized",
        }

        overall_status = "healthy" if db_status == "connected" else "degraded"

        return {
            "status": overall_status,
            "timestamp": datetime.now().isoformat(),
            "environment": {
                "supabase_configured": bool(SUPABASE_URL and SUPABASE_ANON_KEY),
                "site_id_configured": bool(DEFAULT_SITE_ID),
                "debug_mode": DEBUG,
            },
            "components": components_status,
            "database_error": db_error,
            "message": f"Server is running - Phase 2 implementation ({overall_status})",
        }
    except Exception as e:
        logger.error(f"Health check failed: {e}")
        return {
            "status": "unhealthy",
            "error": str(e),
            "timestamp": datetime.now().isoformat(),
        }


@mcp.tool()
def test_database_connection() -> dict:
    """Test the database connection and return connection details."""
    try:
        # Test connection
        success = db_client.test_connection()

        return {
            "connection_status": "success" if success else "failed",
            "database_url": (
                SUPABASE_URL[:30] + "..." if SUPABASE_URL else "Not configured"
            ),
            "message": "Database connection test completed",
            "timestamp": datetime.now().isoformat(),
        }
    except DatabaseError as e:
        return {
            "connection_status": "error",
            "error": str(e),
            "message": "Database connection failed",
            "timestamp": datetime.now().isoformat(),
        }


@mcp.tool()
def get_translation_info() -> dict:
    """Get information about the translation engine."""
    return {
        "supported_languages": translation_engine.get_supported_languages(),
        "default_language": translation_engine.config.default_language.value,
        "fallback_language": translation_engine.config.fallback_language.value,
        "translatable_fields": translation_engine.config.translatable_fields,
        "status": "initialized",
    }


@mcp.tool()
def get_media_optimization_info() -> dict:
    """Get information about media optimization settings."""
    return {
        "optimization_enabled": media_optimizer.config.enable_optimization,
        "default_format": media_optimizer.config.default_format.value,
        "default_size": media_optimizer.config.default_size.value,
        "quality": media_optimizer.config.quality,
        "base_url": media_optimizer.config.base_url or "Not configured",
        "supported_formats": [fmt.value for fmt in MediaFormat],
        "available_sizes": [size.value for size in ImageSize],
        "status": "initialized",
    }


# Phase 3: Room and Suite Tools
@mcp.tool()
def list_rooms(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> dict:
    """
    List all available hotel rooms and suites.

    Args:
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of rooms to return (default: 20, max: 50)
        offset: Number of rooms to skip for pagination (default: 0)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return rooms.list_rooms(
        site_id=effective_site_id, language=language, limit=limit, offset=offset
    )


@mcp.tool()
def get_room_details(
    room_id: str, language: Optional[str] = None, include_gallery: bool = True
) -> dict:
    """
    Get detailed information about a specific room or suite.

    Args:
        room_id: Unique identifier for the room (required)
        language: Language for translations (es, en, fr, ca)
        include_gallery: Whether to include gallery images (default: True)
    """
    return rooms.get_room_details(
        room_id=room_id, language=language, include_gallery=include_gallery
    )


@mcp.tool()
def search_rooms(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 10,
) -> dict:
    """
    Search for rooms based on a text query.

    Args:
        query: Search query (room name, description, amenities) (required)
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of results (default: 10, max: 20)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return rooms.search_rooms(
        query=query, site_id=effective_site_id, language=language, limit=limit
    )


# Phase 4: Activity Tools
@mcp.tool()
def list_activities(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> dict:
    """
    List all available hotel activities.

    Args:
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of activities to return (default: 20, max: 50)
        offset: Number of activities to skip for pagination (default: 0)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return activities.list_activities(
        site_id=effective_site_id, language=language, limit=limit, offset=offset
    )


@mcp.tool()
def get_activity_details(
    activity_id: str,
    language: Optional[str] = None,
    include_pricing: bool = True,
) -> dict:
    """
    Get detailed information about a specific activity.

    Args:
        activity_id: Unique identifier for the activity (required)
        language: Language for translations (es, en, fr, ca)
        include_pricing: Whether to include pricing information (default: True)
    """
    return activities.get_activity_details(
        activity_id=activity_id, language=language, include_pricing=include_pricing
    )


@mcp.tool()
def search_activities(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 10,
) -> dict:
    """
    Search for activities based on a text query.

    Args:
        query: Search query (activity name, description, type) (required)
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of results (default: 10, max: 20)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return activities.search_activities(
        query=query, site_id=effective_site_id, language=language, limit=limit
    )


# Phase 5: Facility Tools
@mcp.tool()
def list_facilities(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> dict:
    """
    List all available hotel facilities.

    Args:
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of facilities to return (default: 20, max: 50)
        offset: Number of facilities to skip for pagination (default: 0)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return facilities.list_facilities(
        site_id=effective_site_id, language=language, limit=limit, offset=offset
    )


@mcp.tool()
def get_facility_details(
    facility_id: str,
    language: Optional[str] = None,
    include_hours: bool = True,
) -> dict:
    """
    Get detailed information about a specific facility.

    Args:
        facility_id: Unique identifier for the facility (required)
        language: Language for translations (es, en, fr, ca)
        include_hours: Whether to include operating hours information (default: True)
    """
    return facilities.get_facility_details(
        facility_id=facility_id, language=language, include_hours=include_hours
    )


@mcp.tool()
def search_facilities(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 10,
) -> dict:
    """
    Search for facilities based on a text query.

    Args:
        query: Search query (facility name, description, type) (required)
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of results (default: 10, max: 20)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return facilities.search_facilities(
        query=query, site_id=effective_site_id, language=language, limit=limit
    )


# Phase 6: Menu Tools
@mcp.tool()
def list_menu_items(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    dietary_restrictions: Optional[list] = None,
    limit: int = 20,
    offset: int = 0,
) -> dict:
    """
    List all available menu items.

    Args:
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        dietary_restrictions: Filter by dietary restrictions (vegetarian, vegan, gluten-free, etc.)
        limit: Maximum number of menu items to return (default: 20, max: 50)
        offset: Number of menu items to skip for pagination (default: 0)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return menu.list_menu_items(
        site_id=effective_site_id,
        language=language,
        dietary_restrictions=dietary_restrictions,
        limit=limit,
        offset=offset,
    )


@mcp.tool()
def get_menu_item_details(
    menu_item_id: str,
    language: Optional[str] = None,
    include_nutrition: bool = True,
) -> dict:
    """
    Get detailed information about a specific menu item.

    Args:
        menu_item_id: Unique identifier for the menu item (required)
        language: Language for translations (es, en, fr, ca)
        include_nutrition: Whether to include nutritional information (default: True)
    """
    return menu.get_menu_item_details(
        menu_item_id=menu_item_id,
        language=language,
        include_nutrition=include_nutrition,
    )


@mcp.tool()
def search_menu_items(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    dietary_restrictions: Optional[list] = None,
    limit: int = 10,
) -> dict:
    """
    Search for menu items based on a text query.

    Args:
        query: Search query (item name, description, ingredients) (required)
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        dietary_restrictions: Filter by dietary restrictions (optional)
        limit: Maximum number of results (default: 10, max: 20)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return menu.search_menu_items(
        query=query,
        site_id=effective_site_id,
        language=language,
        dietary_restrictions=dietary_restrictions,
        limit=limit,
    )


# Phase 7: Gallery Tools
@mcp.tool()
def list_galleries(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> dict:
    """
    List all available photo galleries.

    Args:
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of galleries to return (default: 20, max: 50)
        offset: Number of galleries to skip for pagination (default: 0)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return galleries.list_galleries(
        site_id=effective_site_id, language=language, limit=limit, offset=offset
    )


@mcp.tool()
def get_gallery_details(
    gallery_id: str,
    language: Optional[str] = None,
    include_metadata: bool = True,
) -> dict:
    """
    Get detailed information about a specific gallery.

    Args:
        gallery_id: Unique identifier for the gallery (required)
        language: Language for translations (es, en, fr, ca)
        include_metadata: Whether to include photo metadata (default: True)
    """
    return galleries.get_gallery_details(
        gallery_id=gallery_id, language=language, include_metadata=include_metadata
    )


@mcp.tool()
def search_galleries(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 10,
) -> dict:
    """
    Search for galleries based on a text query.

    Args:
        query: Search query (gallery name, description, tags) (required)
        site_id: Filter by specific hotel site (optional, defaults to DEFAULT_SITE_ID)
        language: Language for translations (es, en, fr, ca)
        limit: Maximum number of results (default: 10, max: 20)
    """
    # Use default site_id if not provided
    effective_site_id = site_id or DEFAULT_SITE_ID

    return galleries.search_galleries(
        query=query, site_id=effective_site_id, language=language, limit=limit
    )


# Phase 8: MCP Resources - Intelligent data access using existing tools
@mcp.resource("hotel://info/general/{site_id}")
def get_general_info(site_id: str) -> str:
    """Get comprehensive hotel information as a resource."""
    # Use default site_id if not provided or invalid
    effective_site_id = site_id or DEFAULT_SITE_ID
    return get_hotel_general_info(site_id=effective_site_id, language=DEFAULT_LANGUAGE)


@mcp.resource("hotel://info/general/{site_id}/{language}")
def get_general_info_with_language(site_id: str, language: str) -> str:
    """Get comprehensive hotel information in specific language as a resource."""
    effective_site_id = site_id or DEFAULT_SITE_ID
    return get_hotel_general_info(site_id=effective_site_id, language=language)


@mcp.resource("hotel://category/{category}/{site_id}")
def get_category_info(category: str, site_id: str) -> str:
    """Get detailed information for a specific category as a resource."""
    effective_site_id = site_id or DEFAULT_SITE_ID
    return get_category_resource(
        category=category, site_id=effective_site_id, language=DEFAULT_LANGUAGE
    )


@mcp.resource("hotel://category/{category}/{site_id}/{language}")
def get_category_info_with_language(category: str, site_id: str, language: str) -> str:
    """Get detailed category information in specific language as a resource."""
    effective_site_id = site_id or DEFAULT_SITE_ID
    return get_category_resource(
        category=category, site_id=effective_site_id, language=language
    )


@mcp.resource("hotel://search/{query}/{site_id}")
def get_search_results(query: str, site_id: str) -> str:
    """Get search results across all categories as a resource."""
    effective_site_id = site_id or DEFAULT_SITE_ID
    return get_search_resource(
        query=query, site_id=effective_site_id, language=DEFAULT_LANGUAGE
    )


@mcp.resource("hotel://search/{query}/{site_id}/{language}")
def get_search_results_with_language(query: str, site_id: str, language: str) -> str:
    """Get search results in specific language as a resource."""
    effective_site_id = site_id or DEFAULT_SITE_ID
    return get_search_resource(
        query=query, site_id=effective_site_id, language=language
    )


# Phase 8: URL Builder Tools
@mcp.tool()
def build_url(
    base_url: str,
    path: Optional[str] = None,
    query_params: Optional[dict] = None,
    fragment: Optional[str] = None,
    encode_params: bool = True,
) -> dict:
    """
    Build a complete URL from components.

    Args:
        base_url: The base URL (required)
        path: Additional path to append to base URL
        query_params: Dictionary of query parameters
        fragment: URL fragment (anchor)
        encode_params: Whether to URL encode query parameters

    Returns:
        Dictionary containing the built URL and components
    """
    return url_builder.build_url(
        base_url=base_url,
        path=path,
        query_params=query_params,
        fragment=fragment,
        encode_params=encode_params,
    )


@mcp.tool()
def parse_url(url: str) -> dict:
    """
    Parse a URL into its components.

    Args:
        url: The URL to parse (required)

    Returns:
        Dictionary containing parsed URL components
    """
    return url_builder.parse_url(url=url)


@mcp.tool()
def encode_url_component(
    text: str, component_type: str = "query", safe_chars: Optional[str] = None
) -> dict:
    """
    URL encode a text component.

    Args:
        text: Text to encode (required)
        component_type: Type of component (query, path, fragment)
        safe_chars: Characters to not encode (optional)

    Returns:
        Dictionary containing encoded text and details
    """
    return url_builder.encode_url_component(
        text=text,
        component_type=component_type,
        safe_chars=safe_chars,
    )


@mcp.tool()
def decode_url_component(encoded_text: str, component_type: str = "query") -> dict:
    """
    URL decode a text component.

    Args:
        encoded_text: Encoded text to decode (required)
        component_type: Type of component (query, path, fragment)

    Returns:
        Dictionary containing decoded text and details
    """
    return url_builder.decode_url_component(
        encoded_text=encoded_text,
        component_type=component_type,
    )


@mcp.tool()
def build_url_from_template(
    template: str,
    path_params: Optional[dict] = None,
    query_params: Optional[dict] = None,
) -> dict:
    """
    Build URL from a template with path parameter substitution.

    Args:
        template: URL template with {param} placeholders (required)
        path_params: Dictionary of path parameters to substitute
        query_params: Dictionary of query parameters to add

    Returns:
        Dictionary containing the built URL and substitution details
    """
    return url_builder.build_url_from_template(
        template=template,
        path_params=path_params,
        query_params=query_params,
    )


@mcp.tool()
def validate_url(url: str, allowed_schemes: Optional[list] = None) -> dict:
    """
    Validate a URL and check its components.

    Args:
        url: URL to validate (required)
        allowed_schemes: List of allowed schemes (default: ['http', 'https'])

    Returns:
        Dictionary containing validation results
    """
    return url_builder.validate_url(
        url=url,
        allowed_schemes=allowed_schemes,
    )


# Intelligent Hotel-Specific URL Builder Tools
@mcp.tool()
def build_hotel_reservation_url(
    domain: Optional[str] = None,
    room_id: Optional[str] = None,
    check_in: Optional[str] = None,
    check_out: Optional[str] = None,
    adults: int = 2,
    children: int = 0,
    guest_name: Optional[str] = None,
    guest_email: Optional[str] = None,
    guest_phone: Optional[str] = None,
    language: Optional[str] = None,
) -> dict:
    """
    Build intelligent hotel reservation URL using real room data.

    ⚠️  CRITICAL: This tool REQUIRES roomType for the reservation form to work!

    The roomType parameter is ESSENTIAL for the hotel website to display the
    reservation form. Without it, visitors will see an empty page.

    This tool integrates with hotel MCP data to generate URLs for the
    /accommodation/reservations page with proper query parameters.

    Args:
        domain: The hotel website domain (e.g., "https://hotel.com").
                If not provided, uses HOTEL_BASE_URL environment variable.
                Domain is required - either as parameter or environment variable.
        room_id: Room ID to get real data from MCP (REQUIRED for roomType)
        check_in: Check-in date in YYYY-MM-DD format (optional)
        check_out: Check-out date in YYYY-MM-DD format (optional)
        adults: Number of adult guests (default: 2)
        children: Number of children (default: 0)
        guest_name: Guest name for pre-filling form (optional)
        guest_email: Guest email for pre-filling form (optional)
        guest_phone: Guest phone for pre-filling form (optional)
        language: Language for room data - es, en, fr, ca (optional)

    Returns:
        Dictionary containing the built reservation URL and metadata

    Note: Will raise error if room_id is not provided or room has no slug
    """
    return url_builder.build_hotel_reservation_url(
        domain=domain,
        room_id=room_id,
        check_in=check_in,
        check_out=check_out,
        adults=adults,
        children=children,
        guest_name=guest_name,
        guest_email=guest_email,
        guest_phone=guest_phone,
        language=language,
    )


@mcp.tool()
def build_room_reservation_url_from_search(
    search_query: str,
    domain: Optional[str] = None,
    check_in: Optional[str] = None,
    check_out: Optional[str] = None,
    adults: int = 2,
    children: int = 0,
    language: Optional[str] = None,
    site_id: Optional[str] = None,
) -> dict:
    """
    Build reservation URL by searching for rooms and using the best match.

    This tool searches the hotel's room inventory and generates a reservation
    URL for the best matching room.

    Args:
        search_query: Search query to find matching rooms (required)
        domain: The hotel website domain. If not provided, uses HOTEL_BASE_URL environment variable.
                Domain is required - either as parameter or environment variable.
        check_in: Check-in date in YYYY-MM-DD format (optional)
        check_out: Check-out date in YYYY-MM-DD format (optional)
        adults: Number of adult guests (default: 2)
        children: Number of children (default: 0)
        language: Language for search and room data (optional)
        site_id: Hotel site ID for filtering (optional)

    Returns:
        Dictionary with reservation URL and search results
    """
    return url_builder.build_room_reservation_url_from_search(
        search_query=search_query,
        domain=domain,
        check_in=check_in,
        check_out=check_out,
        adults=adults,
        children=children,
        language=language,
        site_id=site_id,
    )


@mcp.tool()
def build_multiple_reservation_urls(
    domain: Optional[str] = None,
    room_ids: Optional[list] = None,
    check_in: Optional[str] = None,
    check_out: Optional[str] = None,
    adults: int = 2,
    children: int = 0,
    language: Optional[str] = None,
    site_id: Optional[str] = None,
    limit: int = 10,
) -> dict:
    """
    Build multiple reservation URLs for different rooms.

    This tool generates reservation URLs for multiple rooms, either from
    a provided list of room IDs or by fetching available rooms.

    Args:
        domain: The hotel website domain. If not provided, uses HOTEL_BASE_URL environment variable.
                Domain is required - either as parameter or environment variable.
        room_ids: List of specific room IDs (optional)
        check_in: Check-in date in YYYY-MM-DD format (optional)
        check_out: Check-out date in YYYY-MM-DD format (optional)
        adults: Number of adult guests (default: 2)
        children: Number of children (default: 0)
        language: Language for room data (optional)
        site_id: Hotel site ID for filtering (optional)
        limit: Maximum number of URLs to generate (default: 10)

    Returns:
        Dictionary with multiple reservation URLs
    """
    return url_builder.build_multiple_reservation_urls(
        domain=domain,
        room_ids=room_ids,
        check_in=check_in,
        check_out=check_out,
        adults=adults,
        children=children,
        language=language,
        site_id=site_id,
        limit=limit,
    )


# Phase 12: Monitoring and Performance Tools
@mcp.tool()
def get_performance_metrics() -> dict:
    """Get comprehensive performance metrics and monitoring data."""
    try:
        monitoring_data = get_monitoring_summary()
        cache_data = get_cache_summary()

        return {
            "timestamp": datetime.now().isoformat(),
            "monitoring": monitoring_data,
            "cache": cache_data,
            "status": "operational",
            "message": "Performance metrics retrieved successfully",
        }
    except Exception as e:
        logger.error(f"Error getting performance metrics: {e}")
        return {
            "timestamp": datetime.now().isoformat(),
            "error": str(e),
            "status": "error",
            "message": "Failed to retrieve performance metrics",
        }


@mcp.tool()
def get_cache_statistics() -> dict:
    """Get detailed cache performance statistics."""
    try:
        cache_stats = get_cache_summary()

        return {
            "timestamp": datetime.now().isoformat(),
            "cache_performance": cache_stats,
            "recommendations": _get_cache_recommendations(cache_stats),
            "status": "operational",
            "message": "Cache statistics retrieved successfully",
        }
    except Exception as e:
        logger.error(f"Error getting cache statistics: {e}")
        return {
            "timestamp": datetime.now().isoformat(),
            "error": str(e),
            "status": "error",
            "message": "Failed to retrieve cache statistics",
        }


def _get_cache_recommendations(cache_stats: dict) -> list:
    """Generate cache optimization recommendations."""
    recommendations = []

    if "cache_stats" in cache_stats:
        stats = cache_stats["cache_stats"]
        hit_rate = stats.get("hit_rate", 0)

        if hit_rate < 0.5:
            recommendations.append("Consider increasing cache TTL for better hit rates")
        elif hit_rate > 0.9:
            recommendations.append(
                "Excellent cache performance - consider expanding cache size"
            )

        if stats.get("size", 0) > stats.get("max_size", 1000) * 0.9:
            recommendations.append(
                "Cache is near capacity - consider increasing max_size"
            )

    if not recommendations:
        recommendations.append("Cache performance is optimal")

    return recommendations


if __name__ == "__main__":
    logger.info("Starting Hotel MCP Server...")
    mcp.run()