"""
Facility Tools for Hotel MCP Server.

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

import logging
from typing import Any, Dict, 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_facilities(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> Dict[str, Any]:
    """
    List all available hotel facilities.

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

    Returns:
        Dictionary containing facilities 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 facilities
        db_client = get_database_client()
        facilities_data = db_client.get_facilities(
            site_id=site_id, limit=limit, offset=offset
        )

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

        # Apply translations
        translation_engine = get_translation_engine()
        translated_facilities = translation_engine.translate_records(
            facilities_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_facilities = media_optimizer.optimize_records_media(
            translated_facilities
        )

        # Prepare response
        has_more = len(optimized_facilities) == limit
        response = {
            "facilities": optimized_facilities,
            "total_count": len(optimized_facilities),
            "message": f"Found {len(optimized_facilities)} facilities",
            "pagination": {"limit": limit, "offset": offset, "has_more": has_more},
            "filters": {
                "site_id": site_id,
                "language": translation_engine.normalize_language(language),
            },
        }

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

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


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

    Args:
        facility_id: Unique identifier for the facility
        language: Language for translations (es, en, fr, ca)
        include_hours: Whether to include operating hours information (default: True)

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

        facility_id = facility_id.strip()

        # Get database client and fetch facility details
        db_client = get_database_client()
        facility_data = db_client.get_facility_by_id(facility_id)

        if not facility_data:
            return {
                "facility": None,
                "error": "Facility not found",
                "message": f"No facility found with ID: {facility_id}",
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_facility = translation_engine.translate_record(
            facility_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_facility = media_optimizer.optimize_record_media(translated_facility)

        # Add additional facility metadata
        optimized_facility["_facility_meta"] = {
            "facility_id": facility_id,
            "language": translation_engine.normalize_language(language),
            "include_hours": include_hours,
            "available_translations": translation_engine.get_available_translations(
                facility_data, "name"
            ),
            "translation_completeness": translation_engine.get_translation_completeness(
                facility_data
            ),
        }

        # Handle operating hours information
        if not include_hours:
            # Remove hours fields if not requested
            hours_fields = ["hours", "operating_hours", "schedule", "availability"]
            for field in hours_fields:
                if field in optimized_facility:
                    del optimized_facility[field]
            optimized_facility["_facility_meta"]["hours_removed"] = True

        response = {
            "facility": optimized_facility,
            "message": "Facility details retrieved successfully",
            "facility_id": facility_id,
        }

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

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


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

    Args:
        query: Search query (facility name, description, type)
        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 {
                "facilities": [],
                "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 facilities for searching
        db_client = get_database_client()
        all_facilities = db_client.get_facilities(site_id=site_id, limit=100)

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

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

        for facility in translated_facilities:
            # Search in name, description, and type fields
            name = str(facility.get("name", "")).lower()
            description = str(facility.get("description", "")).lower()
            facility_type = str(facility.get("type", "")).lower()

            if (
                query_lower in name
                or query_lower in description
                or query_lower in facility_type
            ):
                matching_facilities.append(facility)

            if len(matching_facilities) >= limit:
                break

        # Optimize media URLs for results
        media_optimizer = get_media_optimizer()
        optimized_facilities = media_optimizer.optimize_records_media(
            matching_facilities
        )

        response = {
            "facilities": optimized_facilities,
            "total_count": len(optimized_facilities),
            "message": f"Found {len(optimized_facilities)} facilities 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_facilities)} facility results"
        )
        return response

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