import bunco
import xlsxwriter
from blessings import Terminal

t = Terminal()
g = bunco.Game("players.csv")

def plural(str,n,suffix="s"):
    return str + suffix if n > 1 else str

def print_center(before, string, after):
    col = int((t.width - len(string)) / 2) - 1
    print(f"{t.move_x(col)}{before}{string}{after}")

def display_dashboard():
    print(t.clear,t.move(0,0))
    print_center(t.bold_red,"B U N C O   S I M U L A T O R", t.normal)
    print(f"{t.red}{'-'*t.width}{t.normal}\n")
    
    # Print column headings for rounds
    rounds = [str(n + 1).rjust(4) for n in range(g.current_round())]
    round_str = "".join(rounds)
    print(f"{t.move_x(18)}{t.bold}{round_str}{t.normal}")

    # Print table of players and their scores each round
    for table in g.tables:
        print(f"  {t.blue}{table}")
        for player in table.players:
            if player is bunco.fuzzydie_holder:
                print(f"🎲",end='')
            print(f"{t.move_x(3)}{t.cyan}{player}{t.normal}",end='')
            for n in range(g.current_round()):
                print(t.move_x(18+(4*n)),end='')
                print(str(player.round_scores[n]).rjust(4),end='')
            print('')

g.play_one_round()
display_dashboard()

def do1():
    g.prep_next_round()
    g.play_one_round()
    display_dashboard()

def summary(n):
    return summary_text(g.players[n])

def summary_text(player):
    for table in g.tables:
        if player in table.players:
            curtable = table
            break
    
    sitch = curtable.get_player_situation(player)

    if player.round_scores[g.current_round()-1] > sitch['opponent_score']:
        winloss = "beating"
    else:
        winloss = "losing to"
    foe_names = " & ".join([str(opp) for opp in sitch['opponents']])

    bunco_ct = player.round_bunco_counts[g.current_round()-1]
    if bunco_ct > 0:
        buncos = f" (& {bunco_ct} {plural('bunco',bunco_ct)}!)"
    else:
        buncos = ""

    ts = [f"Round {g.current_round()} @ {curtable} with {sitch['teammate']}:",
          f"You made {player.round_roll_counts[g.current_round()-1]} rolls,",
          f"adding {player.personal_roll_scores[g.current_round()-1]} pts{buncos}",
          f"to your team score of {player.round_scores[g.current_round()-1]},",
          f"{winloss} {foe_names}’s score of {sitch['opponent_score']}."]
    return " ".join(ts)

def excel_sheet(title):
    wb = xlsxwriter.Workbook('bunco.xlsx')
    ws = wb.add_worksheet('Overview')

    col_heading = wb.add_format({'font_name': 'Back Issues BB', 
                                 'font_size': 12,
                                 'align': 'center'})
    title_style = wb.add_format({'font_name': 'Back Issues BB', 
                                 'font_size': 14,
                                 'bold': True})
    row_heading = wb.add_format({'font_name': 'Back Issues BB', 
                                 'font_size': 12})
    score_style = wb.add_format({'font_name': 'Milk Mustache BB', 
                                 'font_size': 14,
                                 'align': 'right',
                                 'num_format': '_(* #,##0_);_(* (#,##0);_(* "-"??_);_(@_)',
                                 'color': '#0070C0'})
    total_style = wb.add_format({'font_name': 'Milk Mustache BB', 
                                 'font_size': 14,
                                 'align': 'center',
                                 'bold': 'true'})
    
    ws.set_column('A:A', 30)
    
    ws.write('A1', title, title_style)
    ws.set_landscape()
    ws.fit_to_pages(1, 1)

    # Column headings for each round
    for n in range(g.current_round()):
        ws.write(2, n + 1, n + 1, col_heading)
    
    end_col = g.current_round()
    ws.set_column(1, end_col, 5)
    ws.set_column(end_col + 1, end_col + 5, 10)

    ws.write(2, end_col + 1, "Total", col_heading)
    ws.write(2, end_col + 2, "Wins", col_heading)
    ws.write(2, end_col + 3, "Losses", col_heading)
    ws.write(2, end_col + 4, "Buncos", col_heading)
    ws.write(2, end_col + 5, "Rolls", col_heading)

    # Write players and their scores for each round
    for n, player in enumerate(g.players):
        row = n + 3
        ws.write(row, 0, player.name, row_heading)

        for r in range(g.current_round()):
            col = r + 1
            ws.write(row, col, player.round_scores[r], score_style)
        
        # derive losses from wins
        losses = [int(not x) for x in player.round_wins]

        ws.write(row, end_col + 1, sum(player.round_scores), total_style)
        ws.write(row, end_col + 2, sum(player.round_wins), total_style)
        ws.write(row, end_col + 3, sum(losses), total_style)
        ws.write(row, end_col + 4, sum(player.round_bunco_counts), total_style)
        ws.write(row, end_col + 5, sum(player.round_roll_counts), total_style)

    wb.close()