description = []
for d in cl_cleaned['desc']:
    desc_temp = " "
    for s in d.split('\n\n\n')[1].split('\n'):
        desc_temp += s
    description.append(desc_temp)

cl_cleaned['desc'] = description

# Combine title and description columns

cl_cleaned['review'] = cl_cleaned['title'] + cl_cleaned['desc']

# Manually extracted keywords for each brand

brands = {"Microsoft": ["xbox", "microsoft", "360", "xbox one", " rig ", "x box", "series x", "series s", 
                        "halo","kinect"], 
          "Nintendo": ["wii", "gamecube", "game cube", " ds ", "gameboy", "nintendo", "switch", "cube", 
                       "lite", " dsi ", "2ds", "wii fit", "nunchuck", "game boy", "game boy", "onyx", "oled", 
                       "3ds", "gba","wii remote"], 
          "Sony": ["playstation", "play station", " ps ", "sony", " psp ", "ps4", "ps3", "ps5", "ps vr", "pro", 
                   "ps4 slim"], 
          "Arcade": ["arcade", "atari", "slot machine", "pinball", "machine"], 
          "Meta": ["oculus", "meta", "quest", "quest 2", "vr headset", "rift", "quest 2 elite", "touch controller", 
                   "halo headband", "head strap"]
         }

# We created new columns for all the brands and calculated scores for each sample if any keywords exist in description
# or title. Then we identified which brand each post belongs to based on the brand that had the largest score.
# We created the 'Other' column and assign 0.5 for all samples as default so that samples that had score 0 for all 
# brands can be classfieid to 'Other' category.

import numpy as np

for brand in brands:
    cl_cleaned[brand] = np.repeat(0, len(cl))
    for word in brands[brand]:
        cl_cleaned[brand] += cl_cleaned.title.str.contains(word)
        cl_cleaned[brand] += cl_cleaned.desc.str.contains(word)

cl_cleaned['Other'] = np.repeat(0.5, 3011)
cl_cleaned['Brand'] = cl_cleaned.iloc[:,-6:].idxmax(axis=1)

# Create review and target dataframes separately
reviews = list(cl['review'])
target = list(cl['Brand'])


# Split the review and target data into train(75%) and test(25%) dataset
from sklearn.model_selection import train_test_split

train_input, test_input, train_y, test_y = train_test_split(reviews, target, random_state=12)

import nltk
from nltk.corpus import stopwords
from sklearn.feature_extraction.text import TfidfVectorizer

# Tokenization, and Normalization
review_preprocessed_tokenized = []

lemmatizer = nltk.stem.WordNetLemmatizer()
for review in train_input:
    tokens = nltk.word_tokenize(review.lower())
    lemmatized_token = [lemmatizer.lemmatize(token) for token in tokens if token.isalpha()]
    stopwords_removed = [token for token in lemmatized_token if not token in stopwords.words('english')]
    review_preprocessed_tokenized.append(stopwords_removed)

# Vectorization, training the model and transformation to numerical representations

review_preprocessed = []
for review in review_preprocessed_tokenized:
    review_preprocessed.append(" ".join(review))

vectorizer = TfidfVectorizer(ngram_range=(1,2), min_df=2)
vectorizer.fit(review_preprocessed)

train_x = vectorizer.transform(train_input)
test_x = vectorizer.transform(test_input)

docs_x = []
docs_train_x = []
docs_test_x = []
for review in train_input:
    docs_x.append(nltk.word_tokenize(str(review).lower()))
    docs_train_x.append(nltk.word_tokenize(str(review).lower()))
for review in train_input:
    docs_x.append(nltk.word_tokenize(str(review).lower()))
    docs_test_x.append(nltk.word_tokenize(str(review).lower()))

from collections import Counter
words = [j for i in docs_x for j in i]
count_words = Counter(words)
total_words = len(words)
sorted_words = count_words.most_common(total_words)
vocab_to_int = {w: i+1 for i, (w,c) in enumerate(sorted_words)} 

text_int = []
for i in docs_train_x:
    r = [vocab_to_int[w] for w in i]
    text_int.append(r)


text_test_int = []
for i in docs_test_x:
    r = [vocab_to_int[w] for w in i]
    text_test_int.append(r)


from keras.preprocessing import sequence 
from keras.models import Sequential 
from keras.layers import Dense, Embedding, Flatten 
from keras.layers import LSTM
max_features = total_words
maxlen = 250
batch_size = 32

x_train = sequence.pad_sequences(text_int, maxlen=maxlen)
x_test = sequence.pad_sequences(text_test_int, maxlen=maxlen)

encoded_train = [0 if label =='Sony' else 1 if label == "Nintendo" else 2 if label == "Microsoft" else 3 if label == "Arcade" else 4 if label == "Meta" else 5 for label in train_y]
encoded_test = [0 if label =='Sony' else 1 if label == "Nintendo" else 2 if label == "Microsoft" else 3 if label == "Arcade" else 4 if label == "Meta" else 5 for label in test_y]

model = Sequential()
model.add(Embedding(max_features, 20, input_length=maxlen))
model.add(LSTM(100, dropout=0.10, recurrent_dropout=0.10))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x_train.tolist(), encoded_train, batch_size=batch_size, epochs=2, validation_data=(x_test.tolist(), encoded_test))