import os, csv
import numpy as np
import pandas as pd

import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')
%matplotlib inline

ipa_ratings = [file for file in os.listdir('tIJ_IPA/') if file[-3:] == 'txt']
print ipa_ratings

d = {}

for ipa in ipa_ratings:
    ipa_file = 'tIJ_IPA/' + ipa
    ipa_name = (ipa.split('_')[2])
    with open(ipa_file, 'r') as f:
        next(f)
        temp_dict = {}
        for line in f:
            line = line.strip()
            key, val = line.split('\t')
            temp_dict[key] = float(val)

        d[ipa_name] = temp_dict
        
df_ipa = pd.DataFrame.from_dict(d)
print df_ipa.shape
df_ipa.head()

# df_ipa.to_csv('tIJ_IPA/ipa_listing.csv')

df_ipa.plot.box()

df_ipa.plot.hist(alpha=0.5)

df_ipa['ratings_cnt'] = df_ipa.notnull().sum(axis=1)

print df_ipa[df_ipa.ratings_cnt > 1].shape
df_ipa[df_ipa.ratings_cnt > 1].head()

df_ipa[(df_ipa.ratings_cnt > 1) & (df_ipa.tij >= .1)].head()

# mean ratings of beers based on number of IPA's from collection rated
# i.e., some reviewers only rated 1 beer, others all 9
# i myself have had 8 of 9; missing 'surly'

df_ipa.groupby('ratings_cnt').mean()

ipa_comp = np.zeros(81).reshape(9,9)

for i in range(len(df_ipa.columns[:-1])):
    for j in range(len(df_ipa.columns[:-1])):
        # +1 for outright better rating
        ipa_comp[i][j] += np.sum(df_ipa.iloc[:, i] > df_ipa.iloc[:, j])
        # +0.5 for even score
        # makes more sense for "winning percentage"
        ipa_comp[i][j] += np.sum(df_ipa.iloc[:, i] == df_ipa.iloc[:, j])/2.0
    ipa_comp[i][i] = 0

print 'Post comparison tally:\n'
print ipa_comp

# number of head-to-head match ups
np.sum(ipa_comp)

# number of reviewers
# obviously only counting reviewers with two or more IPA's rated
# info already available above but highlighting it here
np.sum(df_ipa.ratings_cnt > 1)

ipa_perc = np.zeros(81).reshape(9,9)

for i in range(len(df_ipa.columns[:-1])):
    for j in range(len(df_ipa.columns[:-1])):
        try:
            ipa_perc[i][j] = ipa_comp[i][j]/float(ipa_comp[i][j] + ipa_comp[j][i])
        except:
            ipa_perc[i][j] = 0
        
print 'Post percentage calculation:\n'
print np.round_(ipa_perc, 4)

print df_ipa.columns[:-1].tolist()
print np.round_(ipa_perc, 3)

toy_wins = np.array([[0, 1, 1], [0, 0, 1], [1, 0, 0]])
toy_wins

rating_iter = []
rating_iter.append(np.ones(3).reshape((3,1)))
rating_iter

idx_a = 0
idx_b = 1
idx_c = 2

# newA
np.sum(toy_wins[idx_a]) /\
    float( np.sum(toy_wins[idx_a][idx_b]+toy_wins[idx_b][idx_a])/float(rating_iter[0][idx_a]+rating_iter[0][idx_b]) +\
           np.sum(toy_wins[idx_a][idx_c]+toy_wins[idx_c][idx_a])/float(rating_iter[0][idx_a]+rating_iter[0][idx_c])
         )

# newB
np.sum(toy_wins[idx_b]) /\
    float( np.sum(toy_wins[idx_a][idx_b]+toy_wins[idx_b][idx_a])/float(rating_iter[0][idx_a]+rating_iter[0][idx_b]) +\
           np.sum(toy_wins[idx_b][idx_c]+toy_wins[idx_c][idx_b])/float(rating_iter[0][idx_b]+rating_iter[0][idx_c])
         )

# newC
np.sum(toy_wins[idx_c]) /\
    float( np.sum(toy_wins[idx_a][idx_c]+toy_wins[idx_c][idx_a])/float(rating_iter[0][idx_a]+rating_iter[0][idx_c]) +\
           np.sum(toy_wins[idx_b][idx_c]+toy_wins[idx_c][idx_b])/float(rating_iter[0][idx_b]+rating_iter[0][idx_c])
         )

teams = {'a': 0, 'b': 1, 'c': 2}

def new_rating(team, rating=0):
    
    team_list = [team]
    wins = float(np.sum(toy_wins[teams[team]]))
    
    denom = 0
    
    for t, idx in teams.items():
        if t not in team_list:
            games_against = float(np.sum(toy_wins[teams[team]][idx]+toy_wins[idx][teams[team]]))
            denom += games_against/float(rating_iter[rating][teams[team]]+rating_iter[rating][idx])
    
    return wins/denom

