Состояние

from __future__ import annotations
from abc import ABC, abstractmethod


class TrafficLightState(ABC):
    def __init__(self, light: "TrafficLight") -> None:
        self._light = light

    @property
    @abstractmethod
    def color(self) -> str: ...

    @property
    @abstractmethod
    def duration(self) -> int: ...

    @abstractmethod
    def next(self) -> None:
        """Перейти в следующее состояние."""
        ...


class RedState(TrafficLightState):
    @property
    def color(self) -> str:
        return "RED"

    @property
    def duration(self) -> int:
        return 60

    def next(self) -> None:
        # TODO: перейти в GreenState
        pass


class YellowState(TrafficLightState):
    @property
    def color(self) -> str:
        return "YELLOW"

    @property
    def duration(self) -> int:
        return 5

    def next(self) -> None:
        # TODO: перейти в RedState
        pass


class GreenState(TrafficLightState):
    @property
    def color(self) -> str:
        return "GREEN"

    @property
    def duration(self) -> int:
        return 45

    def next(self) -> None:
        # TODO: перейти в YellowState
        pass


class TrafficLight:
    def __init__(self) -> None:
        # TODO: начальное состояние — Red
        self._state: TrafficLightState | None = None

    def change_state(self, state: TrafficLightState) -> None:
        self._state = state
        print(f"[TrafficLight] → {state.color} ({state.duration}s)")

    def tick(self) -> None:
        """Переключить на следующее состояние."""
        # TODO: делегировать текущему состоянию
        pass

    @property
    def current_color(self) -> str:
        return self._state.color


# Ожидаемый результат:
# light = TrafficLight()
# # [TrafficLight] → RED (60s)
# light.tick()
# # [TrafficLight] → GREEN (45s)
# light.tick()
# # [TrafficLight] → YELLOW (5s)
# light.tick()
# # [TrafficLight] → RED (60s)
# print(light.current_color)  # RED

from __future__ import annotations
from abc import ABC, abstractmethod


class OrderState(ABC):
    def __init__(self, order: "Order") -> None:
        self._order = order

    @property
    @abstractmethod
    def name(self) -> str: ...

    def pay(self) -> None:
        print(f"[{self.name}] Действие недоступно в текущем состоянии")

    def ship(self) -> None:
        print(f"[{self.name}] Действие недоступно в текущем состоянии")

    def deliver(self) -> None:
        print(f"[{self.name}] Действие недоступно в текущем состоянии")

    def complete(self) -> None:
        print(f"[{self.name}] Действие недоступно в текущем состоянии")

    def cancel(self) -> None:
        print(f"[{self.name}] Действие недоступно в текущем состоянии")


class NewState(OrderState):
    @property
    def name(self) -> str:
        return "New"

    def pay(self) -> None:
        # TODO: перейти в PaidState
        pass

    def cancel(self) -> None:
        # TODO: перейти в CancelledState
        pass


class PaidState(OrderState):
    @property
    def name(self) -> str:
        return "Paid"

    def ship(self) -> None:
        # TODO: перейти в ShippedState
        pass

    def cancel(self) -> None:
        # TODO: перейти в CancelledState (возврат средств)
        pass


class ShippedState(OrderState):
    @property
    def name(self) -> str:
        return "Shipped"

    def deliver(self) -> None:
        # TODO: перейти в DeliveredState
        pass

    def cancel(self) -> None:
        # TODO: перейти в CancelledState
        pass


class DeliveredState(OrderState):
    @property
    def name(self) -> str:
        return "Delivered"

    def complete(self) -> None:
        # TODO: перейти в CompletedState
        pass

    # cancel недоступен из Delivered


class CompletedState(OrderState):
    @property
    def name(self) -> str:
        return "Completed"

    # Терминальное состояние — все действия недоступны


class CancelledState(OrderState):
    @property
    def name(self) -> str:
        return "Cancelled"

    # Терминальное состояние


