def fetch_defense_stats():
    # team defense statistics
    statistics = {}
    for team in map(lambda x: x[0], nflgame.teams):
        statistics[team] = create_empty_entry()

    for year in range(2009, 2015):
        for week in range(1, 18):
            for game in nflgame.games(year=year, week=week):
                home = game.home
                away = game.away
                statistics[home][str(year)][str(week)] = {
                    'home': home,
                    'away': away,
                    'points_allowed': game.score_away,
                    'passing_yards_allowed': game.stats_away[2],
                    'rushing_yards_allowed': game.stats_away[3],
                    'turnovers': game.stats_away[6],
                    'played': True

                }
                statistics[away][str(year)][str(week)] = {
                    'home': home,
                    'away': away,
                    'points_allowed': game.score_home,
                    'passing_yards_allowed': game.stats_home[2],
                    'rushing_yards_allowed': game.stats_home[3],
                    'turnovers': game.stats_home[6],
                    'played': True
                }

    return statistics

def raw_nfl_data_out():
    print "%s,%s,%s,%s,%s,%s,%s,%s" % ( "season","week","gametype","home","home_score","away","away_score","home_score_margin" )
    for s in y:
            for k in gametype:
                    games = nfl.games(s,kind=k)
                    for g in games:
                        print "%i, %i, %s, %s, %i, %s, %i, %i" % (g.season(), g.schedule['week'],k ,g.home,g.score_home,g.away,g.score_away,g.score_home-g.score_away)

def getPlayerStats(plyr,stat): 
	game = nflgame.games(2012,week=[2,3,4,6])
	players = nflgame.combine(game)
	player = players.name(plyr)
	playerStats = player.stats
	if stat in playerStats:
		print 'stat: ',stat,' value = ',playerStats[stat]

def away_rushing_tds_in_year(year, player, team):
    avg = 0.0
    away_games = nflgame.games(year, home=team)
    players = nflgame.combine(away_games)
    this_player = players.name(player)
    avg += this_player.rushing_tds
    print year, this_player, this_player.rushing_tds, (avg / 8)

def fetch_games(year, week, team = None):
    games = nflgame.games(year, week)
    if team:
        for game in games:
            if game.home == team or game.away == team:
                return [ game ]
    return games

def get_game_data(name, team, book, year):

    if __name__ == '__main__':
        try:
            player = nflgame.find(name)[0]
        except BaseException:
            return

    if '(, )' in str(player):
        print ("Player Inactive, or Player Not Found\n\n")
        return

    print ("*" *79)
    print (player)

    data = create_csv(player)
    data.append_separator(name)

    print (str(year) + '\n')
    data.append_separator(year)
    games = nflgame.games(year, home=team, away=team)
    for game in games:
        plyr = game.players.name(player.gsis_name)
        print ('-'*79)
        print (game)
        to_csv(data, plyr, game, year, player.position)

    with open(name + '.xls', 'wb') as f:
        f.write(data.xls)
    book.add_sheet(data)

def _get_stats(season, week, kind):
    """
    Memoized stats getter. Requires fully-specified arguments to make effective
    use of the cache.
    """
    games = nflgame.games(season, week=week, kind=kind)
    return nflgame.combine_max_stats(games)

def home_passing_tds_in_year(year, player, team):
    avg = 0.0
    home_games = nflgame.games(year, home=team)
    players = nflgame.combine(home_games)
    this_player = players.name(player)
    avg += this_player.passing_tds
    print year, this_player, this_player.passing_tds, (avg / 8)

 def make_team_stats(self):
     """
     Collect all stats for a given year, week(s), team(s).
     """
     for year in self.year:
         for week in self.week:
             if year < CURRENT_YEAR or (year == CURRENT_YEAR and week <= CURRENT_WEEK):
                 games = ng.games(year, week)
                 for game in games:
                     if 'home' in self.site and game.home in self.which_team:
                         home_team = self.teams[game.home][year][week]
                         home_team['OWN']['game'] = game
                         home_team['OWN']['OPP'] = game.away
                         home_team['OWN']['pts'] = game.score_home
                         home_team['OPP']['pts'] = game.score_away
                         home_team['OWN_TOTAL']['OPP'] = game.away
                         self.add_defense_stats(game.home, year, week, game)
                         self.add_passing_stats(game.home, year, week, game)
                         self.add_rushing_stats(game.home, year, week, game)
                     if 'away' in self.site and game.away in self.which_team:
                         away_team = self.teams[game.away][year][week]
                         away_team['OWN']['game'] = game
                         away_team['OWN']['OPP'] = '@ ' + game.home
                         away_team['OWN']['pts'] = game.score_away
                         away_team['OPP']['pts'] = game.score_home
                         away_team['OWN_TOTAL']['OPP'] = game.home
                         self.add_defense_stats(game.away, year, week, game)
                         self.add_passing_stats(game.away, year, week, game)
                         self.add_rushing_stats(game.away, year, week, game)

