PyMarket Fase 3: Servicios, Menús y Flujo Completo

[                                  ← ① El archivo completo es UNA LISTA
    {                              ← ② Cada usuario es UN DICCIONARIO
        "id": 1,                  ← ③ número, SIN comillas
        "nombre": "juan",
        "correo": "juan@gmail.com",
        "password": "1234",       ← texto, CON comillas
        "rol": "vendedor"
    },                             ← ④ coma separa los elementos
    {
        "id": 2,
        "nombre": "maria",
        "correo": "maria@gmail.com",
        "password": "abcd",
        "rol": "comprador"
    }
]

[
    {
        "id": 1,
        "nombre": "Audífonos Bluetooth",
        "categoria": "Tecnología",
        "precio": 85000.0,          ← decimal (float en Python)
        "stock": 10,                 ← entero (int en Python)
        "id_vendedor": 1             ← ⑤ ¡La conexión con usuarios.json!
    }
]

[
    {
        "id": 1,
        "id_comprador": 2,           ← apunta al usuario con id 2
        "nombre_comprador": "maria",
        "productos": [               ← ⑥ ¡una lista DENTRO del diccionario!
            {
                "id_producto": 1,
                "nombre": "Audífonos Bluetooth",
                "cantidad": 2,
                "precio_unitario": 85000.0,
                "subtotal": 170000.0
            }
        ],
        "total": 170000.0,
        "fecha": "2026-07-02 10:30:00"
    }
]

# ① Importamos la función que dibuja el menú principal
from menus.menu_principal import mostrar_menu_principal

# ② Este if es el "portero" del programa
if __name__ == "__main__":
    mostrar_menu_principal()   # ③ ← estas 4 espacios de indentación son OBLIGATORIOS

# ① Importamos de las DOS capas que este menú necesita
from services.auth_service import registrar_usuario, iniciar_sesion
from menus.menu_admin import menu_admin
from menus.menu_vendedor import menu_vendedor
from menus.menu_comprador import menu_comprador
from services.producto_service import listar_productos


def mostrar_menu_principal():
    while True:                        # ② ciclo infinito: el menú se repite hasta el break
        print("\n====================================")
        print("        PYMARKET CONSOLE")
        print("====================================")
        print("1. Registrarse")
        print("2. Iniciar sesión")
        print("3. Ver productos disponibles")
        print("4. Salir")

        opcion = input("Seleccione una opción: ")

        if opcion == "1":
            registrar_usuario()

        elif opcion == "2":
            usuario = iniciar_sesion()    # ③ recibimos el dict… o None

            if usuario:                   # ④ None se evalúa como False
                if usuario["rol"] == "admin":
                    menu_admin(usuario)   # ⑤ ¡le PASAMOS el usuario al menú!
                elif usuario["rol"] == "vendedor":
                    menu_vendedor(usuario)
                elif usuario["rol"] == "comprador":
                    menu_comprador(usuario)
            else:
                print("Credenciales incorrectas.")

        elif opcion == "3":
            listar_productos()            # cualquiera puede ver productos sin login

        elif opcion == "4":
            print("Gracias por usar PyMarket Console.")
            break                         # ⑥ única salida del while True

        else:
            print("Opción no válida.")

from utils.file_manager import leer_json, guardar_json

RUTA_USUARIOS = "data/usuarios.json"


def obtener_usuarios():
    """
    Retorna la lista completa de usuarios registrados.
    """                                    # ① docstring: documentación oficial de la función
    return leer_json(RUTA_USUARIOS)


def guardar_usuarios(usuarios):
    """
    Guarda la lista completa de usuarios en el archivo JSON.
    """
    guardar_json(RUTA_USUARIOS, usuarios)


def generar_id_usuario():
    """
    Genera un ID automático para un nuevo usuario.
    """
    usuarios = obtener_usuarios()

    if len(usuarios) == 0:
        return 1                        # si no hay nadie, el primero es el 1

    # ② busca el id MÁS ALTO y le suma 1
    ultimo_id = max(usuario["id"] for usuario in usuarios)
    return ultimo_id + 1


def buscar_usuario_por_correo(correo):
    """
    Busca un usuario por correo electrónico.
    Retorna el usuario si existe, de lo contrario retorna None.
    """
    usuarios = obtener_usuarios()

    for usuario in usuarios:
        # ③ .lower() vuelve todo minúsculas antes de comparar
        if usuario["correo"].lower() == correo.lower():
            return usuario

    return None


