Revisão Prática — 2ª VA

"""Cadastro de pizzaria — POO + coleções + arquivos (aulas 02–05, 17, 18)."""

from pathlib import Path

ARQUIVO = Path(__file__).parent / "pedidos.txt"  # ancorado ao lado do script (aula 17)


class Pedido:
    """Um pedido: cliente, sabor e valor. Encapsula o valor (aulas 02–04)."""

    def __init__(self, cliente, sabor, valor):
        self.cliente = cliente          # atributos simples (aula 02)
        self.sabor = sabor
        self.valor = valor              # passa pelo setter -> valida

    @property
    def valor(self):                    # getter (aula 04)
        return self._valor

    @valor.setter
    def valor(self, novo):              # setter valida e guarda (aula 04)
        if novo <= 0:
            raise ValueError("valor deve ser positivo")
        self._valor = novo

    def __str__(self):                  # representação amigável (aula 03)
        return f"{self.cliente} — {self.sabor} (R$ {self._valor:.2f})"

class Cadastro:
    """Compõe uma lista de Pedidos e persiste em arquivo (aulas 05, 17, 18)."""

    def __init__(self):
        self._pedidos = []              # composição (aula 05)

    def adicionar(self, pedido):
        self._pedidos.append(pedido)

    def salvar(self, caminho=ARQUIVO):
        # reescreve o arquivo inteiro em "w" (aula 17)
        with open(caminho, "w", encoding="utf-8") as f:
            for p in self._pedidos:
                f.write(f"{p.cliente};{p.sabor};{p.valor}\n")

    @classmethod
    def carregar_todos(cls, caminho=ARQUIVO):
        # factory que reconstrói os objetos a partir do texto (aula 17)
        cadastro = cls()
        try:
            with open(caminho, "r", encoding="utf-8") as f:
                for linha in f:
                    cliente, sabor, valor = linha.strip().split(";")
                    cadastro.adicionar(Pedido(cliente, sabor, float(valor)))
        except FileNotFoundError:
            pass                        # 1ª execução: arquivo ainda não existe
        return cadastro

    def buscar_por_cliente(self, alvo):
        # list comprehension filtrando (aula 18)
        return [p for p in self._pedidos if p.cliente == alvo]

    def por_valor(self):
        # ordena com sorted(key=lambda) — devolve lista nova (aula 18)
        return sorted(self._pedidos, key=lambda p: p.valor)

# ── Demonstração ──────────────────────────────────────────────────────
cadastro = Cadastro()
cadastro.adicionar(Pedido("Ana", "Calabresa", 39.90))
cadastro.adicionar(Pedido("Bruno", "Marguerita", 42.00))
cadastro.adicionar(Pedido("Ana", "Portuguesa", 45.50))

# valor inválido é barrado na origem (aula 04/14)
try:
    Pedido("Carla", "Frango", -5)
except ValueError as erro:
    print(f"[recusado] {erro}")

cadastro.salvar()                       # grava em pedidos.txt

# recarrega do zero, provando a persistência (aula 17)
recarregado = Cadastro.carregar_todos()

print("Pedidos da Ana:")
for p in recarregado.buscar_por_cliente("Ana"):
    print(f"  - {p}")

print("Todos por valor (crescente):")
for p in recarregado.por_valor():
    print(f"  - {p}")

# Saída no terminal:
# [recusado] valor deve ser positivo
# Pedidos da Ana:
#   - Ana — Calabresa (R$ 39.90)
#   - Ana — Portuguesa (R$ 45.50)
# Todos por valor (crescente):
#   - Ana — Calabresa (R$ 39.90)
#   - Bruno — Marguerita (R$ 42.00)
#   - Ana — Portuguesa (R$ 45.50)

"""Repositório SQLite — CRUD de produtos (aulas 24, 04, 14)."""

import sqlite3
from pathlib import Path

BANCO = Path(__file__).parent / "loja.db"  # ancorado ao lado do script (aula 24)


class ProdutoInvalidoError(Exception):
    """Erro de domínio: o produto fere uma regra da tabela (aula 14)."""

    def __init__(self, motivo):
        self.motivo = motivo            # guarda o dado do erro
        super().__init__(f"Produto inválido: {motivo}")


class Produto:
    """Objeto de domínio; sabe virar/voltar de uma linha (ORM manual, aula 24)."""

    def __init__(self, nome, preco, id=None):
        self.id = id
        self.nome = nome
        self.preco = preco

    @classmethod
    def from_row(cls, linha):           # tupla do banco -> objeto (aula 24)
        id, nome, preco = linha
        return cls(nome, preco, id)

    def to_params(self):                # objeto -> tupla p/ os ? (SEM o id)
        return (self.nome, self.preco)

    def __str__(self):
        return f"#{self.id} {self.nome} — R$ {self.preco:.2f}"

