# --- Day 4: Giant Squid ---

# You're already almost 1.5km (almost a mile) below the surface of the ocean,
# already so deep that you can't see any sunlight. What you can see, however,
# is a giant squid that has attached itself to the outside of your submarine.

# Maybe it wants to play bingo?

# Bingo is played on a set of boards each consisting of a 5x5 grid of numbers.
# Numbers are chosen at random, and the chosen number is marked on all boards
# on which it appears. (Numbers may not appear on all boards.) If all numbers
# in any row or any column of a board are marked, that board wins. (Diagonals
# don't count.)

# The submarine has a bingo subsystem to help passengers (currently, you and
# the giant squid) pass the time. It automatically generates a random order in
# which to draw numbers and a random set of boards (your puzzle input). For
# example:

# 7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1

# 22 13 17 11  0
#  8  2 23  4 24
# 21  9 14 16  7
#  6 10  3 18  5
#  1 12 20 15 19

#  3 15  0  2 22
#  9 18 13 17  5
# 19  8  7 25 23
# 20 11 10 24  4
# 14 21 16 12  6

# 14 21 17 24  4
# 10 16 15  9 19
# 18  8 23 26 20
# 22 11 13  6  5
#  2  0 12  3  7

# After the first five numbers are drawn (7, 4, 9, 5, and 11), there are no
# winners, but the boards are marked as follows (shown here adjacent to each
# other to save space):

# 22 13 17 11  0         3 15  0  2 22        14 21 17 24  4
#  8  2 23  4 24         9 18 13 17  5        10 16 15  9 19
# 21  9 14 16  7        19  8  7 25 23        18  8 23 26 20
#  6 10  3 18  5        20 11 10 24  4        22 11 13  6  5
#  1 12 20 15 19        14 21 16 12  6         2  0 12  3  7

# After the next six numbers are drawn (17, 23, 2, 0, 14, and 21), there are
# still no winners:

# 22 13 17 11  0         3 15  0  2 22        14 21 17 24  4
#  8  2 23  4 24         9 18 13 17  5        10 16 15  9 19
# 21  9 14 16  7        19  8  7 25 23        18  8 23 26 20
#  6 10  3 18  5        20 11 10 24  4        22 11 13  6  5
#  1 12 20 15 19        14 21 16 12  6         2  0 12  3  7

# Finally, 24 is drawn:

# 22 13 17 11  0         3 15  0  2 22        14 21 17 24  4
#  8  2 23  4 24         9 18 13 17  5        10 16 15  9 19
# 21  9 14 16  7        19  8  7 25 23        18  8 23 26 20
#  6 10  3 18  5        20 11 10 24  4        22 11 13  6  5
#  1 12 20 15 19        14 21 16 12  6         2  0 12  3  7

# At this point, the third board wins because it has at least one complete row
# or column of marked numbers (in this case, the entire top row is marked:
# 14 21 17 24 4).

# The score of the winning board can now be calculated. Start by finding the
# sum of all unmarked numbers on that board; in this case, the sum is 188.
# Then, multiply that sum by the number that was just called when the board
# won, 24, to get the final score, 188 * 24 = 4512.

# To guarantee victory against the giant squid, figure out which board will win
# first. What will your final score be if you choose that board?

import queue
from typing import Tuple

with open("files/P4.txt", "r") as f:
    data = [line for line in f.read().strip().split("\n\n")]
    numbers, all_boards = data[0].split(","), [
        board.split("\n") for board in data[1:]
    ]


def _boards(lst: list[str]) -> list[Tuple[str, ...]]:
    return [tuple(tup.split()) for tup in lst]


def sum_board(board: list[Tuple[str, ...]], lst: list[str]) -> int:
    return sum(
        int(number) for row in board for number in row if number not in lst
    )


def has_won(board: list[Tuple[str, ...]], lst: list[str]) -> bool:
    for row in board:
        winner = all(num in lst for num in row)
        if winner:
            return winner

    for col in range(5):
        winner = all(num in lst for num in [row[col] for row in board])
        if winner:
            return winner

    return False


boards = [_boards(board) for board in all_boards]


def part_1() -> None:
    numbers_drawn = []
    for number in numbers:
        numbers_drawn.append(number)
        if len(numbers_drawn) < 5:
            continue
        for board in boards:
            if has_won(board, numbers_drawn):
                return print(sum_board(board, numbers_drawn) * int(number))


# --- Part Two ---

# On the other hand, it might be wise to try a different strategy: let the
# giant squid win.

# You aren't sure how many bingo boards a giant squid could play at once, so
# rather than waste time counting its arms, the safe thing to do is to figure
# out which board will win last and choose that one. That way, no matter which
# boards it picks, it will win for sure.

# In the above example, the second board is the last to win, which happens
# after 13 is eventually called and its middle column is completely marked. If
# you were to keep playing until this point, the second board would have a sum
# of unmarked numbers equal to 148 for a final score of 148 * 13 = 1924.

# Figure out which board will win last. Once it wins, what would its final
# score be?


def part_2() -> None:
    numbers_drawn = []
    winner = False
    while not winner:
        for number in numbers:
            numbers_drawn.append(number)
            if len(numbers_drawn) < 5:
                continue
            idx = 0
            while idx < len(boards):
                if has_won(boards[idx], numbers_drawn):
                    if len(boards) > 1:
                        boards.pop(idx)
                    else:
                        return print(
                            sum_board(boards[idx], numbers_drawn) * int(number)
                        )
                else:
                    idx += 1


if __name__ == "__main__":
    part_1()
    part_2()