"""Gym."""


class Trainers:
    """Represent city module."""

    def __init__(self, stamina: int, color: str):
        """
        Init.

        :param stamina:
        :param color:
        """
        self.stamina = stamina
        self.color = color

    def __repr__(self):
        """Trainers: [{tossude vastupidavus}, {tossude värv}]."""
        return f"Trainers: [{self.stamina}, {self.color}]"


class Member:
    """Represent member module."""

    def __init__(self, name: str, age: int, trainers: Trainers):
        """
        Init.

        :param name:
        :param age:
        :param trainers:
        """
        self.name = name
        self.age = age
        self.trainers = trainers
        self.member_in_gym = []

    def add_to_gym(self, gym):
        """Add yo gym.

        :return
        """
        self.member_in_gym.append(gym)

    def remove_from_gym(self, gym):
        """
        Remove ftom gym.

        :param gym:
        :return:
        """
        self.member_in_gym.remove(gym)

    def get_all_gyms(self) -> list:
        """
        Get all gyms.

        :return:
        """
        pass

    def __repr__(self):
        """
        Repr.

        :return:
        """
        return f"{self.name}, {self.age}: {self.trainers}"


class Gym:
    """Docstring."""

    def __init__(self, name: str, max_members_number: int):
        """
        Unit.

        :param name:
        :param max_members_number:
        """
        self.name = name
        self.max_members_numbers = max_members_number
        self.member_to_gym = []
        self.only_members_name = []
        self.only_members_stamina = []
        # self.member_to_gym = {}

    def get_members_count_by_trainers_color(self, color):
        """
        Get members count by trainers color.

        :param color:
        :return:
        """
        count = 0
        for member in self.member_to_gym:
            if member.trainers is not None:
                if member.trainers.color == color:
                    count += 1
        return count

    def get_members_count_by_name(self, name):
        """
        Get members count by name.

        :param name:
        :return:
        """
        count = 0
        for member in self.member_to_gym:
            if member.name is not None:
                if member.name == name:
                    count += 1
                else:
                    pass
        return count

    def minimum_stamina(self):
        """
        Minimal stamina.

        :return:
        """
        members_with_low_stamina = []
        low_stamina = float('inf')
        for i in self.member_to_gym:
            if i.trainers.stamina < low_stamina:
                members_with_low_stamina = [i]
                low_stamina = i.trainers.stamina
            elif i.trainers.stamina == low_stamina:
                members_with_low_stamina.append(i)
        return members_with_low_stamina

    def add_member(self, member: Member) -> Member:
        """
        Add member.

        :param member:
        :return:
        """
        if self.can_add_member(member):
            if member not in self.member_to_gym:
                if len(self.member_to_gym) < self.max_members_numbers:
                    member.member_in_gym.append(self)
                    self.member_to_gym.append(member)
                    # print(self.member_to_gym)
                    return member
                if len(self.member_to_gym) >= self.max_members_numbers:
                    for i in self.minimum_stamina():
                        self.member_to_gym.remove(i)
                    self.member_to_gym.append(member)
                    return member

    def can_add_member(self, member: Member) -> bool:
        """
        Can add member.

        :param member:
        :return:
        """
        if isinstance(member, Member):
            if member.trainers.stamina >= 0:
                if isinstance(member.trainers.color, str):
                    if len(member.trainers.color) >= 1:
                        return True
        else:
            return False

    def remove_member(self, member: Member):
        """
        Remove member.

        :param member:
        :return:
        """
        if member in self.member_to_gym:
            member.member_in_gym.remove(self)
            self.member_to_gym.remove(member)
        # for i in self.member_to_gym:
        #     if i == member:
        #         self.member_to_gym.remove(i)

    def get_total_stamina(self) -> int:
        """
        Total stamina.

        :return:
        """
        stamina = []
        for member in self.member_to_gym:
            stamina.append(member.trainers.stamina)
        return sum(stamina)

    def get_members_number(self) -> int:
        """
        Member number.

        :return:
        """
        return len(self.member_to_gym)

    def get_all_members(self) -> list:
        """
        All members.

        :return:
        """
        return self.member_to_gym

    def get_average_age(self) -> float:
        """
        Average age.

        :return:
        """
        age = []
        for member in self.member_to_gym:
            age.append(member.age)
        return sum(age) / len(self.member_to_gym)
        # return round((sum(age) / len(self.member_to_gym)), 2)

    def __str__(self) -> str:
        """
        Str.

        :return:
        """
        return f"Gym {self.name}: {len(self.member_to_gym)} member(s)"

    def __repr__(self):
        """
        Repr.

        :return:
        """
        return f"Gym {self.name}: {len(self.member_to_gym)} member(s)"


