# -*- coding: utf-8 -*-
"""HS_Text_REC_Games_Gradio_Blocks.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/19yJ8RC70IDljwSmPlqtOzWz192gwLAHF
"""

import pandas as pd
import numpy as np
from fuzzywuzzy import fuzz
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import gradio as gr

df = pd.read_csv("Metacritic_Reviews_Only.csv",  error_bad_lines=False, encoding='utf-8')

#Remove title from review
def remove_title(row):
  game_title = row['Game Title']
  body_text = row['Reviews']
  new_doc = body_text.replace(game_title, "")
  return new_doc

df['Reviews'] = df.apply(remove_title, axis=1)
#drop redundant column
df = df.drop(['Unnamed: 0'], axis=1)

df.dropna(inplace=True) #Drop Null Reviews

# Instantiate the vectorizer object to the vectorizer variable
#Minimum word count 2 to be included, words that appear in over 70% of docs should not be included
vectorizer = TfidfVectorizer(min_df=2, max_df=0.7)

# Fit and transform the plot column
vectorized_data = vectorizer.fit_transform(df['Reviews'])

# Create Dataframe from TF-IDFarray
tfidf_df = pd.DataFrame(vectorized_data.toarray(), columns=vectorizer.get_feature_names())

# Assign the game titles to the index
tfidf_df.index = df['Game Title']

# Find the cosine similarity measures between all game and assign the results to cosine_similarity_array.
cosine_similarity_array = cosine_similarity(tfidf_df)

# Create a DataFrame from the cosine_similarity_array with tfidf_df.index as its rows and columns.
cosine_similarity_df = pd.DataFrame(cosine_similarity_array, index=tfidf_df.index, columns=tfidf_df.index)

# Find the values for the game Batman: Arkham City
cosine_similarity_series = cosine_similarity_df.loc['Batman: Arkham City']

# Sort these values highest to lowest
ordered_similarities = cosine_similarity_series.sort_values(ascending=False)

# Print the results
print(ordered_similarities)

# create a function to find the closest title
def matching_score(a,b):
  #fuzz.ratio(a,b) calculates the Levenshtein Distance between a and b, and returns the score for the distance
   return fuzz.ratio(a,b)
   # exactly the same, the score becomes 100

#Convert index to title_year
def get_title_from_index(index):
   return df[df.index == index]['Game Title'].values[0]

# A function to return the most similar title to the words a user type
# Without this, the recommender only works when a user enters the exact title which the data has.
def find_closest_title(title):
  #matching_score(a,b) > a is the current row, b is the title we're trying to match
   leven_scores = list(enumerate(df['Game Title'].apply(matching_score, b=title))) #[(0, 30), (1,95), (2, 19)~~] A tuple of distances per index
   sorted_leven_scores = sorted(leven_scores, key=lambda x: x[1], reverse=True) #Sorts list of tuples by distance [(1, 95), (3, 49), (0, 30)~~]
   closest_title = get_title_from_index(sorted_leven_scores[0][0])
   distance_score = sorted_leven_scores[0][1]
   return closest_title, distance_score
   # Bejeweled Twist, 100

def find_closest_titles(title):
   leven_scores = list(enumerate(df['Game Title'].apply(matching_score, b=title))) #[(0, 30), (1,95), (2, 19)~~] A tuple of distances per index
   sorted_leven_scores = sorted(leven_scores, key=lambda x: x[1], reverse=True) #Sorts list of tuples by distance [(1, 95), (3, 49), (0, 30)~~]
   closest_titles = [get_title_from_index(sorted_leven_scores[i][0]) for i in range(5)]
   distance_scores = [sorted_leven_scores[i][1] for i in range(5)]
   return closest_titles, distance_scores
   # Bejeweled Twist, 100

def recommend_games_v1(game1, game2, game3, max_results):
  #Counter for Ranking
  number = 1
  print('Recommended because you played {}, {} and {}:\n'.format(game1, game2, game3))

  list_of_games_enjoyed = [game1, game2, game3]
  games_enjoyed_df = tfidf_df.reindex(list_of_games_enjoyed)
  user_prof = games_enjoyed_df.mean()
  
  tfidf_subset_df = tfidf_df.drop([game1, game2, game3], axis=0)
  similarity_array = cosine_similarity(user_prof.values.reshape(1, -1), tfidf_subset_df)
  similarity_df = pd.DataFrame(similarity_array.T, index=tfidf_subset_df.index, columns=["similarity_score"])

  # Sort the values from high to low by the values in the similarity_score
  sorted_similarity_df = similarity_df.sort_values(by="similarity_score", ascending=False)

  number = 0
  rank = 1
  rank_range = []
  name_list = []
  score_list = []
  for n in sorted_similarity_df.index:
    if rank <= max_results:
      rank_range.append(rank)
      name_list.append(n)
      score_list.append(str(round(sorted_similarity_df.iloc[number]['similarity_score']*100,2)) + "% ") #format score as a percentage
      number+=1
      rank +=1
  #Turn lists into a dictionary
  data = {'Rank': rank_range, 'Game Title': name_list, '% Match': score_list}
  rec_table = pd.DataFrame.from_dict(data) #Convert dictionary into dataframe
  rec_table.set_index('Rank', inplace=True) #Make Rank column the index
  return rec_table

demo = gr.Blocks()

with demo:
  gr.Markdown(
          """
      # Game Recommendations
      Input 3 games you enjoyed playing and use the dropdown to confirm your selections. Hopefully they are registered in the database. Once all 3 have been chosen, please generate your recommendations.
      """
      )
  
  options = ['Dragonball', 'Batman', 'Tekken']
  def Dropdown_list(x):
    new_options =  [*options, x + " Remastered", x + ": The Remake", x + ": Game of the Year Edition", x + " Steelbook Edition"]
    return gr.Dropdown.update(choices=new_options)

  with gr.Column(visible=True):
    first_entry = gr.Textbox(label="Game Title 1")
    first_dropdown = gr.Dropdown(choices=[], label="Closest Matches")
    update_first = gr.Button("Match Closest Title 1")

  with gr.Column(visible=True):
    second_entry = gr.Textbox(label="Game Title 2")
    second_dropdown = gr.Dropdown(label="Closest Matches")
    update_second = gr.Button("Match Closest Title 2")

  with gr.Column(visible=True):
    third_entry = gr.Textbox(label="Game Title 3")
    third_dropdown = gr.Dropdown(label="Closest Matches")
    update_third = gr.Button("Match Closest Title 3")
  
  with gr.Row():
    slider = gr.Slider(1, 20, step=1)

  with gr.Row():
    generate = gr.Button("Generate")
    results = gr.Dataframe(label="Top Results")

  def filter_matches(entry):
    top_matches = find_closest_titles(entry)
    top_matches = list(top_matches[0])
    return gr.Dropdown.update(choices=top_matches) #, gr.update(visible=True)

  def new_match(text):
    top_match = find_closest_title(text)
    return text

  first_entry.change(new_match, inputs=first_entry, outputs=first_dropdown)
  update_first.click(filter_matches, inputs=first_dropdown, outputs=first_dropdown)
  second_entry.change(new_match, inputs=second_entry, outputs=second_dropdown)
  update_second.click(filter_matches, inputs=second_dropdown, outputs=second_dropdown)
  third_entry.change(new_match, inputs=third_entry, outputs=third_dropdown)
  update_third.click(filter_matches, inputs=third_dropdown, outputs=third_dropdown)

  
  generate.click(recommend_games_v1, inputs=[first_dropdown, second_dropdown, third_dropdown, slider], outputs=results)
demo.launch()