📘 Programación Orientada a Objetos

# ═══════════════════════════════════════════════════════
# SISTEMA DE HOTEL — Unidad 1, ejemplo de negocio
# Aprende a leer: cada línea tiene su explicación ↓
# ═══════════════════════════════════════════════════════

class Habitacion:
    """
    Esta es la CLASE Habitacion.
    Una clase es como un MOLDE para crear objetos.
    Imagina que el molde define cómo es cada habitación.
    """

    def __init__(self, numero, tipo, precio_noche):
        # __init__ es el CONSTRUCTOR: se ejecuta al crear cada habitación.
        # 'self' representa a ESTA habitación específica (el objeto).
        # Los parámetros son datos que recibimos al crear la habitación.
        self.numero = numero              # Guardamos el número (ej: 101)
        self.tipo = tipo                  # Guardamos el tipo (ej: "suite")
        self.precio_noche = precio_noche  # Precio por noche (ej: 850.0)
        self.disponible = True           # Al inicio, siempre disponible

    def reservar(self):
        # Este es un MÉTODO: una acción que puede hacer la habitación.
        if self.disponible:
            self.disponible = False      # Marcamos como NO disponible
            return f"✅ Habitación {self.numero} reservada con éxito."
        else:
            return f"❌ Habitación {self.numero} ya está ocupada."

    def liberar(self):
        self.disponible = True
        return f"🔓 Habitación {self.numero} disponible nuevamente."

    def __str__(self):
        # __str__ define cómo se muestra el objeto cuando usamos print()
        estado = "Disponible" if self.disponible else "Ocupada"
        return f"Hab. {self.numero} | {self.tipo} | ${self.precio_noche}/noche | {estado}"


class Persona:
    # CLASE BASE (padre). Contiene lo que tienen en común clientes y empleados.
    def __init__(self, nombre, email):
        self.nombre = nombre
        self.email = email


class Cliente(Persona):
    """
    HERENCIA: Cliente HEREDA de Persona.
    Escrito como: class Cliente(Persona)
    Esto significa que Cliente tiene TODO lo de Persona
    (nombre y email), MÁS sus propias cosas.
    """
    def __init__(self, nombre, email, telefono):
        super().__init__(nombre, email)  # Llama al constructor de Persona
        self.telefono = telefono           # Agrega atributo propio
        self.reservaciones = []            # Lista vacía de reservaciones

    def agregar_reservacion(self, reservacion):
        self.reservaciones.append(reservacion)


class Reservacion:
    def __init__(self, cliente, habitacion, fecha_entrada, fecha_salida):
        self.cliente = cliente
        self.habitacion = habitacion
        self.fecha_entrada = fecha_entrada
        self.fecha_salida = fecha_salida

    def calcular_costo(self, noches):
        return self.habitacion.precio_noche * noches

    def confirmar(self):
        resultado = self.habitacion.reservar()   # Llama al método de Habitacion
        self.cliente.agregar_reservacion(self)   # Agrega a la lista del cliente
        return resultado


# ══════════════════ PROGRAMA PRINCIPAL ══════════════════
# Aquí creamos objetos (instancias) de nuestras clases

hab101 = Habitacion(101, "Suite Ejecutiva", 1200.0)
hab102 = Habitacion(102, "Doble Estándar", 650.0)

cliente1 = Cliente("Ana García", "ana@mail.com", "662-100-2000")

reserva = Reservacion(cliente1, hab101, "2026-06-01", "2026-06-04")
print(reserva.confirmar())                 # ✅ Habitación 101 reservada
print(hab101)                              # Muestra estado de la habitación
print(f"Costo: ${reserva.calcular_costo(3)}")  # Costo por 3 noches

class ConfiguracionHotel:
    """
    PATRÓN SINGLETON: garantiza que solo exista
    UNA instancia de esta clase en todo el programa.
    Útil para configuraciones, conexiones a BD, etc.
    """
    _instancia = None   # Almacena la única instancia (empieza vacía)

    def __new__(cls):
        # __new__ se llama ANTES de __init__, al crear el objeto.
        # Si no existe instancia, la creamos; si ya existe, devolvemos la misma.
        if cls._instancia is None:
            cls._instancia = super().__new__(cls)
        return cls._instancia

    def __init__(self):
        self.nombre_hotel = "Hotel UTH Grand"
        self.ciudad = "Hermosillo, Sonora"
        self.max_habitaciones = 50

# Probamos que solo hay UNA instancia:
cfg1 = ConfiguracionHotel()
cfg2 = ConfiguracionHotel()
print(cfg1 is cfg2)   # True — ¡son el mismo objeto!
print(cfg1.nombre_hotel)

