from fnmatch import fnmatch
from matplotlib import rcParams
import numpy as np
from numpy import *
import pandas as pd
import matplotlib.pyplot as plt
import requests
from pattern import web
import html5lib
from bs4 import BeautifulSoup
import csv
from datetime import datetime
import scipy.stats as stats
import sklearn.cross_validation as cv
from collections import defaultdict 
import datetime, time
from random import choice
import operator
from IPython.display import Image

%matplotlib inline

team_acronym = {'Atlanta Hawks': 'ATL',
'Brooklyn Nets': 'BKN',
'New Jersey Nets': 'BKN',
'Boston Celtics': 'BOS',
'Charlotte Bobcats': 'CHA',
'Chicago Bulls': 'CHI',
'Cleveland Cavaliers': 'CLE',
'Dallas Mavericks': 'DAL',
'Denver Nuggets': 'DEN',
'Detroit Pistons': 'DET',
'Golden State Warriors': 'GSW',
'Houston Rockets': 'HOU',
'Indiana Pacers': 'IND',
'Los Angeles Clippers': 'LAC',
'Los Angeles Lakers': 'LAL',
'Memphis Grizzlies': 'MEM',
'Miami Heat': 'MIA',
'Milwaukee Bucks': 'MIL',
'Minnesota Timberwolves': 'MIN',
'New Orleans Hornets': 'NOH',
'New Orleans Pelicans': 'NOH',
'New York Knicks': 'NYK',
'Oklahoma City Thunder': 'OKC',
"Seattle SuperSonics": "OKC",
'Orlando Magic': 'ORL',
'Philadelphia 76ers': 'PHI',
'Phoenix Suns': 'PHX',
'Portland Trail Blazers': 'POR',
'Sacramento Kings': 'SAC',
'San Antonio Spurs': 'SAS',
'Toronto Raptors': 'TOR',
'Utah Jazz': 'UTA',
'Washington Wizards': 'WAS'}

team_names = dict(zip(team_acronym.values(), team_acronym.keys()))

NBA_teams= ['ATL', 'BKN', 'BOS', 'CHA', 'CHI', 
            'CLE', 'DAL', 'DEN', 'DET', 'GSW', 'HOU', 
            'IND', 'LAC','LAL','MEM', 'MIA', 'MIL', 
            'MIN', 'NOH', 'NYK', 'OKC', 'ORL', 
            'PHI', 'PHX', 'POR', 'SAC', 'SAS', 'TOR', 'UTA', 'WAS']

NBA_divisions= {"Atlantic": ['BOS','BKN','PHI','NYK','TOR'], "Central":['CHI','CLE','DET','IND','MIL'] , 
                "SE":['ATL','CHA','MIA','ORL','WAS'], "NW":['DEN','MIN','OKC','POR','UTA'], "Pacific":['GSW','LAC','LAL','PHX','SAC'], 
                "SW":['DAL','HOU','MEM','NOH','SAS']}

NBA_conferences = {"East": ["Atlantic", "Central", "SE"], 
                   "West": ["NW", "Pacific", "SW"] }

NBA_conferencesT = {"East": ['BOS','BKN','PHI','NYK','TOR','CHI','CLE','DET','IND','MIL', 'ATL','CHA','MIA','ORL','WAS'],
                   "West": ['DEN','MIN','OKC','POR','UTA','GSW','LAC','LAL','PHX','SAC','DAL','HOU','MEM','NOH','SAS']}

'''grab table header
input: html table (beautifulsoup format), string to filter by id
output: array of data table
'''
def makeheader(head):
    #find all "th" tags
    head_names = []
    table_head = head.find('thead')
    
    for x in table_head.findAll('th'):
        #grab the text within the tags; "N" if empty tag
        header = x.find(text=True)
        if header == None:
            header = "N"
        head_names.append(header) 
    return head_names

'''turn html table into 2D array
input: html table (beautifulsoup format), string to filter by id
output: 2D array of data table
'''
def maketable(table, id_string=None):
    data = []
    
    #retrieve all rows. filter by id if necessary
    if id_string==None:
        allrows = table.findAll('tr')
    else:
        allrows = table.findAll('tr', id=lambda x: x and x.startswith(id_string))
    
    for row in allrows:
        cells = []
        #grab each cell, append data to row variable
        allcols = row.findAll('td')
        for col in allcols:
            cells.append(col.find(text=True))
        #append row variable to data matrix
        data.append(cells)
    
    return data

'''retrieve schedule results for individual player statistics
input: string of the year that a season ends. For example, for the 2012-2013 season, the input should be "2013"
output: None, function writes directly to a csv file
'''
def game_finalscores(date):
    
    #retrieve html of site
    url = "http://www.basketball-reference.com/leagues/NBA_"+date+"_games.html"
    site= requests.get(url).text
    soup = BeautifulSoup(site, 'html.parser') 
    
    #retrieve table and transform into DataFrame
    table = soup.find('table', {'id': 'games'})
    table_head = makeheader(table)
    table_data = maketable(table)    
    table_mod = pd.DataFrame(table_data, columns=table_head)
    
    #remove unneeded columns and empty row
    del table_mod["N"]
    del table_mod["Notes"]
    
    #remove empty columns
    table_mod = table_mod.dropna(how="all")
    
    #apply the team acronyms
    table_mod["Visitor/Neutral"] = table_mod["Visitor/Neutral"].applymap(lambda x: team_acronym[x])
    table_mod["Home/Neutral"] = table_mod["Home/Neutral"].applymap(lambda x: team_acronym[x])
    
    #write to csv file
    filename = "finalscore_"+date+".csv"
    table_mod.to_csv(filename, index=False)
    
    print "Done"

'''The code below retrieves the data for 2008-2014. This has been commented out as the csv files have already been made
year = ["2014","2013", "2012", "2011", "2010", "2009", "2008"]
for x in year:
    gamescores = game_finalscores(x)'''

'''scrape the "All Players" page to retrieve URLs of pages with a list of URLS of players whose last names start with the name letter
input: URL of the "All Players" page
returns: list of ending URLS for players by last name
'''
#match function to only grab URL with players' last names
def is_name(l):  
    pattern = '*players/?/'
    return fnmatch(l, pattern)

def find_nameurl(url):
    
    #retrieve the html
    dom = web.Element(requests.get(url).text)
    
    #retrieve all links
    links = [a.attributes.get('href', '') for a in dom.by_tag('a')] 
    #filter for letters of last names
    links = [x for x in links if is_name(x)]
    
    #remove duplicate links
    return list(set(links))

'''scrape the page to retrieve URLs of pages of players 
input: URL of the page with all players' URL listed
returns: list of ending URLS for players by last name
'''

#match function to only retrieve links to players' stats pages
def is_player(l):  
    pattern = '*players/?/*.html'
    return fnmatch(l, pattern)

