"""
Menu Tools for Hotel MCP Server.

This module provides MCP tools for accessing hotel menu and dining information
with rich media content, multilingual support, and dietary restriction filtering.
"""

import logging
from typing import Any, Dict, List, Optional

from ..database import DatabaseError, get_database_client
from ..media import get_media_optimizer
from ..translations import get_translation_engine

logger = logging.getLogger(__name__)


def list_menu_items(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    dietary_restrictions: Optional[List[str]] = None,
    limit: int = 20,
    offset: int = 0,
) -> Dict[str, Any]:
    """
    List all available menu items.

    Args:
        site_id: Filter by specific hotel site (optional)
        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)

    Returns:
        Dictionary containing menu items list and metadata
    """
    try:
        # Validate and sanitize inputs
        limit = min(max(1, limit), 50)  # Ensure limit is between 1 and 50
        offset = max(0, offset)  # Ensure offset is non-negative

        # Get database client and fetch menu items
        db_client = get_database_client()
        menu_data = db_client.get_menu_items(
            site_id=site_id,
            dietary_restrictions=dietary_restrictions,
            limit=limit,
            offset=offset,
        )

        if not menu_data:
            return {
                "menu_items": [],
                "total_count": 0,
                "message": "No menu items found",
                "pagination": {"limit": limit, "offset": offset, "has_more": False},
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_menu = translation_engine.translate_records(
            menu_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_menu = media_optimizer.optimize_records_media(translated_menu)

        # Prepare response
        has_more = len(optimized_menu) == limit
        response = {
            "menu_items": optimized_menu,
            "total_count": len(optimized_menu),
            "message": f"Found {len(optimized_menu)} menu items",
            "pagination": {"limit": limit, "offset": offset, "has_more": has_more},
            "filters": {
                "site_id": site_id,
                "language": translation_engine.normalize_language(language),
                "dietary_restrictions": dietary_restrictions,
            },
        }

        logger.info(
            f"Listed {len(optimized_menu)} menu items for site_id={site_id}, language={language}"
        )
        return response

    except DatabaseError as e:
        logger.error(f"Database error in list_menu_items: {e}")
        return {
            "menu_items": [],
            "total_count": 0,
            "error": f"Database error: {e}",
            "message": "Failed to retrieve menu items due to database error",
        }
    except Exception as e:
        logger.error(f"Unexpected error in list_menu_items: {e}")
        return {
            "menu_items": [],
            "total_count": 0,
            "error": f"Unexpected error: {e}",
            "message": "Failed to retrieve menu items due to unexpected error",
        }


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

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

    Returns:
        Dictionary containing detailed menu item information
    """
    try:
        # Validate inputs
        if not menu_item_id or not menu_item_id.strip():
            return {
                "menu_item": None,
                "error": "Menu item ID is required",
                "message": "Please provide a valid menu item ID",
            }

        menu_item_id = menu_item_id.strip()

        # Get database client and fetch menu item details
        db_client = get_database_client()
        menu_item_data = db_client.get_menu_item_by_id(menu_item_id)

        if not menu_item_data:
            return {
                "menu_item": None,
                "error": "Menu item not found",
                "message": f"No menu item found with ID: {menu_item_id}",
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_menu_item = translation_engine.translate_record(
            menu_item_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_menu_item = media_optimizer.optimize_record_media(
            translated_menu_item
        )

        # Add additional menu item metadata
        optimized_menu_item["_menu_item_meta"] = {
            "menu_item_id": menu_item_id,
            "language": translation_engine.normalize_language(language),
            "include_nutrition": include_nutrition,
            "available_translations": translation_engine.get_available_translations(
                menu_item_data, "name"
            ),
            "translation_completeness": translation_engine.get_translation_completeness(
                menu_item_data
            ),
        }

        # Handle nutritional information
        if not include_nutrition:
            # Remove nutrition fields if not requested
            nutrition_fields = [
                "calories",
                "protein",
                "carbs",
                "fat",
                "nutrition",
                "allergens",
            ]
            for field in nutrition_fields:
                if field in optimized_menu_item:
                    del optimized_menu_item[field]
            optimized_menu_item["_menu_item_meta"]["nutrition_removed"] = True

        response = {
            "menu_item": optimized_menu_item,
            "message": "Menu item details retrieved successfully",
            "menu_item_id": menu_item_id,
        }

        logger.info(
            f"Retrieved details for menu item {menu_item_id}, language={language}"
        )
        return response

    except DatabaseError as e:
        logger.error(f"Database error in get_menu_item_details: {e}")
        return {
            "menu_item": None,
            "error": f"Database error: {e}",
            "message": "Failed to retrieve menu item details due to database error",
        }
    except Exception as e:
        logger.error(f"Unexpected error in get_menu_item_details: {e}")
        return {
            "menu_item": None,
            "error": f"Unexpected error: {e}",
            "message": "Failed to retrieve menu item details due to unexpected error",
        }


def search_menu_items(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    dietary_restrictions: Optional[List[str]] = None,
    limit: int = 10,
) -> Dict[str, Any]:
    """
    Search for menu items based on a text query.

    Args:
        query: Search query (item name, description, ingredients)
        site_id: Filter by specific hotel site (optional)
        language: Language for translations (es, en, fr, ca)
        dietary_restrictions: Filter by dietary restrictions (optional)
        limit: Maximum number of results (default: 10, max: 20)

    Returns:
        Dictionary containing search results and metadata
    """
    try:
        # Validate inputs
        if not query or not query.strip():
            return {
                "menu_items": [],
                "total_count": 0,
                "error": "Search query is required",
                "message": "Please provide a search query",
            }

        query = query.strip()
        limit = min(max(1, limit), 20)  # Ensure limit is between 1 and 20

        # Get all menu items for searching
        db_client = get_database_client()
        all_menu_items = db_client.get_menu_items(
            site_id=site_id, dietary_restrictions=dietary_restrictions, limit=100
        )

        # Apply translations first for better search
        translation_engine = get_translation_engine()
        translated_menu_items = translation_engine.translate_records(
            all_menu_items, target_language=language
        )

        # Simple text search in name, description, and ingredients
        query_lower = query.lower()
        matching_menu_items = []

        for menu_item in translated_menu_items:
            # Search in name, description, and ingredients fields
            name = str(menu_item.get("name", "")).lower()
            description = str(menu_item.get("description", "")).lower()
            ingredients = str(menu_item.get("ingredients", "")).lower()
            category = str(menu_item.get("category", "")).lower()

            if (
                query_lower in name
                or query_lower in description
                or query_lower in ingredients
                or query_lower in category
            ):
                matching_menu_items.append(menu_item)

            if len(matching_menu_items) >= limit:
                break

        # Optimize media URLs for results
        media_optimizer = get_media_optimizer()
        optimized_menu_items = media_optimizer.optimize_records_media(
            matching_menu_items
        )

        response = {
            "menu_items": optimized_menu_items,
            "total_count": len(optimized_menu_items),
            "message": f"Found {len(optimized_menu_items)} menu items matching '{query}'",
            "search": {
                "query": query,
                "site_id": site_id,
                "language": translation_engine.normalize_language(language),
                "dietary_restrictions": dietary_restrictions,
                "limit": limit,
            },
        }

        logger.info(
            f"Search for '{query}' returned {len(optimized_menu_items)} menu item results"
        )
        return response

    except DatabaseError as e:
        logger.error(f"Database error in search_menu_items: {e}")
        return {
            "menu_items": [],
            "total_count": 0,
            "error": f"Database error: {e}",
            "message": "Failed to search menu items due to database error",
        }
    except Exception as e:
        logger.error(f"Unexpected error in search_menu_items: {e}")
        return {
            "menu_items": [],
            "total_count": 0,
            "error": f"Unexpected error: {e}",
            "message": "Failed to search menu items due to unexpected error",
        }