class HabitacionFactory:
    """
    PATRÓN FACTORY: una clase que se encarga de CREAR otros objetos.
    En lugar de crear objetos directamente con Habitacion(...),
    le pedimos a la fábrica que lo haga según el tipo.
    """
    @staticmethod
    def crear(tipo):
        # Según el tipo, creamos y configuramos la habitación
        if tipo == "suite":
            return Habitacion(0, "Suite Ejecutiva", 1500.0)
        elif tipo == "doble":
            return Habitacion(0, "Doble Estándar", 700.0)
        elif tipo == "sencilla":
            return Habitacion(0, "Sencilla", 450.0)
        else:
            raise ValueError(f"Tipo desconocido: {tipo}")

# Uso: le pedimos a la fábrica
suite = HabitacionFactory.crear("suite")
doble = HabitacionFactory.crear("doble")
print(suite)
print(doble)

# ═════════════════════════════════════════════════════════════════
# SISTEMA DE INVENTARIO — Tienda de Ropa "Moda Hermosillo"
# Unidad 2: Herencia, Encapsulamiento, Polimorfismo
# ═════════════════════════════════════════════════════════════════

class Producto:
    """
    CLASE BASE para todos los productos de la tienda.
    Define lo que tienen en común: nombre, precio, stock.
    """
    iva = 0.16   # Atributo de CLASE: compartido por todos los productos

    def __init__(self, nombre, precio_base, stock):
        self.nombre = nombre
        self.__precio_base = precio_base   # __ = privado (encapsulado)
        self.__stock = stock               # __ = privado

    # ── PROPIEDADES (acceso controlado a atributos privados) ──

    @property
    def precio_base(self):
        # @property permite acceder como atributo: producto.precio_base
        return self.__precio_base

    @precio_base.setter
    def precio_base(self, valor):
        # El setter VALIDA el dato antes de guardarlo
        if valor < 0:
            raise ValueError("El precio no puede ser negativo.")
        self.__precio_base = valor

    @property
    def stock(self):
        return self.__stock

    def precio_con_iva(self):
        # Calcula el precio final sumando el IVA
        return self.__precio_base * (1 + self.iva)

    def vender(self, cantidad):
        # Verifica stock antes de vender
        if cantidad > self.__stock:
            return f"❌ Stock insuficiente. Solo hay {self.__stock} unidades."
        self.__stock -= cantidad
        return f"✅ Venta de {cantidad} '{self.nombre}' registrada. Stock: {self.__stock}"

    def descripcion(self):
        # Método que CADA subclase puede reemplazar (polimorfismo)
        return f"Producto genérico: {self.nombre}"

    def __str__(self):
        return (
            f"📦 {self.nombre}\n"
            f"   Precio base: ${self.__precio_base:.2f}\n"
            f"   Precio con IVA: ${self.precio_con_iva():.2f}\n"
            f"   Stock: {self.__stock} unidades"
        )


class Ropa(Producto):
    """
    SUBCLASE de Producto. Agrega talla y color.
    Hereda TODO de Producto y le añade sus propias cosas.
    """
    def __init__(self, nombre, precio_base, stock, talla, color):
        super().__init__(nombre, precio_base, stock)  # Inicializa la parte de Producto
        self.talla = talla
        self.color = color

    def descripcion(self):
        # SOBREESCRITURA del método (polimorfismo): Ropa tiene su propia descripción
        return f"👔 Ropa: {self.nombre} | Talla: {self.talla} | Color: {self.color}"


class Calzado(Producto):
    def __init__(self, nombre, precio_base, stock, numero, material):
        super().__init__(nombre, precio_base, stock)
        self.numero = numero
        self.material = material

    def descripcion(self):
        return f"👟 Calzado: {self.nombre} | No.{self.numero} | {self.material}"


class Inventario:
    """
    Clase que CONTIENE una lista de productos (Composición).
    El inventario tiene productos, no hereda de ellos.
    """
    def __init__(self, nombre_tienda):
        self.nombre_tienda = nombre_tienda
        self.productos = []

    def agregar(self, producto):
        self.productos.append(producto)
        print(f"➕ '{producto.nombre}' añadido al inventario.")

    def mostrar_catalogo(self):
        print(f"\n{'='*50}")
        print(f"🏪 {self.nombre_tienda} — Catálogo")
        print(f"{'='*50}")
        for p in self.productos:
            print(p.descripcion())  # POLIMORFISMO: cada p llama su propia descripcion()
            print(f"   Precio con IVA: ${p.precio_con_iva():.2f}")


# ══════════════════ PROGRAMA PRINCIPAL ══════════════════
inv = Inventario("Moda Hermosillo")

