#!/usr/bin/python

import scanf, re, math

class StageBonus:
    def __init__(self,first,second,third):
        self.first = first
        self.second = second
        self.third = third

class Riders:
    def __init__(self,name,place,team,time,bonus,proj_bonus):
        self.name = name
        self.place = place
        self.team = team
        self.time = time
        self.bonus = bonus # will be the adjusted time for bonuses, in seconds
        self.proj_bonus = proj_bonus

class Teams:
    def __init__(self,name,list,totalTime,projtotalTime,index):
        self.name = name
        self.list = list
        self.totalTime = totalTime
        self.projtotalTime = projtotalTime
        self.projRank = 0
        self.index = index

class JerseyBonus:
    def __init__(self,green1,green2,green3,polka1,polka2,polka3):
        self.green1 = green1
        self.green2 = green2
        self.green3 = green3
        self.polka1 = polka1
        self.polka2 = polka2
        self.polka3 = polka3

# pick the top (smallest time) six for each team, we'll just reorder their positions in place
def pickTeams(teamsTemp,ridersTemp):
    for team in teamsTemp:
        # we'll sort by the real time
        team.list.sort(lambda x, y: cmp(ridersTemp[x].time,ridersTemp[y].time))
    return teamsTemp

# rank the teams by the top six riders in each team, moving them inside teams
def rankTeams(teamsTemp,ridersTemp):
    tempList = []
    tempTeams = []
    for j,team in enumerate(teamsTemp):
        totalTime = 0
        projtotalTime = 0
        bonus = 0
        proj_bonus = 0
        for i in range(6):
            totalTime += ridersTemp[team.list[i]].time
            projtotalTime += ridersTemp[team.list[i]].time
            #print 'index ' + str(team.index) + ' rider bib ' + str(team.list[i]) + ' real time ' + str(convertTime(ridersTemp[team.list[i]].time))
        # calculate the bonus time for this team, it will be a negative number
        for bib in team.list:
            bonus += ridersTemp[bib].bonus
            proj_bonus += ridersTemp[bib].proj_bonus
            #print 'bonus ' + str(bonus)
        # apply it to totalTime
        totalTime = totalTime + bonus
        projtotalTime = projtotalTime + proj_bonus
        teamsTemp[j].totalTime = totalTime
        teamsTemp[j].projtotalTime = projtotalTime
        tempList.append([j,totalTime])
        #print 'rankTeams ' + str(team.index) + ' ' + str(convertTime(totalTime))
    # now sort the tempList by second index
    tempList.sort(lambda x,y: cmp(x[1],y[1]))
    # reorder teams
    for item in tempList:
        tempTeams.append(teamsTemp[item[0]])
    # copy it back
    teamsTemp = tempTeams
    # now sort by projected time, and store it in .projRank
    tempList = []
    for j,team in enumerate(teamsTemp):
        tempList.append([j,team.projtotalTime])
    tempList.sort(lambda x,y: cmp(x[1],y[1]))
    for i,item in enumerate(tempList):
        teamsTemp[item[0]].projRank = i
    return teamsTemp

def quickPrint(teams,quickfp):
    line = str('Rank').ljust(5) + str('Draft Order').ljust(12) + \
        str('Team').ljust(20) + str('Time (w/bonus)').ljust(15) + \
        str('Gap to 1st').ljust(15) + str('Gap to next').ljust(15) + \
        str('Proj Rank').ljust(13) + str('Proj Gap to 1st') + '\n'
    quickfp.write(line)
    min_projtime = 100000000000
    for team in teams:
        if team.projtotalTime < min_projtime:
            min_projtime = team.projtotalTime
            min_index = team.index
    for i, team in enumerate(teams):
        line = str(i+1).ljust(5) + str(team.index+1).ljust(12) + str(team.name).ljust(20)
        timeString = convertTime(team.totalTime)
        if (i==0):
            firstTime = team.totalTime
            lastTime = team.totalTime
        if (i>0): firstDiff = team.totalTime - firstTime
        if (i>0):
            timeDiff = team.totalTime - lastTime
            lastTime = team.totalTime
        #print str(team.index) + ' ' + str(team.totalTime)
        if (i==0):
            line = line + str(timeString).ljust(45)
        if (i>0):
            line = line + str(timeString).ljust(15)
        #quickfp.write(line)
        if (i>0):
            timeString = convertTime(firstDiff)
            line = line + str(timeString).ljust(15)
            #quickfp.write(line)
        if (i>0):
            timeString = convertTime(timeDiff)
            #line = '  The time to next is: %s.\n' % timeString
            line = line + str(timeString).ljust(15)
        # projected rank
        line = line + str(team.projRank+1).ljust(13)
        if team.index != min_index:
            timeString = convertTime(team.projtotalTime-min_projtime)
        else:
            timeString = ''
        line = line + str(timeString).ljust(22)
        line = line + '\n'
        quickfp.write(line)

