Посредник

from __future__ import annotations
from abc import ABC, abstractmethod
from datetime import datetime


class ChatMediator(ABC):
    @abstractmethod
    def send_message(self, sender: "User", message: str,
                     recipient: "User" = None) -> None: ...

    @abstractmethod
    def add_user(self, user: "User") -> None: ...


class ChatRoom(ChatMediator):
    def __init__(self, name: str) -> None:
        self.name = name
        # TODO: хранить список пользователей и историю сообщений

    def add_user(self, user: "User") -> None:
        # TODO: добавить пользователя и оповестить комнату
        pass

    def send_message(self, sender: "User", message: str,
                     recipient: "User" = None) -> None:
        # TODO: если recipient указан — приватное сообщение,
        #       иначе — broadcast всем кроме отправителя
        pass

    def get_history(self) -> list[str]:
        # TODO: вернуть историю сообщений
        pass


class User:
    def __init__(self, name: str) -> None:
        self.name = name
        self._mediator: ChatMediator | None = None

    def join(self, room: ChatMediator) -> None:
        # TODO: подключиться к комнате
        pass

    def send(self, message: str, to: "User" = None) -> None:
        # TODO: отправить сообщение через посредника
        pass

    def receive(self, message: str) -> None:
        print(f"[{self.name}] {message}")


# Ожидаемый результат:
# room = ChatRoom("General")
# alice, bob, carol = User("Alice"), User("Bob"), User("Carol")
# alice.join(room); bob.join(room); carol.join(room)
# alice.send("Всем привет!")
# bob.send("Привет, Алиса!", to=alice)
# carol.send("Как дела?")
# print(room.get_history())

from __future__ import annotations
from abc import ABC, abstractmethod
from enum import Enum


class RunwayStatus(Enum):
    FREE = "free"
    OCCUPIED = "occupied"


class AirTrafficMediator(ABC):
    @abstractmethod
    def request_landing(self, aircraft: "Aircraft") -> bool: ...

    @abstractmethod
    def request_takeoff(self, aircraft: "Aircraft") -> bool: ...

    @abstractmethod
    def notify_landed(self, aircraft: "Aircraft") -> None: ...

    @abstractmethod
    def notify_taken_off(self, aircraft: "Aircraft") -> None: ...


class ControlTower(AirTrafficMediator):
    def __init__(self, runways: int = 2) -> None:
        # TODO: хранить состояние полос и очередь ожидания
        pass

    def request_landing(self, aircraft: "Aircraft") -> bool:
        # TODO: если есть свободная полоса — разрешить посадку,
        #       иначе добавить в очередь ожидания
        pass

    def request_takeoff(self, aircraft: "Aircraft") -> bool:
        # TODO: аналогично для взлёта
        pass

    def notify_landed(self, aircraft: "Aircraft") -> None:
        # TODO: освободить полосу и разрешить следующему из очереди
        pass

    def notify_taken_off(self, aircraft: "Aircraft") -> None:
        # TODO: освободить полосу
        pass


class Aircraft:
    def __init__(self, flight_id: str, tower: AirTrafficMediator) -> None:
        self.flight_id = flight_id
        self._tower = tower

    def land(self) -> None:
        # TODO: запросить посадку через башню
        pass

    def take_off(self) -> None:
        # TODO: запросить взлёт через башню
        pass


# Ожидаемый результат:
# tower = ControlTower(runways=1)
# f1 = Aircraft("SU-101", tower)
# f2 = Aircraft("SU-202", tower)
# f3 = Aircraft("SU-303", tower)
# f1.land()   # SU-101: Посадка разрешена, полоса 1
# f2.land()   # SU-202: Ожидание...
# f3.land()   # SU-303: Ожидание...
# f1.take_off()  # башня освобождает полосу, SU-202 получает разрешение

from __future__ import annotations
from abc import ABC, abstractmethod


class FormMediator(ABC):
    @abstractmethod
    def notify(self, sender: "FormComponent", event: str) -> None: ...