inv.agregar(Ropa("Playera Polo", 250.0, 30, "M", "Azul marino"))
inv.agregar(Ropa("Jeans Skinny", 480.0, 15, "28", "Negro"))
inv.agregar(Calzado("Tenis Running", 890.0, 10, 27, "Sintético"))

inv.mostrar_catalogo()

# Probamos venta:
print("\n🛒 Realizando venta...")
print(inv.productos[0].vender(3))   # Vende 3 playeras
print(inv.productos[0].vender(50))  # Intenta vender 50 (stock insuficiente)

class CuentaBancaria:
    def __init__(self, titular, saldo_inicial):
        self.titular = titular            # Público
        self.__saldo = saldo_inicial      # Privado — nadie lo toca directamente
        self.__historial = []             # Privado — registro de movimientos

    @property
    def saldo(self):
        # Getter: permite LEER el saldo de forma controlada
        return self.__saldo

    def depositar(self, monto):
        if monto <= 0:
            return "❌ Monto debe ser mayor a 0."
        self.__saldo += monto
        self.__historial.append(f"+${monto}")
        return f"✅ Depósito de ${monto}. Saldo: ${self.__saldo}"

    def retirar(self, monto):
        if monto > self.__saldo:
            return "❌ Fondos insuficientes."
        self.__saldo -= monto
        self.__historial.append(f"-${monto}")
        return f"✅ Retiro de ${monto}. Saldo: ${self.__saldo}"

    def ver_historial(self):
        return self.__historial

# Prueba:
cuenta = CuentaBancaria("Juan López", 5000)
print(cuenta.depositar(2000))
print(cuenta.retirar(800))
print(f"Saldo actual: ${cuenta.saldo}")  # Usamos la property
# cuenta.__saldo = 999999  ← ERROR: no se puede acceder directamente

class MetodoPago:
    # Clase abstracta base para métodos de pago
    def procesar(self, monto):
        raise NotImplementedError("Cada pago debe implementar procesar()")

class PagoEfectivo(MetodoPago):
    def procesar(self, monto):
        return f"💵 Pago en efectivo de ${monto:.2f} recibido."

class PagoTarjeta(MetodoPago):
    def __init__(self, ultimos4):
        self.ultimos4 = ultimos4
    def procesar(self, monto):
        return f"💳 Cargo de ${monto:.2f} a tarjeta ****{self.ultimos4}."

class PagoTransferencia(MetodoPago):
    def __init__(self, banco):
        self.banco = banco
    def procesar(self, monto):
        return f"🏦 Transferencia de ${monto:.2f} vía {self.banco}."

# POLIMORFISMO en acción:
# La función no necesita saber QUÉ tipo de pago es, solo llama procesar()
def cobrar(pago: MetodoPago, total: float):
    resultado = pago.procesar(total)   # Cada objeto responde diferente
    print(resultado)

cobrar(PagoEfectivo(), 350.00)
cobrar(PagoTarjeta("4521"), 1280.50)
cobrar(PagoTransferencia("BBVA"), 9500.00)

# ═══════════════════════════════════════════════════════════════
# ABSTRACCIÓN — Sistema de Reportes
# Empresa de Logística "Envíos Sonora"
# Unidad 2 · Programación Orientada a Objetos
# ═══════════════════════════════════════════════════════════════

from abc import ABC, abstractmethod   # Paso 1: importar el módulo abc


# ── CLASE ABSTRACTA BASE ────────────────────────────────────────
# No se puede instanciar: ReporteBase() lanzaría TypeError
# Solo define el CONTRATO que deben cumplir las subclases
class ReporteBase(ABC):
    """
    Contrato base para todos los tipos de reporte.
    Cualquier clase que herede de ReporteBase DEBE implementar:
        - generar()
        - enviar()
        - nombre_formato (propiedad)
    """

    def __init__(self, titulo, datos):
        self.titulo = titulo          # Común a todos los reportes
        self.datos  = datos           # Lista de registros a reportar

    # ── Métodos ABSTRACTOS: cada subclase los implementa a su manera ──

    @abstractmethod
    def generar(self):
        """Genera el contenido del reporte en el formato específico."""
        ...   # Los '...' indican que el cuerpo lo define la subclase

    @abstractmethod
    def enviar(self, destino):
        """Envía el reporte generado al destino indicado."""
        ...

    @property
    @abstractmethod
    def nombre_formato(self):
        """Devuelve el nombre del formato (PDF, Excel, Email...)."""
        ...

    # ── Método CONCRETO: ya tiene implementación, se hereda tal cual ──
    def encabezado(self):
        # Este método funciona igual para TODOS los formatos
        sep = "═" * 48
        return (
            f"\n{sep}\n"
            f"  📊 {self.titulo}\n"
            f"  Formato : {self.nombre_formato}\n"
            f"  Registros: {len(self.datos)}\n"
            f"{sep}"
        )


