app.py

import pandas as pd
import requests
from bs4 import BeautifulSoup
import os
import re
import random
import io # No longer needed for CSV data, but keep for other potential uses
from dotenv import load_dotenv
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import torch
import gradio as gr
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import time # For adding slight delays if TMDB API rate limits are hit

# --- Configuration ---
load_dotenv() # Load environment variables from .env file for local testing
TMDB_API_KEY = os.environ.get("TMDB_API_KEY")
HF_TOKEN = os.environ.get("HF_TOKEN")

MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.1"

BASE_TMDB_URL = "https://api.themoviedb.org/3"
POSTER_BASE_URL = "https://image.tmdb.org/t/p/w500"
NUM_RECOMMENDATIONS_TO_GENERATE = 20 # Generate more initially
NUM_RECOMMENDATIONS_TO_DISPLAY = 5  # Display top 5
MIN_RATING_FOR_SEED = 3.5
MIN_VOTE_COUNT_TMDB = 100 # Min votes on TMDB for a movie to be considered

# --- Global Variables for Data (Load once) ---
df_profile_global = None
df_comments_global = None
df_watchlist_global = None
df_reviews_global = None
df_diary_global = None
df_ratings_global = None
df_watched_global = None # This will be a consolidated df

uri_to_movie_map_global = {}
all_watched_titles_global = set()
watchlist_titles_global = set()
favorite_film_details_global = []
seed_movies_global = []

# LLM Pipeline (Load once)
llm_pipeline = None
llm_tokenizer = None

# --- Helper Functions ---
def clean_html(raw_html):
    if pd.isna(raw_html) or raw_html is None:
        return ""
    # Add space before tags to handle cases like </b>text
    text = str(raw_html)
    text = re.sub(r'<br\s*/?>', '\n', text) # Convert <br> to newlines
    soup = BeautifulSoup(text, "html.parser")
    return soup.get_text(separator=" ", strip=True)

def get_movie_uri_map(dfs_dict):
    """Creates a map from Letterboxd URI to (Name, Year)."""
    uri_map = {}
    # Order of preference for names/years if URIs are duplicated across files
    # (though Name/Year should ideally be consistent for the same URI)
    df_priority = ['reviews.csv', 'diary.csv', 'ratings.csv', 'watched.csv', 'watchlist.csv']
    
    processed_uris = set()

    for df_name in df_priority:
        df = dfs_dict.get(df_name)
        if df is not None and 'Letterboxd URI' in df.columns and 'Name' in df.columns and 'Year' in df.columns:
            for _, row in df.iterrows():
                uri = row['Letterboxd URI']
                if pd.notna(uri) and uri not in processed_uris:
                    if pd.notna(row['Name']) and pd.notna(row['Year']):
                        try:
                            year = int(row['Year']) # Ensure year is int
                            uri_map[uri] = (str(row['Name']), year)
                            processed_uris.add(uri)
                        except ValueError:
                            # print(f"Warning: Could not parse year for {row['Name']} in {df_name}. Skipping URI map entry.")
                            pass # Or handle as an error/log
    return uri_map