def writeBonuses(stageBonuses,riders,bonusfp,teams):
    for j,stage in enumerate(stageBonuses):
        line = 'Stage ' +str(j) +'\n'
        bonusfp.write(line)
        # This is really ghetto but I don't care
        name1 = 'No Team'
        name2 = 'No Team'
        name3 = 'No Team'
        if stage.first != 888:
            for team in teams:
                if stage.first in team.list:
                    name1 = team.name
                if stage.second in team.list:
                    name2 = team.name
                if stage.third in team.list:
                    name3 = team.name
            line = 'First: %s (%s)\n' % (riders[stage.first].name, name1)
            bonusfp.write(line)
            line = 'Second: %s (%s)\n' % (riders[stage.second].name, name2)
            bonusfp.write(line)
            line = 'Third: %s (%s)\n\n' % (riders[stage.third].name, name3)
            bonusfp.write(line)
        else:
            line = 'No bonuses.\n\n'
            bonusfp.write(line)

def printTeams(teams,riders,finalfp):
    # find the lowest time
    minTime = 10e10
    for rider in riders:
        if (riders[rider].place == 1):
            minTime = riders[rider].time
    for i,team in enumerate(teams):
        line = '%s is ranked %d\n' % (team.name, i+1) # name, rank number
        finalfp.write(line)
        timeString = convertTime(team.totalTime)
        finalfp.write('The top six riders time total (w/bonus): %s\n' % timeString)
        line = str('pos').ljust(4) + str('bib').ljust(4) + str('Name').ljust(30) + str('Team').ljust(35) \
        + str('Real Time').ljust(13) + str('Behind Leader').ljust(15) + str('Bonus Time') + '\n'
        finalfp.write(line)
        for i,rider in enumerate(team.list):
            if (i==6):
                line = '-------------------------------------------------------------------------------------------------------------'
                finalfp.write(line + '\n')
            line = str(riders[rider].place).ljust(4) + str(rider).ljust(4) + str(riders[rider].name).ljust(30) + str(riders[rider].team).ljust(35) \
            + str(convertTime(riders[rider].time)).ljust(13) + str(convertTime(riders[rider].time - minTime)).ljust(15) + str(convertTime(riders[rider].bonus))
            finalfp.write(line + '\n')
        finalfp.write('\n\n')

def printToGraph(teamsTemp,graphfp,stage):
    line = str(stage).ljust(3)
    diffs = {}
    for i, team in enumerate(teamsTemp):
        timeString = convertTime(team.totalTime)
        #print timeString
        if (i==0):
            firstTime = team.totalTime
            diffs[team.index] = 0
        if (i>0):
            diffs[team.index] = team.totalTime - firstTime
    for i in range(len(teamsTemp)):
        for j in range(len(teamsTemp)):
            if (i == j):
                line = line + str(float(diffs[j])/60.).ljust(15)
    line = line + '\n'
    graphfp.write(line)

def convertTime(time):
    timeFlag = 0
    if (time < 0):
        timeFlag = 1
        time = -time
    hours = int(time/3600)
    minutes = int((time - hours * 3600)/60)
    seconds = int((time - hours * 3600 - minutes * 60))
    if (timeFlag == 1):
        if (hours > 0):
            hours = -hours
        else:
            minutes = -minutes
    string = '%dh %dm %ds' % (hours,minutes,seconds)
    return string