def find_playerurl(suffix):
    #retrieve html
    url = "http://www.basketball-reference.com"+suffix
    dom = web.Element(requests.get(url).text)
    
    #retrieve active players (whose names are bolded)
    links = []
    for link in dom.by_tag('strong'):
        for a in link.by_tag('a'):
            links.append(a.attributes.get('href', ''))

    links = [x for x in links if is_player(x)]
    
    return list(set(links))
 

'''retrieves all 2014 active players' URL
input: none
returns: list of url suffix for all players
'''
def retrieve_playerdata():
    name_url = find_nameurl("http://www.basketball-reference.com/players/")
    player_url = []
    
    #grab URL suffixes
    for x in name_url:
        player_url.extend(find_playerurl(x))
        
    return player_url 

'''writes players game data into csv file
input: unique url segment of a player, year
output: None, write to csv file for performance issues
'''
def get_table(player_url, date):

    #retrieve table headers
    url = "http://www.basketball-reference.com/players/f/foyera01/gamelog/"+date+"/"
    site= requests.get(url).text
    soup = BeautifulSoup(site, 'html.parser') 
    table = soup.find('table', {'id': 'pgl_basic'})
    col_names = makeheader(table)
    col_names.append("name")

    #write table headers
    filename = "playerdata_"+date+".csv"
    with open(filename,'wb') as fp:
        writer = csv.writer(fp, delimiter=',')
        writer.writerow(col_names)
        
        for y in player_url:
            #trim player_url
            y = y[0:-5]
            
            #grab html
            url = "http://www.basketball-reference.com"+str(y)+"/gamelog/"+date+"/"
            site= requests.get(url).text
            soup = BeautifulSoup(site, 'html.parser')
            
            #find name of player
            children = soup.find('p', {'class': 'margin_top'}).findChildren()
            name = children[0].text
            
            #grab data table html
            table = soup.find('table', {'id': 'pgl_basic'})
            if table == None:
                continue
            
            #retrieve 2D array of table
            table_mod = maketable(table, 'pgl')
            
            #write to csv
            table_mod = np.asarray([x + [name] for x in table_mod])
            np.savetxt(fp, table_mod, delimiter=",", fmt="%s")
            
    fp.close()
    
    print "Done"

'''The code below retrieves the data for 2008-2014. This has been commented out as the csv files have already been made
urls = retrieve_playerdata()
year = ["2013","2012", "2011", "2010", "2009", "2008"]
for x in year:
    playerdata_totals = get_table(urls, x)'''

'''Formatting of data files to account for changes in team names

#combine all players_data files and change team acronyms for consistency
players_data = pd.read_csv("playerdata_2013.csv", delimiter=',')

players_data = players_data.append(pd.read_csv("playerdata_2012.csv", delimiter=','))
players_data = players_data.append(pd.read_csv("playerdata_2011.csv", delimiter=','))
players_data = players_data.append(pd.read_csv("playerdata_2010.csv", delimiter=','))
players_data = players_data.append(pd.read_csv("playerdata_2009.csv", delimiter=','))
players_data = players_data.append(pd.read_csv("playerdata_2008.csv", delimiter=','))

players_data["Tm"]= players_data["Tm"].map(lambda x: "BKN" if x=="NJN" else x)
players_data["Tm"]= players_data["Tm"].map(lambda x: "BKN" if x=="BRK" else x)
players_data["Tm"]= players_data["Tm"].map(lambda x: "OKC" if x=="SEA" else x)
players_data["Tm"]= players_data["Tm"].map(lambda x: "PHX" if x=="PHO" else x)

players_data.to_csv("playersdata_all.csv", index=False)

#combine all finalscore files and change team acronyms for consistency
allscores = pd.read_csv("finalscore_2013.csv", delimiter=',')
allscores = allscores.append(pd.read_csv("finalscore_2012.csv", delimiter=','))
allscores = allscores.append(pd.read_csv("finalscore_2011.csv", delimiter=','))
allscores = allscores.append(pd.read_csv("finalscore_2010.csv", delimiter=','))
allscores = allscores.append(pd.read_csv("finalscore_2009.csv", delimiter=','))
allscores = allscores.append(pd.read_csv("finalscore_2008.csv", delimiter=','))

allscores["Visitor/Neutral"]= allscores["Visitor/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
allscores["Visitor/Neutral"]= allscores["Visitor/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
allscores["Visitor/Neutral"]= allscores["Visitor/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
allscores["Visitor/Neutral"]= allscores["Visitor/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

allscores["Home/Neutral"]= allscores["Home/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
allscores["Home/Neutral"]= allscores["Home/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
allscores["Home/Neutral"]= allscores["Home/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
allscores["Home/Neutral"]= allscores["Home/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

allscores.to_csv("finalscore_all.csv", index=False)

scores_2014 = pd.read_csv("finalscore_2014.csv", delimiter=",")
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "NOH" if x=="NOP" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "NOH" if x=="NOP" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

scores_2014.to_csv("finalscore_2014.csv", index=False)


players_2014 = pd.read_csv("playerdata_2014.csv", delimiter=',')
players_2014["Tm"]= players_2014["Tm"].map(lambda x: "NOH" if x=="NOP" else x)
players_2014["Tm"]= players_2014["Tm"].map(lambda x: "BKN" if x=="NJN" else x)
players_2014["Tm"]= players_2014["Tm"].map(lambda x: "BKN" if x=="BRK" else x)
players_2014["Tm"]= players_2014["Tm"].map(lambda x: "OKC" if x=="SEA" else x)
players_2014["Tm"]= players_2014["Tm"].map(lambda x: "PHX" if x=="PHO" else x)

players_2014.to_csv("playerdata_2014.csv", index=False)


scores_2014 = pd.read_csv("finalscore_2014121013.csv", delimiter=",")
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "NOH" if x=="NOP" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "NOH" if x=="NOP" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

scores_2014.to_csv("finalscore_2014120813.csv", index=False)

scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "NOH" if x=="NOP" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "NOH" if x=="NOP" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
scores_2014["Visitor/Neutral"]= scores_2014["Visitor/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "BKN" if x=="NJN" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "BKN" if x=="BRK" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "OKC" if x=="SEA" else x)
scores_2014["Home/Neutral"]= scores_2014["Home/Neutral"].map(lambda x: "PHX" if x=="PHO" else x)

scores_2014.to_csv("finalscore_2014120813.csv", index=False)

'''

#let us read in the csv files we have just made
players_data = pd.read_csv("playersdata_all.csv", delimiter=',')
gamescores = pd.read_csv("finalscore_2013.csv", delimiter=',')
allscores = pd.read_csv("finalscore_all.csv", delimiter=',')

#record the 2014 schedule
schedule_2014 = pd.read_csv("finalscore_2014.csv", delimiter=",")

#record only the games played so far in 2014
scores_2014 = schedule_2014.dropna(how='any')

