# Gradio Interface
import gradio as gr
import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from sentence_transformers import SentenceTransformer
import requests
from PIL import Image
from transformers import BlipProcessor, BlipForConditionalGeneration
sentence_model = SentenceTransformer("all-MiniLM-L6-v2")

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
image_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

def generate_input(input_type, image=None, text=None, response_amount=3):
    # Initialize the input variable
    combined_input = ""

    # Handle image input if chosen
    if input_type == "Image" and image:
        inputs = processor(images=image, return_tensors="pt")
        out = image_model.generate(**inputs)
        image_caption = processor.decode(out[0], skip_special_tokens=True)
        combined_input += image_caption  # Add the image caption to input

    # Handle text input if chosen
    elif input_type == "Text" and text:
        combined_input += text  # Add the text to input

    # Handle both text and image input if chosen
    elif input_type == "Both" and image and text:
        inputs = processor(images=image, return_tensors="pt")
        out = image_model.generate(**inputs)
        image_caption = processor.decode(out[0], skip_special_tokens=True)
        combined_input += image_caption + " and " + text  # Combine image caption and text
    
    # If no input, fallback
    if not combined_input:
        combined_input = "No input provided."
    if response_amount is None:
        response_amount=3

    return vector_search(combined_input,response_amount)

# Load embeddings and metadata
embeddings = np.load("netflix_embeddings.npy")  #created using sentence_transformers on kaggle
metadata = pd.read_csv("netflix_metadata.csv") #created using sentence_transformers on kaggle

# Vector search function
def vector_search(query,top_n=3):
    query_embedding = sentence_model.encode(query)
    similarities = cosine_similarity([query_embedding], embeddings)[0]
    if top_n is None:
        top_n=3
    top_indices = similarities.argsort()[-top_n:][::-1]
    results = metadata.iloc[top_indices]
    result_text=""
    for index,row in results.iterrows():
        if index!=top_n-1:
            result_text+=f"Title: {row['title']}  Description: {row['description']}  Genre: {row['listed_in']}\n\n"
        else:
            result_text+=f"Title: {row['title']}  Description: {row['description']}  Genre: {row['listed_in']}"
    return result_text


def set_response_amount(response_amount):
    if response_amount is None:
        return 3
    return response_amount

 # Based on the selected input type, make the appropriate input visible
def update_inputs(input_type):
    if input_type == "Image":
        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=True)
    elif input_type == "Text":
        return gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
    elif input_type == "Both":
        return gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
with gr.Blocks() as demo:
    gr.Markdown("# Netflix Recommendation System")
    gr.Markdown("Enter a query to receive Netflix show recommendations based on title, description, and genre.")
   
    input_type = gr.Radio(["Image", "Text", "Both"], label="Select Input Type", type="value")
    response_type=gr.Dropdown(choices=[3,5,10,25], type="value", label="Select Response Amount", visible=False)
    image_input = gr.Image(label="Upload Image", type="pil", visible=False)  # Hidden initially
    text_input = gr.Textbox(label="Enter Text Query", placeholder="Enter a description or query here", visible=False)  # Hidden initially
  
    input_type.change(fn=update_inputs, inputs=input_type, outputs=[image_input, text_input, response_type])
   # State variable to store the selected response amount
    selected_response_amount = gr.State()

    # Capture response amount immediately when dropdown changes
    response_type.change(fn=set_response_amount, inputs=response_type, outputs=selected_response_amount)
    
    submit_button = gr.Button("Submit")
    output = gr.Textbox(label="Recommendations")
    if selected_response_amount is None:
        selected_response_amount=3

    submit_button.click(fn=generate_input, inputs=[input_type,image_input, text_input,selected_response_amount], outputs=output)
demo.launch(ssr_mode = False)


# with gr.Blocks() as demo:
#     gr.Markdown("# Netflix Recommendation System")
#     gr.Markdown("Enter a query to receive Netflix show recommendations based on title, description, and genre.")
#     query = gr.Textbox(label="Enter your query")
#     output = gr.Textbox(label="Recommendations")
#     submit_button = gr.Button("Submit")
    
#     submit_button.click(fn=lambda q: vector_search(q, model), inputs=query, outputs=output)
# import gradio as gr

