1from enum import StrEnum
  2
  3
  4class EggSide(StrEnum):
  5    top = "top"
  6    bottom = "bottom"
  7
  8
  9class Egg:
 10    def __init__(self):
 11        self.top_coloring = []
 12        self.bottom_coloring = []
 13        self.broken_sides = []
 14
 15    def paint(self, *colors):
 16        total_coverage = sum(percentage for _, percentage in self.top_coloring + self.bottom_coloring + list(colors))
 17        if total_coverage > 100:
 18            raise ValueError(f"Cannot overpaint egg, egg is already at {total_coverage}%")
 19        for color, percentage in colors:
 20            coverage_top = sum(percentage for _, percentage in self.top_coloring)
 21            if leftover_coverage_top := 50 - coverage_top:
 22                self.top_coloring.append((color, min(leftover_coverage_top, percentage)))
 23            if coverage_top + percentage > 50:
 24                self.bottom_coloring.append((color, percentage - leftover_coverage_top))
 25
 26    def _calculate_hardness(self, side):
 27        return sum(
 28            (int(color[:2], base=16) + int(color[2:4], base=16) + int(color[4:], base=16) + 1) * percentage
 29            for color, percentage in getattr(self, f"{side}_coloring")
 30        )
 31
 32    @property
 33    def top_hardness(self):
 34        return self._calculate_hardness(EggSide.top)
 35
 36    @property
 37    def bottom_hardness(self):
 38        return self._calculate_hardness(EggSide.bottom)
 39
 40    def break_side(self, side):
 41        self.broken_sides.append(side)
 42
 43    def _collide_eggs(self, other, side):
 44        if side in self.broken_sides or side in other.broken_sides:
 45            raise TypeError("Cannot collide with broken sides")
 46        if getattr(self, f"{side}_hardness") > getattr(other, f"{side}_hardness"):
 47            winner, loser = self, other
 48        else:
 49            winner, loser = other, self
 50        loser.break_side(side)
 51        EggTournament.log_fight(self, other, side, winner)
 52        return winner
 53
 54    def __mul__(self, other):
 55        return self._collide_eggs(other, EggSide.top)
 56
 57    def __matmul__(self, other):
 58        return self._collide_eggs(other, EggSide.bottom)
 59
 60
 61class EggTournament:
 62    instances = set()
 63
 64    def __init__(self):
 65        self.instances.add(self)
 66        self.registered_eggs = {}
 67        self.fight_history = {}
 68
 69    def register(self, egg, name):
 70        if name in self.registered_eggs:
 71            raise ValueError(f"Egg with name {name} has already been registered")
 72        if not name.isidentifier():
 73            raise ValueError("Invalid registration name")
 74        if any(egg in tournament.registered_eggs.values() for tournament in self.__class__.instances):
 75            raise ValueError("An egg cannot be registered in multiple tournaments")
 76        self.registered_eggs[name] = egg
 77
 78    @classmethod
 79    def log_fight(cls, first, second, side, winner):
 80        for tournament in cls.instances:
 81            if first in tournament.registered_eggs.values() and second in tournament.registered_eggs.values():
 82                tournament.fight_history[(first, second, side)] = winner
 83
 84    @property
 85    def egg_wins(self):
 86        return {egg: list(self.fight_history.values()).count(egg) for egg in self.registered_eggs.values()}
 87
 88    @property
 89    def ranking(self):
 90        return [
 91            {egg for egg in self.registered_eggs.values() if self.egg_wins[egg] == wins_for_rank}
 92            for wins_for_rank in sorted(set(self.egg_wins.values()), reverse=True)
 93        ]
 94
 95    def __getattr__(self, name):
 96        try:
 97            egg = self.registered_eggs[name]
 98        except KeyError:
 99            raise AttributeError("Apologies, there is no such egg registered")
100        for rank, eggs in enumerate(self.ranking, start=1):
101            if egg in eggs:
102                return {"position": rank, "victories": self.egg_wins[egg]}
103
104    def __getitem__(self, key):
105        if isinstance(key, slice):
106            key = key.start, key.stop, key.step
107        try:
108            return self.fight_history[key]
109        except KeyError:
110            return self.fight_history[key[1], key[0], key[2]]
111
112    def __rmatmul__(self, position):
113        return eggs_on_rank if len(eggs_on_rank := self.ranking[position - 1]) > 1 else eggs_on_rank.pop()
114
115    def __contains__(self, value):
116        return value in self.registered_eggs.values()