print new_rating('a', 0)
print new_rating('b')
print new_rating('c')

for team in teams:
    print 'team %s: %f\n' % (team, new_rating(team))

rating_iter = []
rating_iter.append(np.ones(3).reshape((3,1)))


for i in range(2000):
    temp_ratings = []
    # specifiy ratings order via list
    # notice in test function in cell above 'b' and 'c' swap prefered order
    for j in ['a', 'b', 'c']:
        temp_ratings.append(new_rating(j, i))
    rating_iter.append(temp_ratings)
    
    if np.array_equal(rating_iter[-2], rating_iter[-1]):
        print "number or iterations to maximize:", i
        break

print "ratings:", rating_iter[-1]
print "Team A beats B: %f" % (rating_iter[-1][0]/(rating_iter[-1][0]+rating_iter[-1][1]))

rating_iter = []
rating_iter.append(np.ones(9).reshape((9,1)))
rating_iter

ipas = {k:v for k, v in zip(df_ipa.columns[:-1], range(9))}
print ipas

def new_beer_rating(beer, grid=ipa_comp, rating=0):
    
    beer_list = [beer]
    wins = float(np.sum(grid[ipas[beer]]))
    
    denom = 0
    
    for b, idx in ipas.items():
        if b not in beer_list:
            games_against = float(np.sum(grid[ipas[beer]][idx]+grid[idx][ipas[beer]]))
            denom += games_against/float(rating_iter[rating][ipas[beer]]+rating_iter[rating][idx])
    
    return wins/denom

print new_beer_rating('tij')

# notice again the IPA's get random sorting
for ipa in ipas:
    print '1st rating update of %s: %f' % (ipa, new_beer_rating(ipa))

# just to have the IPA order present for reference
print df_ipa.columns[:-1]

rating_iter = []
rating_iter.append(np.ones(9).reshape((9,1)))


for i in range(2000):
    temp_ratings = []
    # specifiy ratings order via list
    # notice in test function in cell above 'b' and 'c' swap prefered order
    for j in df_ipa.columns[:-1]:
        temp_ratings.append(new_beer_rating(j, ipa_comp, i))
    rating_iter.append(temp_ratings)
    
    if np.array_equal(rating_iter[-2], rating_iter[-1]):
        print "number or iterations to maximize:", i
        break

print "ratings:", rating_iter[-1]
print "'t IJ beats Stone: %f" % (rating_iter[-1][7]/(rating_iter[-1][7]+rating_iter[-1][5]))

# generate ratings dict and sort in desc order for creation of grids
ipa_rating_score = {k:v for k,v in zip(df_ipa.columns[:-1], rating_iter[-1])}
ipa_rating_score = sorted(ipa_rating_score.items(), key=lambda x: (-x[1], x[0]))
ipa_rating_score

ipa_perc_sorted = np.zeros(81).reshape(9,9)

new_beer_row = 0

for i in ipa_rating_score:
    new_beer_col = 0
    for j in ipa_rating_score:
        old_beer_row = ipas[i[0]]
        old_beer_col = ipas[j[0]]
#         print i, j, old_beer_row, old_beer_col
        ipa_perc_sorted[new_beer_row][new_beer_col] = ipa_perc[old_beer_row][old_beer_col]
        new_beer_col += 1
    new_beer_row += 1
        
np.round_(ipa_perc_sorted, 2)

ipa_est_pref = np.zeros(81).reshape(9,9)

est_row = 0

for i in ipa_rating_score:
    est_col = 0
    for j in ipa_rating_score:
        if i[0] == j[0]:
            est_col += 1
            pass
        else:
            ipa_est_pref[est_row][est_col] = i[1]/(i[1]+j[1])
            est_col += 1
    est_row += 1

print [beer[0] for beer in ipa_rating_score]
np.round_(ipa_est_pref, 2)           

# import plotly.plotly as py
# import plotly.graph_objs as go

# - OR -
# import seaborn as sns

# {k:v for k,v in zip(range(9), [beer[0] for beer in ipa_rating_score])}

ipa_perc_sorted_df = pd.DataFrame(ipa_perc_sorted, 
                               columns=[beer[0] for beer in ipa_rating_score], 
                               index=[beer[0] for beer in ipa_rating_score])

ipa_est_pref_df = pd.DataFrame(ipa_est_pref, 
                               columns=[beer[0] for beer in ipa_rating_score], 
                               index=[beer[0] for beer in ipa_rating_score])

import seaborn as sns

# User Rating Preferences
plt.figure(figsize=(12, 12))
plt.title('User Rating Preferences')
sns.heatmap(ipa_perc_sorted_df, annot=True, cbar=False, cmap="YlGnBu")

# Maximum Liklihood Estimates
plt.figure(figsize=(12, 12))
plt.title('Maximum Liklihood Estimates')
sns.heatmap(ipa_est_pref_df.replace(0, np.nan), annot=True, cbar=False)