from datetime import date, datetime
import numpy as np
import pandas as pd
pd.set_option('chained_assignment',None)
pd.set_option('display.max_columns',None)
import os
import pickle as pkl
from Source.Predict.predict import predict

# get team abbreviations
with open('Source/Pickles/team_abbreviation_to_name.pkl', 'rb') as f:
    team_abbreviation_to_name = pkl.load(f)

# get this year's odds and results
gbg_and_odds_this_year = pd.read_csv('Source/Data/gbg_and_odds_this_year.csv')
results = pd.read_csv('Source/Data/results.csv')

# make predictions
from tqdm import tqdm
print("Predicting games and getting record")
predictions = {}
for game_id,home,away,season,week,total in tqdm(gbg_and_odds_this_year[['game_id','home_team','away_team','Season','GP','Total Score Close']].values):
    if week!=1:
        predictions[game_id] = predict(home,away,season,week,total)

# merge data
predictions_df = pd.DataFrame(predictions).T
predictions_df['predicted_winner'] = [i['Winner'][0] if type(i['Winner'])==list else None for i in predictions_df[1]]
predictions_df['predicted_winner'] = predictions_df['predicted_winner'].map(team_abbreviation_to_name)
predictions_df['predicted_winner_probability'] = [i['Probabilities'][0] if type(i['Probabilities'])==list else None for i in predictions_df[1]]
predictions_df['predicted_over_under'] = [i['Over/Under'][0] if type(i['Over/Under'])==list else None for i in predictions_df[2]]
predictions_df['predicted_over_under_probability'] = [i['Probability'][0] if type(i['Probability'])==list else None for i in predictions_df[2]]
predictions_df = predictions_df.merge(results, left_index=True, right_on='game_id').merge(gbg_and_odds_this_year[['game_id','Total Score Close','home_team','away_team','game_date','Home Odds Close','Away Odds Close']]).dropna(subset=['predicted_winner'])
predictions_df['over_under'] = ['Over' if t>tsc else 'Under' if t<tsc else 'Push' for t,tsc in predictions_df[['total','Total Score Close']].values]
predictions_df['game_date'] = pd.to_datetime(predictions_df['game_date'])

# get returns
predictions_df['home'] = predictions_df['home_team'].map(team_abbreviation_to_name)
predictions_df['away'] = predictions_df['away_team'].map(team_abbreviation_to_name)
predictions_df['picked_home'] = (predictions_df['home']==predictions_df['predicted_winner'])
predictions_df['picked_away'] = (predictions_df['away']==predictions_df['predicted_winner'])

predictions_df['winner_correct'] = (predictions_df['predicted_winner']==predictions_df['winner'])
predictions_df['winner_incorrect'] = ((predictions_df['predicted_winner']!=predictions_df['winner']) & (predictions_df['winner']!='Tie'))
predictions_df['winner_tie'] = (predictions_df['winner']=='Tie')
predictions_df['over_under_correct'] = (predictions_df['predicted_over_under']==predictions_df['over_under'])
predictions_df['over_under_incorrect'] = ((predictions_df['predicted_over_under']!=predictions_df['over_under']) & (predictions_df['over_under']!='Push'))
predictions_df['over_under_push'] = (predictions_df['over_under']=='Push')

predictions_df['winner_return'] = [0 if tie else ao-1 if (pa and wc) else ho-1 if (ph and wc) else -1 for ao,ho,pa,ph,wc,tie in predictions_df[['Away Odds Close','Home Odds Close','picked_away','picked_home','winner_correct','winner_tie']].values]
predictions_df['over_under_return'] = [0 if push else 0.91 if ouc else -1 for ouc,push in predictions_df[['over_under_correct','over_under_push']].values]
predictions_df = predictions_df.loc[predictions_df['game_date']>datetime(year=2023,month=9,day=19)]

# Save
predictions_df.to_csv('Source/Data/predictions.csv')
bins = np.arange(0.5, 1.05, 0.05)
bin_midpoints = [(bins[i] + bins[i+1]) / 2 for i in range(len(bins) - 1)]

predictions_df['winner_probability_bin'] = pd.cut(predictions_df['predicted_winner_probability'], bins=bins, labels=bin_midpoints)
predictions_df['over_under_probability_bin'] = pd.cut(predictions_df['predicted_over_under_probability'], bins=bins, labels=bin_midpoints)
winner_binned = predictions_df.groupby('winner_probability_bin')['winner_correct'].mean().reset_index()
over_under_binned = predictions_df.groupby('over_under_probability_bin')['over_under_correct'].mean().reset_index()

## plot

import matplotlib.pyplot as plt
import numpy as np

def style_plot(ax, title):
    ax.set_facecolor('black')
    ax.set_title(title, color='white')
    ax.set_xlabel('MARCI Predicted Probability', color='white')
    ax.set_ylabel('Actual Probability', color='white')
    ax.tick_params(axis='x', colors='white')
    ax.tick_params(axis='y', colors='white')
    ax.spines['bottom'].set_color('white')
    ax.spines['top'].set_color('white')
    ax.spines['left'].set_color('white')
    ax.spines['right'].set_color('white')
    #ax.grid(True, linestyle='--', linewidth=0.5, color='grey')
    ax.set_ylim((0,1.1))

def add_identity_line(ax, max_x):
    x = np.linspace(0.5, max_x, 100)
    ax.plot(x, x, linestyle='--', color='grey')