class Order:
    def __init__(self, order_id: str) -> None:
        self.order_id = order_id
        self._state: OrderState = NewState(self)
        print(f"Order {order_id} создан. Статус: {self._state.name}")

    def change_state(self, state: OrderState) -> None:
        self._state = state
        print(f"Order {self.order_id} → {state.name}")

    def pay(self) -> None: self._state.pay()
    def ship(self) -> None: self._state.ship()
    def deliver(self) -> None: self._state.deliver()
    def complete(self) -> None: self._state.complete()
    def cancel(self) -> None: self._state.cancel()

    @property
    def status(self) -> str:
        return self._state.name


# Ожидаемый результат:
# order = Order("ORD-001")
# order.ship()     # [New] Действие недоступно
# order.pay()      # Order ORD-001 → Paid
# order.ship()     # Order ORD-001 → Shipped
# order.deliver()  # Order ORD-001 → Delivered
# order.cancel()   # [Delivered] Действие недоступно
# order.complete() # Order ORD-001 → Completed
# print(order.status)  # Completed

from __future__ import annotations
from abc import ABC, abstractmethod


class ATMState(ABC):
    def __init__(self, atm: "ATM") -> None:
        self._atm = atm

    @abstractmethod
    def insert_card(self, card_number: str) -> None: ...

    @abstractmethod
    def enter_pin(self, pin: str) -> None: ...

    @abstractmethod
    def select_amount(self, amount: float) -> None: ...

    @abstractmethod
    def eject_card(self) -> None: ...


class IdleState(ATMState):
    def insert_card(self, card_number: str) -> None:
        # TODO: сохранить card_number в ATM, перейти в CardInsertedState
        pass

    def enter_pin(self, pin: str) -> None:
        print("[Idle] Сначала вставьте карту")

    def select_amount(self, amount: float) -> None:
        print("[Idle] Сначала вставьте карту")

    def eject_card(self) -> None:
        print("[Idle] Карта не вставлена")


class CardInsertedState(ATMState):
    def insert_card(self, card_number: str) -> None:
        print("[CardInserted] Карта уже вставлена")

    def enter_pin(self, pin: str) -> None:
        # TODO: проверить PIN через atm.verify_pin(pin),
        #       при успехе → AuthenticatedState,
        #       при 3 неудачах → CardBlockedState
        pass

    def select_amount(self, amount: float) -> None:
        print("[CardInserted] Сначала введите PIN")

    def eject_card(self) -> None:
        # TODO: вернуть карту, → IdleState
        pass


class AuthenticatedState(ATMState):
    def insert_card(self, card_number: str) -> None:
        print("[Authenticated] Сессия уже активна")

    def enter_pin(self, pin: str) -> None:
        print("[Authenticated] PIN уже введён")

    def select_amount(self, amount: float) -> None:
        # TODO: проверить баланс, перейти в DispensingCashState
        pass

    def eject_card(self) -> None:
        # TODO: завершить сессию, → IdleState
        pass


class DispensingCashState(ATMState):
    def insert_card(self, card_number: str) -> None:
        print("[Dispensing] Операция выполняется")

    def enter_pin(self, pin: str) -> None:
        print("[Dispensing] Операция выполняется")

    def select_amount(self, amount: float) -> None:
        print("[Dispensing] Операция выполняется")

    def eject_card(self) -> None:
        # TODO: выдать наличные, списать с баланса, → IdleState
        pass


class CardBlockedState(ATMState):
    def insert_card(self, card_number: str) -> None:
        print("[Blocked] Карта заблокирована")

    def enter_pin(self, pin: str) -> None:
        print("[Blocked] Карта заблокирована")

    def select_amount(self, amount: float) -> None:
        print("[Blocked] Карта заблокирована")

    def eject_card(self) -> None:
        # TODO: вернуть карту (заблокированную), → IdleState
        pass