class City:
    """Represent city modul."""

    def __init__(self, max_gym_number: int):
        """Docstring."""
        self.max_gym_number = max_gym_number
        self.gym_in_city = []

    def build_gym(self, gym):
        """Docstring."""
        if self.can_build_gym():
            self.gym_in_city.append(gym)
        else:
            return None

    def can_build_gym(self) -> bool:
        """Docstring."""
        if len(self.gym_in_city) < self.max_gym_number:
            return True
        else:
            return False

    def destroy_gym(self):
        """Docstring."""
        gyms_to_destroy = []
        for gym in self.gym_in_city:
            min_memebers_in_gym_count = min(map(lambda gym: len(gym.member_to_gym), self.gym_in_city))
            if len(gym.member_to_gym) < min_memebers_in_gym_count:
                min_memebers_in_gym_count = len(gym.member_to_gym)
                gyms_to_destroy = [gym]
            elif len(gym.member_to_gym) == min_memebers_in_gym_count:
                gyms_to_destroy.append(gym)
            else:
                pass
        for gym in gyms_to_destroy:
            self.gym_in_city.remove(gym)

    def get_max_members_gym(self) -> list:
        """Docstring."""
        max_memebers_in_gym_count = max(map(lambda gym: len(gym.member_to_gym), self.gym_in_city))
        list_of_max_memebers = []
        list_of_max_memebers.append(max_memebers_in_gym_count)
        return list_of_max_memebers

    def get_max_stamina_gyms(self) -> list:
        """Docstring."""
        counter = 0
        max_stamina_gym = []
        for gym in self.gym_in_city:
            if gym.get_total_stamina() > counter:
                counter = gym.get_total_stamina()
                max_stamina_gym = [gym]
            elif gym.get_total_stamina() == counter:
                max_stamina_gym.append(gym)
        return max_stamina_gym

    def get_max_average_ages(self) -> list:
        """Docstring."""
        try:
            counter = 0
            max_age = []
            for gym in self.gym_in_city:
                if gym.get_average_age() > counter:
                    counter = gym.get_average_age()
                    max_age = [gym]
                elif gym.get_average_age() == counter:
                    max_age.append(gym)
            return max_age
        except ZeroDivisionError:
            pass

    def get_min_average_ages(self) -> list:
        """Docstring."""
        try:
            counter = float('inf')
            min_age = []
            for gym in self.gym_in_city:
                if gym.get_average_age() < counter:
                    counter = gym.get_average_age()
                    min_age = [gym]
                elif gym.get_average_age() == counter:
                    min_age.append(gym)
            return min_age
        except ZeroDivisionError:
            pass

    def get_gyms_by_trainers_color(self, color: str) -> list:
        """Docstring."""
        return sorted(self.gym_in_city, key=lambda gym: gym.get_members_count_by_trainers_color(color), reverse=True)

    # def list_of_name(self, name):
    #     list = []
    #     for gym in self.gym_in_city:
    #         count = 0
    #         for member in gym.get_all_members():
    #             if member.name == name:
    #                 count += 1
    #         if count >= 1:
    #             list.append([gym, count])
    #     list = sorted(list, key=lambda x: x[1], reverse=True)
    #     return list

    def get_gyms_by_name(self, name: str) -> list:
        """Docstring."""
        sorted_list_by_name = []
        not_sorted_list = []
        for gym in self.gym_in_city:
            counter = 0
            for member in gym.member_to_gym:
                if member.name == name:
                    counter += 1
            if counter >= 1:
                not_sorted_list.append([gym, counter])
            not_sorted_list = sorted(not_sorted_list, key=lambda x: x[1], reverse=True)
        for i in not_sorted_list:
            sorted_list_by_name.append(i[0])
        return sorted_list_by_name
        # return sorted(self.gym_in_city, key=lambda gym: gym.get_members_count_by_name(name), reverse=True)

    def get_all_gyms(self) -> list:
        """Get all gyms."""
        return self.gym_in_city