# ── SUBCLASE CONCRETA 1: Reporte en PDF ─────────────────────────
class ReportePDF(ReporteBase):
    """Implementación concreta para reportes en formato PDF."""

    @property
    def nombre_formato(self):
        return "PDF"

    def generar(self):
        # Aquí iría la librería reportlab/fpdf en un proyecto real
        lineas = [f"  • {r['paquete']} → {r['destino']} [{r['estado']}]"
                  for r in self.datos]
        return self.encabezado() + "\n" + "\n".join(lineas)

    def enviar(self, destino):
        return f"📤 PDF enviado a la ruta: {destino}/reporte.pdf"


# ── SUBCLASE CONCRETA 2: Reporte en Excel ───────────────────────
class ReporteExcel(ReporteBase):
    """Implementación concreta para reportes en formato Excel."""

    @property
    def nombre_formato(self):
        return "Excel (.xlsx)"

    def generar(self):
        # En proyecto real usaría openpyxl o pandas
        encabezado_cols = "  PAQUETE          | DESTINO       | ESTADO"
        filas = [f"  {r['paquete']:<18}| {r['destino']:<14}| {r['estado']}"
                 for r in self.datos]
        return self.encabezado() + f"\n{encabezado_cols}\n" + "\n".join(filas)

    def enviar(self, destino):
        return f"📊 Excel guardado en: {destino}/reporte.xlsx"


# ── SUBCLASE CONCRETA 3: Reporte por Correo ─────────────────────
class ReporteEmail(ReporteBase):
    """Implementación concreta para envío por correo electrónico."""

    @property
    def nombre_formato(self):
        return "Correo Electrónico"

    def generar(self):
        resumen = f"Total de envíos: {len(self.datos)}\n"
        pendientes = sum(1 for r in self.datos if r['estado'] == "Pendiente")
        return self.encabezado() + f"\n  {resumen}  Pendientes: {pendientes}"

    def enviar(self, destino):
        return f"✉️  Correo enviado a: {destino}"


# ══════════════════ PROGRAMA PRINCIPAL ══════════════════
paquetes = [
    {"paquete": "PKT-001", "destino": "Hermosillo", "estado": "Entregado"},
    {"paquete": "PKT-002", "destino": "Nogales",    "estado": "En tránsito"},
    {"paquete": "PKT-003", "destino": "Guaymas",    "estado": "Pendiente"},
]

# Creamos los tres tipos de reporte
reportes = [
    ReportePDF  ("Envíos Sonora — Semana 18", paquetes),
    ReporteExcel("Envíos Sonora — Semana 18", paquetes),
    ReporteEmail("Envíos Sonora — Semana 18", paquetes),
]

# ABSTRACCIÓN + POLIMORFISMO: el mismo código funciona con cualquier tipo
for rep in reportes:
    print(rep.generar())
    print(rep.enviar("C:/reportes"))
    print()

# ── ¿Qué pasa si intentamos instanciar la clase abstracta? ──
# reporte = ReporteBase("X", [])   ← TypeError: Can't instantiate abstract class
# Python NO lo permite. ¡Eso es justamente la abstracción!

"""
inventario_tienda.py
====================
Sistema de Inventario para Tienda de Ropa.
Módulo principal — Versión 1.0

Autor: Nombre del Alumno
Materia: Programación Orientada a Objetos
Docente: Bernardo Prado Díaz
Fecha: Mayo 2026
"""

class Producto:
    """
    Representa un producto en el inventario de la tienda.

    Atributos:
        nombre (str): Nombre descriptivo del producto.
        precio_base (float): Precio antes de impuestos.
        stock (int): Unidades disponibles.

    Ejemplo:
        >>> p = Producto("Playera", 200.0, 10)
        >>> p.precio_con_iva()
        232.0
    """

    def precio_con_iva(self) -> float:
        """
        Calcula el precio total incluyendo IVA del 16%.

        Returns:
            float: Precio base más 16% de IVA.
        """
        return self.precio_base * 1.16

import flet as ft   # Importamos FLET con el alias "ft"

