# --- Day 10: Balance Bots ---

# You come upon a factory in which many robots are zooming around handing small
# microchips to each other.

# Upon closer examination, you notice that each bot only proceeds when it has
# two microchips, and once it does, it gives each one to a different bot or
# puts it in a marked "output" bin. Sometimes, bots take microchips from
# "input" bins, too.

# Inspecting one of the microchips, it seems like they each contain a single
# number; the bots must use some logic to decide what to do with each chip.
# You access the local control computer and download the bots' instructions
# (your puzzle input).

# Some of the instructions specify that a specific-valued microchip should be
# given to a specific bot; the rest of the instructions indicate what a given
# bot should do with its lower-value or higher-value chip.

# For example, consider the following instructions:

# value 5 goes to bot 2
# bot 2 gives low to bot 1 and high to bot 0
# value 3 goes to bot 1
# bot 1 gives low to output 1 and high to bot 0
# bot 0 gives low to output 2 and high to output 0
# value 2 goes to bot 2

#     Initially, bot 1 starts with a value-3 chip, and bot 2 starts with a
# value-2 chip and a value-5 chip.
#     Because bot 2 has two microchips, it gives its lower one (2) to bot 1 and
# its higher one (5) to bot 0.
#     Then, bot 1 has two microchips; it puts the value-2 chip in output 1 and
# gives the value-3 chip to bot 0.
#     Finally, bot 0 has two microchips; it puts the 3 in output 2 and the 5 in
# output 0.

# In the end, output bin 0 contains a value-5 microchip, output bin 1 contains
# a value-2 microchip, and output bin 2 contains a value-3 microchip. In this
# configuration, bot number 2 is responsible for comparing value-5 microchips
# with value-2 microchips.

# Based on your instructions, what is the number of the bot that is responsible
# for comparing value-61 microchips with value-17 microchips?

import re
from collections import defaultdict
from math import prod

with open("files/P10.txt") as f:
    instructions = [line for line in f.read().strip().split("\n")]

bots_dic: dict[int, list] = defaultdict(list)
outputs_dic: dict[int, list] = defaultdict(list)

pipeline = {}
for line in instructions:
    if line.startswith("value"):
        value, bot = map(int, re.findall(r"\d+", line))
        bots_dic[bot].append(value)
    if line.startswith("bot"):
        bot, low, high = map(int, re.findall(r"\d+", line))
        given_to = re.findall(r" (bot|output)", line)
        pipeline[bot] = (given_to[0], low), (given_to[1], high)


def part_1() -> None:
    found = False
    while not found:
        for bot, value in dict(bots_dic).items():
            if len(value) == 2:
                low_val, high_val = sorted(bots_dic.pop(bot))
                if low_val == 17 and high_val == 61:
                    print(f"The bot responsible has number {bot}")
                    found = True
                    break
                (_, low), (_, high) = pipeline[bot]
                bots_dic[low].append(low_val)
                bots_dic[high].append(high_val)


# --- Part Two ---

# What do you get if you multiply together the values of one chip in each of
# outputs 0, 1, and 2?


def part_2() -> None:
    types = {"bot": bots_dic, "output": outputs_dic}
    while bots_dic:
        for bot, value in dict(bots_dic).items():
            if len(value) == 2:
                low_val, high_val = sorted(bots_dic.pop(bot))
                (t1, low), (t2, high) = pipeline[bot]
                types[t1][low].append(low_val)
                types[t2][high].append(high_val)

    res = prod(outputs_dic[k][0] for k in [0, 1, 2])
    print(f"The answer is {res}")


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