def readRiders(HTMLname,ridersTemp):
    HTMLfp = open(HTMLname, 'r')
    HTMLline = HTMLfp.readline()
    tbodyflag = 0
    #ridersTemp ={}
    maxtime = 0
    while HTMLline:
        # skip past the table header
        while ((tbodyflag == 0) and HTMLline.count('tbody') == 0):
            HTMLline = HTMLfp.readline()
        HTMLline = tabs.subn('',HTMLline)[0]
        HTMLline = apos.subn('\'',HTMLline)[0]
        if (HTMLline.count('tbody')):
            tbodyflag = 1
        if (HTMLline.count('col_1')):
            placetemp = re.split('>|<',HTMLline)[2]
            place = int(float(placetemp))
        if (HTMLline.count('col_2')):
            #print HTMLline
            nametemp = re.split('>|<',HTMLline)
            name = nametemp[4]
        if (HTMLline.count('col_3')):
            bibtemp = re.split('>|<',HTMLline)
            bib = int(bibtemp[4])
        if (HTMLline.count('col_4')):
            teamtemp = re.split('>|<',HTMLline)
            team = teamtemp[2]
        if (HTMLline.count('col_5')):
            timetemp = re.split('>|<',HTMLline)[2]
            try:
                timetemp = scanf.sscanf(timetemp,'%dh %d\' %d"')
                time = 3600 * timetemp[0] + 60 * timetemp[1] + timetemp[2] # get the time in total seconds
            except:
                timetemp = scanf.sscanf(timetemp,'%d\' %d"')
                time = 60 * timetemp[0] + timetemp[1]
            if (time > maxtime):
                maxtime = time
        if (HTMLline.count('</tr')): # we're done with the rider
            ridersTemp[bib] = Riders(name,place,team,time,0,0)
        HTMLline = HTMLfp.readline()
    
    HTMLfp.close
    #print maxtime
    return (ridersTemp,maxtime)

# figure out the best riders & not picked best riders
def bestRiders(riders,teams,bestfp,notpickedfp,nobonusfp):
    for rider in riders:
        if (riders[rider].place == 1):
            minTime = riders[rider].time
    # make a list of times for sorting, with bib number
    best = []
    for bib in riders:
        timeTemp = riders[bib].time + riders[bib].bonus # bonus is negative
        best.append([bib,timeTemp])
    best.sort(lambda x,y: cmp(x[1],y[1])) # sort by time
    # write out the results
    line = str('pos').ljust(4) + str('bib').ljust(4) + str('Name').ljust(30) + str('Team').ljust(35) \
    + str('Real Time').ljust(13) + str('Behind Leader').ljust(15) + str('Bonus Time').ljust(15) + str('Effective Time').ljust(15) + '\n'
    bestfp.write(line)
    for i in range(15):
        line = str(riders[best[i][0]].place).ljust(4) + str(best[i][0]).ljust(4) \
        + str(riders[best[i][0]].name).ljust(30) + str(riders[best[i][0]].team).ljust(35) \
        + str(convertTime(riders[best[i][0]].time)).ljust(13) \
        + str(convertTime(riders[best[i][0]].time - minTime)).ljust(15) \
        + str(convertTime(riders[best[i][0]].bonus)).ljust(15) \
        + str(convertTime(riders[best[i][0]].time + riders[best[i][0]].bonus - minTime)) 
        bestfp.write(line + '\n')
    # find the best not picked riders
    notpicked = []
    i = 0
    while (len(notpicked) < 6):
        bibTemp = best[i][0]
        if (onTeam(bibTemp,teams) == -1): # add this rider to notpicked
            notpicked.append(bibTemp)
        i += 1
    # find out how the notpicked riders would fare as a team
    notTime = 0
    for bib in notpicked:
        notTime += riders[bib].time + riders[bib].bonus # find the 'team' time
    # find the place it would be
    notPlace=0
    while (teams[notPlace].totalTime < notTime):
        notPlace += 1
        if (notPlace == len(teams)): break
    line = str('If this was a team, it would be in place ') + str(notPlace + 1) + str(' with a time of ') + \
    str(convertTime(notTime)) + '\n'
    notpickedfp.write(line)
    # write out the results
    line = str('pos').ljust(4) + str('bib').ljust(4) + str('Name').ljust(30) + str('Team').ljust(35) \
    + str('Real Time').ljust(13) + str('Behind Leader').ljust(15) + str('Bonus Time').ljust(15) + str('Effective Time').ljust(15) + '\n'
    notpickedfp.write(line)
    for bib in notpicked:
        line = str(riders[bib].place).ljust(4) + str(bib).ljust(4) \
        + str(riders[bib].name).ljust(30) + str(riders[bib].team).ljust(35) \
        + str(convertTime(riders[bib].time)).ljust(13) \
        + str(convertTime(riders[bib].time - minTime)).ljust(15) \
        + str(convertTime(riders[bib].bonus)).ljust(15) \
        + str(convertTime(riders[bib].time + riders[bib].bonus - minTime))
        notpickedfp.write(line + '\n')
    # now do the riders with bonuses no one picked
    nobonus = []
    for rider in best:
        bibTemp = rider[0]
        if ((onTeam(bibTemp,teams) == -1) and (riders[bibTemp].bonus < 0)): # add this rider to nobonus
            nobonus.append(bibTemp)
    # write out the results
    line = str('pos').ljust(4) + str('bib').ljust(4) + str('Name').ljust(30) + str('Team').ljust(35) \
    + str('Real Time').ljust(13) + str('Behind Leader').ljust(15) + str('Bonus Time').ljust(15) + str('Effective Time').ljust(15) + '\n'
    nobonusfp.write(line)
    for bib in nobonus:
        line = str(riders[bib].place).ljust(4) + str(bib).ljust(4) \
        + str(riders[bib].name).ljust(30) + str(riders[bib].team).ljust(35) \
        + str(convertTime(riders[bib].time)).ljust(13) \
        + str(convertTime(riders[bib].time - minTime)).ljust(15) \
        + str(convertTime(riders[bib].bonus)).ljust(15) \
        + str(convertTime(riders[bib].time + riders[bib].bonus - minTime))
        nobonusfp.write(line + '\n')