if __name__ == "__main__":
    city1 = City(100)
    gym = Gym("TTÜ Sport", 50)
    city1.build_gym(gym)

    trainers1 = Trainers(50, "blue")
    trainers2 = Trainers(50, "grey")

    member = Member("Ago Luberg", 35, trainers1)
    member2 = Member("Ahti Lohk", 35, trainers2)

    gym.add_member(member)
    gym.add_member(member2)

    print(gym.get_members_number())  # 2

    print(gym.get_all_members())  # [Ago Luberg, 35: Trainers: [50, blue], Ahti Lohk, 35: Trainers: [50, grey]]

    gym.add_member(member)  # Trying to add Ago again
    print(gym.get_members_number())  # 2 //We can't...

    for i in range(48):
        gym.add_member(Member("Tudeng Tudeng", 20, Trainers(49, "blue")))

    print(gym.get_members_number())  # 50

    trainers3 = Trainers(60, "blue")
    member_new = Member("Megane", 19, trainers3)
    gym.add_member(member_new)

    print(
        gym.get_members_number())  # 3 -> Ago, Ahti and Megan, all others were removed because of the lowest trainers' stamina

    city2 = City(10)
    city2.build_gym(Gym("MyFitness", 100))
    city2.destroy_gym()

    for i in range(9):
        city2.build_gym(Gym("Super Gym", 10))

    print(city2.can_build_gym())  # False -> Cannot build gym, city is full of them

    #######################################################################################

    city3 = City(100)

    gym4 = Gym("Sparta", 50)
    gym5 = Gym("People Fitness", 30)
    gym6 = Gym("Gym Eesti", 100)

    city3.build_gym(gym4)
    city3.build_gym(gym5)
    city3.build_gym(gym6)

    gym4.add_member(Member("Bob", 18, Trainers(50, "black")))
    gym4.add_member(Member("Emma", 20, Trainers(70, "red")))
    gym4.add_member(Member("Ken", 25, Trainers(40, "grey")))

    gym5.add_member(Member("Merili", 18, Trainers(100, "pink")))
    gym5.add_member(Member("Richard", 20, Trainers(70, "green")))

    gym6.add_member(Member("Bella", 40, Trainers(15, "green")))
    gym6.add_member(Member("Bob", 50, Trainers(70, "green")))
    gym6.add_member(Member("Sandra", 25, Trainers(30, "pink")))
    gym6.add_member(Member("Bob", 35, Trainers(50, "black")))

    city2.get_max_members_gym()  # [Gym Gym Eesti : 4 member(s)]
    city2.get_max_stamina_gyms()  # [Gym People Fitness : 2 member(s)]
    city2.get_max_average_ages()  # [Gym Gym Eesti : 4 member(s)] => average age 37,5
    city2.get_min_average_ages()  # [Gym People Fitness : 2 member(s)] => average age 19
    city2.get_gyms_by_trainers_color(
        "green")  # [Gym Gym Eesti : 4 member(s), Gym People Fitness : 2 member(s)] => Gym Eesti has 2 members with
    # green trainers, People Fitness has 1.
    city2.get_gyms_by_name(
        "Bob")  # [Gym Gym Eesti : 4 member(s), Gym Sparta : 2 member(s)] => Gym Eesti has 2 members with name Bob,
    #  Sparta has 1.