#player data so far for 2014
players_2014 = pd.read_csv("playerdata_2014.csv", delimiter=',')

#append 2014 data to the 2008-2013 data
players_data_08_14 = players_data.append(players_2014)

#append 2014 data to the 2008-2013 final results
allscores_2014 = allscores.append(scores_2014)

print players_data
print gamescores.head()

players_data_13 = pd.read_csv("playerdata_2013.csv", delimiter=',')

all_players = players_data_13.groupby("name").groups.keys()
print "Total Active Players: " + str(len(all_players))

all_teams = players_data_13.groupby("Tm").groups.keys()
print "Total Active Teams: " + str(len(all_teams))

all_dates = sorted(players_data_13.groupby("Date").groups.keys())
print "First date of season: " + all_dates[0]
print "Last date of season: " + all_dates[-1]

players_dict = players_data_13.groupby("name").groups
games_dict = {}

#count the number of games played per player
for player, games in players_dict.iteritems():
    games_dict[player] = len(games)

#plot graph
plt.figure(figsize=(10, 10))
plt.title("Distribution of number of games played by players in the 2013 season")
plt.xlim(0, 83)
plt.hist(games_dict.values(), bins=80)
plt.ylabel("Number of players")
plt.xlabel("Number of games played")
plt.show()
full_season_players = []
for player, games in players_dict.iteritems():
    if len(games) > 81:
        full_season_players.append(player)
print "Number of players who played all 82 regular season games:", len(full_season_players)

#display average score per game per player
plt.figure(figsize=(10, 10))
points = players_data_13["PTS"].groupby(players_data_13["name"]).mean()
plt.hist(points.values, bins=40)
plt.title("Average number of points per player per game")
plt.ylabel("Number of players")
plt.xlabel("Number of points")
plt.show()

print "Top 10 players with the highest average number of points per game:"
players = players_data_13["PTS"].groupby(players_data_13["name"]).mean().copy()
players.sort(ascending=False)
print players[0:10]

#total number of points per player
plt.figure(figsize=(10, 10))
points = players_data_13["PTS"].groupby(players_data_13["name"]).sum().copy()
plt.hist(points.values, bins=40)

plt.title("Total number of points per player throughout the season")
plt.ylabel("Number of players")
plt.xlabel("Number of points")
plt.show()
print "Top 10 scorers in the 2012-13 season and number of points:"
players = players_data_13["PTS"].groupby(players_data_13["name"]).sum()
players.sort(ascending=False)
print players[0:10]

#calculate average number of 3 points made per player per game
plt.figure(figsize=(10, 10))
points = players_data_13["3P"].groupby(players_data_13["name"]).mean()

plt.hist(points.values, bins=40, log=True)
plt.title("Average number of 3 pointers made per player per game (log scale)")
plt.ylabel("Number of players")
plt.xlabel("Number of 3 pointers made per game")
plt.show()

print "Top 5 3-point shooters in the 2012-13 season and the number of 3-pointers made:"
players = players_data_13["3P"].groupby(players_data_13["name"]).sum()
players.sort(ascending=False)
print players[0:5]

plt.figure(figsize=(15, 15))
three_point_shooting = players_data_13['3P'].groupby(players_data_13["name"]).sum()
field_goals = players_data_13['FG'].groupby(players_data_13["name"]).sum()
labels = []

#find three point shooting scores
for i, shots in enumerate(three_point_shooting):
    if ((shots > 80 and field_goals[i] > 450) or (field_goals[i] > 600) or (shots > 180)):
        labels.append((three_point_shooting.index[i], three_point_shooting[i], field_goals[i]))
plt.scatter(three_point_shooting, field_goals)

for label in labels:
    (name, x, y) = label
    plt.annotate(name, (x + 2, y + 2))
plt.ylabel("Number of field goals")
plt.xlabel("Number of 3 pointes")
plt.title("Scatterplot of field goals over 3 pointers")
plt.xlim(-10, 350)
plt.show()

plt.figure(figsize=(20, 20))

#find scores, steals, and +/-
three_point_shooting = players_data_13['3P'].groupby(players_data_13["name"]).sum()
steals = players_data_13['STL'].groupby(players_data_13["name"]).mean()
plusminus = players_data_13['+/-'].groupby(players_data_13["name"]).values
plusminus2 = []

#calculate +/- adjusted metric
for values in plusminus:
    result = []
    for v in values:
        if v == 'None':
            result.append(0)
        else:
            result.append(int(v))
    plusminus2.append(float(sum(result))/len(result))

#combine steals and +/-    
steals_and_plusminus = []
for i, s in enumerate(steals):
    steals_and_plusminus.append(s + plusminus2[i])

#grab player labels
labels = []
for i, shots in enumerate(three_point_shooting):
    if shots > 150 or steals_and_plusminus[i] > 8 or steals_and_plusminus[i] < -5:
        labels.append((three_point_shooting.index[i], three_point_shooting[i], steals_and_plusminus[i]))

#plot
plt.scatter(three_point_shooting, steals_and_plusminus)
for label in labels:
    (name, x, y) = label
    plt.annotate(name, (x + 0.5, y + 0.2))
plt.ylabel("Average number of steals + average +/- rating (our representation of a defensive rating)")
plt.xlabel("Number of 3 pointers")
plt.title("Scatterplot of steals plus the average +/- over the number of 3 pointers")
plt.xlim(-10, 350)
plt.show()

players_data_13 = pd.read_csv("playerdata_2013.csv", delimiter=',')
players_data_12 = pd.read_csv("playerdata_2012.csv", delimiter=',')
players_data_11 = pd.read_csv("playerdata_2011.csv", delimiter=',')
players_data_10 = pd.read_csv("playerdata_2010.csv", delimiter=',')
players_data_09 = pd.read_csv("playerdata_2009.csv", delimiter=',')
players_data_08 = pd.read_csv("playerdata_2008.csv", delimiter=',')

players12 = players_data_12["PTS"].groupby(players_data_12["name"]).sum().to_dict()
players11 = players_data_11["PTS"].groupby(players_data_11["name"]).sum().to_dict()
players10 = players_data_11["PTS"].groupby(players_data_10["name"]).sum().to_dict()
players09 = players_data_11["PTS"].groupby(players_data_09["name"]).sum().to_dict()
players08 = players_data_11["PTS"].groupby(players_data_08["name"]).sum().to_dict()

# First get the top 15 scorers who have played from the 08 until the 13 seasons.
players13 = players_data_13["PTS"].groupby(players_data_13["name"]).sum()
players13.sort(ascending=False)
players13.to_dict()
veterans = []
for i, points in enumerate(players13):
    name = players13.index[i]
    if name in players12 and name in players11 and name in players10 and name in players09 and name in players08:
        veterans.append(name)
    if (len(veterans) > 15):
        break