def crear_usuario(nombre, correo, password, rol):
    """
    Crea un nuevo usuario comprador o vendedor.
    """
    usuarios = obtener_usuarios()

    # ④ reutilizamos la función de arriba — sin import, mismo archivo
    if buscar_usuario_por_correo(correo) is not None:
        return False, "Ya existe un usuario con ese correo."

    nuevo_usuario = {
        "id": generar_id_usuario(),
        "nombre": nombre,
        "correo": correo,
        "password": password,
        "rol": rol
    }

    usuarios.append(nuevo_usuario)
    guardar_usuarios(usuarios)

    # ⑤ ¡devolvemos DOS valores a la vez!
    return True, "Usuario registrado correctamente."

from utils.file_manager import leer_json, guardar_json

RUTA_PRODUCTOS = "data/productos.json"


def listar_productos():
    productos = leer_json(RUTA_PRODUCTOS)

    print("\n===== PRODUCTOS DISPONIBLES =====")

    if len(productos) == 0:
        print("No hay productos publicados.")
        return                            # ① salida temprana: no hay nada que mostrar

    for producto in productos:
        if producto["stock"] > 0:       # ② solo mostramos lo que hay en bodega
            print("--------------------------------")
            print(f"ID: {producto['id']}")
            print(f"Nombre: {producto['nombre']}")
            print(f"Categoría: {producto['categoria']}")
            print(f"Precio: ${producto['precio']}")
            print(f"Stock: {producto['stock']}")


def crear_producto(usuario):              # ③ recibe al vendedor logueado como parámetro
    productos = leer_json(RUTA_PRODUCTOS)

    print("\n===== PUBLICAR PRODUCTO =====")

    nombre = input("Nombre del producto: ")
    categoria = input("Categoría: ")

    try:                                  # ④ input() da texto; lo convertimos a número
        precio = float(input("Precio: "))
        stock = int(input("Stock: "))
    except ValueError:
        print("Precio o stock inválido.")
        return

    if precio <= 0 or stock < 0:        # ⑤ regla de negocio, no de formato
        print("El precio debe ser mayor a 0 y el stock no puede ser negativo.")
        return

    nuevo_producto = {
        "id": generar_id_producto(productos),
        "nombre": nombre,
        "categoria": categoria,
        "precio": precio,
        "stock": stock,
        "id_vendedor": usuario["id"]    # ⑥ ¡aquí nace la relación entre archivos!
    }

    productos.append(nuevo_producto)
    guardar_json(RUTA_PRODUCTOS, productos)

    print("Producto publicado correctamente.")


def generar_id_producto(productos):
    if len(productos) == 0:
        return 1

    ultimo_id = max(producto["id"] for producto in productos)
    return ultimo_id + 1

def listar_mis_productos(usuario):
    productos = leer_json(RUTA_PRODUCTOS)

    # ⑦ list comprehension: filtra la lista en 4 líneas
    mis_productos = [
        producto for producto in productos
        if producto["id_vendedor"] == usuario["id"]
    ]

    print("\n===== MIS PRODUCTOS =====")

    if len(mis_productos) == 0:
        print("No tienes productos publicados.")
        return

    for producto in mis_productos:
        print("--------------------------------")
        print(f"ID: {producto['id']}")
        print(f"Nombre: {producto['nombre']}")
        print(f"Categoría: {producto['categoria']}")
        print(f"Precio: ${producto['precio']}")
        print(f"Stock: {producto['stock']}")


def buscar_producto_por_nombre():
    productos = leer_json(RUTA_PRODUCTOS)

    print("\n===== BUSCAR PRODUCTO =====")

    if len(productos) == 0:
        print("No hay productos registrados.")
        return

    nombre_busqueda = input("Ingrese el nombre del producto: ").lower()

    encontrados = []                      # lista vacía que iremos llenando

    for producto in productos:
        # ⑧ "in" pregunta si un texto está CONTENIDO en otro
        if nombre_busqueda in producto["nombre"].lower():
            encontrados.append(producto)

    if len(encontrados) == 0:
        print("No se encontraron productos.")
        return

    print("\n===== RESULTADOS =====")

    for producto in encontrados:
        print("--------------------------------")
        print(f"ID: {producto['id']}")
        print(f"Nombre: {producto['nombre']}")
        print(f"Categoría: {producto['categoria']}")
        print(f"Precio: ${producto['precio']}")
        print(f"Stock: {producto['stock']}")