def main(page: ft.Page):
    """
    'page' es la VENTANA de la aplicación.
    Todo lo que pongas aquí aparecerá en pantalla.
    """
    page.title = "Mi Primera App FLET"    # Título de la ventana
    page.bgcolor = ft.colors.BLUE_GREY_50  # Color de fondo
    page.window_width = 500              # Ancho de la ventana en pixeles
    page.window_height = 400             # Alto de la ventana en pixeles

    # ft.Text crea un texto visible
    titulo = ft.Text(
        value="¡Hola, UTH! 🎓",           # El texto a mostrar
        size=32,                          # Tamaño de fuente
        color=ft.colors.BLUE_900,         # Color del texto
        weight=ft.FontWeight.BOLD         # Negrita
    )

    # ft.ElevatedButton crea un botón
    boton = ft.ElevatedButton(
        text="Presióname 👋",
        on_click=lambda e: page.add(   # on_click = qué hacer al presionar
            ft.Text("¡Botón presionado! 🎉", color=ft.colors.GREEN_700)
        )
    )

    # page.add() agrega componentes a la ventana
    page.add(
        ft.Column(                        # Column organiza elementos verticalmente
            controls=[titulo, boton],     # Lista de componentes
            horizontal_alignment=ft.CrossAxisAlignment.CENTER,
            spacing=20                   # Espacio entre elementos
        )
    )

# ft.app() inicia la aplicación y llama a la función main
ft.app(target=main)

-- Ejecuta este script en DBeaver o phpMyAdmin
-- Selecciona la BD 'pos_tienda' antes de ejecutar

USE pos_tienda;

-- Tabla de Categorías
CREATE TABLE categorias (
    id         INT AUTO_INCREMENT PRIMARY KEY,
    nombre     VARCHAR(100) NOT NULL,
    descripcion TEXT
);

-- Tabla de Productos
CREATE TABLE productos (
    id           INT AUTO_INCREMENT PRIMARY KEY,
    nombre       VARCHAR(150) NOT NULL,
    precio       DECIMAL(10,2) NOT NULL,
    stock        INT DEFAULT 0,
    id_categoria INT,
    codigo_barra VARCHAR(50),
    FOREIGN KEY (id_categoria) REFERENCES categorias(id)
);

-- Tabla de Clientes
CREATE TABLE clientes (
    id       INT AUTO_INCREMENT PRIMARY KEY,
    nombre   VARCHAR(150) NOT NULL,
    telefono VARCHAR(20),
    email    VARCHAR(100)
);

-- Tabla de Ventas (encabezado)
CREATE TABLE ventas (
    id         INT AUTO_INCREMENT PRIMARY KEY,
    id_cliente INT,
    fecha      DATETIME DEFAULT NOW(),
    total      DECIMAL(10,2),
    FOREIGN KEY (id_cliente) REFERENCES clientes(id)
);

-- Tabla de Detalle de Venta
CREATE TABLE detalle_venta (
    id          INT AUTO_INCREMENT PRIMARY KEY,
    id_venta    INT,
    id_producto INT,
    cantidad    INT,
    precio_unit DECIMAL(10,2),
    FOREIGN KEY (id_venta) REFERENCES ventas(id),
    FOREIGN KEY (id_producto) REFERENCES productos(id)
);

-- Datos de prueba
INSERT INTO categorias (nombre) VALUES
    ('Abarrotes'), ('Bebidas'), ('Lácteos');

INSERT INTO productos (nombre, precio, stock, id_categoria) VALUES
    ('Arroz 1kg', 22.50, 100, 1),
    ('Refresco 600ml', 18.00, 60, 2),
    ('Leche 1L', 28.00, 40, 3);

import mysql.connector   # Importamos el conector de MySQL

class Conexion:
    """
    Clase que maneja la conexión a MySQL.
    Usamos el patrón Singleton para que solo haya UNA conexión.
    """
    _instancia = None

    def __new__(cls):
        if cls._instancia is None:
            cls._instancia = super().__new__(cls)
            cls._instancia._conectar()
        return cls._instancia

    def _conectar(self):
        # Establece la conexión con MySQL
        self.conn = mysql.connector.connect(
            host="localhost",      # El servidor (WampServer)
            user="root",           # Usuario MySQL
            password="tu_password",# Tu contraseña configurada
            database="pos_tienda"  # Nombre de la BD
        )
        self.cursor = self.conn.cursor(dictionary=True)
        # dictionary=True → los resultados vienen como dicts {col: valor}

    def ejecutar(self, sql, params=None):
        # Ejecuta una instrucción SQL (INSERT, UPDATE, DELETE)
        self.cursor.execute(sql, params)
        self.conn.commit()         # Guarda los cambios en la BD

    def consultar(self, sql, params=None):
        # Ejecuta un SELECT y retorna los resultados
        self.cursor.execute(sql, params)
        return self.cursor.fetchall()  # Lista de diccionarios

    def cerrar(self):
        self.cursor.close()
        self.conn.close()
        Conexion._instancia = None   # Limpia el singleton

from database import Conexion