season13 = []
season12 = []
season11 = []
season10 = []
season09 = []
season08 = []
for name in veterans:
    season13.append(players13[name])
    season12.append(players12[name])
    season11.append(players11[name])
    season10.append(players10[name])
    season09.append(players09[name])
    season08.append(players08[name])
    
d = {'07-08': pd.Series(season08, index=veterans), 
     '08-09': pd.Series(season09, index=veterans), 
     '09-10': pd.Series(season10, index=veterans),
     '10-11': pd.Series(season11, index=veterans), 
     '11-12': pd.Series(season12, index=veterans), 
     '12-13': pd.Series(season13, index=veterans)}
df = pd.DataFrame(d)
print df

"""
Function
--------
parallel_coordinates(df, style=None,fmt=None)

Plot parallel_coordinates plot of given DataFrame.

Parameters
----------
df : DataFrame 
    Line names should be in the index (not first row). The data (numerical only) for those lines should be in the body of the 
    DataFrame. The column names become the names of the y-axes. See cell below for example of properly formatted dataset. 
    Note that besides these minimal parameters, the function dynamic accommodates theoretically infinite many rows and columns.

(optional) style: Array
    Array of matplotlib color+line formatting combinations (such as 'r--' or 'k-.'). Default is automatic color/line cycle.
    
(optional) fmt: rcParams function
    rcParams function determining style of graph. Default is plt.xkcd().

See cell below for properly formatted dataset. 

Returns
-------
Plot parallel_coordinates plot of given DataFrame.
"""
import itertools as itertools
def parallel_coordinates(df, style=None,fmt=None):
    
    # Use kewl formatz.
    if fmt==None:
        fmt = plt.xkcd()
    with fmt:
        
        rcParams['figure.figsize'] = (10, 6)
        rcParams['figure.dpi'] = 150
        rcParams['lines.linewidth'] = 2
        rcParams['axes.grid'] = False
        rcParams['axes.facecolor'] = 'white'
        rcParams['font.size'] = 14
        rcParams['patch.edgecolor'] = 'none'
        
        # Convert dataframe to list of lists.
        data_sets = []
        for teamnumber, teamval in enumerate(df.index):
            foo = [x for x in df.irow(teamnumber)]
            data_sets.append(foo)
            
        dims = len(data_sets[0])
        x    = range(dims)
        fig, axes = plt.subplots(1, dims-1, sharey=False)
    
        # Set color styles.
        if style is None:
            cyc = []
            style = []
            lines = ["-","--",":"]
            colors = ["b","g","r","c","m","y","k"]
            for linetype in lines:
                for colortype in colors:
                    cyc.append(linetype + colortype)
            cyc = itertools.cycle(cyc)
            for i in range(len(data_sets)):
                style.append(next(cyc))
    
        # Calculate the limits on the data
        min_max_range = list()
        for m in zip(*data_sets):
            mn = min(m)
            mx = max(m)
            if mn == mx:
                mn -= 0.5
                mx = mn + 1.
            r  = float(mx - mn)
            min_max_range.append((mn, mx, r))
    
        # Normalize the data sets
        norm_data_sets = list()
        for ds in data_sets:
            nds = [(value - min_max_range[dimension][0]) / 
                    min_max_range[dimension][2] 
                    for dimension,value in enumerate(ds)]
            norm_data_sets.append(nds)
        data_sets = norm_data_sets
    
        # Plot the datasets on all the subplots
        for i, ax in enumerate(axes):
            for dsi, d in enumerate(data_sets):
                ax.plot(x, d, style[dsi], label=df.index[dsi])
            ax.set_xlim([x[i], x[i+1]])
            ax.set_xticklabels([df.columns[i],df.columns[len(axes)]]) 
            ax.xaxis.tick_top()
            ax.spines["top"].set_visible(False)
         
        # Set the x axis ticks 
        for dimension, (axx,xx) in enumerate(zip(axes, x[:-1])):
            axx.xaxis.set_major_locator(plt.FixedLocator([xx]))
            ticks = len(axx.get_yticklabels())
            labels = []
            step = min_max_range[dimension][2] / (ticks - 1)
            mn   = min_max_range[dimension][0]
            for i in xrange(ticks):
                v = mn + i*step
                labels.append('%4.2f' % v)
            axx.set_yticklabels(labels)
    
        # Move the final axis' ticks to the right-hand side
        axx = plt.twinx(axes[-1])
        dimension += 1
        axx.xaxis.set_major_locator(plt.FixedLocator([x[-2], x[-1]]))
        ticks = len(axx.get_yticklabels())
        step = min_max_range[dimension][2] / (ticks - 1)
        mn   = min_max_range[dimension][0]
        labels = ['%4.2f' % (mn + i*step) for i in xrange(ticks)]
        axx.set_yticklabels(labels)
        
        # Stack the subplots 
        plt.subplots_adjust(wspace=0)
        
        #added this to get the legend to work
        handles,labels = ax.get_legend_handles_labels()
        ax.legend(handles, labels, ncol=dims-1,loc='upper center', bbox_to_anchor=(-1,-0.1))

    return plt

# Run graph.
parallel_coordinates(df).show()

'''Determine which distribution best fit the points distribution'''
points = players_data["PTS"].groupby(players_data["name"]).mean()
cdfs = [
    "norm",            #Normal (Gaussian)
    "beta",            #Beta
    "chi",             #Chi
    "chi2",            #Chi-squared
    "expon",        #Exponential Power
    "fatiguelife",     #Fatigue Life (Birnbaum-Sanders)
    "f",               #F (Snecdor F)
    ]
for cdf in cdfs:
    #fit our data set against every probability distribution
    parameters = eval("stats."+cdf+".fit(players_data['PTS'])");
 
    #Applying the Kolmogorov-Smirnof one sided test
    D, p = stats.kstest(points, cdf, args=parameters);
 
    #pretty-print the results
    print cdf.ljust(16) + ("p: "+str(p)).ljust(25)+"D: "+str(D)+"  Param: "+str(parameters);

'''store fitted param for individual players' score distributions
input: distribution name in scipy, optional: DataFrame to retrieve the data from
output: dictionary of fitted parameters
'''
def distribution_param(distribution, data=players_data):
    
    #grab all players names
    player_namesunique  = list(set(data['name']))
    player_distribution = {}
    
    #fit the distribution to the player
    for x in player_namesunique:
        points = list(data[data['name']==x].PTS)
        param= eval("stats."+distribution+".fit(points)")
        player_distribution.setdefault(x, []).append(param)
    
    return player_distribution

player_distributionchi = distribution_param("chi")
player_distributionfl = distribution_param("fatiguelife")

''' Creates a dictionary from which the bootstrap function will 
randomly sample historical points scored per player per game

input: DataFrame of the players data
output: dictionary of individual players' historical score

'''