def actualizar_producto(usuario):
    productos = leer_json(RUTA_PRODUCTOS)

    mis_productos = [
        producto for producto in productos
        if producto["id_vendedor"] == usuario["id"]
    ]

    print("\n===== ACTUALIZAR PRODUCTO =====")

    if len(mis_productos) == 0:
        print("No tienes productos para actualizar.")
        return

    listar_mis_productos(usuario)         # reutilizamos: mostrar antes de elegir

    try:
        id_producto = int(input("\nIngrese el ID del producto a actualizar: "))
    except ValueError:
        print("Debe ingresar un ID válido.")
        return

    # ⑨ patrón "buscar y quedarse con la referencia"
    producto_encontrado = None

    for producto in productos:
        if producto["id"] == id_producto and producto["id_vendedor"] == usuario["id"]:
            producto_encontrado = producto
            break                         # ya lo encontramos: no hay que seguir buscando

    if producto_encontrado is None:
        print("No se encontró un producto suyo con ese ID.")
        return

    print("\nDeje el campo vacío si no desea modificarlo.")

    # ⑩ mostramos el valor actual entre paréntesis como pista
    nuevo_nombre = input(f"Nuevo nombre ({producto_encontrado['nombre']}): ")
    nueva_categoria = input(f"Nueva categoría ({producto_encontrado['categoria']}): ")
    nuevo_precio = input(f"Nuevo precio ({producto_encontrado['precio']}): ")
    nuevo_stock = input(f"Nuevo stock ({producto_encontrado['stock']}): ")

    if nuevo_nombre != "":                # ⑪ vacío = "no quiero cambiarlo"
        producto_encontrado["nombre"] = nuevo_nombre

    if nueva_categoria != "":
        producto_encontrado["categoria"] = nueva_categoria

    if nuevo_precio != "":
        try:
            nuevo_precio = float(nuevo_precio)
            if nuevo_precio <= 0:
                print("El precio debe ser mayor a 0.")
                return
            producto_encontrado["precio"] = nuevo_precio
        except ValueError:
            print("Precio inválido.")
            return

    if nuevo_stock != "":
        try:
            nuevo_stock = int(nuevo_stock)
            if nuevo_stock < 0:
                print("El stock no puede ser negativo.")
                return
            producto_encontrado["stock"] = nuevo_stock
        except ValueError:
            print("Stock inválido.")
            return

    guardar_json(RUTA_PRODUCTOS, productos)  # ⑫ guardamos la lista COMPLETA

    print("Producto actualizado correctamente.")


def eliminar_producto(usuario):
    productos = leer_json(RUTA_PRODUCTOS)

    mis_productos = [
        producto for producto in productos
        if producto["id_vendedor"] == usuario["id"]
    ]

    print("\n===== ELIMINAR PRODUCTO =====")

    if len(mis_productos) == 0:
        print("No tienes productos para eliminar.")
        return

    listar_mis_productos(usuario)

    try:
        id_producto = int(input("\nIngrese el ID del producto a eliminar: "))
    except ValueError:
        print("Debe ingresar un ID válido.")
        return

    producto_encontrado = None

    for producto in productos:
        if producto["id"] == id_producto and producto["id_vendedor"] == usuario["id"]:
            producto_encontrado = producto
            break

    if producto_encontrado is None:
        print("No se encontró un producto suyo con ese ID.")
        return

    # ⑬ pedir confirmación antes de una acción destructiva
    confirmacion = input(
        f"¿Está seguro de eliminar el producto '{producto_encontrado['nombre']}'? (s/n): "
    ).lower()

    if confirmacion == "s":
        productos.remove(producto_encontrado)   # ⑭ saca el elemento de la lista
        guardar_json(RUTA_PRODUCTOS, productos)
        print("Producto eliminado correctamente.")
    else:
        print("Eliminación cancelada.")

# ① import multilínea: paréntesis para no hacer una línea kilométrica
from services.producto_service import (
    crear_producto,
    listar_mis_productos,
    actualizar_producto,
    eliminar_producto
)


