1"""
  2Solution to homework 3 for Introduction to Python course at FMI
  3by Nikolay Nikolaev.
  4"""
  5import sys
  6
  7
  8class Candy:
  9    """
 10    Defines candy objects that have mass and uranium percentage. The two
 11    methods are getters for the class values.
 12    """
 13    def __init__(self, mass, uranium):
 14        self.mass = mass
 15        self.uranium = uranium
 16
 17    def get_uranium_quantity(self):
 18        """Returns the mass of the uranium in the candy."""
 19        return self.mass * self.uranium
 20
 21    def get_mass(self):
 22        """Returns the mass of the candy."""
 23        return self.mass
 24
 25
 26class Person:
 27    """
 28    Defines person object who is positioned in position. The two
 29    methods are a setter and a getter for the position.
 30    """
 31    def __init__(self, position):
 32        self.position = position
 33
 34    def get_position(self):
 35        """"Returns the position of the person."""
 36        return self.position
 37
 38    def set_position(self, position):
 39        """"Sets the position of the person."""
 40        self.position = position
 41
 42
 43class Kid(Person):
 44    """
 45    Defines kid object that is inherited from Person. The initiative
 46    attribute is used for sorting purposes of the kids. They can add
 47    candy objects in their baskets.
 48    """
 49    def __init__(self, position, initiative):
 50        super().__init__(position)
 51        self.initiative = initiative
 52        self.candy_basket = []
 53
 54    def get_initiative(self):
 55        """Returns the initiative of the kid."""
 56        return self.initiative
 57
 58    def add_candy(self, candy):
 59        """Adds a Candy object to the candy_basket of the kid."""
 60        self.candy_basket.append(candy)
 61
 62    def is_critical(self):
 63        """
 64        Return True if the mass of the uranium in the basket is
 65        bigger than 20 grams.
 66        """
 67        uranium_quantity = 0
 68        for candy in self.candy_basket:
 69            uranium_quantity += candy.get_uranium_quantity()
 70        return uranium_quantity > 20
 71
 72
 73class Host(Person):
 74    """
 75    Defines host objects that are inherited from Person. They hold a
 76    basket of Candy objects which they can remove.
 77    """
 78    def __init__(self, position, candies):
 79        super().__init__(position)
 80        self.candy_basket = [Candy(mass, uranium) for mass, uranium in candies]
 81
 82    def remove_candy(self, determining_function):
 83        """Removes a candy from the host's candy basket and retruns it."""
 84        if self.candy_basket:
 85            chosen_candy = determining_function(self.candy_basket)
 86            self.candy_basket.remove(chosen_candy)
 87            return chosen_candy
 88        return None
 89
 90
 91class FluxCapacitor:
 92    """
 93    Organises a scenario where the participants are kids and hosts. The kids
 94    collect candies from hosts. Whenever a kid/kids collect/s a critical mass
 95    of uranium, all the hosts are visited by all the kids, or all candies of
 96    the hosts baskets are collected - the simulation stops. In the first case
 97    the victims are returned and in the other two - None. 
 98    """
 99    def __init__(self, participants):
100        self.participants = participants
101
102    def get_victim(self):
103        """
104        Simulates the events of kids collecting candies of hosts. Returns
105        the victims if there are any. Otherwise, returns None.
106        """
107        kids = {kid for kid in self.participants if isinstance(kid, Kid)}
108        hosts = {host for host in self.participants if isinstance(host, Host)}
109        is_visited_by_all_kids = {host:[] for host in hosts}
110
111        while True:
112            victims = set()
113
114            for kid in kids:
115                if kid.is_critical():
116                    victims.add(kid)
117
118            # If there is at least one victim, return it
119            if victims:
120                return victims
121
122            # If all hosts don't have candies or were
123            # visited by all kids, return None
124            if not hosts:
125                return None
126
127            # The variable current_visitors stores all the
128            # kids that are at each host at the current iteration.
129            current_visitors = {host:[] for host in hosts}
130            for kid in kids:
131                minimum_distance = sys.float_info.max
132                next_host = None
133
134                # Finds the nearest host for each kid without repetition
135                for host in hosts:
136                    if kid not in is_visited_by_all_kids[host]:
137                        distance = calculate_distance(kid, host)
138                        if distance == minimum_distance:
139                            next_host = determine_better_host(host, next_host)
140                        if distance < minimum_distance:
141                            minimum_distance = distance
142                            next_host = host
143
144                if next_host is not None:
145                    current_visitors[next_host].append(kid)
146                    kid.set_position(next_host.get_position())
147
148            hosts_to_remove = []
149            for host in hosts:
150                # Sort kids by their initiative
151                current_visitors[host] = sorted(current_visitors[host],
152                    key=lambda kid: kid.get_initiative(), reverse = True)
153
154                is_visited_by_all_kids[host] += current_visitors[host]
155                # and give them candy.
156                for kid in current_visitors[host]:
157                    candy = host.remove_candy(determine_max_mass)
158                    if candy:
159                        kid.add_candy(candy)
160                    else:
161                        break
162
163                # Mark hosts for removal from the participants
164                if len(is_visited_by_all_kids[host]) == len(kids):
165                    hosts_to_remove.append(host)
166
167            for host in hosts_to_remove:
168                hosts.remove(host)
169                is_visited_by_all_kids.pop(host)
170
171
172def calculate_distance(kid, host):
173    """Calculates the distance between two participants of the event."""
174    x1, y1 = kid.get_position()
175    x2, y2 = host.get_position()
176    return ((x2-x1)**2 + (y2-y1)**2)**(1/2)
177
178
179def determine_better_host(host, other_host):
180    """
181    If two hosts are equally distanced from a kid, returns the one with
182    lower x coordinate or else the one with lower y coordinate.
183    """
184    if host.get_position()[0] < other_host.get_position()[0]:
185        return host
186    if host.get_position()[0] > other_host.get_position()[0]:
187        return other_host
188    if host.get_position()[1] < other_host.get_position()[1]:
189        return host
190    return other_host
191
192
193def determine_max_mass(candies):
194    """Returns the heaviest candy, measured by mass(not only uranium)."""
195    return max(candies, key=lambda candy: candy.get_mass())