import os
from fastai.vision.all import *
import gradio as gr
import pickle
import tempfile
from transformers import AutoTokenizer, AutoModelWithLMHead
from speechbrain.inference.interfaces import foreign_class



# Facial expression classifier

# Emotion
learn_emotion = load_learner('emotions_vgg.pkl')
learn_emotion_labels = learn_emotion.dls.vocab


# Predict
def predict(img):
    img = PILImage.create(img)
    pred_emotion, pred_emotion_idx, probs_emotion = learn_emotion.predict(img)
    predicted_emotion = learn_emotion_labels[pred_emotion_idx]
    return predicted_emotion


# Gradio
title = "Facial Emotion Detector 🔎"

description = gr.Markdown(
    """Ever wondered what a person might be feeling just by looking at their picture? 
    Well, get ready to unleash your inner psychic with this hilarious app! 
    Simply upload a close-up facial image in JPG or PNG format, and brace yourself for the laugh riot. 
    Our emotion detector will take one look at their face and reveal what they might have felt 
    when the picture was taken. 

    ## Pro Tip:
    For best results, make sure only their face is in the picture.It's like reading their mind, but with pixels! 😄 
    And hey, if you're feeling a bit down, this app is sure to turn that frown upside down!""").value

article = gr.Markdown(
    """
    ## Disclaimer
    This app isn't powered by actual mind-reading technology! 
    So, take the results with a grain of salt, or better yet, a pinch of laughter! 

    ## Fun Fact
    Our facial emotion detector was trained on a bunch of wacky pictures 
    from the FER2013 dataset. It's not perfect, but it'll give you a good chuckle! 

    ## Data Jokes
    Did you know the FER2013 dataset consists of 48x48 pixel grayscale images of faces? 
    We're talking emotions captured in a tiny pixel universe! 
    It's like trying to decipher emotions from a microcosm of hilarity! 🧐
    """).value
enable_queue=True

examples = ["happy1.jpg","happy2.jpeg","netural.jpg","sad.jpeg","surprise.jpeg"]

image_mode=gr.Interface(fn = predict, 
             inputs = gr.Image( image_mode='L',label='Image'), 
             outputs = [gr.Label(label='Emotion')], #gr.Label(),
             title = title,
             examples = examples,
             description = description,
             article=article,
             allow_flagging='never')




# Txet Model

# Load tokenizer and model from pickles
with open("emotion_tokenizer.pkl", "rb") as f:
    tokenizer = pickle.load(f)

with open("emotion_model.pkl", "rb") as f:
    model = pickle.load(f)



def classify_emotion(text):
    # Tokenize input text and generate output
    input_ids = tokenizer.encode("emotion: " + text, return_tensors="pt")
    output = model.generate(input_ids)
    output_text = tokenizer.decode(output[0], skip_special_tokens=True)
    
    # Classify the emotion into positive, negative, or neutral
    if output_text in ["joy", "love"]:
        return "Positive"
    elif output_text == "surprise":
        return "Neutral"
    else:
        return "Negative"
    return output_text




# Gradio
text_title = "Text Emotion Detector 😄🤨😠"

text_description = gr.Markdown(
                """
## Introduction
Welcome to our Text Emotion Detector, also known as The Mood Meter! 🎭 This nifty tool helps you decipher the emotional rollercoaster hidden within any piece of text. Whether it's an enthusiastic rave, a stone-cold report, or a fiery rant, we'll break it down into three simple categories: positive, neutral, or negative vibes. Let's have some fun with words! 🚀

## How It Works
Our Mood Meter uses top-notch text analysis wizardry to understand the feels behind your words. We've trained it on mountains of text data and equipped it with cutting-edge algorithms to accurately predict whether your text is partying in positivity, chilling in neutrality, or burning with negativity. 🔥


Now, who said sentiment analysis couldn't be the highlight of your day? Let's turn those words into a mood-boosting adventure! 🚀""").value

text_article = gr.Markdown(
             """

## Data
Our Mood Meter has gobbled up datasets filled with everything from Shakespearean sonnets to social media rants. We've trained it to handle diverse dialects, and writing styles. Because emotions don't stick to a script, and neither do we! 🌍

## Disclaimer
While The Mood Meter aims to tickle your funny bone while analyzing sentiment, remember that text analysis is an art, not an exact science. Take our results with a sprinkle of salt (or confetti) and always trust your gut (or your funny bone). 😉✨
              """).value

enable_queue=True


text_examples=["I aced my exam and received praise from my teacher for my hard work.",
"I just got a promotion at work, and I'm feeling on top of the world!",
"The sudden change in weather surprised everyone, but it didn't cause any inconvenience.",
"I accidentally spilled coffee on my laptop, causing it to malfunction.",
"I burnt my dinner while trying out a new recipe, and now I have nothing to eat."    
          
]


text_model=gr.Interface(fn = classify_emotion, 
             inputs = gr.Textbox( label='Text'), 
             outputs = gr.Textbox(label='Emotion'), 
             title = text_title,
             examples = text_examples,
             description = text_description,
             article=text_article,
             allow_flagging='never')












# Initialize the classifier
classifier = foreign_class(source="speechbrain/emotion-recognition-wav2vec2-IEMOCAP", pymodule_file="custom_interface.py", classname="CustomEncoderWav2vec2Classifier")

def save_uploaded_file(uploaded_file):
    temp_dir = tempfile.TemporaryDirectory()
    file_path = os.path.join(temp_dir.name, uploaded_file.name)
    with open(file_path, "wb") as f:
        f.write(uploaded_file.getbuffer())
    return file_path