class ProductoDAO:
    """
    DAO (Data Access Object) para la tabla 'productos'.
    TODA la lógica de base de datos de productos va aquí.
    Principio de Responsabilidad Única (SOLID-S):
    esta clase solo se encarga de acceso a datos.
    """

    def __init__(self):
        self.db = Conexion()   # Obtenemos la conexión (singleton)

    def obtener_todos(self):
        # SELECT: obtiene todos los productos
        sql = "SELECT p.id, p.nombre, p.precio, p.stock, c.nombre AS categoria FROM productos p LEFT JOIN categorias c ON p.id_categoria = c.id"
        return self.db.consultar(sql)

    def insertar(self, nombre, precio, stock, id_categoria):
        # INSERT: agrega un nuevo producto
        # Usamos %s como marcadores de posición (evita SQL Injection)
        sql = "INSERT INTO productos (nombre, precio, stock, id_categoria) VALUES (%s, %s, %s, %s)"
        self.db.ejecutar(sql, (nombre, precio, stock, id_categoria))

    def actualizar(self, id_prod, nombre, precio, stock):
        # UPDATE: modifica un producto existente
        sql = "UPDATE productos SET nombre=%s, precio=%s, stock=%s WHERE id=%s"
        self.db.ejecutar(sql, (nombre, precio, stock, id_prod))

    def eliminar(self, id_prod):
        # DELETE: elimina un producto por ID
        sql = "DELETE FROM productos WHERE id = %s"
        self.db.ejecutar(sql, (id_prod,))   # Nota la coma: es una tupla

    def buscar_por_nombre(self, texto):
        sql = "SELECT * FROM productos WHERE nombre LIKE %s"
        return self.db.consultar(sql, (f"%{texto}%",))

import flet as ft
from producto_dao import ProductoDAO

def main(page: ft.Page):
    page.title = "🏪 POS Tienda Hermosillo"
    page.bgcolor = ft.colors.GREY_50
    page.window_width = 900
    page.window_height = 650
    page.window_center()

    dao = ProductoDAO()   # Creamos el DAO para acceder a la BD

    # ── Campos del formulario ──
    txt_nombre  = ft.TextField(label="Nombre del producto", expand=True)
    txt_precio  = ft.TextField(label="Precio ($)", width=150)
    txt_stock   = ft.TextField(label="Stock", width=100)
    id_seleccionado = [None]   # Lista para guardar el ID seleccionado

    # ── Tabla de datos ──
    tabla = ft.DataTable(
        columns=[
            ft.DataColumn(ft.Text("ID")),
            ft.DataColumn(ft.Text("Nombre")),
            ft.DataColumn(ft.Text("Precio")),
            ft.DataColumn(ft.Text("Stock")),
            ft.DataColumn(ft.Text("Categoría")),
        ],
        rows=[],   # Se llenará con datos de BD
        border=ft.border.all(1, ft.colors.GREY_300),
    )

    def cargar_productos(e=None):
        # Lee productos de MySQL y llena la tabla
        tabla.rows.clear()
        productos = dao.obtener_todos()
        for p in productos:
            tabla.rows.append(ft.DataRow(
                cells=[
                    ft.DataCell(ft.Text(str(p["id"]))),
                    ft.DataCell(ft.Text(p["nombre"])),
                    ft.DataCell(ft.Text(f"${p['precio']:.2f}")),
                    ft.DataCell(ft.Text(str(p["stock"]))),
                    ft.DataCell(ft.Text(p["categoria"] or "—")),
                ],
                on_select_changed=lambda e, prod=p: seleccionar(prod)
            ))
        page.update()   # Refresca la interfaz

    def seleccionar(prod):
        # Rellena el formulario con los datos del producto seleccionado
        txt_nombre.value  = prod["nombre"]
        txt_precio.value  = str(prod["precio"])
        txt_stock.value   = str(prod["stock"])
        id_seleccionado[0] = prod["id"]
        page.update()

    def guardar(e):
        if id_seleccionado[0]:
            # Si hay ID seleccionado → UPDATE
            dao.actualizar(id_seleccionado[0], txt_nombre.value,
                           float(txt_precio.value), int(txt_stock.value))
        else:
            # Si no → INSERT
            dao.insertar(txt_nombre.value, float(txt_precio.value),
                         int(txt_stock.value), 1)
        limpiar(None)
        cargar_productos()

    def eliminar(e):
        if id_seleccionado[0]:
            dao.eliminar(id_seleccionado[0])
            limpiar(None)
            cargar_productos()

    def limpiar(e):
        txt_nombre.value = txt_precio.value = txt_stock.value = ""
        id_seleccionado[0] = None
        page.update()

    # ── Botones ──
    btns = ft.Row([
        ft.ElevatedButton("💾 Guardar",  on_click=guardar,
                          bgcolor=ft.colors.BLUE_700, color=ft.colors.WHITE),
        ft.ElevatedButton("🗑 Eliminar", on_click=eliminar,
                          bgcolor=ft.colors.RED_700,  color=ft.colors.WHITE),
        ft.ElevatedButton("🔄 Refrescar",on_click=cargar_productos),
        ft.TextButton("✖ Limpiar", on_click=limpiar),
    ])

    # ── AppBar (barra superior) ──
    page.appbar = ft.AppBar(
        title=ft.Text("Sistema POS — Tienda Hermosillo", color=ft.colors.WHITE),
        bgcolor=ft.colors.BLUE_900
    )

    # ── Layout principal ──
    page.add(
        ft.Column([
            ft.Text("📦 Gestión de Productos", size=18, weight=ft.FontWeight.BOLD),
            ft.Row([txt_nombre, txt_precio, txt_stock]),
            btns,
            ft.Divider(),
            ft.Text("Haz clic en una fila para seleccionar", size=12, color=ft.colors.GREY_600),
            tabla,
        ], scroll=ft.ScrollMode.AUTO)
    )

    cargar_productos()   # Carga datos al iniciar la app