def create_all_players(host, port, year, kind, game_weeks):
  games = []
  for week in game_weeks:
    for game in nflgame.games(year, week = week, kind = kind):
      games.append(Game(game, week))

  if not games:
    raise RuntimeError("Couldn't find any {}-games in {}, did you get the year right?".format(kind, year))

  offensive_players = {}
  defensive_players = {}

  for game in games:
    for player in game.offensive_players():
      if player.playerid not in offensive_players:
        offensive_players[player.playerid] = player
    for player in game.defensive_players():
      if player.team not in defensive_players:
        defensive_players[player.team] = player

  all_players = dict(offensive_players.items() + defensive_players.items())
  total_no_players = len(all_players.keys())
  counter = 1
  for key, value in all_players.iteritems():
    print "Uploading player "+value.name+" "+str(counter)+"/"+str(total_no_players)
    response = value.get_api_facade(host, port).create()
    if response.status_code != 200:
      print "Error creating player "+player.name+" code was "+str(response.status_code)
    counter += 1

def main():
    # Necessary lists
    seasonList, seasons, score, firstDowns, totalYards, passingYards, rushingYards, penaltyCount, penaltyYards, \
    turnovers, puntCount, puntYards, puntAverage = [], [], [], [], [], [], [], [], [], [], [], [], []
    # Creates each season
    for x in range(0,8):
        seasonListIteration = nflgame.games(x+2009)
        seasons += [x+2009 for y in range (0, len(seasonListIteration))]
        seasonList += seasonListIteration
    # Populates lists for each season
    for x in seasonList:
        score += [x.score_home, x.score_away]
        firstDowns += [x.stats_home.first_downs, x.stats_away.first_downs]
        totalYards += [x.stats_home.total_yds, x.stats_away.total_yds]
        passingYards += [x.stats_home.passing_yds, x.stats_away.passing_yds]
        rushingYards += [x.stats_home.rushing_yds, x.stats_away.rushing_yds]
        penaltyCount += [x.stats_home.penalty_cnt, x.stats_away.penalty_cnt]
        penaltyYards += [x.stats_home.penalty_yds, x.stats_away.penalty_yds]
        turnovers += [x.stats_home.turnovers, x.stats_away.turnovers]
        puntCount += [x.stats_home.punt_cnt, x.stats_away.punt_cnt]
        puntYards += [x.stats_home.punt_yds, x.stats_away.punt_yds]
        puntAverage += [x.stats_home.punt_avg, x.stats_away.punt_avg]
    # Writes .CSV with format Score, First Downs, Total Yards, Passing Yards, Rushing Yards, Penalty Count,
    # Penalty Yards, Turnovers, Punt Count, Punt Yards, Punt Average
    with open('NFL Stats Rewrite.csv', 'wb') as csvfile:
        gameWriter = csv.writer(csvfile, delimiter=',', quotechar=',', quoting=csv.QUOTE_MINIMAL)
        gameWriter.writerow(['Score', 'First Downs', 'Total Yards', 'Passing Yards', 'Rushing Yards', 'Penalty Count',
                             'Penalty Yards', 'Turnovers', 'Punt Count', 'Punt Yards', 'Punt Average'])
        for x in range(0, len(score)):
            gameWriter.writerow(
                [score[x], firstDowns[x], totalYards[x], passingYards[x], rushingYards[x], penaltyCount[x],
                 penaltyYards[x], turnovers[x], puntCount[x], puntYards[x], puntAverage[x]])

def get_games(years):
    """
    Given a list of N years, N .csv files will be written,
    each containing game data for the regular season of that year.
    """
    for year in years:
        f = file('games/games_%s.csv' % year, 'w')
        print_header(f)

        games = nflgame.games(int(year))
        for game in games:
            home_team = game.home
            home_score = game.score_home
            away_team = game.away
            away_score = game.score_away
            week = game.schedule['week']

            f.write(
                '%s,%s,%d,%d,%d,%d\n' %
                (year, home_team, 1, week, home_score, away_score)
            )
            f.write(
                '%s,%s,%d,%d,%d,%d\n' %
                (year, away_team, 0, week, away_score, home_score)
            )
        f.close()

def current_week():
    # returns current week of season
    year = date.today().year
    for x in range(1, 18):
        games = nflgame.games(year, week=x, home=None, away=None, kind='REG', started=False)
        if games == []:
            return x-1

	def getSeasonStats(self, plyr, stat, season):   
		data = []
		# if season == 2014:
		# 	print "HERE"
		for x in range(1, 18):
			game = nflgame.games(season,week=x)
			if game == []:
				break
			players = nflgame.combine_game_stats(game)
			player = players.name(plyr)
			if player is None:
				data.append({'week':str(x),'active':'false'})
			else:
				playerStats = player.stats
				week_obj = {'week':str(x)}
				if(stat == 'all'):
					for x in playerStats:
						week_obj[x] = playerStats[x]
					week_obj['active'] = 'true'
					data.append(week_obj)
					# if season == 2014:
					# 	print week_obj
				else:
					data.append({'week':str(x),stat:str(playerStats[stat]), 'active':'true'})
		return data

    def getNextQuestion(self, cfg):
        while True:
            week = random.randrange(self._firstWeek, self._lastWeek+1)
            year = random.randrange(self._firstYear, self._thisYear+1)
            print year, week
            try:
                games = nflgame.games(year, week=week)
                g = random.randrange(0, len(games))
                game = games[g]
                if game.score_away_q5 > 0 or game.score_home_q5 > 0:
                    continue

                self.homeTeam = game.home
                self.awayTeam = game.away
                self.gameDate = datetime.datetime(game.schedule['year'], game.schedule['month'], game.schedule['day'])
                self.gameTime = game.schedule['time']

                self.homeScores = [game.score_home_q1, game.score_home_q2, game.score_home_q3, game.score_home_q4]
                self.awayScores = [game.score_away_q1, game.score_away_q2, game.score_away_q3, game.score_away_q4]
                self.homeFinalScore = game.score_home
                self.awayFinalScore = game.score_away

                break
            except:
                pass
        return self

