# -*- coding: utf-8 -*-
from abc import ABC
from enum import Enum
from functools import reduce
from typing import Iterator

from aoc import BaseAssignment, I, T


class Color(Enum):
    red = 'red'
    green = 'green'
    blue = 'blue'

ColorCount = tuple[int, Color]

class Assignment(BaseAssignment, ABC):
    def parse_item(self, item: str) -> list[tuple[ColorCount, ...]]:
        _, items = item.split(': ')

        return [
            tuple(
                ColorCount((
                    int(_.split(' ')[0]),
                    Color(_.split(' ')[1])
                ))
                for _ in pair.split(', ')
            )
            for pair in items.split('; ')
        ]


class AssignmentOne(Assignment):
    example_result = 8

    inventory = {
        Color.red: 12,
        Color.green: 13,
        Color.blue: 14,
    }

    def is_possible(self, game: list[tuple[ColorCount, ...]]):
        for item in game:
            for count, color in item:
                if count > self.inventory[color]:
                    return False

        return True

    def run(self, input: Iterator[list[tuple[ColorCount, ...]]]) -> int:
        possible_games = []

        for index, game in enumerate(input):
            if self.is_possible(game):
                possible_games.append(index + 1)

        return sum(possible_games)


class AssignmentTwo(Assignment):
    example_result = 2286

    def get_least_numbers(self, game: list[tuple[ColorCount, ...]]):
        counts = {}

        for item in game:
            for count, color in item:
                if color not in counts or count > counts[color]:
                    counts[color] = count

        return counts

    def run(self, input: Iterator[list[tuple[ColorCount, ...]]]) -> int:
        powers = []

        for game in input:
            counts = self.get_least_numbers(game)
            powers.append(
                reduce(
                    lambda total, item: total * item,
                    counts.values(),
                    1
                )
            )

        return sum(powers)