import streamlit as st
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing.sequence import pad_sequences
import joblib
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler

# Load the tokenizer (ensure it's the one used during training)
tokenizer = joblib.load('tokenizer.pkl')

# Load the emotion prediction model
emotion_model = load_model('lstm_model.h5')

# Load the dataset
df = pd.read_csv('df1.csv')
df = df.drop(['Unnamed: 0', 'lyrics_filename', 'analysis_url', 'track_href', "type", "id", "uri"], axis=1)

# Preprocess for content-based
audio_feature_columns = ['danceability', 'energy', 'key', 'loudness', 'mode', 'speechiness',
       'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo',
       'duration_ms', 'time_signature']

audio_features = df[audio_feature_columns]
mood_cats = df[['mood_cats']]
mood_cats_df = pd.DataFrame(mood_cats)

# Normalize audio features for content-based
scaler_cb = StandardScaler()
audio_features_scaled_cb = scaler_cb.fit_transform(audio_features)
audio_features_df_cb = pd.DataFrame(audio_features_scaled_cb, columns=audio_feature_columns)
combined_features_cb = pd.concat([mood_cats, audio_features_df_cb], axis=1)

# Load the similarity matrix for content-based
similarity_matrix = np.load('similarity_matrix.npy')

# Load the content-based recommendation function
recommend_cont = joblib.load('recommendation_cont_function.joblib')

# Preprocessing for KNN
scaler_knn = StandardScaler()
audio_features_scaled_knn = scaler_knn.fit_transform(audio_features)
audio_features_df_knn = pd.DataFrame(audio_features_scaled_knn, columns=audio_feature_columns)
combined_features_knn = pd.concat([mood_cats_df, audio_features_df_knn], axis=1)

# Load the KNN model
knn = joblib.load('knn_model.joblib')

# Load the KNN recommendation function
recommend_knn = joblib.load('recommendation_knn_function.joblib')

# Load the hybrid recommendation function
hybrid_recommendation = joblib.load('hybrid_recommendation_function.joblib')

# Set up the title of the app
st.title('Emotion and Audio Feature-based Song Recommendation System')

# Get data from index 0
query_data = df.iloc[0]

# Process the lyrics
sequence = tokenizer.texts_to_sequences([query_data['lyrics']])
padded_sequence = pad_sequences(sequence, maxlen=50)
emotion = emotion_model.predict(padded_sequence).flatten()

# Mapping emotion predictions to encoded categories
emotion_mapping = {0: 'happy', 1: 'sad', 2: 'calm', 3: 'anger'}
encoded_emotion = np.argmax(emotion)  
emotion_category = emotion_mapping[encoded_emotion]

# Combine emotion and audio features for recommendation
combined_features_hybrid = np.concatenate([encoded_emotion, query_data[audio_feature_columns].values])

# Generate recommendations using the hybrid model
hybrid_recs = hybrid_recommendation(song_index=0)

st.write("Emotion Detected:", emotion[0])
st.header('Recommended Songs (Hybrid)')
st.write(hybrid_recs)