def getFantasyPoints(seasons, weeks):
    """
    Download game stats for every season and week and calculate the fantasy
    points scored for each player in each game.

    Args:
        seasons (list): List of seasons (int).
        weeks (list): List of weeks (int).

    Returns:
        dict: Dictionary of fantasy points scored.
    """
    data = {}
    schedule = nflgame.sched.games
    for s in seasons:
        print s
        data[s] = {}
        for w in weeks:
            games = nflgame.games(s, w)
            players = nflgame.combine_game_stats(games)
            data[s][w] = []
            positions = ["QB", "RB", "WR", "TE"]
            gen = (p for p in players if p.player.position in positions)
            for player in gen:
                points = calculateFantasyPoints(player)
                points.append(getOpponent(schedule, s, w, player))
                data[s][w].append(points)
    return data

def getRushers(year=None):
	games = nflgame.games(int(year))
	players = nflgame.combine(games)
	myQuery = {}
	for p in players.rushing().sort("rushing_yds").limit(10):
		myQuery[str(p)] = p.rushing_yds
	return render_template('index.html', year=year, myQuery=myQuery, player="rushers")

def update_week(week):
    """
    Update stats & points for the Week's DefenseWeek and PlayerWeek children.
    """
    teams = {team.abbreviation: initialize_defense_week(week, team)
             for team in NFLTeam.query.all()}
    games = nflgame.games(week.season.year, week=week.number)
    for game in games:
        try:
            teams[game.winner].wins = 1
        except (KeyError, AttributeError):
            pass
        teams[game.home].points_allowed = game.score_away
        teams[game.away].points_allowed = game.score_home
    player_stats = nflgame.combine_play_stats(games)
    for player in player_stats:
        update_defense_by_player(teams[player.team], player)
        update_player_week(player, week)
    for defense in teams.values():
        try:
            defense._score_defense()
        except TypeError:
            # for teams on bye
            pass
    db.session.merge(week)
    db.session.commit()

    def updateScores(self):
        cur = self.conn.cursor()

        # query for all games that are not in final state
        sql = "Select id, week, home_team, away_team, season FROM games WHERE final=0 ORDER BY week"
        cur.execute(sql)

        week = 0
        games = None

        update_sql = ""
        #updated_spreads = {}
        for row in cur:
            print row
            if row[1] != week:
                week = row[1]
                # get schedule and results for the week
                games = nflgame.games(self.season,week=int(week))
                scores = {}
                final = {}
                for g in games:
                    print g
                    scores[self.getNflgameName(g.away)] = g.score_away;
                    scores[self.getNflgameName(g.home)] = g.score_home;
                    final[self.getNflgameName(g.home)] = g.game_over();

            season = row[4]
            table_id = row[0]
            home_team = row[2]
            away_team = row[3]

            home_score = scores[home_team]
            away_score = scores[away_team]

            single_sql = "UPDATE games SET home_score = %d, away_score = %d, final = %d WHERE id=%s;" % (home_score, away_score, final[home_team], table_id)

            if final[home_team] == True:
                away_margin = away_score - home_score
                home_margin = home_score - away_score

                #updated_spreads[home_team] = home_margin
                #updated_spreads[away_team] = away_margin

                home_spread_sql = 'UPDATE spreads SET cover = CASE WHEN spread + %d > 0 THEN 1.0 WHEN spread + %d < 0 THEN 0.0 ELSE 0.5 END WHERE team=\'%s\' AND week=%d AND season=%d;' % (home_margin, home_margin, home_team, week, self.season)
                away_spread_sql = 'UPDATE spreads SET cover = CASE WHEN spread + %d > 0 THEN 1.0 WHEN spread + %d < 0 THEN 0.0 ELSE 0.5 END WHERE team=\'%s\' AND week=%d AND season=%d;' % (away_margin, away_margin, away_team, week, self.season)

                update_sql = update_sql + home_spread_sql + away_spread_sql


            update_sql = update_sql + single_sql


        print update_sql
        if update_sql:
            cur.execute(update_sql)
            cur.connection.commit()


        cur.close()

    def updateGames(self):
        #cur = self.conn.cursor()
        week = 15

        games = nflgame.games(self.season,week=int(week))
        for g in games:
            print g
            self.addGame(week, g.home, g.away)