# is the rider on any team? if so, return that team's index
def onTeam(bib,teams):
    indexTemp = -1
    for team in teams:
        if team.list.count(bib):
            indexTemp = team.index
            break
    return indexTemp

# calculate bonus distribution
def bonusAnalyze(teams,riders,stages,bonusAnalyzefp):
    totalTime = stages * (-30) * 60 # negative, in seconds
    # create teamTime dict and zero it out, -1 slot is for unclaimed time
    teamTime = {}
    teamPercent = {}
    teamAvailPercent = {}
    for i in range(len(teams)+1):
        j = i-1
        teamTime[j]=0
    for bib in riders:
        team = onTeam(bib,teams)
        teamTime[team] += riders[bib].bonus # bonuses are negative
    availTime = totalTime - teamTime[-1] # a less negative number
    for i in range(len(teams)+1):
        j = i-1
        teamPercent[j] = 100.0 * teamTime[j] / totalTime
        teamAvailPercent[j] = 100.0 * teamTime[j] / availTime
    line = str('Team').ljust(20) + str('Bonus Time').ljust(15) + str('% of Total').ljust(12) + str('% of Claimed') + '\n'
    bonusAnalyzefp.write(line)
    for i in range(len(teams)):
        for j in range(len(teams)):
            if (teams[j].index == i):
                name = teams[j].name
        line = str(name).ljust(20) + str(convertTime(teamTime[i])).ljust(15) + str('%2.1f'%teamPercent[i]).ljust(12) + str('%2.1f'%teamAvailPercent[i]) + '\n'
        bonusAnalyzefp.write(line)
    line = str('No Team').ljust(20) + str(convertTime(teamTime[-1])).ljust(15) + str('%2.1f'%teamPercent[-1]) + '\n'
    bonusAnalyzefp.write(line)

def droppedRiders(dropped,riders,teams,droppedfp):
    written = 0
    for key in dropped:
        line = ''
        if len(dropped[key]):
            line = 'Stage %02d:' % (key)
            for rider in dropped[key]:
                # more ghettoness, but I don't care, again!
                name = 'No Team'
                for team in teams:
                    if rider in team.list:
                        name = team.name
                line = line + ' %s (%s),' % (riders[rider].name, name)
                written += 1
            line = line + '\n'
        droppedfp.write(line)
    if written == 0:
        line = 'None so far.\n'
        droppedfp.write(line)

def printResultsLinks(HTMLnames,letourfp):
    template1 = 'http://www.letour.fr/2010/TDF/LIVE/us'
    template2 = 'classement/index.html'
    line = '<p><b>Full results</b> at letour.fr after stage:\n'
    letourfp.write(line)
    for i,name in enumerate(HTMLnames):
        if i == 0:
            line = '<a href="%s/%d/%s">%d</a>;\n' % (template1,i,template2,i)
        else:
            line = '<a href="%s/%d00/%s">%d</a>;\n' % (template1,i,template2,i)
        letourfp.write(line)
    line = '</p>\n'
    letourfp.write(line)

def getTeam(bib, teams):
    # Really ghetto!
    for team in teams:
        if bib in team.list:
            return team.name
    return 'No Team'