def load_all_data():
    global df_profile_global, df_comments_global, df_watchlist_global, df_reviews_global
    global df_diary_global, df_ratings_global, df_watched_global, uri_to_movie_map_global
    global all_watched_titles_global, watchlist_titles_global, favorite_film_details_global, seed_movies_global

    # --- Load DataFrames from CSV files ---
    # IMPORTANT: Ensure these CSV files are uploaded to your Hugging Face Space root.
    try:
        df_profile_global = pd.read_csv("profile.csv")
        df_comments_global = pd.read_csv("comments.csv")
        df_watchlist_global = pd.read_csv("watchlist.csv")
        df_reviews_global = pd.read_csv("reviews.csv")
        df_diary_global = pd.read_csv("diary.csv")
        df_ratings_global = pd.read_csv("ratings.csv")
        # The 'watched.csv' you provided seems to be a log similar to diary, but without ratings.
        # We'll primarily use diary, reviews, and ratings for watched history with ratings.
        _df_watched_log = pd.read_csv("watched.csv") # Raw watched log
    except FileNotFoundError as e:
        print(f"ERROR: CSV file not found: {e}. Please ensure all CSV files are uploaded to the HF Space.")
        return False # Indicate failure

    dfs_for_uri_map = {
        "reviews.csv": df_reviews_global,
        "diary.csv": df_diary_global,
        "ratings.csv": df_ratings_global,
        "watched.csv": _df_watched_log, # from watched.csv
        "watchlist.csv": df_watchlist_global
    }
    uri_to_movie_map_global = get_movie_uri_map(dfs_for_uri_map)

    # --- Consolidate Watched History ---
    # Combine diary, reviews, and ratings to get a comprehensive view of watched movies and their ratings/reviews
    # Standardize column names for easier merging
    df_diary_global.rename(columns={'Rating': 'Diary Rating'}, inplace=True)
    df_reviews_global.rename(columns={'Rating': 'Review Rating', 'Review': 'Review Text'}, inplace=True)
    df_ratings_global.rename(columns={'Rating': 'Simple Rating'}, inplace=True)

    # Merge based on Letterboxd URI, Name, and Year (if URI is missing, try Name/Year)
    # Start with reviews as it's richest
    consolidated = df_reviews_global[['Letterboxd URI', 'Name', 'Year', 'Review Rating', 'Review Text', 'Watched Date']].copy()
    consolidated.rename(columns={'Review Rating': 'Rating'}, inplace=True)

    # Merge diary
    diary_subset = df_diary_global[['Letterboxd URI', 'Name', 'Year', 'Diary Rating', 'Watched Date']].copy()
    diary_subset.rename(columns={'Diary Rating': 'Rating_diary', 'Watched Date': 'Watched Date_diary'}, inplace=True)
    consolidated = pd.merge(consolidated, diary_subset, on=['Letterboxd URI', 'Name', 'Year'], how='outer', suffixes=('', '_diary'))
    consolidated['Rating'] = consolidated['Rating'].fillna(consolidated['Rating_diary'])
    consolidated['Watched Date'] = consolidated['Watched Date'].fillna(consolidated['Watched Date_diary'])
    consolidated.drop(columns=['Rating_diary', 'Watched Date_diary'], inplace=True)


    # Merge simple ratings
    ratings_subset = df_ratings_global[['Letterboxd URI', 'Name', 'Year', 'Simple Rating']].copy()
    ratings_subset.rename(columns={'Simple Rating': 'Rating_simple'}, inplace=True)
    consolidated = pd.merge(consolidated, ratings_subset, on=['Letterboxd URI', 'Name', 'Year'], how='outer', suffixes=('', '_simple'))
    consolidated['Rating'] = consolidated['Rating'].fillna(consolidated['Rating_simple'])
    consolidated.drop(columns=['Rating_simple'], inplace=True)

    # Add movies from the raw watched.csv if they aren't already there (they won't have ratings from this source)
    watched_log_subset = _df_watched_log[['Letterboxd URI', 'Name', 'Year']].copy()
    # Add a 'Watched' column to mark these, and merge, filling NaNs appropriately
    watched_log_subset['from_watched_log'] = True
    consolidated = pd.merge(consolidated, watched_log_subset, on=['Letterboxd URI', 'Name', 'Year'], how='outer')
    consolidated['from_watched_log'] = consolidated['from_watched_log'].fillna(False)


    # Clean up and fill NAs
    consolidated['Review Text'] = consolidated['Review Text'].fillna('').apply(clean_html)
    consolidated['Year'] = pd.to_numeric(consolidated['Year'], errors='coerce').astype('Int64') # Handle potential non-numeric years
    consolidated.dropna(subset=['Name', 'Year'], inplace=True) # Movies must have a name and year
    consolidated.drop_duplicates(subset=['Name', 'Year'], keep='first', inplace=True)

    df_watched_global = consolidated

    # Populate all_watched_titles_global (Name, Year) tuples
    all_watched_titles_global = set(zip(df_watched_global['Name'].astype(str), df_watched_global['Year'].astype(int)))
    # Add from raw watched log as well
    for _, row in _df_watched_log.iterrows():
        if pd.notna(row['Name']) and pd.notna(row['Year']):
            try:
                all_watched_titles_global.add((str(row['Name']), int(row['Year'])))
            except ValueError:
                pass


    # --- Process Watchlist ---
    if df_watchlist_global is not None:
        watchlist_titles_global = set()
        for _, row in df_watchlist_global.iterrows():
            if pd.notna(row['Name']) and pd.notna(row['Year']):
                try:
                    watchlist_titles_global.add((str(row['Name']), int(row['Year'])))
                except ValueError:
                    pass


    # --- Process Favorite Films ---
    favorite_film_details_global = []
    if df_profile_global is not None and 'Favorite Films' in df_profile_global.columns:
        fav_uris_str = df_profile_global.iloc[0]['Favorite Films']
        if pd.notna(fav_uris_str):
            fav_uris = [uri.strip() for uri in fav_uris_str.split(',')]
            for uri in fav_uris:
                if uri in uri_to_movie_map_global:
                    name, year = uri_to_movie_map_global[uri]
                    # Try to find rating and review from consolidated watched data
                    match = df_watched_global[(df_watched_global['Name'] == name) & (df_watched_global['Year'] == year)]
                    rating = match['Rating'].iloc[0] if not match.empty and pd.notna(match['Rating'].iloc[0]) else None
                    review = match['Review Text'].iloc[0] if not match.empty and match['Review Text'].iloc[0] else ""
                    favorite_film_details_global.append({'name': name, 'year': year, 'rating': rating, 'review_text': review, 'uri': uri})

    # --- Identify Seed Movies ---
    # Start with favorites
    seed_movies_global.extend(favorite_film_details_global)
    
    # Add other highly-rated movies (non-favorites)
    highly_rated_df = df_watched_global[df_watched_global['Rating'] >= MIN_RATING_FOR_SEED]
    
    favorite_uris = {fav['uri'] for fav in favorite_film_details_global if 'uri' in fav}

    for _, row in highly_rated_df.iterrows():
        if row['Letterboxd URI'] not in favorite_uris: # Avoid duplicates if already in favorites
            seed_movies_global.append({
                'name': row['Name'], 
                'year': row['Year'], 
                'rating': row['Rating'], 
                'review_text': row['Review Text'],
                'uri': row['Letterboxd URI']
            })
    # Remove duplicates based on name and year, preferring entries with more info (e.g., from favorites)
    temp_df = pd.DataFrame(seed_movies_global)
    temp_df.drop_duplicates(subset=['name', 'year'], keep='first', inplace=True)
    seed_movies_global = temp_df.to_dict('records')
    
    random.shuffle(seed_movies_global) # Shuffle to get variety if we pick a subset

    return True # Indicate success