def emotion(file_path):
   
    if file_path:
        # Classify the file
        out_prob, score, index, text_lab = classifier.classify_file(file_path)
        if isinstance(text_lab, list):
            text_lab = text_lab[0]
        # Map the original labels to the desired categories
        emotion_mapping = {
            'neu': 'Neutral',
            'ang': 'Angry',
            'hap': 'Happy',
            'sad': 'Sadness'
        }
        # Get the corresponding category from the mapping
        emotion_category = emotion_mapping.get(text_lab, 'Unknown')
        
        emotion_category = emotion_mapping.get(text_lab, 'Unknown')
        # Return the emotion category
        return emotion_category
    else:
        return "Please provide the path to an audio file."




import gradio as gr

# Gradio
audio_title = "Audio Emotion Detector 🎙️"

audio_description = gr.Markdown(
    """Ever wondered what emotions someone's voice might be hiding? 
    Prepare to dive into the wild world of vocal emotions with this uproariously entertaining app! 
    Just upload an audio clip in WAV or MP3 format, and our trusty emotion detector 
    will spill the beans on what kind of emotional rollercoaster ride they're on. 

    ## Pro Tip 
    Make sure the audio clip captures only their voice for maximum hilarity! 
    Let's see if they're serenading with sorrow or belting out bursts of bliss! 🎶 And hey, if you're feeling a bit blue yourself, this app is sure to hit all the right notes 
    and lift your spirits!""").value

audio_article = gr.Markdown(
    """
    ## Disclaimer 
    This app isn't equipped with psychic powers! 
    So, take the results with a pinch of musical humor, or better yet, a dollop of whimsy! 

    ## Fun Fact
    Our audio emotion detector was trained on a zany collection of audio clips 
    that range from dramatic monologues to cat karaoke concerts! It's not just about the tones; 
    it's about the tunes too! 🐱🎤

    ## Data Delights
    Did you know our dataset includes a cacophony of audio clips 
    in WAV and MP3 formats? It's like tuning into an emotion-filled radio station 
    where every frequency is a new adventure in hilarity! 📻
    """).value




audio_examples=["Audio 1.wav","Audio 2.wav","Audio 3.wav","Audio 4.wav","Audio 5.wav"]


audio_model=gr.Interface(fn = emotion, 
             inputs = gr.Textbox( label='Audio File Path'), 
             outputs = gr.Textbox(label='Emotion'), 
             title = audio_title,
             examples = audio_examples,
             description = audio_description,
             article=audio_article,
             allow_flagging='never')






#Home Page
HP_title = "Multimodal Sentiment Analysis: Feel the Emotion in Every Pixel, Word, and Sound!"
HP_description = gr.Markdown(
"""
## Hey There! 🌟
Welcome to our spectacular project, Multimodal Sentiment Analysis! 🚀 Here, we're all about unraveling the emotions tucked away in text, audio, and images. Think of us as your personal emotion whisperers across various platforms!
## Why It's So Darn Cool 😎
Imagine this: understanding emotions unlocks the door to understanding people better. With our project, we're diving headfirst into a pool of sentiments! From heartwarming messages to catchy tunes, and from breathtaking landscapes to hilarious memes, we're decoding it all!
## Explore Emotions Effortlessly with Tabs! 📑
Navigate through emotions seamlessly with our nifty tabs:
- **Text Emotion Recognition**: Unravel the emotional rollercoaster hidden in every word!
- **Image Emotion Recognition**: Peek into the feelings behind every snapshot!
- **Audio Emotion Recognition**: Tune in to the vibes of emotions with every sound clip!
## Meet Our Awesome Models 🌟
### 1. Text Emotion Recognition
This model is your go-to buddy for understanding the emotional vibe in written text! Whether it's a love letter or a tweet storm, our Text Emotion Recognition model has got your back, decrypting emotions like a champ!
### 2. Image Emotion Recognition
Ever wondered what feelings those grins, frowns, and winks in photos convey? Our Image Emotion Recognition model spills the beans! It's like having a personal mood interpreter for every pic you snap!
### 3. Audio Emotion Recognition
Listen up! Our Audio Emotion Recognition model tunes in to the subtle nuances of voice, capturing emotions in every syllable! From giggles to sobs and everything in between, it's your trusty sidekick for decoding the melodies of emotions!
## Meet the Fabulous Team Behind the Magic! 🧠
Let's give a round of applause to the brilliant minds who made it all happen:
- **Pavan**: The wordsmith behind the Text Emotion Recognition model, spinning magic with language and algorithms!
- **Abhiram**: The visionary behind the Image Emotion Recognition model, bringing pixels to life with emotion decoding powers!
- **Karthik**: The audio maestro shaping the Audio Emotion Recognition model, capturing the symphony of emotions in every sound wave!
- **Ganesh**: The glue holding it all together, orchestrating the dance of emotions and teamwork!
""").value

def greet(name):
    pass
home_page=gr.Interface(fn = greet, 
             inputs = gr.Textbox(label="Hey there! Ready to spice up your title game? Drop your name, and let's turn it into a giggling sensation!"
            ), 
             outputs = None,
             description = HP_description,
             theme='gradio/monochrome',
             title=HP_title,
             allow_flagging='never')



main_model = gr.TabbedInterface([home_page,text_model, image_mode,audio_model], ["Home Page","Text Emotion Recognition", "Image Emotion Recognition" , "Audio Emotion Recognition"], theme=gr.themes.Default(font="Bahnschrift Light"))

main_model.launch()