"""
Room and Suite Tools for Hotel MCP Server.

This module provides MCP tools for accessing hotel room and suite information
with rich media content, multilingual support, and optimized performance.
"""

import logging
from typing import Any, Dict, Optional

from ..cache import cache_by_site_and_language
from ..database import DatabaseError, get_database_client
from ..media import get_media_optimizer
from ..monitoring import performance_monitor
from ..translations import get_translation_engine

logger = logging.getLogger(__name__)


@performance_monitor("list_rooms")
@cache_by_site_and_language(ttl=300)  # Cache for 5 minutes
def list_rooms(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> Dict[str, Any]:
    """
    List all available hotel rooms and suites.

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

    Returns:
        Dictionary containing rooms 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 rooms
        db_client = get_database_client()
        rooms_data = db_client.get_suites(site_id=site_id, limit=limit, offset=offset)

        if not rooms_data:
            return {
                "rooms": [],
                "total_count": 0,
                "message": "No rooms found",
                "pagination": {"limit": limit, "offset": offset, "has_more": False},
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_rooms = translation_engine.translate_records(
            rooms_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_rooms = media_optimizer.optimize_records_media(translated_rooms)

        # Prepare response
        response = {
            "rooms": optimized_rooms,
            "total_count": len(optimized_rooms),
            "message": f"Found {len(optimized_rooms)} rooms",
            "pagination": {
                "limit": limit,
                "offset": offset,
                "has_more": len(optimized_rooms)
                == limit,  # Assume more if we got full page
            },
            "filters": {
                "site_id": site_id,
                "language": translation_engine.normalize_language(language),
            },
        }

        logger.info(
            f"Listed {len(optimized_rooms)} rooms for site_id={site_id}, language={language}"
        )
        return response

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


@performance_monitor("get_room_details")
@cache_by_site_and_language(ttl=600)  # Cache for 10 minutes
def get_room_details(
    room_id: str, language: Optional[str] = None, include_gallery: bool = True
) -> Dict[str, Any]:
    """
    Get detailed information about a specific room or suite.

    Args:
        room_id: Unique identifier for the room
        language: Language for translations (es, en, fr, ca)
        include_gallery: Whether to include gallery images (default: True)

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

        room_id = room_id.strip()

        # Get database client and fetch room details
        db_client = get_database_client()
        room_data = db_client.get_suite_by_id(room_id)

        if not room_data:
            return {
                "room": None,
                "error": "Room not found",
                "message": f"No room found with ID: {room_id}",
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_room = translation_engine.translate_record(
            room_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_room = media_optimizer.optimize_record_media(translated_room)

        # Add additional room metadata
        optimized_room["_room_meta"] = {
            "room_id": room_id,
            "language": translation_engine.normalize_language(language),
            "include_gallery": include_gallery,
            "available_translations": translation_engine.get_available_translations(
                room_data, "name"
            ),
            "translation_completeness": translation_engine.get_translation_completeness(
                room_data
            ),
        }

        # If gallery is requested and not already included, fetch it
        if include_gallery and "gallery" not in optimized_room:
            try:
                # This would fetch related gallery images
                # For now, we'll add a placeholder
                optimized_room["gallery"] = []
                optimized_room["_room_meta"][
                    "gallery_note"
                ] = "Gallery fetching not yet implemented"
            except Exception as e:
                logger.warning(f"Failed to fetch gallery for room {room_id}: {e}")
                optimized_room["_room_meta"]["gallery_error"] = str(e)

        response = {
            "room": optimized_room,
            "message": "Room details retrieved successfully",
            "room_id": room_id,
        }

        logger.info(f"Retrieved details for room {room_id}, language={language}")
        return response

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


@performance_monitor("search_rooms")
@cache_by_site_and_language(ttl=180)  # Cache for 3 minutes
def search_rooms(
    query: str,
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 10,
) -> Dict[str, Any]:
    """
    Search for rooms based on a text query.

    Args:
        query: Search query (room name, description, amenities)
        site_id: Filter by specific hotel site (optional)
        language: Language for translations (es, en, fr, ca)
        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 {
                "rooms": [],
                "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

        # For now, we'll implement a simple search by getting all rooms and filtering
        # In a production system, this would use database full-text search
        db_client = get_database_client()
        all_rooms = db_client.get_suites(
            site_id=site_id, limit=100
        )  # Get more for searching

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

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

        for room in translated_rooms:
            # Search in name and description
            name = str(room.get("name", "")).lower()
            description = str(room.get("description", "")).lower()

            if query_lower in name or query_lower in description:
                matching_rooms.append(room)

            if len(matching_rooms) >= limit:
                break

        # Optimize media URLs for results
        media_optimizer = get_media_optimizer()
        optimized_rooms = media_optimizer.optimize_records_media(matching_rooms)

        response = {
            "rooms": optimized_rooms,
            "total_count": len(optimized_rooms),
            "message": f"Found {len(optimized_rooms)} rooms matching '{query}'",
            "search": {
                "query": query,
                "site_id": site_id,
                "language": translation_engine.normalize_language(language),
                "limit": limit,
            },
        }

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

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