def printJerseyLeaders(fname, jb, riders, teams):
    jbpf = open(fname, 'w')
    jbpf.write("Points - Green\n")
    jbpf.write("First : %s (%s)\n" % (riders[jb.green1].name, getTeam(jb.green1,teams)))
    jbpf.write("Second: %s (%s)\n" % (riders[jb.green2].name, getTeam(jb.green2,teams)))
    jbpf.write("Third : %s (%s)\n" % (riders[jb.green3].name, getTeam(jb.green3,teams)))
    jbpf.write("\nMountains - Polka Dot\n")
    jbpf.write("First : %s (%s)\n" % (riders[jb.polka1].name, getTeam(jb.polka1,teams)))
    jbpf.write("Second: %s (%s)\n" % (riders[jb.polka2].name, getTeam(jb.polka2,teams)))
    jbpf.write("Third : %s (%s)\n" % (riders[jb.polka3].name, getTeam(jb.polka3,teams)))
    jbpf.close()
    

# --- EDIT BELOW HERE DAILY ---- #
# list the stage winners by bib number
stageBonuses = []
stageBonuses.append(StageBonus(13,115,57)) # stage 0
stageBonuses.append(StageBonus(208,117,95)) # stage 1
stageBonuses.append(StageBonus(131,82,149)) # stage 2
stageBonuses.append(StageBonus(95,39,121)) # stage 3
stageBonuses.append(StageBonus(208,52,36)) # stage 4
stageBonuses.append(StageBonus(111,142,36)) # stage 5
stageBonuses.append(StageBonus(111,53,208)) # stage 6
stageBonuses.append(StageBonus(131,219,194)) # stage 7
stageBonuses.append(StageBonus(11,181,195)) # stage 8
stageBonuses.append(StageBonus(62,161,201)) # stage 9
stageBonuses.append(StageBonus(27,165,134)) # stage 10
stageBonuses.append(StageBonus(111,208,53)) # stage 11
stageBonuses.append(StageBonus(77,1,9)) # stage 12
stageBonuses.append(StageBonus(9,111,208)) # stage 13
stageBonuses.append(StageBonus(89,191,181)) # stage 14
stageBonuses.append(StageBonus(151,122,218)) # stage 15
stageBonuses.append(StageBonus(154,62,168)) # stage 16
stageBonuses.append(StageBonus(11,1,77)) # stage 17
stageBonuses.append(StageBonus(111,52,208)) # stage 18
stageBonuses.append(StageBonus(13,115,113)) # stage 19
stageBonuses.append(StageBonus(111,208,52)) # stage 20

graphName = 'graph.out'

# all the HTML files, starting with the first stage that counts
HTMLnames = ['00-ITG.html','01.html','02.html','03.html','04.html', '05.html',
    '06.html','07.html','08.html','09.html','10.html','11.html','12.html',
    '13.html','14.html','15.html','16.html','17.html','18.html','19.html',
    '20.html']

# dropped riders, zero-based
dropped = {}
dropped[0] = [92]
dropped[1] = [125,213]
dropped[2] = [114,104]
dropped[3] = [86,16,51,148]
dropped[4] = []
dropped[5] = [187]
dropped[6] = []
dropped[7] = [78,184]
dropped[8] = []
dropped[9] = [71,35,216,215,144]
dropped[10] = []
dropped[11] = [117,109,55]
dropped[12] = [53,173]
dropped[13] = [171]
dropped[14] = []
dropped[15] = [129]
dropped[16] = [217,198]
dropped[17] = [209]
dropped[18] = [136]
dropped[19] = []
dropped[20] = []

# Update after each stage
jb = JerseyBonus(208,111,95,153,166,11)

# --- EDIT HERE AT THE BEGINNING OF THE TOUR ---- #

# list the teams
teams = []
teams.append(Teams('Onate',[1,2,28,48,85,91,107,154,165,177,193,195],0,0,0))
teams.append(Teams('Team Q',[11,51,61,62,88,89,93,125,128,131,145,191],0,0,1))
teams.append(Teams('Hannon',[3,9,13,23,41,42,115,149,166,172,173,192],0,0,2))
teams.append(Teams('Gay Queens',[6,14,16,17,21,22,36,39,54,116,119,181],0,0,3))
teams.append(Teams('Arnold',[18,24,27,31,71,73,101,106,118,156,176,183],0,0,4))
teams.append(Teams('Storky',[25,32,53,56,57,59,75,81,111,112,126,187],0,0,5))
teams.append(Teams('Carr Wreck',[44,77,92,95,151,155,159,171,194,12,19,35],0,0,6))
teams.append(Teams('Wells', [63,86,102,121,122,141,161,164,201,8,37,142],0,0,7))