class ATM:
    def __init__(self, balance: float = 10000.0) -> None:
        self._balance = balance
        self._card_number: str | None = None
        self._pin_attempts = 0
        self._requested_amount = 0.0
        self._state: ATMState = IdleState(self)
        # Фиктивная БД: card_number → PIN
        self._cards = {"1234-5678": "1234", "8765-4321": "0000"}
        self._accounts = {"1234-5678": 5000.0, "8765-4321": 300.0}

    def change_state(self, state: ATMState) -> None:
        self._state = state

    def verify_pin(self, pin: str) -> bool:
        return self._cards.get(self._card_number) == pin

    def get_account_balance(self) -> float:
        return self._accounts.get(self._card_number, 0.0)

    def deduct(self, amount: float) -> None:
        self._accounts[self._card_number] -= amount
        self._balance -= amount

    # Публичный интерфейс
    def insert_card(self, card_number: str) -> None:
        self._state.insert_card(card_number)

    def enter_pin(self, pin: str) -> None:
        self._state.enter_pin(pin)

    def select_amount(self, amount: float) -> None:
        self._state.select_amount(amount)

    def eject_card(self) -> None:
        self._state.eject_card()


# Ожидаемый результат:
# atm = ATM()
# atm.insert_card("1234-5678")   # Карта принята
# atm.enter_pin("9999")          # Неверный PIN (попытка 1/3)
# atm.enter_pin("9999")          # Неверный PIN (попытка 2/3)
# atm.enter_pin("1234")          # Успешная аутентификация
# atm.select_amount(500.0)       # Запрос 500.0
# atm.eject_card()               # Выдано 500.0, карта возвращена

from __future__ import annotations
from abc import ABC, abstractmethod


class TCPState(ABC):
    def __init__(self, connection: "TCPConnection") -> None:
        self._conn = connection

    @property
    @abstractmethod
    def name(self) -> str: ...

    def open(self) -> None:
        print(f"[{self.name}] Недопустимое действие")

    def syn(self) -> None:
        print(f"[{self.name}] Недопустимое действие")

    def ack(self) -> None:
        print(f"[{self.name}] Недопустимое действие")

    def close(self) -> None:
        print(f"[{self.name}] Недопустимое действие")

    def send(self, data: str) -> None:
        print(f"[{self.name}] Соединение не установлено")


class ClosedState(TCPState):
    @property
    def name(self) -> str:
        return "CLOSED"

    def open(self) -> None:
        # TODO: → ListenState
        pass


class ListenState(TCPState):
    @property
    def name(self) -> str:
        return "LISTEN"

    def syn(self) -> None:
        # TODO: → SynReceivedState
        pass

    def close(self) -> None:
        # TODO: → ClosedState
        pass


class SynReceivedState(TCPState):
    @property
    def name(self) -> str:
        return "SYN_RECEIVED"

    def ack(self) -> None:
        # TODO: → EstablishedState
        pass

    def close(self) -> None:
        # TODO: → ClosedState
        pass


class EstablishedState(TCPState):
    @property
    def name(self) -> str:
        return "ESTABLISHED"

    def send(self, data: str) -> None:
        print(f"[ESTABLISHED] Отправка данных: '{data}'")
        self._conn.log_sent(data)

    def close(self) -> None:
        # TODO: → ClosedState, выполнить four-way handshake (FIN)
        pass


class TCPConnection:
    def __init__(self) -> None:
        self._state: TCPState = ClosedState(self)
        self._sent: list[str] = []
        print(f"TCP Connection создано. Состояние: {self._state.name}")

    def change_state(self, state: TCPState) -> None:
        self._state = state
        print(f"TCP → {state.name}")

    def log_sent(self, data: str) -> None:
        self._sent.append(data)

    def open(self) -> None: self._state.open()
    def syn(self) -> None: self._state.syn()
    def ack(self) -> None: self._state.ack()
    def close(self) -> None: self._state.close()
    def send(self, data: str) -> None: self._state.send(data)

    @property
    def state_name(self) -> str:
        return self._state.name


# Ожидаемый результат:
# conn = TCPConnection()   # CLOSED
# conn.send("hello")       # [CLOSED] Соединение не установлено
# conn.open()              # TCP → LISTEN
# conn.syn()               # TCP → SYN_RECEIVED
# conn.ack()               # TCP → ESTABLISHED
# conn.send("Hello!")      # [ESTABLISHED] Отправка данных: 'Hello!'
# conn.send("World!")      # [ESTABLISHED] Отправка данных: 'World!'
# conn.close()             # TCP → CLOSED
# conn.send("late")        # [CLOSED] Соединение не установлено

