1from decimal import localcontext, Decimal, ROUND_HALF_DOWN
  2from functools import reduce
  3from copy import deepcopy
  4
  5class Effect:
  6   
  7    @staticmethod
  8    def get_molecule_mass(name):
  9        return reduce(lambda a, b: a + ord(b), name, 0)
 10
 11    def __init__(self, name, effect):
 12        self. is_depleted = False
 13        self.intensity = 1
 14        self.effect = effect
 15        self.molecule_mass = Effect.get_molecule_mass(name)
 16
 17    def __call__(self, target):
 18        if self.is_depleted:
 19            raise TypeError("Effect is depleted.")
 20
 21        for _ in range(self.intensity):
 22            self.effect(target)
 23        self.is_depleted = True
 24    
 25    def reapply(self, target):
 26        for _ in range(self.intensity):
 27            self.effect(target)
 28
 29
 30class Potion:
 31    
 32    def __init__(self, effects, duration):
 33        self.is_something_bigger = False
 34        self.is_depleted = False
 35        self.effects = {name: Effect(name, effect) for name, effect in effects.items()}
 36        self.duration = duration
 37
 38    def __getattr__(self, name):
 39        if name in self.effects:
 40            if self.is_something_bigger:
 41                raise TypeError(
 42                    "Potion is now part of something bigger than itself.")
 43
 44            if self.is_depleted:
 45                    raise TypeError("Potion is depleted.")
 46
 47            return self.effects[name]
 48
 49        raise AttributeError(f"No such effect: {name}")
 50
 51    def get_check_for_deep_meaning_decorator(is_target):
 52        def check_for_deep_meaning_decorator(fun):
 53            def check_for_deep_meaning(self, target):
 54                if self.is_something_bigger or (is_target and target.is_something_bigger):
 55                    raise TypeError("Potion is now part of something bigger than itself.")
 56                  
 57                if self.is_depleted or (is_target and target.is_depleted):
 58                    raise TypeError("Potion is depleted.")
 59                
 60                return fun(self, target)
 61            return check_for_deep_meaning
 62        return check_for_deep_meaning_decorator
 63
 64    def get_is_something_bigger_decorator(is_target):
 65        def is_something_bigger_decorator(fun):
 66            def is_something_bigger(self, target):
 67                self.is_something_bigger = True
 68                if is_target:
 69                    target.is_something_bigger = True
 70                return fun(self, target)
 71            return is_something_bigger
 72        return is_something_bigger_decorator
 73
 74    @get_check_for_deep_meaning_decorator(True)
 75    @get_is_something_bigger_decorator(True)
 76    def __add__(self, other):
 77        new_duration = max(self.duration, other.duration)
 78        not_used_effects_potion_1 = filter(
 79            lambda item: not item[1].is_depleted,  self.effects.items())
 80        not_used_effects_potion_2 = filter(
 81            lambda item: not item[1].is_depleted,  other.effects.items())
 82        new_effects = dict(not_used_effects_potion_1)
 83
 84        for key, effect in not_used_effects_potion_2:
 85            if key in new_effects:
 86                new_effects[key].intensity += effect.intensity
 87            else:
 88                new_effects[key] = effect
 89
 90        new_potion = Potion({}, new_duration)
 91        new_potion.effects = new_effects
 92
 93        return new_potion
 94
 95    @staticmethod
 96    def round_half_down(num):
 97        with localcontext() as ctx:
 98            ctx.rounding = ROUND_HALF_DOWN
 99            return int(Decimal(num).to_integral_value())