class RepositorioProduto:
    """Esconde todo o SQL atrás de métodos do domínio (Repositório, aulas 04/24)."""

    def __init__(self, caminho=BANCO):
        self.caminho = caminho
        self.criar_tabela()

    def criar_tabela(self):
        with sqlite3.connect(self.caminho) as con:
            con.execute(
                "CREATE TABLE IF NOT EXISTS produtos ("
                "id INTEGER PRIMARY KEY AUTOINCREMENT, "
                "nome TEXT NOT NULL, "
                "preco REAL NOT NULL)"
            )

    def salvar(self, produto):
        # INSERT com placeholder ? (nunca f-string!) — aula 24
        try:
            with sqlite3.connect(self.caminho) as con:
                cursor = con.execute(
                    "INSERT INTO produtos (nome, preco) VALUES (?, ?)",
                    produto.to_params(),
                )
                produto.id = cursor.lastrowid   # id gerado pelo banco
                return produto
        except sqlite3.IntegrityError:          # feriu uma regra da tabela (ex.: NOT NULL) — aula 14
            raise ProdutoInvalidoError("nome e preço são obrigatórios")
        except sqlite3.Error as erro:           # rede de segurança geral
            print(f"[erro no banco] {erro}")
            return None

    def listar(self):
        with sqlite3.connect(self.caminho) as con:
            cursor = con.execute("SELECT id, nome, preco FROM produtos ORDER BY id")
            return [Produto.from_row(l) for l in cursor.fetchall()]

    def buscar_por_nome(self, termo):
        with sqlite3.connect(self.caminho) as con:
            cursor = con.execute(
                "SELECT id, nome, preco FROM produtos WHERE nome LIKE ?",
                (f"%{termo}%",),        # busca parcial com LIKE + % (aula 24)
            )
            return [Produto.from_row(l) for l in cursor.fetchall()]

    def atualizar(self, produto):
        with sqlite3.connect(self.caminho) as con:
            con.execute(
                "UPDATE produtos SET nome = ?, preco = ? WHERE id = ?",
                (produto.nome, produto.preco, produto.id),
            )

    def remover(self, id):
        with sqlite3.connect(self.caminho) as con:
            con.execute("DELETE FROM produtos WHERE id = ?", (id,))

# ── Demonstração (rode num loja.db novo pra bater a saída) ─────────────
repo = RepositorioProduto()
repo.salvar(Produto("Cafe", 18.0))
repo.salvar(Produto("Leite", 6.5))
repo.salvar(Produto("Pao", 8.0))

# produto sem nome: fere o NOT NULL; o Repositório traduz o IntegrityError (aula 14)
try:
    repo.salvar(Produto(None, 20.0))
except ProdutoInvalidoError as erro:
    print(f"[recusado] {erro}")        # print(erro) usa a mensagem do super().__init__

print("Todos os produtos:")
for p in repo.listar():
    print(f"  {p}")

cafe = repo.buscar_por_nome("Cafe")[0]  # atualiza o preço do café
cafe.preco = 21.0
repo.atualizar(cafe)

leite = repo.buscar_por_nome("Leite")[0]  # remove o leite
repo.remover(leite.id)

print("Depois de atualizar Cafe e remover Leite:")
for p in repo.listar():
    print(f"  {p}")

print("Busca por 'a':")
for p in repo.buscar_por_nome("a"):
    print(f"  {p}")

# Saída no terminal:
# [recusado] Produto inválido: nome e preço são obrigatórios
# Todos os produtos:
#   #1 Cafe — R$ 18.00
#   #2 Leite — R$ 6.50
#   #3 Pao — R$ 8.00
# Depois de atualizar Cafe e remover Leite:
#   #1 Cafe — R$ 21.00
#   #3 Pao — R$ 8.00
# Busca por 'a':
#   #1 Cafe — R$ 21.00
#   #3 Pao — R$ 8.00

"""Padrões aplicados — Observer e Strategy (aula 21)."""

from abc import ABC, abstractmethod


# ── Observer: um Canal avisa vários inscritos (aula 21) ────────────────
class Inscrito(ABC):
    @abstractmethod
    def atualizar(self, video):         # contrato do observer
        pass


class Pessoa(Inscrito):
    def __init__(self, nome):
        self.nome = nome

    def atualizar(self, video):         # cada observer reage do seu jeito
        print(f"  {self.nome} recebeu: '{video}'")


class Canal:
    """Subject: mantém a lista e notifica todos (um-para-muitos)."""

    def __init__(self, nome):
        self.nome = nome
        self._inscritos = []            # composição (aula 05)

    def inscrever(self, inscrito):
        self._inscritos.append(inscrito)

    def notificar(self, video):
        print(f"[{self.nome}] publicou '{video}' — avisando {len(self._inscritos)}:")
        for inscrito in self._inscritos:  # polimorfismo: mesma chamada (aula 09)
            inscrito.atualizar(video)

# ── Strategy: o Carrinho troca a regra de desconto em runtime (aula 21) ─
class Desconto(ABC):
    @abstractmethod
    def calcular(self, valor):          # contrato da estratégia
        pass