from __future__ import annotations
from abc import ABC, abstractmethod


class VendingState(ABC):
    def __init__(self, machine: "VendingMachine") -> None:
        self._machine = machine

    @abstractmethod
    def insert_coin(self, amount: float) -> None: ...

    @abstractmethod
    def select_product(self, product: str) -> None: ...

    @abstractmethod
    def cancel(self) -> None: ...

    @abstractmethod
    def dispense(self) -> None: ...


class IdleState(VendingState):
    def insert_coin(self, amount: float) -> None:
        # TODO: добавить деньги в machine.balance, → HasMoneyState
        pass

    def select_product(self, product: str) -> None:
        print("[Idle] Сначала внесите монету")

    def cancel(self) -> None:
        print("[Idle] Нечего отменять")

    def dispense(self) -> None:
        print("[Idle] Сначала выберите товар")


class HasMoneyState(VendingState):
    def insert_coin(self, amount: float) -> None:
        # TODO: добавить к текущему балансу
        pass

    def select_product(self, product: str) -> None:
        # TODO: проверить наличие товара и достаточность суммы,
        #       установить machine.selected_product, → DispensingState
        #       если недостаточно средств — сообщить и остаться
        pass

    def cancel(self) -> None:
        # TODO: вернуть деньги, → IdleState
        pass

    def dispense(self) -> None:
        print("[HasMoney] Сначала выберите товар")


class DispensingState(VendingState):
    def insert_coin(self, amount: float) -> None:
        print("[Dispensing] Подождите, идёт выдача")

    def select_product(self, product: str) -> None:
        print("[Dispensing] Подождите, идёт выдача")

    def cancel(self) -> None:
        print("[Dispensing] Невозможно отменить")

    def dispense(self) -> None:
        # TODO: выдать товар, вернуть сдачу,
        #       если товаров больше нет → OutOfStockState, иначе → IdleState
        pass


class OutOfStockState(VendingState):
    def insert_coin(self, amount: float) -> None:
        print("[OutOfStock] Нет товаров, монета возвращена")

    def select_product(self, product: str) -> None:
        print("[OutOfStock] Нет товаров")

    def cancel(self) -> None:
        print("[OutOfStock] Нет активной транзакции")

    def dispense(self) -> None:
        print("[OutOfStock] Нет товаров")


class VendingMachine:
    def __init__(self) -> None:
        self.balance: float = 0.0
        self.selected_product: str | None = None
        self._inventory: dict[str, tuple[float, int]] = {
            # product: (price, quantity)
            "Cola": (1.5, 3),
            "Water": (1.0, 2),
            "Chips": (2.0, 1),
        }
        self._state: VendingState = IdleState(self)

    def change_state(self, state: VendingState) -> None:
        self._state = state

    def get_price(self, product: str) -> float | None:
        item = self._inventory.get(product)
        return item[0] if item else None

    def get_stock(self, product: str) -> int:
        item = self._inventory.get(product)
        return item[1] if item else 0

    def reduce_stock(self, product: str) -> None:
        price, qty = self._inventory[product]
        self._inventory[product] = (price, qty - 1)

    def has_any_stock(self) -> bool:
        return any(qty > 0 for _, qty in self._inventory.values())

    def insert_coin(self, amount: float) -> None: self._state.insert_coin(amount)
    def select_product(self, product: str) -> None: self._state.select_product(product)
    def cancel(self) -> None: self._state.cancel()
    def dispense(self) -> None: self._state.dispense()


# Ожидаемый результат:
# vm = VendingMachine()
# vm.select_product("Cola")    # [Idle] Сначала внесите монету
# vm.insert_coin(1.0)          # Баланс: 1.0
# vm.insert_coin(1.0)          # Баланс: 2.0
# vm.select_product("Cola")    # Выбрана Cola (1.5). Сдача: 0.5
# vm.dispense()                # Выдаётся Cola. Сдача: 0.5 возвращена
# vm.insert_coin(1.0)
# vm.select_product("Water")
# vm.cancel()                  # Возврат 1.0