100
101    @get_check_for_deep_meaning_decorator(False)
102    @get_is_something_bigger_decorator(False)
103    def __mul__(self, number):
104        new_effects = {}
105
106        for key, effect in self.effects.items():
107            if effect.is_depleted:
108                continue
109
110            new_effects[key] = Effect(key, effect.effect)
111            new_effects[key].intensity = Potion.round_half_down(effect.intensity * number)
112
113        new_potion = Potion({}, self.duration)
114        new_potion.effects = new_effects
115
116        return new_potion
117
118    @get_check_for_deep_meaning_decorator(True)
119    @get_is_something_bigger_decorator(True)
120    def __sub__(self, target):
121        new_effects = {}
122
123        for key, effect in target.effects.items():
124            if key not in self.effects:
125                raise TypeError("Throwing Beans")
126
127            if effect.is_depleted or self.effects[key].is_depleted:
128                continue
129
130            new_effect = Effect(key, effect.effect)
131            new_effect.intensity = self.effects[key].intensity - effect.intensity
132            if new_effect.intensity <= 0:
133                continue
134            new_effects[key] = new_effect
135
136        for key, effect in self.effects.items():
137            if key not in target.effects or (target.effects[key].is_depleted and not effect.is_depleted):
138                new_effects[key] = effect
139        
140        new_potion = Potion({}, self.duration)
141        new_potion.effects = new_effects
142        return new_potion
143    
144    @get_check_for_deep_meaning_decorator(False)
145    @get_is_something_bigger_decorator(False)
146    def __truediv__(self, number):
147        new_effects = {}
148
149        for key, effect in self.effects.items():
150            if effect.is_depleted:
151                continue
152
153            new_effects[key] = effect
154            new_effects[key].intensity = Potion.round_half_down(effect.intensity / number)
155        
156        def create_new_potion():
157            new_potion = Potion({}, self.duration)
158            copy_new_effects = {}
159
160            for name, effect in new_effects.items():
161                copy_new_effects[name] = Effect(name, effect.effect)
162                copy_new_effects[name].intensity = effect.intensity
163            
164            new_potion.effects = copy_new_effects
165            return new_potion
166        return (create_new_potion() for _ in range(number))
167    
168    @get_check_for_deep_meaning_decorator(True)
169    def __eq__(self, other):
170        if(self.effects.keys() != other.effects.keys()):
171            return False
172
173        for key, effect in self.effects.items():
174            if effect.is_depleted:
175                effect.intensity = 0
176
177            if other.effects[key].is_depleted:
178                other.effects[key].intensity = 0
179
180            if effect.intensity != other.effects[key].intensity:
181                return False
182        
183        return True
184    
185    @get_check_for_deep_meaning_decorator(True)
186    def __lt__(self, other):
187        left_part = sum(effect.intensity if not effect.is_depleted else 0 for effect in self.effects.values())
188        right_part = sum(effect.intensity if not effect.is_depleted else 0 for effect in other.effects.values())
189        return left_part < right_part
190            
191    
192    @property
193    def effects_for_potions(self):
194        not_used_effects = filter(lambda effect: not effect.is_depleted, self.effects.values())
195        sorted_not_used_effects = sorted(not_used_effects, key=lambda effect: effect.molecule_mass, reverse=True)
196        return list(sorted_not_used_effects)
197        
198
199    @get_check_for_deep_meaning_decorator(False)
200    def apply(self, target):
201        self.is_depleted = True
202        effects = self.effects_for_potions
203
204        for effect in effects:
205            effect(target)
206
207        return effects
208    
209
210
211class EnchantedTarget:
212    
213    def __init__(self, target):
214        self.target = target
215        self.target_dict = deepcopy(target.__dict__)
216        self.active_potions = []
217
218    def add_potion(self, potion, active_to):
219        self.active_potions.append((potion.apply(self.target), active_to))
220
221    def tick(self, time):
222        still_active_potions = list(filter(lambda potion: potion[1] > time, self.active_potions))
223       
224        self.target.__dict__ = deepcopy(self.target_dict)
225        for potion in still_active_potions:
226            for effect in potion[0]:
227                effect.reapply(self.target)
228        
229        self.active_potions = still_active_potions
230    
231
232
233class ГоспожатаПоХимия:
234
235    def __init__(self):
236        self.timer = 0
237        self.narcos = {}
238
239    def apply(self, target, potion):
240        if potion.duration <= 0:
241            return
242        
243        target_id = id(target)
244        if target_id not in self.narcos:
245            self.narcos[target_id] = EnchantedTarget(target)
246
247        self.narcos[target_id].add_potion(potion, self.timer + potion.duration)
248
249    def tick(self):
250        self.timer += 1
251
252        for enchanted_target in self.narcos.values():
253            enchanted_target.tick(self.timer)