app.py

import os
import requests
import gradio as gr
from dotenv import load_dotenv
import re
from typing import Optional
import base64
from time import sleep


def get_book_recommendations(prompt: str) -> str:
    """
    Fetches a book recommendation from Google Books API.
    Args:
        prompt: User search query, e.g., "thriller novel by Gillian Flynn"
    Returns:
        Top book recommendation in formatted text.
    """
    load_dotenv()  # Make sure this is called before accessing environment variables

    api_key = os.getenv("GOOGLE_BOOKS_API_KEY")
    if not api_key:
        return "API key not found."

    search_query = prompt.strip()
    url = f"https://www.googleapis.com/books/v1/volumes?q={search_query}&key={api_key}"

    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        books = response.json().get("items", [])
        if not books:
            return "No books found."

        volume_info = books[0].get("volumeInfo", {})
        title = volume_info.get("title", "Unknown Title")
        authors = ", ".join(volume_info.get("authors", ["Unknown Author"]))
        description = volume_info.get("description", "No description available.")

        return f"📚 **{title}** by *{authors}*\n\n{description}"
    except Exception as e:
        return f"Error: {str(e)}"
    

def get_random_recipe(tags: str = "", exclude_ingredients: str = "") -> str:
    """
    Fetches a random recipe using the Spoonacular API and returns it in a formatted string.

    Args:
        tags (str): Comma-separated tags like 'vegetarian,dessert'.
        exclude_ingredients (str): Comma-separated ingredients to exclude.

    Returns:
        str: A formatted string with title, preparation time, ingredients, and cooking steps.
    
    """
    load_dotenv()

    recipe_api_key = os.getenv("SPOONACULAR_API_KEY")
    if not recipe_api_key:
        return "❌ API key not found in environment."

    url = "https://api.spoonacular.com/recipes/random"
    params = {
        "number": 1,
        "tags": tags,
        "excludeIngredients": exclude_ingredients,
        "apiKey": recipe_api_key
    }

    try:
        response = requests.get(url, params=params, timeout=10)
        data = response.json()
    except Exception:
        return "❌ Failed to parse JSON from API response."

    if response.status_code != 200:
        return f"❌ API Error: {data.get('message', 'Unknown error')}"

    if not data.get("recipes"):
        return "❌ No recipes returned."

    recipe = data["recipes"][0]

    title = recipe.get("title", "Unknown")
    ready_in = recipe.get("readyInMinutes", "?")
    ingredients = [i["name"] for i in recipe.get("extendedIngredients", [])]

    steps = []
    for block in recipe.get("analyzedInstructions", []):
        for step in block.get("steps", []):
            steps.append(step["step"])

    formatted = f"🍽️ **Title**: {title}\n"
    formatted += f"🕒 **Ready in**: {ready_in} minutes\n"
    formatted += f"📋 **Ingredients**: {', '.join(ingredients) if ingredients else 'N/A'}\n"
    formatted += "👨‍🍳 **Steps**:\n"
    for idx, step in enumerate(steps, 1):
        formatted += f"  {idx}. {step.strip()}\n"

    return formatted.strip()




def get_now_playing_movies(retries=3) -> str:
    api_key = os.getenv("TMDB_API_KEY")
    url = f"https://api.themoviedb.org/3/movie/now_playing?api_key={api_key}&language=en-US&page=1"

    for attempt in range(1, retries + 1):
        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status()
            movies = response.json().get("results", [])
            if not movies:
                return "No movies currently playing."

            formatted = []
            for movie in movies[:5]:
                title = movie.get("title", "Untitled")
                overview = movie.get("overview", "No description available.")
                formatted.append(f"🎬 **{title}**\n{overview}\n")
            return "\n".join(formatted)

        except Exception as e:
            if attempt == retries:
                return f"❌ Failed after {retries} attempts: {e}"
            sleep(1)  # Wait before retrying

def get_music_recommendations(prompt: str, num_songs: int = 3, min_popularity: int = 0, year: str = "") -> str:
    """
    Fetches multiple music recommendations from Spotify API.
    
    Args:
        prompt: Search query (genre, mood, etc.)
        num_songs: Number of song recommendations to return.
        min_popularity: Minimum popularity score (0–100).
        year: Optional release year filter, e.g., '2022' or '2010-2020'.
    
    Returns:
        Markdown-formatted string of top song recommendations.
    """
    load_dotenv()
    client_id = os.getenv("SPOTIFY_CLIENT_ID")
    client_secret = os.getenv("SPOTIFY_CLIENT_SECRET")

    if not client_id or not client_secret:
        return "Spotify API credentials not found."

    # Encode client_id:client_secret
    auth_str = f"{client_id}:{client_secret}"
    b64_auth_str = base64.b64encode(auth_str.encode()).decode()

    try:
        token_response = requests.post(
            "https://accounts.spotify.com/api/token",
            data={"grant_type": "client_credentials"},
            headers={"Authorization": f"Basic {b64_auth_str}"}
        )
        token_response.raise_for_status()
        access_token = token_response.json().get("access_token")
    except Exception as e:
        return f"Token Error: {str(e)}"

    try:
        # Append year filter if provided
        search_query = prompt.strip()
        if year:
            search_query += f" year:{year}"

        url = f"https://api.spotify.com/v1/search?q={search_query}&type=track&limit={num_songs}"
        headers = {"Authorization": f"Bearer {access_token}"}

        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        tracks = response.json().get("tracks", {}).get("items", [])

        if not tracks:
            return "No songs found."

        # Filter by popularity and format results
        filtered_tracks = [
            track for track in tracks if track["popularity"] >= min_popularity
        ]

        if not filtered_tracks:
            return f"No songs found with popularity ≥ {min_popularity}."

        output_lines = []
        for track in filtered_tracks:
            name = track["name"]
            artist = ", ".join(artist["name"] for artist in track["artists"])
            popularity = track["popularity"]
            spotify_url = track["external_urls"]["spotify"]
            preview_url = track.get("preview_url")

            entry = f"🎵 **{name}** by *{artist}* (Popularity: {popularity})\n[Listen on Spotify]({spotify_url})"
            if preview_url:
                entry += f"\nPreview: {preview_url}"
            output_lines.append(entry)

        return "\n\n---\n\n".join(output_lines)
    except Exception as e:
        return f"Error: {str(e)}"
    


