"""Gym."""
from operator import attrgetter


class Trainers:
    """Represent city modul."""

    def __init__(self, stamina: int, color: str):
        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 modul"""

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

        self.name = name
        self.age = age
        self.trainers = trainers
        self.member_in_gym = []

    def add_to_gym(self, gym):
        self.member_in_gym.append(gym)

    def remove_from_gym(self, gym):
        self.member_in_gym.remove(gym)

    def get_all_gyms(self) -> list:
        """Docstring."""
        pass

    def __repr__(self):
        return f'{self.name}, {self.age}: {member.trainers}'


class Gym:
    """Docstring."""

    def __init__(self, name: str, max_members_number: int):
        """Docstring."""
        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, trainers: Trainers):
        count = 0
        for i in self.member_to_gym:
            if member.trainers is not None and member.trainers == trainers.color:
                count += 1
        return count

    def get_memebers_count_by_name(self, member: Member):
        count = 0
        for _ in self.member_to_gym:
            if member.name is not None and member == member.name:
                count += 1
        return count

    def get_only_member_name(self, member: Member):
        self.only_members_name.append(member.name)
        return self.only_members_name

    def get_only_stamina(self, member: Member):
        self.only_members_stamina.append(member.trainers.stamina)
        return self.only_members_stamina

    # def list_to_dictionary(self, dictionary):
    #     dictionary = {}
    #     for i in self.get_only_member_name(member):
    #         if len(self.get_only_stamina(member)) != 0:
    #             dictionary[i] = self.get_only_stamina(member)[0]
    #             self.get_only_stamina(member).remove(self.get_only_stamina(member)[0])
    #         else:
    #             break
    #     return dictionary

    def add_member(self, member: Member) -> Member:
        """Docstring."""
        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(member)
                    # self.member_to_gym[member.name] = {member.trainers.stamina}
                    self.member_to_gym.append(f'{member.name}, {member.age}: Trainers:[{member.trainers.stamina}, {member.trainers.color}]')
                    # print(self.member_to_gym)
                    return member
                if len(self.member_to_gym) >= self.max_members_numbers:
                    pass
                    # dictionary = {}
                    # for i in self.get_only_member_name(member):
                    #     if len(self.get_only_stamina(member)) != 0:
                    #         dictionary[i] = self.get_only_stamina(member)[0]
                    #         self.get_only_stamina(member).remove(self.get_only_stamina(member)[0])
                    #     else:
                    #         break
                    # key_min = min(dictionary.keys(), key=(lambda k: dictionary[k]))
                    # for k, v in dictionary.items():
                    #     if k == key_min:
                    #         self.member_to_gym.remove(k)


    def can_add_member(self, member: Member) -> bool:
        """Docstring"""
        if isinstance(member, Member):
            if member.trainers is not None and member.trainers.color is not None and member.trainers.stamina >= 0:
                if member not in self.member_to_gym:
                    return True
        else:
            return False

    def remove_member(self, member: Member):
        """Docstring."""
        for i in self.member_to_gym:
            if i == member.name:
                self.member_to_gym.remove(i)

    def get_total_stamina(self) -> int:
        """Docstring."""
        # self.member_stamina.append(member.trainers.stamina)
        # return sum(self.member_stamina)
        pass

    def get_members_number(self) -> int:
        """Docstring."""
        return len(self.member_to_gym)

    def get_all_members(self) -> list:
        """Docstring."""
        return self.member_to_gym

    def get_average_age(self) -> float:
        """Docstring."""
        # self.member_age.append(member.age)
        # average_age = round(sum(self.member_age) / len(self.member_age), 2)
        # return average_age
        pass

    def __str__(self) -> str:
        """Gym [saali nimi] : [saali liikmete arv] member(s)"""
        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."""
        min_memebers_in_gym_count = min(map(lambda gym: len(gym.member_to_gym), self.gym_in_city))
        gyms_to_destroy = []
        for gym in 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:
            # destroy gym
            pass

    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."""
        # summary_stamina = sum(gym.get_total_stamina())
        # summary_stamina_list = []
        # summary_stamina_list.append(summary_stamina)
        # return summary_stamina_list
        pass

    def get_max_average_ages(self) -> list:
        """Docstring."""
        pass

    def get_min_average_ages(self) -> list:
        """Docstring."""
        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))

    def get_gyms_by_name(self, name: str) -> list:
        """Docstring."""
        return sorted(self.gym_in_city, key=lambda gym: gym.get_memebers_count_by_name(name))

    def get_all_gyms(self) -> list:
        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.