def initialize_llm():
    global llm_pipeline, llm_tokenizer
    if llm_pipeline is None:
        print(f"Initializing LLM: {MODEL_NAME}")
        try:
            llm_tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
            # For CPU, bfloat16 might not be supported, try float32 or default
            # Adding device_map="auto" and load_in_8bit=True for potentially better memory management on CPU
            # For Spaces CPU, bitsandbytes might not be ideal. Try without quantization first if issues arise.
            # Remove load_in_8bit if it causes issues on standard CPU Space.
            model = AutoModelForCausalLM.from_pretrained(
                MODEL_NAME,
                torch_dtype=torch.float16, # Use float16 for faster inference and less memory
                device_map="auto", # Automatically maps to available device (CPU or GPU if available)
                # load_in_8bit=True, # Quantization - might need bitsandbytes
                trust_remote_code=True,
                token=HF_TOKEN if HF_TOKEN else None
            )
            llm_pipeline = pipeline(
                "text-generation",
                model=model,
                tokenizer=llm_tokenizer,
                torch_dtype=torch.float16,
                device_map="auto"
            )
            print("LLM Initialized Successfully.")
        except Exception as e:
            print(f"Error initializing LLM: {e}")
            llm_pipeline = None # Ensure it's None if initialization fails

# --- TMDB API Functions ---
def search_tmdb_movie_details(title, year):
    if not TMDB_API_KEY:
        print("TMDB API Key not configured.")
        return None
    try:
        search_url = f"{BASE_TMDB_URL}/search/movie"
        params = {'api_key': TMDB_API_KEY, 'query': title, 'year': year, 'language': 'en-US'}
        response = requests.get(search_url, params=params)
        response.raise_for_status()
        results = response.json().get('results', [])
        if results:
            movie = results[0]
            # Fetch genres using the /movie/{movie_id} endpoint to get full genre names
            movie_details_url = f"{BASE_TMDB_URL}/movie/{movie['id']}"
            details_params = {'api_key': TMDB_API_KEY, 'language': 'en-US'}
            details_response = requests.get(movie_details_url, params=details_params)
            details_response.raise_for_status()
            movie_full_details = details_response.json()
            
            return {
                'id': movie.get('id'),
                'title': movie.get('title'),
                'year': str(movie.get('release_date', ''))[:4],
                'overview': movie.get('overview'),
                'poster_path': POSTER_BASE_URL + movie.get('poster_path') if movie.get('poster_path') else "https://via.placeholder.com/500x750.png?text=No+Poster",
                'genres': [genre['name'] for genre in movie_full_details.get('genres', [])],
                'vote_average': movie.get('vote_average'),
                'vote_count': movie.get('vote_count'),
                'popularity': movie.get('popularity')
            }
        time.sleep(0.2) # Small delay to respect API rate limits
    except requests.RequestException as e:
        print(f"Error searching TMDB for {title} ({year}): {e}")
    except Exception as ex:
        print(f"Unexpected error in search_tmdb_movie_details for {title} ({year}): {ex}")
    return None