def bootstrap_build(data=players_data):
    
    #grab all unique players
    player_namesunique  = list(set(data['name']))
    result = dict.fromkeys(player_namesunique, [])

    #find the points scored by each player
    for x in player_namesunique:
        points = list(data[data['name']==x].PTS)
        result[x] = points
        
    return result

database_simplePTS = bootstrap_build()

print database_simplePTS["LeBron Raymone James"]

'''find the 5 players with the highest average score per game. We will draw from their distributions
input: players DataFrame
output: Dictionary of the starting 5 players for each team
'''
def starting_lineup(data):
    #calculate the average points scored for each player and sort by the average points
    players_grouped = data.groupby(['Tm','name']).PTS.mean()
    players_grouped = players_grouped.order(ascending = False)
    players_grouped = pd.DataFrame(players_grouped.reset_index())
    
    #retrieve the five highest scorers, which will represent the starting lineup
    players_grouped2 = players_grouped.groupby(['Tm'])
    starters = {}
    for name, group in players_grouped2:
        starters[name] = group['name'][0:5].values
    return starters

'''Function that randomly select points scored from a given distribution
input: data, fitted param, distribution type
output: predicted team score
'''
def projected_score(team, starting, fit, dist):
    
    distribution =0
    #find the starting lineup
    players = starting[team]
    
    #fit the curve to the data using the parameters determined above and randomly select a score
    for name in players:
        p0,p1, p2= fit[name][0]
        distribution += eval("stats."+dist+".rvs(p0, p1, p2)")
    return distribution

'''Bootstrap Sampling Function
input: string of team name, database of player data
output: sampled team score
'''

def projected_score_boot(team, database, starting, actual=gamescores, data=players_data):
    
    t_scores= 0 
    
    #retrieve the players on the starting lineup
    players = starting[team]
 
    #randomly select a score for each player and add to the team total
    for name in players:
        t_scores += choice(database[name])
  
    return t_scores

#retrieve the starting lineup based on highest historical average score
starting_five = starting_lineup(players_data)
print starting_five["GSW"]

print projected_score("BOS", starting_five, player_distributionchi, "chi")
print projected_score("BOS", starting_five, player_distributionfl, "fatiguelife")
print projected_score_boot("BOS", database_simplePTS, starting_five)

#predict probability of winning using these 2 models

#prediction using the chi distribution
result = []

#find predicted team score for both teams
for x in range (0,100):
    t1_r = projected_score("BOS", starting_five, player_distributionchi, "chi")
    t2_r = projected_score("NYK", starting_five, player_distributionchi, "chi")
    result.append([t1_r, t2_r])

#plot the simulation results
result = np.array(result)
plt.scatter(result[:,0], result[:,1])
plt.plot([40,180], [40,180])
plt.xlim([40,180])
plt.ylim([40,180])
plt.title("Fitted Model: Chi")
plt.ylabel("Knicks")
plt.xlabel("Boston")
plt.show()

#determine the probability of BOS win
bos_win = len(result[result[:,0]>result[:,1]])/100.
print "Probability of BOS Win: "+str(bos_win)


#prediction using the fatiguelife distribution
result = []
for x in range (0,100):
    t1_r = projected_score("BOS", starting_five, player_distributionfl, "fatiguelife")
    t2_r = projected_score("NYK", starting_five, player_distributionfl, "fatiguelife")
    result.append([t1_r, t2_r])
result = np.array(result)
plt.scatter(result[:,0], result[:,1])
plt.plot([40,180], [40,180])
plt.xlim([40,180])
plt.ylim([40,180])
plt.title("Fitted Model: Fatiguelife")
plt.ylabel("Knicks")
plt.xlabel("Boston")
plt.show()
bos_win = len(result[result[:,0]>result[:,1]])/100.
print "Probability of BOS Win: "+str(bos_win)

#prediction using bootstrap sampling
result = []
for x in range (0,100):
    t1_r = projected_score_boot("BOS", database_simplePTS, starting_five)
    t2_r = projected_score_boot("NYK", database_simplePTS, starting_five)
    result.append([t1_r, t2_r])
result = np.array(result)
plt.scatter(result[:,0], result[:,1])
plt.plot([40,180], [40,180])
plt.xlim([40,180])
plt.ylim([40,180])
plt.title("Bootstrap Model")
plt.ylabel("Knicks")
plt.xlabel("Boston")
plt.show()
bos_win = len(result[result[:,0]>result[:,1]])/100.
print "Probability of BOS Win: "+str(bos_win)

#calculate win percentage of 2013 for comparison
winloss = dict.fromkeys(NBA_teams, 0)
for index, row in gamescores.iterrows():
    if row["PTS"]>row["PTS.1"]:
        winloss[row["Visitor/Neutral"]] +=1
    else:
        winloss[row["Home/Neutral"]] +=1

#divide by 82 games, the official number of games played by most NBA teams
winloss = {x:winloss[x]/82. for x in winloss}
print winloss

'''Calculates percentage of games (all games, close games, and blowout games) correctly predicted 
input: DataFrame with HWin column which displays the probability of the home team winning
output: three floats corresponding to a model's percentage of correctly predicted games (all games, close games, and blowouts)
'''

def calc_accuracy(predictions):
    #determine the margins of actual wins
    predictions["Margins"] = predictions["PTS.1"] - predictions["PTS"]
    
    accuracy_all = 0
    accuracy_close = 0
    accuracy_blowouts = 0
    
    #determine the accuracy of all games
    for index, row in predictions.iterrows():
        #if we correctly predicted a home win or if we correctly predicted a visitor win, increase accuracy by 1
        if ((row["Margins"]<0)&(row["HWin"]<=0.5)) or ((row["Margins"]>0)&(row["HWin"]>0.5)):
            accuracy_all += 1
    accuracy_all = accuracy_all/float(len(predictions))
    
    #determine the accuracy of close games
    predictions_close = predictions.loc[abs(predictions["Margins"])<=3]
    for index, row in predictions_close.iterrows():
        if ((row["Margins"]<0)&(row["HWin"]<=0.5)) or ((row["Margins"]>0)&(row["HWin"]>0.5)):
            accuracy_close += 1
    accuracy_close = accuracy_close/float(len(predictions_close))
    
    #determine the accuracy of blowout games
    predictions_blowouts = predictions.loc[abs(predictions["Margins"])>=10]
    for index, row in predictions_blowouts.iterrows():
        if ((row["Margins"]<0)&(row["HWin"]<=0.5)) or ((row["Margins"]>0)&(row["HWin"]>0.5)):
            accuracy_blowouts += 1
    accuracy_blowouts = accuracy_blowouts/float(len(predictions_blowouts))
    
    return accuracy_all, accuracy_close, accuracy_blowouts

#sanity check to make sure the function works
temp = gamescores.copy()
temp["HWin"] = 0
temp["Margins"] = temp["PTS.1"] - temp["PTS"]
temp.loc[temp["Margins"]>0, "HWin"] =1
print calc_accuracy(temp)