class SemDesconto(Desconto):
    def calcular(self, valor):
        return valor


class DescontoBlackFriday(Desconto):
    def calcular(self, valor):
        return valor * 0.70             # 30% off


class Carrinho:
    """Contexto: guarda a estratégia ativa e DELEGA a ela."""

    def __init__(self, total, desconto):
        self.total = total
        self.desconto = desconto        # composição (aula 05)

    def total_final(self):
        return self.desconto.calcular(self.total)


# ── Demonstração ──────────────────────────────────────────────────────
canal = Canal("SENAI Play")
canal.inscrever(Pessoa("Ana"))
canal.inscrever(Pessoa("Bruno"))
canal.notificar("POO com Python - Aula 24")

carrinho = Carrinho(200.0, SemDesconto())       # mesma compra, estratégias diferentes
print(f"Sem desconto: R$ {carrinho.total_final():.2f}")

carrinho.desconto = DescontoBlackFriday()       # troca em runtime (aula 21)
print(f"Black Friday: R$ {carrinho.total_final():.2f}")

# Saída no terminal:
# [SENAI Play] publicou 'POO com Python - Aula 24' — avisando 2:
#   Ana recebeu: 'POO com Python - Aula 24'
#   Bruno recebeu: 'POO com Python - Aula 24'
# Sem desconto: R$ 200.00
# Black Friday: R$ 140.00

"""App Tkinter que consome o repositório SQLite (aulas 22, 23, 24)."""

import sqlite3
import tkinter as tk
from tkinter import messagebox
from pathlib import Path

BANCO = Path(__file__).parent / "loja_gui.db"  # ancorado ao lado do script (aula 24)


class RepositorioProduto:
    """CRUD mínimo em SQLite (aula 24). A GUI usa isto sem ver SQL."""

    def __init__(self, caminho=BANCO):
        self.caminho = caminho
        with sqlite3.connect(self.caminho) as con:
            con.execute(
                "CREATE TABLE IF NOT EXISTS produtos ("
                "id INTEGER PRIMARY KEY AUTOINCREMENT, nome TEXT NOT NULL)"
            )

    def salvar(self, nome):
        with sqlite3.connect(self.caminho) as con:
            con.execute("INSERT INTO produtos (nome) VALUES (?)", (nome,))

    def listar(self):
        with sqlite3.connect(self.caminho) as con:
            cursor = con.execute("SELECT id, nome FROM produtos ORDER BY id")
            return cursor.fetchall()    # lista de tuplas (id, nome)

    def remover(self, id):
        with sqlite3.connect(self.caminho) as con:
            con.execute("DELETE FROM produtos WHERE id = ?", (id,))

class App(tk.Tk):
    """A janela É um objeto: herda de tk.Tk (aulas 07/23)."""

    def __init__(self, repo):
        super().__init__()              # PRIMEIRA linha do __init__ (aula 23)
        self.repo = repo
        self.title("Estoque")
        self.geometry("320x300")

        # só .pack neste container — um gerente de geometria por container (aula 22)
        self.campo = tk.Entry(self, width=30)
        self.campo.pack(padx=10, pady=(10, 4))

        tk.Button(self, text="Adicionar", command=self.adicionar).pack(pady=2)

        self.lista = tk.Listbox(self, width=40, height=8)
        self.lista.pack(padx=10, pady=4)

        tk.Button(self, text="Excluir", command=self.excluir).pack(pady=2)

        self._ids = []                  # espelha os ids na ordem do Listbox (aula 23)
        self.preencher_lista()

    def preencher_lista(self):
        # o banco é a fonte da verdade; o Listbox é só o espelho (aula 23)
        self.lista.delete(0, tk.END)    # limpa ANTES de reinserir
        self._ids = []
        for id, nome in self.repo.listar():
            self._ids.append(id)
            self.lista.insert(tk.END, nome)

    def adicionar(self):
        nome = self.campo.get().strip()  # Entry.get() sempre string (aula 22)
        if not nome:
            messagebox.showerror("Ops", "Digite um nome.")
            return
        self.repo.salvar(nome)          # grava no banco (aula 24)
        self.campo.delete(0, tk.END)
        self.preencher_lista()
        print(f"[+] adicionado: {nome}")

    def excluir(self):
        selecao = self.lista.curselection()   # tupla, vazia se nada (aula 23)
        if not selecao:
            messagebox.showerror("Ops", "Selecione um item.")
            return
        indice = selecao[0]
        id = self._ids[indice]          # índice do Listbox -> id do banco
        nome = self.lista.get(indice)
        if messagebox.askyesno("Excluir", f"Remover '{nome}'?"):  # confirma (aula 23)
            self.repo.remover(id)
            self.preencher_lista()
            print(f"[-] removido: {nome}")

if __name__ == "__main__":
    repo = RepositorioProduto()
    app = App(repo)
    app.mainloop()                      # o aluno roda de verdade

# Saída no terminal:
# [+] adicionado: Teclado
# [+] adicionado: Mouse
# [-] removido: Teclado