"""Train Station."""


class Passenger:
    """Passenger class."""

    def __init__(self, passenger_id: str, seat: str):
        """Passenger constructor."""
        self._id = passenger_id
        self._seat = seat

    @property
    def id(self) -> str:
        """Id getter."""
        return self._id

    @property
    def seat(self) -> str:
        """Seat getter."""
        return self._seat

    @property
    def train_id(self):
        """Train id getter."""
        return self._seat.split("-")[0]

    @property
    def carriage(self):
        """Train id getter."""
        return self._seat.split("-")[1]

    @property
    def place(self):
        """Train id getter."""
        return self._seat.split("-")[2]

    @property
    def _dict(self):
        """Dict form of Passenger."""
        return self.__dict__

    def __repr__(self):
        return f"{self.train_id} {self._id}"


def check_passenger_may_be_added(passenger: Passenger, train):
    """Function for distribute passengers."""
    if passenger.train_id != train.train_id:
        return False
    if 1 > int(passenger.carriage) or int(passenger.carriage) > train.carriages or \
            1 > int(passenger.place) or int(passenger.place) > train.seats_in_carriage:
        return False
    for pas in train.passengers:
        if passenger.carriage == pas.carriage and passenger.place == pas.place:
            return False
    return True


class Train:
    """Train class."""

    def __init__(self, train_id: str, carriages: int, seats_in_carriage: int):
        """Train constructor."""
        self._train_id = train_id
        self._carriages = carriages
        self._seats_in_carriage = seats_in_carriage
        self._passengers = []

    @property
    def carriages(self) -> int:
        """Carriage getter."""
        return self._carriages

    @property
    def train_id(self) -> str:
        """Train id getter."""
        return self._train_id

    @property
    def seats_in_carriage(self) -> int:
        """Seat count in carriage getter."""
        return self._seats_in_carriage

    @property
    def passengers(self) -> list:
        """Passenger list getter."""
        return self._passengers

    def get_seats_in_train(self) -> int:
        """Seat count in train getter."""
        return self._carriages * self._seats_in_carriage

    def get_number_of_passengers(self) -> int:
        """Passenger count in train getter."""
        return len(self._passengers)

    def get_passengers_in_carriages(self) -> dict:
        """Gog."""
        passengers_in_carriage = {str(x): [] for x in range(1, self._carriages + 1)}
        for passenger in self._passengers:
            if passenger.carriage in passengers_in_carriage:
                passengers_in_carriage[passenger.carriage].append(passenger)
        return passengers_in_carriage

    @train_id.setter
    def train_id(self, value: str):
        """Train id setter."""
        self._train_id = value

    @carriages.setter
    def carriages(self, value: int):
        """Carriage setter."""
        self._carriages = value if value >= 0 else self._carriages

    @seats_in_carriage.setter
    def seats_in_carriage(self, value: int):
        """Seat count in carriage setter."""
        self._seats_in_carriage = value if value >= 0 else self._seats_in_carriage

    def add_passenger(self, passenger: Passenger) -> Passenger:
        """Add passenger to passengers."""
        if check_passenger_may_be_added(passenger, self):
            self._passengers.append(passenger)
        return passenger

    @property
    def to_dict(self):
        """Dict form of Train."""
        return {'train_id': self.train_id,
                'carriages': self.carriages,
                'seats': f'{self.get_number_of_passengers()}/{self.get_seats_in_train()}'}


class TrainStation:
    """Train station."""

    def __init__(self, trains: list, passengers: list):
        """Train station constructor."""
        self._trains = trains
        self._passengers = passengers
        self.distribute_passengers()

    def distribute_passengers(self):
        """Distribute passengers to trains."""
        trains_dict = {train.train_id: train for train in self._trains}
        gatecrashers = []
        for pas in self._passengers:
            if pas.train_id in trains_dict and check_passenger_may_be_added(pas, trains_dict[pas.train_id]):
                trains_dict[pas.train_id].add_passenger(pas)
            else:
                gatecrashers.append(pas)
        self._passengers = [pas for pas in self._passengers if pas not in gatecrashers]

    def get_station_overview(self) -> list:
        """Hz."""
        return [train.to_dict for train in self._trains]

    def get_number_of_passengers(self) -> int:
        """Hz."""
        return len(self._passengers)

    @property
    def passengers(self) -> list:
        """Passenger list getter."""
        return self._passengers

    @passengers.setter
    def passengers(self, value_list: list):
        """Passenger list setter."""
        self._passengers = value_list

    @property
    def trains(self) -> list:
        """Train list getter."""
        return self._trains

    @trains.setter
    def trains(self, value_list: list):
        """Train list setter."""
        self.trains = value_list