'''Simulates a full season using a distribution model

input: 
fit: string of distribution identifier at the end of player_distribution (ex: fit="chi" if you want to access player_distributionchi)
dist: string of the scipy name for the distribution

output:
'''

def predict_results_dist(fit, dist, actual, starting, df=0, adjust=0, param=0):

    #keep track of team wins
    result_team = dict.fromkeys(NBA_teams, 0)
    
    #keep track of predicted result for Home team of each match
    result_games = []

    #create predictions for each game in 2013
    for index, row in actual.iterrows():
        team1 = row["Home/Neutral"]
        team2 = row["Visitor/Neutral"]
        date = row["Date"]
        
        #retrieve initial score prediction
        t1 = projected_score(team1, starting, fit, dist)
        t2 = projected_score(team2, starting, fit, dist)
        
        #adjust prediction for other variables (to be used later in the notebook)
        if adjust !=0:
            code = compile("adjust("+param+")", "<string>", "eval")
            t1 += eval(code)
        
        #if team 1's score is more than team 2's score, add a win to team1 and a win to the Home team for this match
        if t1>t2:
            result_team[team1] += 1
            result_games.append(1)
        else:
            result_team[team2] +=1
            result_games.append(0)
    
    return result_team, result_games

'''Runs simulation model and outputs overall accuracy metrics
'''
def runmodel_dist (n, distributions, actual, param):
    #testing the chi, fatiguelife
    for d in distributions:
        
        #determine the total number of games
        numgames =  float(len(actual[actual["Home/Neutral"]=="ATL"])+len(actual[actual["Home/Neutral"]=="ATL"]))
        if numgames < 80:
            numgames = 20.
        else:
            numgames = 82.
        
        #grabs the distribution database
        dist = eval("player_distribution"+d[0])
        
        #holds the predicted win percentage
        predicted_winper = {}
        
        #DataFrame that will be passed to calc_accuracy
        predicted_result = actual.copy()
        
        #will hold the probability of a Home team win for any given match
        predicted_result["HWin"] = 0
        for x in range (0,n):
            
            #retrieve the number of predicted wins by team and by match
            result_t, result = predict_results_dist(dist, d[1], actual, *param)
            
            #add the predicted win percentage
            result_t = {x:result_t[x]/numgames for x in result_t}
            for k, v in result_t.iteritems():
                predicted_winper.setdefault(k, []).append(v)
                
            #add the predicted Home wins for each game
            predicted_result["HWin"] += result
        
        #calculate the probability of a Home win for each game
        predicted_result["HWin"] /= float(n)
        
        #grab the three accuracy ratings
        accuracy = calc_accuracy(predicted_result)
        
        #print metrics and graph
        print d[1]+" Model"
        print "Overall, the model correctly predicts: {0:.2%} of game outcomes".format(accuracy[0])
        print "Overall, the model correctly predicts: {0:.2%} of close outcomes".format(accuracy[1])
        print "Overall, the model correctly predicts: {0:.2%} of blowout outcomes".format(accuracy[2])
        plot_predictvactual(winloss, predicted_winper)

def predict_results_boot(actual, database, starting, df=0, adjust=0, param=0):
    #keep track of team wins
    result_team = dict.fromkeys(NBA_teams, 0)
    
    #keep track of predicted result for Home team of each match
    result_games = []

    #create predictions for each game in 2013
    for index, row in actual.iterrows():
        team1 = row["Home/Neutral"]
        team2 = row["Visitor/Neutral"]
        date = row["Date"]
        
        #retrieve initial score prediction
        t1 = projected_score_boot(team1, database, starting)
        t2 = projected_score_boot(team2, database, starting)
        
        #adjust prediction for other variables
        if adjust !=0:
            code = compile("adjust("+param+")", "<string>", "eval")
            t1 += eval(code)
        
        #if team 1's score is more than team 2's score, add a win to team1 and a win to the Home team for this match
        if t1>t2:
            result_team[team1] += 1
            result_games.append(1)
        else:
            result_team[team2] +=1
            result_games.append(0)
            
    return result_team, result_games

def runmodel_boot(n, actual, database, param=0):
        
        numgames = float(len(actual[actual["Home/Neutral"]=="ATL"])+len(actual[actual["Home/Neutral"]=="ATL"]))
        
        if numgames < 80:
            numgames = 20.
        else:
            numgames = 82.
        
        #holds the predicted win percentage
        predicted_winper = {}
        
        #DataFrame that will be passed to calc_accuracy
        predicted_result = actual.copy()
        
        #will hold the probability of a Home team win for any given match
        predicted_result["HWin"] = 0
        
        for x in range (0,n):
            
            #retrieve the number of predicted wins by team and by match
            result_t, result = predict_results_boot(actual, database, *param)
            
            #add the predicted win percentage
            result_t = {x:result_t[x]/numgames for x in result_t}
            for k, v in result_t.iteritems():
                predicted_winper.setdefault(k, []).append(v)
                
            #add the predicted Home wins for each game
            predicted_result["HWin"] += result
        
        #calcualte the probability of a Home win for each game
        predicted_result["HWin"] /= float(n)
        
        #grab the three accuracy ratings
        accuracy = calc_accuracy(predicted_result)
        
        #print metrics and graph'''
        print "Bootstrap Model"
        print "Overall, the model correctly predicts: {0:.2%} of game outcomes".format(accuracy[0])
        print "Overall, the model correctly predicts: {0:.2%} of close outcomes".format(accuracy[1])
        print "Overall, the model correctly predicts: {0:.2%} of blowout outcomes".format(accuracy[2])
        plot_predictvactual(winloss, predicted_winper)
        return
    

'''Plot predicted win percentage (x-axis) against actual win percentage (y-axis)
input: Dictionary of actual win percentages by team, Dictionary of predicted win percentages by team
output: None
'''

def plot_predictvactual(final_result, predicted_result):    
    
    predicted_means = final_result.copy()
    
    #calculate the mean predicted win percentage and the standard deviation
    for key, value in predicted_result.iteritems():
        temp = np.array(value)
        predicted_means[key] = [np.mean(temp), np.std(temp)]

    list_actualmeans = []
    list_predictmeans = []
    list_predicterror = []
    
    #create arrays of actual win percentage, mean predicted win percentage, and standard error in the correct order
    for key, value in final_result.iteritems():
        list_actualmeans.append(value)
        list_predictmeans.append(predicted_means[key][0])
        list_predicterror.append(predicted_means[key][1]) 

    #plot
    plt.errorbar(list_predictmeans, list_actualmeans, yerr=list_predicterror, ls="none", fmt='ro')
    plt.plot([0.1,1], [0.1,1])
    plt.xlim([0.1,1])
    plt.ylim([0.1,1])
    plt.xlabel("Mean of Predicted Win Percentage")
    plt.ylabel("Actual Win Percentage") 
    plt.show()
    return