class FormComponent(ABC):
    def __init__(self, name: str) -> None:
        self.name = name
        self._mediator: FormMediator | None = None
        self.enabled = True
        self.visible = True

    def set_mediator(self, mediator: FormMediator) -> None:
        self._mediator = mediator

    def notify(self, event: str) -> None:
        if self._mediator:
            self._mediator.notify(self, event)


class Checkbox(FormComponent):
    def __init__(self, name: str) -> None:
        super().__init__(name)
        self.checked = False

    def toggle(self) -> None:
        self.checked = not self.checked
        self.notify("change")


class TextField(FormComponent):
    def __init__(self, name: str, placeholder: str = "") -> None:
        super().__init__(name)
        self.value = ""
        self.placeholder = placeholder

    def set_value(self, value: str) -> None:
        self.value = value
        self.notify("input")


class SelectField(FormComponent):
    def __init__(self, name: str, options: list[str]) -> None:
        super().__init__(name)
        self.options = options
        self.selected: str | None = None

    def select(self, option: str) -> None:
        self.selected = option
        self.notify("change")


class Button(FormComponent):
    def click(self) -> None:
        if self.enabled:
            self.notify("click")
        else:
            print(f"Button '{self.name}' is disabled")


class RegistrationForm(FormMediator):
    def __init__(self) -> None:
        # TODO: создать компоненты: is_legal (Checkbox), inn (TextField),
        #       country (SelectField), phone (TextField),
        #       email (TextField), submit (Button)
        # TODO: зарегистрировать self как медиатор для каждого
        pass

    def notify(self, sender: FormComponent, event: str) -> None:
        # TODO:
        # - is_legal.change → показать/скрыть inn
        # - country.change → обновить placeholder у phone
        # - любой TextField.input → проверить активность submit
        pass

    def _update_submit_state(self) -> None:
        # TODO: submit активен если email и phone заполнены,
        #       и если is_legal — то inn тоже заполнен
        pass


# Ожидаемый результат:
# form = RegistrationForm()
# print(form.inn.visible)          # False (скрыто по умолчанию)
# form.is_legal.toggle()
# print(form.inn.visible)          # True
# form.country.select("Russia")
# print(form.phone.placeholder)    # "+7 (___) ___-__-__"
# form.email.set_value("a@b.com")
# form.phone.set_value("+71234567890")
# form.inn.set_value("1234567890")
# print(form.submit.enabled)       # True
# form.submit.click()              # Отправка формы...

from __future__ import annotations
from dataclasses import dataclass, field
from enum import Enum


class OrderType(Enum):
    BUY = "buy"
    SELL = "sell"


@dataclass
class Order:
    trader: "Trader"
    order_type: OrderType
    asset: str
    quantity: int
    price: float
    order_id: int = field(default=0)


class Exchange:
    def __init__(self) -> None:
        # TODO: хранить книгу ордеров (buy_orders, sell_orders)
        self._next_id = 1

    def place_order(self, order: Order) -> None:
        # TODO: назначить order_id, попробовать исполнить заявку,
        #       если нет встречной — добавить в книгу ордеров
        pass

    def _match_orders(self, order: Order) -> None:
        # TODO: для BUY ищем SELL с price <= order.price (наименьшую),
        #       для SELL ищем BUY с price >= order.price (наибольшую).
        #       При совпадении оповестить обоих трейдеров через notify_trade()
        pass

    def cancel_order(self, order_id: int, trader: "Trader") -> bool:
        # TODO: снять заявку из книги ордеров
        pass

    def get_order_book(self, asset: str) -> dict:
        # TODO: вернуть {"buy": [...], "sell": [...]}
        pass


class Trader:
    def __init__(self, name: str, exchange: Exchange) -> None:
        self.name = name
        self._exchange = exchange
        self.trades: list[str] = []

    def buy(self, asset: str, quantity: int, price: float) -> Order:
        # TODO: создать и разместить ордер на покупку
        pass

    def sell(self, asset: str, quantity: int, price: float) -> Order:
        # TODO: создать и разместить ордер на продажу
        pass

    def notify_trade(self, message: str) -> None:
        self.trades.append(message)
        print(f"[{self.name}] {message}")