ft.app(target=main)

# 1. Crear el entorno virtual (ejecuta una sola vez)
python -m venv venv

# 2. Activarlo (cada vez que abras el proyecto)
venv\Scripts\activate          # Windows

# Verás el prefijo (venv) en el terminal, significa que está activo

# 3. Instalar librerías dentro del venv
pip install flet mysql-connector-python

# 4. Guardar lista de dependencias
pip freeze > requirements.txt

# 5. Para instalar en otro equipo:
pip install -r requirements.txt

# ── Estructura básica de try/except ──
try:
    # Código que PUEDE fallar va aquí
    numero = int(input("Ingresa un número: "))
    resultado = 100 / numero
    print(f"Resultado: {resultado}")

except ValueError:
    # Se ejecuta si el usuario escribe texto en lugar de número
    print("❌ Error: debes ingresar un número entero.")

except ZeroDivisionError:
    # Se ejecuta si el usuario escribe 0
    print("❌ Error: no se puede dividir entre cero.")

except Exception as e:
    # Captura CUALQUIER otro error inesperado
    print(f"❌ Error inesperado: {e}")

else:
    # Se ejecuta SOLO si NO hubo error
    print("✅ Operación exitosa.")

finally:
    # Se ejecuta SIEMPRE, haya o no error (útil para cerrar BD, archivos)
    print("ℹ️ Fin de la operación.")


# ── Excepciones personalizadas ──
class StockInsuficienteError(Exception):
    """Error propio de nuestra aplicación."""
    def __init__(self, producto, cantidad_pedida, stock_actual):
        self.producto = producto
        mensaje = (
            f"Stock insuficiente para '{producto}'. "
            f"Pedido: {cantidad_pedida}, Disponible: {stock_actual}"
        )
        super().__init__(mensaje)


class ProductoService:
    def vender(self, producto, cantidad, stock):
        if cantidad > stock:
            raise StockInsuficienteError(producto, cantidad, stock)
        return stock - cantidad


# Uso con manejo de la excepción propia:
svc = ProductoService()
try:
    nuevo_stock = svc.vender("Arroz 1kg", 50, 10)
except StockInsuficienteError as e:
    print(f"❌ {e}")   # Muestra el mensaje personalizado


# ── Excepciones en conexión MySQL ──
import mysql.connector

def conectar_bd():
    try:
        conn = mysql.connector.connect(
            host="localhost", user="root",
            password="pass", database="pos_tienda"
        )
        return conn
    except mysql.connector.Error as e:
        print(f"❌ No se pudo conectar a MySQL: {e}")
        return None

import unittest
from inventario_tienda import Producto, Ropa   # Importamos las clases a probar

class TestProducto(unittest.TestCase):
    """
    Clase de pruebas. Hereda de unittest.TestCase.
    Cada método que empiece con 'test_' es una prueba.
    """

    def setUp(self):
        # setUp() se ejecuta ANTES de cada prueba
        # Aquí creamos objetos que necesitaremos en las pruebas
        self.prod = Producto("Arroz", 20.0, 10)

    def test_precio_con_iva(self):
        # Verifica que el cálculo de IVA sea correcto
        resultado = self.prod.precio_con_iva()
        self.assertAlmostEqual(resultado, 23.2, places=2)

    def test_vender_exitoso(self):
        # Verifica que vender 3 unidades funcione
        resultado = self.prod.vender(3)
        self.assertIn("✅", resultado)         # Debe contener ✅
        self.assertEqual(self.prod.stock, 7)  # Stock debe quedar en 7

    def test_vender_stock_insuficiente(self):
        # Verifica que vender más del stock muestre error
        resultado = self.prod.vender(100)
        self.assertIn("❌", resultado)

    def test_precio_negativo_lanza_error(self):
        # Verifica que precio negativo lance ValueError
        with self.assertRaises(ValueError):
            self.prod.precio_base = -100   # Debe lanzar excepción

    def test_herencia_ropa(self):
        # Verifica que Ropa herede correctamente
        ropa = Ropa("Playera", 250.0, 5, "M", "Blanco")
        self.assertIsInstance(ropa, Producto)  # Ropa ES un Producto
        self.assertEqual(ropa.talla, "M")

    def tearDown(self):
        # tearDown() se ejecuta DESPUÉS de cada prueba (limpieza)
        pass