testing_dist = [["chi","chi"], ["fl","fatiguelife"]]
runmodel_dist(50, testing_dist, gamescores, [starting_five])
runmodel_boot(50, gamescores, database_simplePTS, [starting_five])

#base starting lineup on 2013 scores ONLY
starting_five2013 = starting_lineup(players_data[players_data['Date'].str.contains("2013")])

runmodel_dist(50, testing_dist, gamescores, [starting_five2013])
runmodel_boot(50, gamescores, database_simplePTS, [starting_five2013])

'''Transform minutes:second format into total seconds
input: String of time in the format of MM:SS
output: integer of the time in seconds
'''
def convert_time(original):

    #handles the corner case of 60:00
    try:
        #convert to time format
        x = time.strptime(original.split(',')[0],'%M:%S')
    except ValueError:
        return 3600
    
    #return total seconds
    return datetime.timedelta(minutes=x.tm_min,seconds=x.tm_sec).total_seconds()

players_MP13 = players_data[players_data['Date'].str.contains("2013")]
players_MP13['MP'] = players_MP13['MP'].map(lambda x: convert_time(x))

'''Create a starting lineup based on minutes played
input: DataFrame of player data
output: Dictionary of each team's starting lineup
'''
def starting_lineupMP(data):
    #calculate the average minutes played for each player and sort by the average points
    players_grouped = data.groupby(['Tm','name']).MP.mean()
    players_grouped = players_grouped.order(ascending = False)
    players_grouped = pd.DataFrame(players_grouped.reset_index())
    
    #retrieve the five highest MP, which will represent the starting lineup
    players_grouped2 = players_grouped.groupby(['Tm'])
    starters = {}
    for name, group in players_grouped2:
        starters[name] = group['name'][0:5].values
    return starters
starting_fiveMP13 = starting_lineupMP(players_MP13)

runmodel_dist(50, testing_dist, gamescores, [starting_fiveMP13])
runmodel_boot(50, gamescores, database_simplePTS, [starting_fiveMP13])

''' Create a DataFrame of the historical win/loss margins of a team vs. a specific opponent
input: DataFrame of historical scores
output: DataFrame of historical margins of all possible match-ups
'''

def historical_margins(finalscores):
    
    #create DataFrame with the match-up as the index
    finalscores["matches"] = finalscores["Home/Neutral"] + ","+ finalscores["Visitor/Neutral"]
    finalscores = finalscores.set_index("matches")
    
    #determine the margins by which the HOME TEAM won/lost
    finalscores["margins"] = finalscores["PTS.1"]-finalscores["PTS"]
    
    #drop unnecessary columns
    finalscores = finalscores.drop(["Visitor/Neutral","Home/Neutral", "PTS", "PTS.1"], 1)
    
    return finalscores

hist_margins = historical_margins(allscores)
print hist_margins

'''Adjust the predicted score by randomly sampling from historical margins
input: string of team1 name, string of team2 name, DataFrame holding the historical margins
output: int radomly selected from historical margins between team1 and team2
'''
def margin_adjust (team1, team2, margins):
        #grab historical margins for HOME, VISITOR
        result = []
        match = team1+","+team2
        result.extend(margins.ix[match, "margins"])
        
        #grab historical margins for VISITOR, HOME
        match = team2+","+team1
        #multiply by -1 since margins are by how much the HOME team won/loss by
        result.extend(-1*margins.ix[match, "margins"])
        
        #randomy return from among these historical margins
        return choice(result)

testing_dist = [["fl","fatiguelife"]]
runmodel_dist(50, testing_dist, gamescores, [starting_fiveMP13, hist_margins, margin_adjust, "team1, team2, df"])
runmodel_boot(50, gamescores, database_simplePTS, [starting_fiveMP13, hist_margins, margin_adjust, "team1, team2, df"])

''' Creates a dictionary from which the assist_adjust function will randomly sample historical assists per game per player
input: dictionary of the starting lineup for each team, DataFrame of the schedule, DataFrame of the players data
output: dictionary of individual players' historical assists for each match-up on the schedule
'''

def adjust_build(starting, var, actual=gamescores, data=players_data):
    
    #create a Dataframe of all possible match-ups, ignoring home vs. visitor distinctions
    actual_mod = actual.drop_duplicates(cols=["Home/Neutral","Visitor/Neutral"])
    matches = actual_mod["Home/Neutral"] + ","+ actual_mod["Visitor/Neutral"]
    result = dict.fromkeys(matches, [])
    
    #for each match-up, find the historical assist numbers for each teams' starting players
    for index, row in actual_mod.iterrows():
        assists_totalt1 = []
        assists_totalt2 = []
        
        #grab the team names
        team1 = row["Home/Neutral"]
        team2 = row["Visitor/Neutral"]
        
        #grab starting players
        playerst1 = starting[team1]
        playerst2 = starting[team2]
        
        #retrieve history of assists by starting players
        for name in playerst1:
            assists_ind = eval("data[data['name']==name]."+var)
            assists_totalt1.append(assists_ind.values)
        for name in playerst2:
            assists_ind = eval("data[data['name']==name]."+var)
            assists_totalt2.append(assists_ind.values)
        
        #add assists to dictionary
        result[team1+","+team2] = [assists_totalt1,assists_totalt2]
        
    return result

#sanity check to ensure the database was properly made
assists_database = adjust_build(starting_fiveMP13, "AST")
print assists_database["CLE,WAS"][0]

''' Adjust the baseline score prediction

inputs: 
team1- String for team 1
team2- String for team2
margins- DataFrame of historical margins
weight- weight for assist, turnover, and rebound variable
database_adjust- DataFrame from which to sample assist/turnover/rebound for individual players
actual- DataFrame of actual results to compare against, default is 2013 results
starting- Dictionary of starting lineup for each team, default is starting lineup determined by minutes-played
data- DataFrame of individual players data, default is players_data for 2008-2013

output: int by which to adjust the baseline prediction
'''
def model_adjust(team1, team2, margins, weight, database_adjust, actual=gamescores, starting=starting_fiveMP13, data=players_data):
    
    #margin adjustment
    adjust1 = margin_adjust(team1, team2, margins)
    
    #scores for each team
    t1= 0
    t2 = 0

    #retrieve the historical number of assists per player per team
    adjust_team1 = database_adjust[team1+","+team2][0]
    adjust_team2 = database_adjust[team1+","+team2][0]
    
    #randomly select an assist number for each player
    for x in adjust_team1:
        t1 += choice(x)
    for x in adjust_team2:
        t2 += choice(x)
  
    adjust1 += (t1-t2)*weight
    
    return adjust1

#rerun actual win/loss calculation due to weird bug in which win/loss sometimes mutates by this run
winloss = dict.fromkeys(NBA_teams, 0)
for index, row in gamescores.iterrows():
    if row["PTS"]>row["PTS.1"]:
        winloss[row["Visitor/Neutral"]] +=1
    else:
        winloss[row["Home/Neutral"]] +=1