# # def greet(name):
# #     return "Hello " + name + "!!"
# from sentence_transformers import SentenceTransformer
# import numpy as np
# from sklearn.metrics.pairwise import cosine_similarity
# from datasets import load_dataset
# # Load pre-trained SentenceTransformer model
# embedding_model = SentenceTransformer("thenlper/gte-large")

# # # Example dataset with genres (replace with your actual data)
# # dataset = load_dataset("hugginglearners/netflix-shows")
# # dataset = dataset.filter(lambda x: x['description'] is not None and x['listed_in'] is not None and x['title'] is not None)
# # data = dataset['train']  # Accessing the 'train' split of the dataset

# # # Convert the dataset to a list of dictionaries for easier indexing
# # data_list = list[data]
# # print(data_list)
# # # Combine description and genre for embedding
# # def combine_description_title_and_genre(description, listed_in, title):
# #     return f"{description} Genre: {listed_in} Title: {title}"

# # # Generate embedding for the query
# # def get_embedding(text):
# #     return embedding_model.encode(text)

# # # Vector search function
# # def vector_search(query):
# #     query_embedding = get_embedding(query)
    
# #     # Generate embeddings for the combined description and genre
# #     embeddings = np.array([get_embedding(combine_description_title_and_genre(item["description"], item["listed_in"],item["title"])) for item in data_list[0]])

# #     # Calculate cosine similarity between the query and all embeddings
# #     similarities = cosine_similarity([query_embedding], embeddings)
# # Load dataset (using the correct dataset identifier for your case)
# dataset = load_dataset("hugginglearners/netflix-shows")

# # Combine description and genre for embedding
# def combine_description_title_and_genre(description, listed_in, title):
#     return f"{description} Genre: {listed_in} Title: {title}"

# # Generate embedding for the query
# def get_embedding(text):
#     return embedding_model.encode(text)

# # Vector search function
# def vector_search(query):
#     query_embedding = get_embedding(query)
    
#     # Function to generate embeddings for each item in the dataset
#     def generate_embeddings(example):
#         return {
#             'embedding': get_embedding(combine_description_title_and_genre(example["description"], example["listed_in"], example["title"]))
#         }

#     # Generate embeddings for the dataset using map
#     embeddings_dataset = dataset["train"].map(generate_embeddings)

#     # Extract embeddings
#     embeddings = np.array([embedding['embedding'] for embedding in embeddings_dataset])

#     # Calculate cosine similarity between the query and all embeddings
#     similarities = cosine_similarity([query_embedding], embeddings)
#     # # Adjust similarity scores based on ratings
#     # ratings = np.array([item["rating"] for item in data_list])
#     # adjusted_similarities = similarities * ratings.reshape(-1, 1)

#      # Get top N most similar items (e.g., top 3)
#     top_n = 3
#     top_indices = similarities[0].argsort()[-top_n:][::-1]  # Get indices of the top N results
#     top_items = [dataset["train"][i] for i in top_indices]
    
#     # Format the output for display
#     search_result = ""
#     for item in top_items:
#         search_result += f"Title: {item['title']}, Description: {item['description']}, Genre: {item['listed_in']}\n"

#     return search_result

# # Gradio Interface
# def movie_search(query):
#     return vector_search(query)
# with gr.Blocks() as demo:
#     gr.Markdown("# Netflix Recommendation System")
#     gr.Markdown("Enter a query to receive Netflix show recommendations based on title, description, and genre.")
#     query = gr.Textbox(label="Enter your query")
#     output = gr.Textbox(label="Recommendations")
#     submit_button = gr.Button("Submit")

#     submit_button.click(fn=movie_search, inputs=query, outputs=output)

# demo.launch()


# # iface = gr.Interface(fn=movie_search, 
# #                      inputs=gr.inputs.Textbox(label="Enter your query"), 
# #                      outputs="text", 
# #                      live=True,
# #                      title="Netflix Recommendation System",
# #                      description="Enter a query to get Netflix recommendations based on description and genre.")

# # iface.launch()


# # demo = gr.Interface(fn=greet, inputs="text", outputs="text")
# # demo.launch()