def get_tmdb_recommendations(movie_id, page=1):
    if not TMDB_API_KEY:
        print("TMDB API Key not configured.")
        return []
    recommendations = []
    try:
        rec_url = f"{BASE_TMDB_URL}/movie/{movie_id}/recommendations"
        params = {'api_key': TMDB_API_KEY, 'page': page, 'language': 'en-US'}
        response = requests.get(rec_url, params=params)
        response.raise_for_status()
        results = response.json().get('results', [])
        
        for movie in results:
            if movie.get('vote_count', 0) >= MIN_VOTE_COUNT_TMDB:
                recommendations.append({
                    'id': movie.get('id'),
                    'title': movie.get('title'),
                    'year': str(movie.get('release_date', ''))[:4] if movie.get('release_date') else "N/A",
                    'overview': movie.get('overview'),
                    'poster_path': POSTER_BASE_URL + movie.get('poster_path') if movie.get('poster_path') else "https://via.placeholder.com/500x750.png?text=No+Poster",
                    'vote_average': movie.get('vote_average'),
                    'vote_count': movie.get('vote_count'),
                    'popularity': movie.get('popularity')
                })
        time.sleep(0.2) # Small delay
    except requests.RequestException as e:
        print(f"Error getting TMDB recommendations for movie ID {movie_id}: {e}")
    except Exception as ex:
        print(f"Unexpected error in get_tmdb_recommendations for movie ID {movie_id}: {ex}")
    return recommendations

# --- LLM Explanation Generation ---
def generate_saudi_explanation(recommended_movie_title, seed_movie_title, seed_movie_context=""):
    global llm_pipeline, llm_tokenizer
    if llm_pipeline is None or llm_tokenizer is None:
        return "للأسف، نموذج الذكاء الاصطناعي مو جاهز الحين. حاول مرة ثانية بعد شوي."

    # Truncate long context to avoid overly long prompts
    max_context_len = 200 
    if len(seed_movie_context) > max_context_len:
        seed_movie_context_short = seed_movie_context[:max_context_len] + "..."
    else:
        seed_movie_context_short = seed_movie_context
    
    prompt_template = f"""<s>[INST] أنت ناقد أفلام سعودي خبير ودمك خفيف. المستخدم أعجب بالفيلم "{seed_movie_title}".
سبب إعجابه بالفيلم الأول (إذا متوفر): "{seed_movie_context_short}"
بناءً على ذلك، نُرشح له فيلم "{recommended_movie_title}".
اكتب جملة أو جملتين باللهجة السعودية العامية، تشرح ليش ممكن يعجبه الفيلم الجديد "{recommended_movie_title}"، مع ربطها بالفيلم اللي عجبه "{seed_movie_title}". خلي كلامك وناسة ويشد الواحد وما يكون طويل. لا تذكر أبداً أنك نموذج لغوي أو ذكاء اصطناعي.

مثال للأسلوب المطلوب (لو الفيلم اللي عجبه "Mad Max: Fury Road" والفيلم المرشح "Dune"):
"يا طويل العمر، شفت كيف 'Mad Max: Fury Road' عجّبك بجوّه الصحراوي والأكشن اللي ما يوقّف؟ أجل اسمع، 'Dune' بيوديك لصحراء ثانية بس أعظم وأفخم، وقصة تحبس الأنفاس! شد حيلك وشوفه."

الآن، الفيلم الذي أعجب المستخدم هو: "{seed_movie_title}"
سبب إعجابه بالفيلم الأول (إذا متوفر): "{seed_movie_context_short}"
الفيلم المرشح: "{recommended_movie_title}"
اشرح باللهجة السعودية: [/INST]"""

    try:
        sequences = llm_pipeline(
            prompt_template,
            do_sample=True,
            top_k=10,
            num_return_sequences=1,
            eos_token_id=llm_tokenizer.eos_token_id,
            max_new_tokens=100 # Limit output length
        )
        explanation = sequences[0]['generated_text'].split("[/INST]")[-1].strip()
        # Further clean up if the model repeats parts of the prompt or adds unwanted prefixes
        explanation = re.sub(r"^اشرح باللهجة السعودية:\s*", "", explanation, flags=re.IGNORECASE)
        explanation = explanation.replace("<s>", "").replace("</s>", "").strip()
        if not explanation or explanation.lower().startswith("أنت ناقد أفلام"): # Fallback if generation is poor
            return f"شكلك بتنبسط على فيلم '{recommended_movie_title}' لأنه يشبه جو فيلم '{seed_movie_title}' اللي حبيته! عطيه تجربة."
        return explanation
    except Exception as e:
        print(f"Error during LLM generation: {e}")
        return f"يا كابتن، شكلك بتحب '{recommended_movie_title}'، خاصة إنك استمتعت بـ'{seed_movie_title}'. جربه وعطنا رأيك!"