#divide by 82 games, the official number of games played by most NBA teams
winloss = {x:winloss[x]/82. for x in winloss}
print winloss

database_adjustAST = adjust_build(starting_fiveMP13, "AST")
database_adjustTOV = adjust_build(starting_fiveMP13, "TOV")
database_adjustORB = adjust_build(starting_fiveMP13, "ORB")

weights = [0.5,1.,1.5,2.]

#testing only on bootstrap due to speed, following code is a modified runmodel_boot
for weight in weights:
        #holds the predicted win percentage
        predicted_winper2 = {}
        
        #DataFrame that will be passed to calc_accuracy
        predicted_result2 = gamescores.copy()
        
        #will hold the probability of a Home team win for any given match
        predicted_result2["HWin"] = 0
        
        for x in range (0,50):
        
            #retrieve the number of predicted wins by team and by match
            result_t2, result2 = predict_results_boot(gamescores, database_simplePTS, starting_fiveMP13, 
                                                    hist_margins, model_adjust, "team1, team2, df, weight, database_adjustAST, gamescores")
    
            #add the predicted win percentage
            result_t2 = {x:result_t2[x]/82. for x in result_t2}
            for k, v in result_t2.iteritems():
                predicted_winper2.setdefault(k, []).append(v)
                
            #add the predicted Home wins for each game
            predicted_result2["HWin"] += result2
    
        #calculate the probability of a Home win
        predicted_result2["HWin"] /= float(30)
        
        #return accuracy metrics
        accuracy2 = calc_accuracy(predicted_result2)
        
        #plot
        print "Bootstrap Model"
        print "Overall, the model correctly predicts: {0:.2%} of game outcomes".format(accuracy2[0])
        print "Overall, the model correctly predicts: {0:.2%} of close outcomes".format(accuracy2[1])
        print "Overall, the model correctly predicts: {0:.2%} of blowout outcomes".format(accuracy2[2])
        plot_predictvactual(winloss, predicted_winper2)

weights = [1.,2.,4.,6.]


#testing only on bootstrap due to speed, following code is a modified runmodel_boot
for weight in weights:
        #holds the predicted win percentage
        predicted_winper3 = {}
        
        #DataFrame that will be passed to calc_accuracy
        predicted_result3 = gamescores.copy()
        
        #will hold the probability of a Home team win for any given match
        predicted_result3["HWin"] = 0
        
        for x in range (0,50):
        
            #retrieve the number of predicted wins by team and by match
            result_t3, result3 = predict_results_boot(gamescores, database_simplePTS, starting_fiveMP13, 
                                                    hist_margins, model_adjust, "team1, team2, df, weight, database_adjustTOV, gamescores")
    
            #add the predicted win percentage
            result_t3 = {x:result_t3[x]/82. for x in result_t3}
            for k, v in result_t3.iteritems():
                predicted_winper3.setdefault(k, []).append(v)
                
            #add the predicted Home wins for each game
            predicted_result3["HWin"] += result3
        
        #calculate the probability of a Home win
        predicted_result3["HWin"] /= float(30)
        
        #return accuracy metrics
        accuracy3 = calc_accuracy(predicted_result3)
        
        #plot
        print "Bootstrap Model"
        print "Overall, the model correctly predicts: {0:.2%} of game outcomes".format(accuracy3[0])
        print "Overall, the model correctly predicts: {0:.2%} of close outcomes".format(accuracy3[1])
        print "Overall, the model correctly predicts: {0:.2%} of blowout outcomes".format(accuracy3[2])
        plot_predictvactual(winloss, predicted_winper3)

weights = [1.,2.,4.,6.]
database_adjust = adjust_build(starting_fiveMP13, "ORB")

#testing only on bootstrap due to speed, following code is a modified runmodel_boot
for weight in weights:
        #holds the predicted win percentage
        predicted_winper4 = {}
        
        #DataFrame that will be passed to calc_accuracy
        predicted_result4 = gamescores.copy()
        
        #will hold the probability of a Home team win for any given match
        predicted_result4["HWin"] = 0
        
        for x in range (0,50):
            
            #retrieve the number of predicted wins by team and by match
            result_t4, result4 = predict_results_boot(gamescores, database_simplePTS, starting_fiveMP13, 
                                                    hist_margins, model_adjust, "team1, team2, df, weight, database_adjustORB, gamescores")
    
            #add the predicted win percentage
            result_t4 = {x:result_t4[x]/82. for x in result_t4}
            for k, v in result_t4.iteritems():
                predicted_winper4.setdefault(k, []).append(v)
                
            #add the predicted Home wins for each game
            predicted_result4["HWin"] += result4
        
        #calculate the probability of a Home win
        predicted_result4["HWin"] /= float(30)
        
        #return accuracy metrics
        accuracy4 = calc_accuracy(predicted_result4)
        
        #plot
        print "Bootstrap Model"
        print "Overall, the model correctly predicts: {0:.2%} of game outcomes".format(accuracy4[0])
        print "Overall, the model correctly predicts: {0:.2%} of close outcomes".format(accuracy4[1])
        print "Overall, the model correctly predicts: {0:.2%} of blowout outcomes".format(accuracy4[2])
        plot_predictvactual(winloss, predicted_winper4)

print stats.pearsonr(players_data["PTS"], players_data["AST"])
print stats.pearsonr(players_data["PTS"], players_data["TOV"])
print stats.pearsonr(players_data["PTS"], players_data["ORB"])

#grab new 2014 data
players_MP14 = players_2014.copy()
players_MP14["MP"] = players_2014['MP'].map(lambda x: convert_time(x))

#recreate the starting lineup
starting_fiveMP14 = starting_lineupMP(players_MP14)

#update individual player's historical numbers
database_PTS2014 = bootstrap_build(players_data_08_14)

#update historical margins
hist_margins_14 = historical_margins(allscores_2014)
print hist_margins_14

#calculate win percentage of 2014 for comparison
winloss = dict.fromkeys(NBA_teams, 0)
for index, row in scores_2014.iterrows():
    if row["PTS"]>row["PTS.1"]:
        winloss[row["Visitor/Neutral"]] +=1
    else:
        winloss[row["Home/Neutral"]] +=1

#divide by 23 games, the official number of games played so far
winloss = {x:winloss[x]/23. for x in winloss}

#re-run our bootstrap model builder with the margin function
runmodel_boot(100, scores_2014, database_PTS2014, [starting_fiveMP14, hist_margins_14, margin_adjust, "team1, team2, df"])

#update player fit param
player_distributionfl = distribution_param("fatiguelife", players_data_08_14)

#re-run fit fit builder with the margin function
runmodel_dist(100, testing_dist, scores_2014, [starting_fiveMP14, hist_margins_14, margin_adjust, "team1, team2, df"])