"""
MCP Resources for Hotel Information Server.

This module provides MCP resources that offer direct access to hotel data
in structured formats, leveraging existing tools for data retrieval.
"""

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

from .database import get_database_client
from .media import get_media_optimizer
from .tools import activities, facilities, galleries, menu, rooms
from .translations import get_translation_engine

logger = logging.getLogger(__name__)


def get_hotel_general_info(
    site_id: str, language: Optional[str] = None, format: str = "markdown"
) -> str:
    """
    Get comprehensive hotel information as a resource.

    Args:
        site_id: Hotel site identifier
        language: Language for content (es, en, fr, ca)
        format: Output format (markdown, json)

    Returns:
        Formatted hotel information
    """
    try:
        # Get summary data from each category using existing tools
        rooms_data = rooms.list_rooms(site_id=site_id, language=language, limit=5)
        activities_data = activities.list_activities(
            site_id=site_id, language=language, limit=5
        )
        facilities_data = facilities.list_facilities(
            site_id=site_id, language=language, limit=5
        )
        menu_data = menu.list_menu_items(site_id=site_id, language=language, limit=5)
        galleries_data = galleries.list_galleries(
            site_id=site_id, language=language, limit=3
        )

        # Get translation engine for language info
        translation_engine = get_translation_engine()
        normalized_language = translation_engine.normalize_language(language)

        if format == "json":
            return json.dumps(
                {
                    "site_id": site_id,
                    "language": normalized_language,
                    "summary": {
                        "rooms": {
                            "count": rooms_data.get("total_count", 0),
                            "sample": rooms_data.get("rooms", [])[:3],
                        },
                        "activities": {
                            "count": activities_data.get("total_count", 0),
                            "sample": activities_data.get("activities", [])[:3],
                        },
                        "facilities": {
                            "count": facilities_data.get("total_count", 0),
                            "sample": facilities_data.get("facilities", [])[:3],
                        },
                        "menu": {
                            "count": menu_data.get("total_count", 0),
                            "sample": menu_data.get("menu_items", [])[:3],
                        },
                        "galleries": {
                            "count": galleries_data.get("total_count", 0),
                            "sample": galleries_data.get("galleries", [])[:3],
                        },
                    },
                },
                indent=2,
            )

        # Default markdown format
        return f"""# Hotel Information (Site: {site_id})

**Language**: {normalized_language.upper()}
**Last Updated**: {galleries_data.get('message', 'Recently')}

## 🏨 Accommodation Summary
- **Total Rooms**: {rooms_data.get('total_count', 0)}
- **Featured Rooms**: {', '.join([room.get('name', 'N/A') for room in rooms_data.get('rooms', [])[:3]])}

## 🎯 Activities & Experiences
- **Total Activities**: {activities_data.get('total_count', 0)}
- **Popular Activities**: {', '.join([activity.get('name', 'N/A') for activity in activities_data.get('activities', [])[:3]])}

## 🏊 Facilities & Amenities
- **Total Facilities**: {facilities_data.get('total_count', 0)}
- **Key Facilities**: {', '.join([facility.get('name', 'N/A') for facility in facilities_data.get('facilities', [])[:3]])}

## 🍽️ Dining Options
- **Menu Items**: {menu_data.get('total_count', 0)}
- **Signature Dishes**: {', '.join([item.get('name', 'N/A') for item in menu_data.get('menu_items', [])[:3]])}

## 📸 Photo Galleries
- **Total Galleries**: {galleries_data.get('total_count', 0)}
- **Featured Galleries**: {', '.join([gallery.get('name', 'N/A') for gallery in galleries_data.get('galleries', [])[:3]])}

## 🔧 Available Tools
Use these MCP tools to get detailed information:
- `list_rooms`, `get_room_details`, `search_rooms`
- `list_activities`, `get_activity_details`, `search_activities`
- `list_facilities`, `get_facility_details`, `search_facilities`
- `list_menu_items`, `get_menu_item_details`, `search_menu_items`
- `list_galleries`, `get_gallery_details`, `search_galleries`
"""

    except Exception as e:
        logger.error(f"Error generating hotel general info: {e}")
        return f"""# Hotel Information Error

**Site ID**: {site_id}
**Error**: {str(e)}

Please try again or use individual MCP tools for specific information.
"""