# Ejecutar pruebas:
if __name__ == "__main__":
    unittest.main(verbosity=2)   # verbosity=2 muestra detalle de cada prueba

mi_sistema_poo/
│
├── main.py              ← Punto de entrada de la aplicación
│
├── database/
│   ├── __init__.py
│   ├── conexion.py      ← Clase Singleton de conexión MySQL
│   └── script.sql       ← Script para crear la BD
│
├── models/              ← Clases del negocio (POO)
│   ├── __init__.py
│   ├── producto.py
│   ├── cliente.py
│   └── venta.py
│
├── dao/                 ← Clases DAO (acceso a BD)
│   ├── __init__.py
│   ├── producto_dao.py
│   ├── cliente_dao.py
│   └── venta_dao.py
│
├── ui/                  ← Vistas FLET
│   ├── __init__.py
│   ├── login_view.py
│   ├── menu_view.py
│   ├── productos_view.py
│   └── ventas_view.py
│
├── services/            ← Lógica del negocio (SOLID-S)
│   ├── __init__.py
│   └── venta_service.py
│
├── tests/               ← Pruebas unitarias
│   ├── __init__.py
│   ├── test_producto.py
│   └── test_venta.py
│
├── docs/                ← Documentación
│   ├── manual_usuario.pdf
│   ├── guia_instalacion.pdf
│   └── diagrama_clases.drawio
│
├── requirements.txt     ← pip freeze > requirements.txt
└── README.md            ← Descripción del proyecto

"""
Sistema de Administración — Proyecto Final POO
Universidad Tecnológica de Hermosillo
Materia: Programación Orientada a Objetos
Docente: Bernardo Prado Díaz
Alumno: [Tu Nombre]
Fecha: Mayo–Agosto 2026
"""

import flet as ft
from ui.login_view import LoginView
from ui.menu_view import MenuView
from database.conexion import Conexion

def main(page: ft.Page):
    page.title = "Sistema de Administración UTH"
    page.bgcolor = ft.colors.BLUE_GREY_50
    page.window_width = 1200
    page.window_height = 750
    page.window_center()

    def ir_a_menu(usuario):
        # Función para navegar del login al menú principal
        page.clean()
        page.add(MenuView(page, usuario))
        page.update()

    try:
        db = Conexion()    # Verificamos la conexión a BD al iniciar
        page.add(LoginView(page, ir_a_menu))
    except Exception as e:
        # Si no hay conexión, mostramos error en vez de colapsar
        page.add(ft.Column([
            ft.Icon(ft.icons.ERROR_OUTLINE, size=60, color=ft.colors.RED),
            ft.Text("No se pudo conectar a la base de datos", size=20),
            ft.Text(str(e), size=13, color=ft.colors.GREY_600),
            ft.ElevatedButton("Reintentar", on_click=lambda _: page.clean()),
        ], horizontal_alignment=ft.CrossAxisAlignment.CENTER))

    page.update()

ft.app(target=main)

# 🏢 Sistema de Administración [Nombre del Negocio]

## Descripción
Sistema de gestión desarrollado como proyecto final de la asignatura
**Programación Orientada a Objetos** en la Universidad Tecnológica de Hermosillo.

**Alumno:** [Tu Nombre]
**Docente:** Bernardo Prado Díaz
**Periodo:** Mayo–Agosto 2026
**Carrera:** TIID

## Tecnologías
- Python 3.12+
- FLET (GUI)
- MySQL / WampServer 3.3.7
- DBeaver 25.1.0
- Git

## Características
- ✅ CRUD completo de productos y clientes
- ✅ Módulo de ventas con reportes
- ✅ Autenticación de usuarios
- ✅ Manejo de excepciones personalizado
- ✅ Pruebas unitarias

## Instalación
1. Clonar: `git clone [URL]`
2. Activar venv: `venv\Scripts\activate`
3. Instalar: `pip install -r requirements.txt`
4. Ejecutar SQL: abrir `database/script.sql` en DBeaver
5. Configurar contraseña en `database/conexion.py`
6. Ejecutar: `python main.py`

## Estructura del Proyecto
[ver documentación técnica en /docs]