# open the graph file
graphfp = open(graphName,'w')

# open the quick summary file
quickfp = open('quick.txt','w')

# open the final out file
finalfp = open('final.txt','w')

# open the bonuses file
bonusfp = open('bonus.txt', 'w')

# open the best riders file
bestfp = open('best.txt', 'w')

# open the best not-picked riders file
notpickedfp = open('notpicked.txt','w')

# open the not-picked bonuses file
nobonusfp = open('nobonus.txt','w')

# open the bonus time analyze file
bonusAnalyzefp = open('bA.txt','w')

# dropped riders file
droppedfp = open('dropped.txt','w')

# links to results file
letourfp = open('letour.txt','w')

# to remove extra tabs off the lines, the plus means many times
tabs = re.compile('\t+')
# remove the offending apostrophe html symbols
apos = re.compile('&#8217;+')

# read in the data and do the processing
riders = {}
for stage,name in enumerate(HTMLnames):
    # read in the riders, and get the maxTime
    (riders,maxTime) = readRiders(name,riders)
    #print maxTime
    # dropped riders will not have their time updated, so we need to assign them the max time manually
    # first make a list that's current using the dropped dict of dropped riders
    nowDropped = []
    for i in range(stage+1):
        j = i
        for bibItem in dropped[j]:
            nowDropped.append(bibItem)
    # now give maxTime to dropped riders in nowDropped
    for bibItem in nowDropped:
        riders[bibItem].time = maxTime
        #print 'bibItem %d time %d' % (bibItem,maxTime)
        riders[bibItem].place = 999
        # make their bonus 0 because it's not being zeroed in readRiders()
        riders[bibItem].bonus = 0
    # do bonuses
    for i,bonus in enumerate(stageBonuses):
        if (i<=stage):
            riders[bonus.first].bonus -= 15 * 60 # fifteen minute bonus for first each stage
            riders[bonus.first].proj_bonus -= 15 * 60
            riders[bonus.second].bonus -= 10 * 60 # ten minutes
            riders[bonus.second].proj_bonus -= 10 * 60
            riders[bonus.third].bonus -= 5 * 60 # five minutes
            riders[bonus.third].proj_bonus -= 5 * 60
    if stage == stage:
        riders[jb.green1].proj_bonus -= 30 * 60
        riders[jb.green2].proj_bonus -= 20 * 60
        riders[jb.green3].proj_bonus -= 10 * 60
        riders[jb.polka1].proj_bonus -= 30 * 60
        riders[jb.polka2].proj_bonus -= 20 * 60
        riders[jb.polka3].proj_bonus -= 10 * 60
      # Turn this on at the end, leave commented out until then
    if (stage == 20): # only for the last stage
        riders[jb.green1].bonus -= 30 * 60 # 30 minutes for first in points
        riders[jb.green2].bonus -= 20 * 60 # 20 min for second
        riders[jb.green3].bonus -= 10 * 60 # 10 min for third
        riders[jb.polka1].bonus -= 30 * 60 # 30 min for first climber
        riders[jb.polka2].bonus -= 20 * 60 # 20 min second
        riders[jb.polka3].bonus -= 10 * 60 # 10 min third
    # order the riders in each team
    teams = pickTeams(teams,riders)
    # order the teams
    teams = rankTeams(teams,riders)
    # print the graph
    printToGraph(teams,graphfp,stage+1)

# print out the summary
quickPrint(teams,quickfp)

# print out the team data
printTeams(teams,riders,finalfp)

# print out the bonuses
writeBonuses(stageBonuses,riders,bonusfp,teams)

# print out the best riders
bestRiders(riders,teams,bestfp,notpickedfp,nobonusfp)

# bonus analyze
bonusAnalyze(teams,riders,len(stageBonuses)+4,bonusAnalyzefp) # +4 for jersey bonuses

# abandoned riders
droppedRiders(dropped,riders,teams,droppedfp)

# links to results
printResultsLinks(HTMLnames,letourfp)

# Jersey bonuses
printJerseyLeaders('jerseys.txt', jb, riders, teams)

# close the graph file, quick out, final file, etc...
graphfp.close()
quickfp.close()
finalfp.close()
bonusfp.close()
bestfp.close()
notpickedfp.close()
nobonusfp.close()
bonusAnalyzefp.close()
droppedfp.close()
letourfp.close()