def get_category_resource(
    category: str,
    site_id: str,
    language: Optional[str] = None,
    format: str = "markdown",
) -> str:
    """
    Get detailed information for a specific category as a resource.

    Args:
        category: Category name (rooms, activities, facilities, menu, galleries)
        site_id: Hotel site identifier
        language: Language for content
        format: Output format (markdown, json)

    Returns:
        Formatted category information
    """
    try:
        # Map category to appropriate tool function
        category_tools = {
            "rooms": rooms.list_rooms,
            "activities": activities.list_activities,
            "facilities": facilities.list_facilities,
            "menu": menu.list_menu_items,
            "galleries": galleries.list_galleries,
        }

        if category not in category_tools:
            return f"# Error: Unknown category '{category}'"

        # Get data using the appropriate tool
        tool_func = category_tools[category]
        data = tool_func(site_id=site_id, language=language, limit=20)

        if format == "json":
            return json.dumps(data, indent=2)

        # Generate markdown format
        category_name = category.title()
        items_key = list(data.keys())[0]  # First key is usually the items list
        items = data.get(items_key, [])

        markdown = f"""# {category_name} - {site_id}

**Total Count**: {data.get('total_count', 0)}
**Language**: {data.get('filters', {}).get('language', 'N/A')}

## Available {category_name}

"""

        for i, item in enumerate(items[:10], 1):  # Limit to first 10 for readability
            name = item.get("name", f"{category_name} {i}")
            description = item.get("description", "No description available")
            # Truncate long descriptions
            if len(description) > 100:
                description = description[:97] + "..."

            markdown += f"""### {i}. {name}
{description}

"""

        if len(items) > 10:
            markdown += f"\n*... and {len(items) - 10} more {category} available via MCP tools*\n"

        return markdown

    except Exception as e:
        logger.error(f"Error generating {category} resource: {e}")
        return f"""# {category.title()} Resource Error

**Site ID**: {site_id}
**Error**: {str(e)}

Please try again or use the `list_{category}` MCP tool directly.
"""


def get_search_resource(
    query: str, site_id: str, language: Optional[str] = None, format: str = "markdown"
) -> str:
    """
    Get search results across all categories as a resource.

    Args:
        query: Search query
        site_id: Hotel site identifier
        language: Language for content
        format: Output format (markdown, json)

    Returns:
        Formatted search results
    """
    try:
        # Search across all categories
        search_results = {
            "rooms": rooms.search_rooms(
                query=query, site_id=site_id, language=language, limit=5
            ),
            "activities": activities.search_activities(
                query=query, site_id=site_id, language=language, limit=5
            ),
            "facilities": facilities.search_facilities(
                query=query, site_id=site_id, language=language, limit=5
            ),
            "menu": menu.search_menu_items(
                query=query, site_id=site_id, language=language, limit=5
            ),
            "galleries": galleries.search_galleries(
                query=query, site_id=site_id, language=language, limit=5
            ),
        }

        if format == "json":
            return json.dumps(search_results, indent=2)

        # Generate markdown format
        total_results = sum(
            result.get("total_count", 0) for result in search_results.values()
        )

        markdown = f"""# Search Results: "{query}"

**Site ID**: {site_id}
**Total Results**: {total_results}
**Language**: {language or 'default'}

"""

        for category, result in search_results.items():
            count = result.get("total_count", 0)
            if count > 0:
                items_key = list(result.keys())[
                    0
                ]  # First key is usually the items list
                items = result.get(items_key, [])

                markdown += f"""## {category.title()} ({count} results)

"""
                for item in items[:3]:  # Show top 3 results per category
                    name = item.get("name", "N/A")
                    description = item.get("description", "No description")
                    if len(description) > 80:
                        description = description[:77] + "..."
                    markdown += f"- **{name}**: {description}\n"

                if count > 3:
                    markdown += f"  *... and {count - 3} more results*\n"
                markdown += "\n"

        if total_results == 0:
            markdown += "No results found. Try a different search term or browse categories directly.\n"

        return markdown

    except Exception as e:
        logger.error(f"Error generating search resource: {e}")
        return f"""# Search Error

**Query**: {query}
**Site ID**: {site_id}
**Error**: {str(e)}

Please try again or use individual search tools.
"""