# Ожидаемый результат:
# exchange = Exchange()
# alice = Trader("Alice", exchange)
# bob = Trader("Bob", exchange)
# alice.sell("AAPL", quantity=10, price=150.0)
# bob.buy("AAPL", quantity=10, price=155.0)
# # [Alice] Сделка: продано 10 AAPL по 150.0
# # [Bob]   Сделка: куплено 10 AAPL по 150.0
# print(exchange.get_order_book("AAPL"))  # {"buy": [], "sell": []}

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any


class GameMediator(ABC):
    @abstractmethod
    def notify(self, sender: "GameObject", event: str,
               data: Any = None) -> None: ...


class GameObject(ABC):
    def __init__(self, name: str, mediator: GameMediator) -> None:
        self.name = name
        self._mediator = mediator

    def emit(self, event: str, data: Any = None) -> None:
        self._mediator.notify(self, event, data)


class Player(GameObject):
    def __init__(self, mediator: GameMediator, hp: int = 100) -> None:
        super().__init__("Player", mediator)
        self.hp = hp
        self.score = 0

    def take_damage(self, amount: int) -> None:
        self.hp = max(0, self.hp - amount)
        self.emit("player:damage", {"hp": self.hp, "damage": amount})
        if self.hp == 0:
            self.emit("player:dead")

    def add_score(self, points: int) -> None:
        self.score += points
        self.emit("player:score", {"score": self.score})


class Enemy(GameObject):
    def __init__(self, name: str, mediator: GameMediator,
                 hp: int = 30) -> None:
        super().__init__(name, mediator)
        self.hp = hp
        self.alive = True

    def take_damage(self, amount: int) -> None:
        self.hp = max(0, self.hp - amount)
        if self.hp == 0 and self.alive:
            self.alive = False
            self.emit("enemy:killed", {"name": self.name})


class UISystem(GameObject):
    def __init__(self, mediator: GameMediator) -> None:
        super().__init__("UI", mediator)
        self.hp_bar = 100
        self.score = 0

    def update_hp(self, hp: int) -> None:
        self.hp_bar = hp
        print(f"[UI] HP: {hp}")

    def update_score(self, score: int) -> None:
        self.score = score
        print(f"[UI] Score: {score}")

    def show_game_over(self) -> None:
        print("[UI] GAME OVER")

    def show_victory(self) -> None:
        print("[UI] YOU WIN!")


class AudioSystem(GameObject):
    def __init__(self, mediator: GameMediator) -> None:
        super().__init__("Audio", mediator)

    def play(self, sound: str) -> None:
        print(f"[Audio] Playing: {sound}")


class GameLevel(GameMediator):
    def __init__(self, enemies_to_kill: int = 3) -> None:
        self.enemies_to_kill = enemies_to_kill
        self.killed = 0
        # TODO: создать player, ui, audio; список врагов создаётся снаружи

    def notify(self, sender: GameObject, event: str,
               data: Any = None) -> None:
        # TODO:
        # player:damage  → ui.update_hp, audio.play("hit.wav")
        # player:dead    → audio.play("gameover.wav"), ui.show_game_over
        # player:score   → ui.update_score
        # enemy:killed   → player.add_score(100), killed++,
        #                  проверить если killed == enemies_to_kill →
        #                  emit level:complete
        # level:complete → audio.play("victory.wav"), ui.show_victory
        pass


# Ожидаемый результат:
# level = GameLevel(enemies_to_kill=2)
# e1 = Enemy("Goblin", level)
# e2 = Enemy("Orc", level)
# level.player.take_damage(20)
# # [UI] HP: 80
# # [Audio] Playing: hit.wav
# e1.take_damage(30)
# # [UI] Score: 100
# # [Audio] Playing: kill.wav
# e2.take_damage(30)
# # [UI] Score: 200
# # [Audio] Playing: kill.wav
# # [Audio] Playing: victory.wav
# # [UI] YOU WIN!