# --- Recommendation Logic ---
def get_recommendations_for_salman(progress=gr.Progress()):
    if not TMDB_API_KEY:
        return "<p style='color:red; text-align:right;'>خطأ: مفتاح TMDB API مو موجود. الرجاء إضافته كـ Secret في Hugging Face Space.</p>"

    if not all([df_profile_global is not None, df_watched_global is not None, seed_movies_global]):
        return "<p style='color:red; text-align:right;'>خطأ: فشل في تحميل بياناتك. تأكد من رفع ملفات CSV بشكل صحيح.</p>"
    
    if llm_pipeline is None:
        initialize_llm() # Attempt to initialize if not already
        if llm_pipeline is None:
             return "<p style='color:red; text-align:right;'>خطأ: فشل في تهيئة نموذج الذكاء الاصطناعي. حاول تحديث الصفحة.</p>"


    progress(0.1, desc="جمعنا أفلامك المفضلة واللي قيمتها عالي...")
    
    potential_recs = {} # Store as {tmdb_id: {'movie_info': ..., 'seed_movie': ..., 'seed_context': ...}}
    
    # Limit the number of seed movies to process to avoid excessive API calls / long processing
    seeds_to_process = seed_movies_global[:30] if len(seed_movies_global) > 30 else seed_movies_global

    for i, seed_movie in enumerate(seeds_to_process):
        progress(0.1 + (i / len(seeds_to_process)) * 0.4, desc=f"نبحث عن توصيات بناءً على: {seed_movie['name']}")
        
        seed_tmdb_details = search_tmdb_movie_details(seed_movie['name'], seed_movie['year'])
        if seed_tmdb_details and seed_tmdb_details.get('id'):
            tmdb_recs = get_tmdb_recommendations(seed_tmdb_details['id'])
            for rec in tmdb_recs:
                rec_tuple = (str(rec['title']), int(rec['year'])) # (Name, Year)
                # Ensure rec_tuple elements are of correct type before comparison
                if rec.get('id') and rec_tuple not in all_watched_titles_global and rec_tuple not in watchlist_titles_global:
                    if rec['id'] not in potential_recs: # Add if new, prioritizing first seed
                        potential_recs[rec['id']] = {
                            'movie_info': rec,
                            'seed_movie_title': seed_movie['name'],
                            'seed_movie_context': seed_movie.get('review_text', '') or seed_movie.get('comment_text', '')
                        }
        # Simple content-based similarity as a fallback or supplement (Optional, can be complex)
        # For now, primarily TMDB-based

    if not potential_recs:
        return "<p style='text-align:right;'>ما لقينا توصيات جديدة لك حالياً. يمكن شفت كل شيء رهيب! 😉</p>"

    # Sort recommendations (e.g., by popularity or a mix, or just randomize for now)
    # Let's sort by TMDB popularity for now to get some generally well-regarded films
    sorted_recs_list = sorted(potential_recs.values(), key=lambda x: x['movie_info'].get('popularity', 0), reverse=True)
    
    final_recommendations_data = []
    
    # Take top N distinct recommendations
    displayed_ids = set()
    for rec_data in sorted_recs_list:
        if len(final_recommendations_data) >= NUM_RECOMMENDATIONS_TO_DISPLAY:
            break
        if rec_data['movie_info']['id'] not in displayed_ids:
            final_recommendations_data.append(rec_data)
            displayed_ids.add(rec_data['movie_info']['id'])

    if not final_recommendations_data:
         return "<p style='text-align:right;'>ما لقينا توصيات جديدة لك حالياً بعد الفلترة. يمكن شفت كل شيء رهيب! 😉</p>"

    output_html = "<div>" # Main container
    progress(0.6, desc="نجهز لك الشرح باللغة العامية...")

    for i, rec_data in enumerate(final_recommendations_data):
        progress(0.6 + (i / len(final_recommendations_data)) * 0.4, desc=f"نكتب شرح لفيلم: {rec_data['movie_info']['title']}")
        
        explanation = generate_saudi_explanation(
            rec_data['movie_info']['title'],
            rec_data['seed_movie_title'],
            rec_data['seed_movie_context']
        )
        
        poster_url = rec_data['movie_info']['poster_path']
        if not poster_url or "placeholder.com" in poster_url: # Use a default if no poster
            poster_url = f"https://via.placeholder.com/300x450.png?text={rec_data['movie_info']['title'].replace(' ', '+')}"

        output_html += f"""
        <div style="display: flex; flex-direction: row-reverse; align-items: flex-start; margin-bottom: 25px; border-bottom: 1px solid #ddd; padding-bottom:15px; background-color: #f9f9f9; border-radius: 8px; padding: 15px;">
            <img src="{poster_url}" alt="{rec_data['movie_info']['title']}" style="width: 150px; max-width:30%; height: auto; margin-left: 20px; border-radius: 5px; box-shadow: 2px 2px 5px rgba(0,0,0,0.1);">
            <div style="text-align: right; direction: rtl; flex-grow: 1;">
                <h3 style="margin-top:0; color: #c70039;">{rec_data['movie_info']['title']} ({rec_data['movie_info']['year']})</h3>
                <p style="font-size: 1.1em; color: #333; line-height: 1.6;">{explanation}</p>
                <p style="font-size: 0.9em; color: #777; margin-top: 10px;"><em>يا وحش، رشحنا لك هذا الفيلم لأنك حبيت: <strong style="color:#555;">{rec_data['seed_movie_title']}</strong></em></p>
            </div>
        </div>
        """
    output_html += "</div>"
    return gr.HTML(output_html)

