"""Cardápio de uma cafeteria — exercita POO de ponta a ponta.

Cobre as aulas 03 a 11: __str__, encapsulamento, composição, herança,
super(), sobrescrita, polimorfismo, classes abstratas e sobrecarga de
operador (__len__).
"""

from abc import ABC, abstractmethod


# ----------------------------------------------------------------------
# Item — classe abstrata (aula 10)
# ----------------------------------------------------------------------
class Item(ABC):
    """Contrato comum a tudo que pode entrar no cardápio."""

    def __init__(self, nome, preco):
        if preco < 0:
            raise ValueError("preco nao pode ser negativo")
        self._nome = nome
        self._preco = preco

    @property
    def nome(self):
        # somente leitura — encapsulamento (aula 04)
        return self._nome

    @property
    def preco(self):
        return self._preco

    @abstractmethod
    def descricao(self):
        """Cada subclasse descreve o item do seu jeito."""
        pass

    def __str__(self):
        # representacao amigavel (aula 03)
        return f"{self._nome} — R$ {self._preco:.2f}"


# ----------------------------------------------------------------------
# Bebida — herda de Item (aula 07) e sobrescreve descricao (aula 08)
# ----------------------------------------------------------------------
class Bebida(Item):
    def __init__(self, nome, preco, tamanho):
        super().__init__(nome, preco)  # delega ao pai
        self._tamanho = tamanho  # "P", "M" ou "G"

    def descricao(self):
        return (
            f"Bebida {self._nome} ({self._tamanho}) — R$ {self._preco:.2f}"
        )


# ----------------------------------------------------------------------
# Comida — outra filha de Item
# ----------------------------------------------------------------------
class Comida(Item):
    def __init__(self, nome, preco, vegetariana=False):
        super().__init__(nome, preco)
        self._vegetariana = vegetariana

    def descricao(self):
        marca = "vegetariana" if self._vegetariana else "tradicional"
        return f"Comida {self._nome} ({marca}) — R$ {self._preco:.2f}"


# ----------------------------------------------------------------------
# Cardapio — composicao (aula 05) + __len__ (aula 11)
# ----------------------------------------------------------------------
class Cardapio:
    """Guarda itens e calcula o total. Compoe Itens por dentro."""

    def __init__(self):
        self._itens = []

    def adicionar(self, item):
        self._itens.append(item)

    def total(self):
        # generator expression somando precos
        return sum(item.preco for item in self._itens)

    def __len__(self):
        # protocolo Sized — agora len(cardapio) funciona
        return len(self._itens)


# ----------------------------------------------------------------------
# Programa principal
# ----------------------------------------------------------------------
# tentar instanciar a classe abstrata estoura TypeError (aula 10)
try:
    Item("Generico", 5.0)
except TypeError as erro:
    print(f"[abstrata] {erro}")

# monta o cardapio
cardapio = Cardapio()
cardapio.adicionar(Bebida("Cafe", 6.50, "M"))
cardapio.adicionar(Bebida("Suco de laranja", 9.00, "G"))
cardapio.adicionar(Comida("Pao de queijo", 4.00, vegetariana=True))
cardapio.adicionar(Comida("Coxinha", 7.50, vegetariana=False))

# polimorfismo (aula 09): mesmo metodo, comportamento diferente
print("Itens do cardapio:")
for item in cardapio._itens:
    print(f"  - {item.descricao()}")

print(f"Total de itens: {len(cardapio)}")
print(f"Total a pagar: R$ {cardapio.total():.2f}")

"""Fechar a conta usando uma Carteira — exercita a aula 12 inteira.

Programa autossuficiente: excecao customizada com dados, validacao com
raise e o quarteto try/except/else/finally. Trabalha com valores em reais
(numericos), sem depender de nenhum outro arquivo.
"""


# ----------------------------------------------------------------------
# Excecao customizada (aula 12)
# ----------------------------------------------------------------------
class SaldoInsuficienteError(Exception):
    """Levantada quando a carteira nao cobre o total da conta."""

    def __init__(self, saldo, total):
        self.saldo = saldo
        self.total = total
        self.falta = total - saldo
        super().__init__(
            f"Faltam R$ {self.falta:.2f} para pagar R$ {total:.2f}"
        )


# ----------------------------------------------------------------------
# Carteira — encapsulamento + validacao via raise
# ----------------------------------------------------------------------
class Carteira:
    def __init__(self, saldo_inicial=0.0):
        if saldo_inicial < 0:
            raise ValueError("saldo inicial nao pode ser negativo")
        self._saldo = saldo_inicial

    @property
    def saldo(self):
        return self._saldo

    def depositar(self, valor):
        if valor <= 0:
            raise ValueError("valor deve ser positivo")
        self._saldo += valor
        return self._saldo

    def pagar(self, total):
        # detecta na origem, deixa quem chamou tratar
        if total > self._saldo:
            raise SaldoInsuficienteError(self._saldo, total)
        self._saldo -= total
        return self._saldo


# ----------------------------------------------------------------------
# Programa principal
# ----------------------------------------------------------------------
carteira = Carteira(20.00)

total_caro = 27.00  # conta que estoura o saldo

print(f"Saldo inicial: R$ {carteira.saldo:.2f}")
print(f"Total da conta cara: R$ {total_caro:.2f}")

try:
    carteira.pagar(total_caro)
except SaldoInsuficienteError as erro:
    print(f"❌ Pagamento recusado: {erro}")
    print(f"   Deposite mais R$ {erro.falta:.2f} para fechar a conta.")
except ValueError as erro:
    print(f"❌ Valor invalido: {erro}")
else:
    print("Pagamento concluido (caminho feliz).")
finally:
    print(f"Saldo apos tentativa: R$ {carteira.saldo:.2f}")

try:
    carteira.depositar(-10)
except ValueError as erro:
    print(f"❌ Deposito recusado: {erro}")

total_barato = 10.50

try:
    carteira.pagar(total_barato)
except SaldoInsuficienteError as erro:
    print(f"❌ {erro}")
else:
    print(f"✅ Pagamento OK. Sobrou R$ {carteira.saldo:.2f}.")
finally:
    print(f"Saldo final: R$ {carteira.saldo:.2f}")