def get_current_weather(location: str) -> str:
    """
    Fetches current weather for a given city name or coordinates using OpenWeatherMap API.

    Args:
        location: A city name (e.g., "New York") or "lat,lon" format (e.g., "44.34,10.99")

    Returns:
        A formatted weather report string.
    """
    load_dotenv()

    api_key = os.getenv("OPENWEATHER_API_KEY")
    if not api_key:
        return "OpenWeatherMap API key not found."

    try:
        # Check if input is coordinates
        if "," in location:
            lat, lon = map(str.strip, location.split(","))
        else:
            # Use geocoding API to get coordinates from city name
            geo_url = f"http://api.openweathermap.org/geo/1.0/direct?q={location}&limit=1&appid={api_key}"
            geo_resp = requests.get(geo_url, timeout=10)
            geo_resp.raise_for_status()
            geo_data = geo_resp.json()
            if not geo_data:
                return f"Could not find location: {location}"
            lat = geo_data[0]["lat"]
            lon = geo_data[0]["lon"]

        # Get weather
        weather_url = f"https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={api_key}&units=metric"
        weather_resp = requests.get(weather_url, timeout=10)
        weather_resp.raise_for_status()
        data = weather_resp.json()

        city = f"{data.get('name', 'Unknown')}, {data['sys'].get('country', '')}"
        condition = data["weather"][0]["description"].capitalize()
        temp = data["main"]["temp"]
        feels_like = data["main"]["feels_like"]
        humidity = data["main"]["humidity"]
        wind = data["wind"]["speed"]

        return (
            f"🌤 **Weather in {city}**\n"
            f"Condition: {condition}\n"
            f"🌡 Temperature: {temp}°C (Feels like {feels_like}°C)\n"
            f"💧 Humidity: {humidity}%\n"
            f"🌬 Wind Speed: {wind} m/s"
        )

    except Exception as e:
        return f"Error fetching weather: {str(e)}"


# Define Gradio interface
book_interface = gr.Interface(
    fn=get_book_recommendations,
    inputs=gr.Textbox(label="Enter your book query"),
    outputs=gr.Markdown(label="Top Recommendation"),
    api_name="get_book_recommendations"
)

recipe_interface = gr.Interface(
    fn=get_random_recipe,
    inputs=[
        gr.Textbox(label="Tags (e.g., vegetarian,dessert)", placeholder="Enter tags or leave blank"),
        gr.Textbox(label="Exclude Ingredients", placeholder="e.g., nuts,gluten")
    ],
    outputs=gr.Markdown(label="Random Recipe"),
    api_name="get_random_recipe"  # This is critical for Hugging Face MCP endpoints
)

movie_interface = gr.Interface(
    fn=get_now_playing_movies,
    inputs=[],  # No input needed for now-playing movies
    outputs=gr.Markdown(label="Now Playing Movies"),
    api_name="get_now_playing_movies"
)

music_interface = gr.Interface(
    fn=get_music_recommendations,
    inputs=[
        gr.Textbox(label="Enter your music query (e.g., 'lofi beats', 'happy pop')"),
        gr.Slider(minimum=1, maximum=10, value=3, label="Number of Songs"),
        gr.Slider(minimum=0, maximum=100, value=0, label="Minimum Popularity"),
        gr.Textbox(label="Release Year (e.g., 2022 or 2015-2020)", placeholder="Optional")
    ],
    outputs=gr.Markdown(label="Song Recommendations"),
    api_name="get_music_recommendations"
)

weather_interface = gr.Interface(
    fn=get_current_weather,
    inputs=gr.Textbox(label="Enter a location (e.g., 'New York' or '44.34,10.99')"),
    outputs=gr.Markdown(label="Current Weather"),
    api_name="get_current_weather"
)


with gr.Blocks(title="DailyPal: Your Daily Discovery Assistant") as demo:
    gr.Markdown("""
    # 🌟 DailyPal  
    Welcome to **DailyPal**, your all-in-one assistant to discover:
    
    - 📚 Great books
    - 🍳 Random recipes
    - 🎬 Movies now playing
    - 🎵 Music recommendations
    - ☁️ Current weather updates

    ---
    ⚙️ **How to use**:  
    Just select a tab and enter your query or location. Get instant suggestions to brighten your day!
    """)

    gr.TabbedInterface(
        [
            book_interface,
            recipe_interface,
            movie_interface,
            music_interface,
            weather_interface,
            # Add more tools here
        ],
        [
            "Book Finder",
            "Random Recipe",
            "Now Playing Movies",
            "Music Recommendations",
            "Current Weather"
        ]
    )
    gr.Markdown("**Example prompt using mcp client like claude desktop**: I am in new york, if the weather is good, then get me a recipe to grill outdoors, if not get me a book on mars to read, and also get me the songs by weekend to listen.")
    gr.Markdown("### 🔗 [Watch Demo Video](https://drive.google.com/file/d/1DV0Plrhdr7kAWtLRQS91BnVuvRElPbOm/view?usp=drive_link)")


if __name__ == "__main__":
    demo.launch(mcp_server=True)