# --- Gradio Interface ---
css = """
body { font-family: 'Tajawal', sans-serif; }
.gradio-container { font-family: 'Tajawal', sans-serif !important; direction: rtl; }
footer { display: none !important; }
.gr-button { background-color: #c70039 !important; color: white !important; font-size: 1.2em !important; padding: 10px 20px !important; border-radius: 8px !important; }
.gr-button:hover { background-color: #a3002f !important; }
.gr-input { text-align: right !important; }
.gr-output { text-align: right !important; }
h1, h3 { color: #900c3f !important; }
"""

# Load data once when the script starts
data_loaded_successfully = load_all_data()
if data_loaded_successfully:
    print("All user data loaded and preprocessed successfully.")
    # Initialize LLM after data loading to ensure it happens on app startup if data is present
    initialize_llm()
else:
    print("Failed to load user data. The app might not function correctly.")


with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", secondary_hue="pink"), css=css) as iface:
    gr.Markdown(
        """
        <div style="text-align: center;">
            <h1 style="color: #c70039; font-size: 2.5em;">🎬 رفيقك السينمائي 🍿</h1>
            <p style="font-size: 1.2em; color: #555;">يا هلا بك يا سلمان! اضغط الزر تحت وخلنا نعطيك توصيات أفلام على كيف كيفك، مع شرح بالعامية ليش ممكن تدخل مزاجك.</p>
        </div>
        """
    )
    
    recommend_button = gr.Button("يا سلمان، عطني توصيات أفلام!")
    
    with gr.Column():
        output_recommendations = gr.HTML(label="توصياتك النارية 🔥")

    recommend_button.click(
        fn=get_recommendations_for_salman,
        inputs=[],
        outputs=[output_recommendations]
    )
    
    gr.Markdown(
        """
        <div style="text-align: center; margin-top: 30px; font-size: 0.9em; color: #777;">
            <p>تم تطوير هذا النظام بواسطة الذكاء الاصطناعي مع لمسة شخصية من بياناتك في ليتربوكسد.</p>
            <p>استمتع بالمشاهدة! 🎥</p>
        </div>
        """
    )

if __name__ == "__main__":
    iface.launch(debug=True) # debug=True for local testing, remove for HF