"""
Activity Tools for Hotel MCP Server.

This module provides MCP tools for accessing hotel activity 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_activities(
    site_id: Optional[str] = None,
    language: Optional[str] = None,
    limit: int = 20,
    offset: int = 0,
) -> Dict[str, Any]:
    """
    List all available hotel activities.

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

    Returns:
        Dictionary containing activities 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 activities
        db_client = get_database_client()
        activities_data = db_client.get_activities(
            site_id=site_id, limit=limit, offset=offset
        )

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

        # Apply translations
        translation_engine = get_translation_engine()
        translated_activities = translation_engine.translate_records(
            activities_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_activities = media_optimizer.optimize_records_media(
            translated_activities
        )

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

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


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

    Args:
        activity_id: Unique identifier for the activity
        language: Language for translations (es, en, fr, ca)
        include_pricing: Whether to include pricing information (default: True)

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

        activity_id = activity_id.strip()

        # Get database client and fetch activity details
        db_client = get_database_client()
        activity_data = db_client.get_activity_by_id(activity_id)

        if not activity_data:
            return {
                "activity": None,
                "error": "Activity not found",
                "message": f"No activity found with ID: {activity_id}",
            }

        # Apply translations
        translation_engine = get_translation_engine()
        translated_activity = translation_engine.translate_record(
            activity_data, target_language=language
        )

        # Optimize media URLs
        media_optimizer = get_media_optimizer()
        optimized_activity = media_optimizer.optimize_record_media(translated_activity)

        # Add additional activity metadata
        optimized_activity["_activity_meta"] = {
            "activity_id": activity_id,
            "language": translation_engine.normalize_language(language),
            "include_pricing": include_pricing,
            "available_translations": translation_engine.get_available_translations(
                activity_data, "name"
            ),
            "translation_completeness": translation_engine.get_translation_completeness(
                activity_data
            ),
        }

        # Handle pricing information
        if not include_pricing:
            # Remove pricing fields if not requested
            pricing_fields = ["price", "cost", "fee", "rate", "pricing"]
            for field in pricing_fields:
                if field in optimized_activity:
                    del optimized_activity[field]
            optimized_activity["_activity_meta"]["pricing_removed"] = True

        response = {
            "activity": optimized_activity,
            "message": "Activity details retrieved successfully",
            "activity_id": activity_id,
        }

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

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


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

    Args:
        query: Search query (activity 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 {
                "activities": [],
                "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 activities for searching
        db_client = get_database_client()
        all_activities = db_client.get_activities(site_id=site_id, limit=100)

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

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

        for activity in translated_activities:
            # Search in name, description, and type fields
            name = str(activity.get("name", "")).lower()
            description = str(activity.get("description", "")).lower()
            activity_type = str(activity.get("type", "")).lower()

            if (
                query_lower in name
                or query_lower in description
                or query_lower in activity_type
            ):
                matching_activities.append(activity)

            if len(matching_activities) >= limit:
                break

        # Optimize media URLs for results
        media_optimizer = get_media_optimizer()
        optimized_activities = media_optimizer.optimize_records_media(
            matching_activities
        )

        response = {
            "activities": optimized_activities,
            "total_count": len(optimized_activities),
            "message": f"Found {len(optimized_activities)} activities 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_activities)} activity results"
        )
        return response

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