"""
Gallery Tools for Hotel MCP Server.

This module provides MCP tools for accessing hotel photo galleries and media content
with rich media optimization, multilingual support, and advanced filtering.
"""

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_galleries(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> Dict[str, Any]:
    """
    List all available photo galleries.

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

    Returns:
        Dictionary containing galleries 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 galleries
        db_client = get_database_client()
        galleries_data = db_client.get_galleries(
            site_id=site_id, limit=limit, offset=offset
        )

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

        # Apply translations
        translation_engine = get_translation_engine()
        translated_galleries = translation_engine.translate_records(
            galleries_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_galleries = media_optimizer.optimize_records_media(
            translated_galleries
        )

        # Prepare response
        has_more = len(optimized_galleries) == limit
        response = {
            "galleries": optimized_galleries,
            "total_count": len(optimized_galleries),
            "message": f"Found {len(optimized_galleries)} galleries",
            "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_galleries)} galleries for site_id={site_id}, language={language}"
        )
        return response

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


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

    Args:
        gallery_id: Unique identifier for the gallery
        language: Language for translations (es, en, fr, ca)
        include_metadata: Whether to include photo metadata (default: True)

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

        gallery_id = gallery_id.strip()

        # Get database client and fetch gallery details
        db_client = get_database_client()
        gallery_data = db_client.get_gallery_by_id(gallery_id)

        if not gallery_data:
            return {
                "gallery": None,
                "error": "Gallery not found",
                "message": f"No gallery found with ID: {gallery_id}",
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_gallery = translation_engine.translate_record(
            gallery_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_gallery = media_optimizer.optimize_record_media(translated_gallery)

        # Add additional gallery metadata
        optimized_gallery["_gallery_meta"] = {
            "gallery_id": gallery_id,
            "language": translation_engine.normalize_language(language),
            "include_metadata": include_metadata,
            "available_translations": translation_engine.get_available_translations(
                gallery_data, "name"
            ),
            "translation_completeness": translation_engine.get_translation_completeness(
                gallery_data
            ),
        }

        # Handle photo metadata
        if not include_metadata:
            # Remove metadata fields if not requested
            metadata_fields = [
                "exif",
                "camera_info",
                "location",
                "photographer",
                "date_taken",
            ]
            for field in metadata_fields:
                if field in optimized_gallery:
                    del optimized_gallery[field]
            optimized_gallery["_gallery_meta"]["metadata_removed"] = True

        response = {
            "gallery": optimized_gallery,
            "message": "Gallery details retrieved successfully",
            "gallery_id": gallery_id,
        }

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

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


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

    Args:
        query: Search query (gallery name, description, tags)
        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 {
                "galleries": [],
                "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 galleries for searching
        db_client = get_database_client()
        all_galleries = db_client.get_galleries(site_id=site_id, limit=100)

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

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

        for gallery in translated_galleries:
            # Search in name, description, and tags fields
            name = str(gallery.get("name", "")).lower()
            description = str(gallery.get("description", "")).lower()
            tags = str(gallery.get("tags", "")).lower()
            category = str(gallery.get("category", "")).lower()

            if (
                query_lower in name
                or query_lower in description
                or query_lower in tags
                or query_lower in category
            ):
                matching_galleries.append(gallery)

            if len(matching_galleries) >= limit:
                break

        # Optimize media URLs for results
        media_optimizer = get_media_optimizer()
        optimized_galleries = media_optimizer.optimize_records_media(matching_galleries)

        response = {
            "galleries": optimized_galleries,
            "total_count": len(optimized_galleries),
            "message": f"Found {len(optimized_galleries)} galleries 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_galleries)} gallery results"
        )
        return response

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