def menu_vendedor(usuario):              # ② recibe el dict que envió menu_principal
    while True:
        print("\n========== MENÚ VENDEDOR ==========")
        print(f"Bienvenido vendedor: {usuario['nombre']}")
        print("1. Publicar producto")
        print("2. Ver mis productos")
        print("3. Actualizar producto")
        print("4. Eliminar producto")
        print("5. Cerrar sesión")

        opcion = input("Seleccione una opción: ")

        if opcion == "1":
            crear_producto(usuario)       # ③ el usuario sigue viajando hacia abajo

        elif opcion == "2":
            listar_mis_productos(usuario)

        elif opcion == "3":
            actualizar_producto(usuario)

        elif opcion == "4":
            eliminar_producto(usuario)

        elif opcion == "5":
            print("Sesión cerrada correctamente.")
            break                         # ④ vuelve al menú principal, NO cierra el programa

        else:
            print("Opción no válida. Intente nuevamente.")

from utils.file_manager import leer_json, guardar_json
from datetime import datetime          # ① librería estándar para fechas y horas

RUTA_PRODUCTOS = "data/productos.json"
RUTA_VENTAS = "data/ventas.json"       # este servicio usa DOS archivos


def agregar_al_carrito(carrito):        # ② recibe la lista que vive en el menú
    productos = leer_json(RUTA_PRODUCTOS)

    if len(productos) == 0:
        print("No hay productos disponibles.")
        return

    print("\n===== AGREGAR PRODUCTO AL CARRITO =====")

    try:
        id_producto = int(input("Ingrese el ID del producto: "))
        cantidad = int(input("Ingrese la cantidad: "))
    except ValueError:
        print("Debe ingresar valores numéricos.")
        return

    producto_encontrado = None            # el patrón de búsqueda que ya conoces

    for producto in productos:
        if producto["id"] == id_producto:
            producto_encontrado = producto
            break

    if producto_encontrado is None:
        print("Producto no encontrado.")
        return

    if cantidad <= 0:
        print("La cantidad debe ser mayor a cero.")
        return

    if cantidad > producto_encontrado["stock"]:   # ③ no vender lo que no hay
        print("No hay suficiente stock disponible.")
        return

    # ④ el item del carrito es un diccionario NUEVO, hecho a la medida
    item_carrito = {
        "id_producto": producto_encontrado["id"],
        "nombre": producto_encontrado["nombre"],
        "cantidad": cantidad,
        "precio_unitario": producto_encontrado["precio"],
        "subtotal": cantidad * producto_encontrado["precio"]
    }

    carrito.append(item_carrito)         # ⑤ modificamos la lista del menú ¡sin return!

    print("Producto agregado al carrito correctamente.")


def ver_carrito(carrito):
    print("\n===== CARRITO DE COMPRAS =====")

    if len(carrito) == 0:
        print("El carrito está vacío.")
        return

    total = 0                             # ⑥ acumulador: arranca en 0 y crece

    for item in carrito:
        print("--------------------------------")
        print(f"Producto: {item['nombre']}")
        print(f"Cantidad: {item['cantidad']}")
        print(f"Precio unitario: ${item['precio_unitario']}")
        print(f"Subtotal: ${item['subtotal']}")

        total += item["subtotal"]        # total = total + subtotal

    print("--------------------------------")
    print(f"TOTAL A PAGAR: ${total}")

def realizar_compra(usuario, carrito):  # recibe DOS argumentos
    if len(carrito) == 0:
        print("No puede realizar una compra con el carrito vacío.")
        return

    productos = leer_json(RUTA_PRODUCTOS)
    ventas = leer_json(RUTA_VENTAS)

    # ⑦ Validación por si ventas.json está como {} o vacío mal estructurado
    if not isinstance(ventas, list):
        ventas = []

    total = 0

    for item in carrito:
        total += item["subtotal"]

    nueva_venta = {
        "id": len(ventas) + 1,
        "id_comprador": usuario["id"],
        "nombre_comprador": usuario["nombre"],
        "productos": carrito.copy(),      # ⑧ una COPIA, no la lista original
        "total": total,
        "fecha": datetime.now().strftime("%Y-%m-%d %H:%M:%S")  # ⑨
    }

    # ⑩ for anidado: por cada item del carrito, buscar su producto y descontar
    for item in carrito:
        for producto in productos:
            if producto["id"] == item["id_producto"]:
                producto["stock"] -= item["cantidad"]

    ventas.append(nueva_venta)

    guardar_json(RUTA_VENTAS, ventas)     # ⑪ persistimos LOS DOS archivos
    guardar_json(RUTA_PRODUCTOS, productos)

    carrito.clear()                       # ⑫ vaciar el carrito tras comprar

    print("\nCompra realizada correctamente.")
    print(f"Total pagado: ${total}")