def add_best_fit_line(ax, x_values, y_values):
    x_values = x_values.astype('float64')
    y_values = y_values.astype('float64')
    mask = ~np.isnan(x_values) & ~np.isnan(y_values)
    x_values = x_values[mask]
    y_values = y_values[mask]
    coef = np.polyfit(x_values, y_values, 1)
    poly1d_fn = np.poly1d(coef)
    ax.plot(x_values, poly1d_fn(x_values), color='green')
    corr = np.corrcoef(x_values, y_values)[0,1]
    max_x = np.max(x_values)
    max_y = poly1d_fn(max_x)
    #ax.text(max_x, max_y, f'Corr: {corr:.2f}', color='green')

# Create the Winner scatter plot
x_values_winner = winner_binned['winner_probability_bin']
y_values_winner = winner_binned['winner_correct']
fig1 = plt.figure(facecolor='black')
ax1 = fig1.add_subplot(1, 1, 1)
ax1.scatter(x_values_winner,
            y_values_winner,
            color=(0/255, 128/255, 0/255), s=100, marker='o')
add_identity_line(ax1, predictions_df['predicted_winner_probability'].max())
add_best_fit_line(ax1, predictions_df['predicted_winner_probability'], predictions_df['winner_correct'])
line, = ax1.plot([], [], linestyle='--', color='grey') 
marci_line, = ax1.plot([], [], color='green')
ax1.legend([line, marci_line], ['Perfect Model', 'MARCI'], loc='upper left', facecolor='black', edgecolor='white', labelcolor='white')
style_plot(ax1, 'Winner Predictions')
plt.savefig('Static/Winner_Predictions_dark.png', facecolor='black')
plt.close(fig1)

# Create the Over/Under scatter plot
x_values_over_under = over_under_binned['over_under_probability_bin']
y_values_over_under = over_under_binned['over_under_correct'] 
fig2 = plt.figure(facecolor='black')
ax2 = fig2.add_subplot(1, 1, 1)
ax2.scatter(x_values_over_under,
            y_values_over_under,
            color=(0/255, 128/255, 0/255), s=100, marker='o')
add_identity_line(ax2, predictions_df['predicted_over_under_probability'].max())
add_best_fit_line(ax2, predictions_df['predicted_over_under_probability'], predictions_df['over_under_correct'])
line, = ax2.plot([], [], linestyle='--', color='grey') 
marci_line, = ax2.plot([], [], color='green')
ax2.legend([line, marci_line], ['Perfect Model', 'MARCI'], loc='upper left', facecolor='black', edgecolor='white', labelcolor='white')
style_plot(ax2, 'Over/Under Predictions')
plt.savefig('Static/Over_Under_Predictions_dark.png', facecolor='black')
plt.close(fig2)


## get record
threshold = 0.6

winners_correct = predictions_df.loc[predictions_df['predicted_winner_probability']>threshold, 'winner_correct'].sum()
winners_accuracy = predictions_df.loc[predictions_df['predicted_winner_probability']>threshold, 'winner_correct'].mean()
winners_incorrect = predictions_df.loc[predictions_df['predicted_winner_probability']>threshold,'winner_incorrect'].sum()
winners_tie = predictions_df.loc[predictions_df['predicted_winner_probability']>threshold,'winner_tie'].sum()
winners_return = predictions_df.loc[predictions_df['predicted_winner_probability']>threshold, 'winner_return'].sum()

over_unders_correct = predictions_df.loc[predictions_df['predicted_over_under_probability']>threshold,'over_under_correct'].sum()
over_unders_accuracy = predictions_df.loc[predictions_df['predicted_over_under_probability']>threshold,'over_under_correct'].mean()
over_unders_incorrect = predictions_df.loc[predictions_df['predicted_over_under_probability']>threshold,'over_under_incorrect'].sum()
over_unders_push = predictions_df.loc[predictions_df['predicted_over_under_probability']>threshold,'over_under_push'].sum()
over_unders_return = predictions_df.loc[predictions_df['predicted_over_under_probability']>threshold,'over_under_return'].sum()

max_date = predictions_df['game_date'].max()
latest_game = pd.Timestamp(max_date).strftime("%A, %m/%d")

## get binom prob
from scipy.stats import binom

def compare_to_coinflip(c,n):
    prob_fewer = binom.cdf(c, n, 0.5)
    prob_more = 1 - prob_fewer
    return f"{round(prob_more*100,1)}% chance of equal or better performance by flipping a coin."

record = {"winners_correct":str(winners_correct),
        "winners_incorrect":str(winners_incorrect),
        "winners_tie":("-"+str(winners_tie) if winners_tie>0 else ''),
        "winners_return": str(round(winners_accuracy*100,1))+"% accuracy, " + str(round(winners_return,1))+"x return",
        "over_unders_correct":str(over_unders_correct),
        "over_unders_incorrect":str(over_unders_incorrect),
        "over_unders_push":("-"+str(over_unders_push) if over_unders_push>0 else ''),
        "over_unders_return": str(round(over_unders_accuracy*100,1))+"% accuracy, " + str(round(over_unders_return,1))+"x return",
        "latest_game":latest_game,
        "over_unders_binom":compare_to_coinflip(over_unders_correct, (over_unders_incorrect+over_unders_correct)),
        "winners_binom":compare_to_coinflip(winners_correct, (winners_incorrect+winners_correct))}

import json
with open('Source/Data/record.json', 'w') as f:
    json.dump(record,f)