def ver_historial_compras(usuario):
    ventas = leer_json(RUTA_VENTAS)

    compras_usuario = [                   # filtrar MIS compras: comprehension otra vez
        venta for venta in ventas
        if venta["id_comprador"] == usuario["id"]
    ]

    print("\n===== HISTORIAL DE COMPRAS =====")

    if len(compras_usuario) == 0:
        print("No tienes compras registradas.")
        return

    for venta in compras_usuario:
        print("--------------------------------")
        print(f"ID venta: {venta['id']}")
        print(f"Fecha: {venta['fecha']}")
        print(f"Total: ${venta['total']}")
        print("Productos:")

        for producto in venta["productos"]:   # ⑬ for dentro del for: lista anidada
            print(
                f"- {producto['nombre']} | "
                f"Cantidad: {producto['cantidad']} | "
                f"Subtotal: ${producto['subtotal']}"
            )

from services.producto_service import listar_productos, buscar_producto_por_nombre
from services.venta_service import agregar_al_carrito, ver_carrito, realizar_compra, ver_historial_compras


def menu_comprador(usuario):
    carrito = []                          # ① nace ANTES del while → sobrevive cada vuelta

    while True:
        print("\n========== MENÚ COMPRADOR ==========")
        print("1. Ver productos disponibles")
        print("2. Buscar producto por nombre")
        print("3. Agregar producto al carrito")
        print("4. Ver carrito")
        print("5. Realizar compra")
        print("6. Ver historial de compras")
        print("7. Cerrar sesión")

        opcion = input("Seleccione una opción: ")

        if opcion == "1":
            listar_productos()

        elif opcion == "2":
            buscar_producto_por_nombre()

        elif opcion == "3":
            agregar_al_carrito(carrito)   # ② la MISMA lista viaja a cada función

        elif opcion == "4":
            ver_carrito(carrito)

        elif opcion == "5":
            realizar_compra(usuario, carrito)  # ③ dos argumentos: quién y qué

        elif opcion == "6":
            ver_historial_compras(usuario)

        elif opcion == "7":
            print("Sesión cerrada correctamente.")
            break                         # ④ al salir, el carrito muere con la función

        else:
            print("Opción no válida. Intente nuevamente.")

from utils.file_manager import leer_json, guardar_json

RUTA_USUARIOS = "data/usuarios.json"   # ① el admin usa LOS TRES archivos
RUTA_PRODUCTOS = "data/productos.json"
RUTA_VENTAS = "data/ventas.json"


def ver_usuarios():
    usuarios = leer_json(RUTA_USUARIOS)

    print("\n===== USUARIOS REGISTRADOS =====")

    if len(usuarios) == 0:
        print("No hay usuarios registrados.")
        return

    for usuario in usuarios:              # ② SIN filtro: los ve todos
        print("--------------------------------")
        print(f"ID: {usuario['id']}")
        print(f"Nombre: {usuario['nombre']}")
        print(f"Correo: {usuario['correo']}")
        print(f"Rol: {usuario['rol']}")      # nota: NUNCA imprimimos el password


def ver_ventas_generales():
    ventas = leer_json(RUTA_VENTAS)

    print("\n===== VENTAS GENERALES =====")

    if len(ventas) == 0:
        print("No hay ventas registradas.")
        return

    total_general = 0                     # ③ acumulador sobre TODAS las ventas

    for venta in ventas:
        print("--------------------------------")
        print(f"ID venta: {venta['id']}")
        print(f"Comprador: {venta['nombre_comprador']}")
        print(f"Fecha: {venta['fecha']}")
        print(f"Total venta: ${venta['total']}")

        for producto in venta["productos"]:
            print(f"- {producto['nombre']} | Cantidad: {producto['cantidad']}")

        total_general += venta["total"]

    print("--------------------------------")
    print(f"TOTAL GENERAL DE VENTAS: ${total_general}")