Vigía de vencimientos

class Aviso(SQLModel, table=True):
    """Registro de avisos enviados. Es lo que hace idempotente al vigía."""

    id: int | None = Field(default=None, primary_key=True)
    lote_id: int = Field(foreign_key="lote.id")
    tipo: str  # "vence_30d", "vence_7d", "vencido"
    enviado_en: datetime


class Latido(SQLModel, table=True):
    """Última corrida de cada proceso automático. Un registro por proceso."""

    id: int | None = Field(default=None, primary_key=True)
    proceso: str = Field(unique=True)
    ultima_corrida: datetime
    detalle: str | None = None

"""Canales por los que el vigía avisa. Todos cumplen el mismo protocolo: enviar(texto)."""

import os

import httpx


class NotificadorConsola:
    """Imprime el aviso. Sirve para desarrollo y para tests."""

    def enviar(self, texto: str) -> None:
        print(texto)


class TelegramNotificador:
    """Manda el aviso a un chat de Telegram usando la API HTTP del bot."""

    def __init__(self, token: str | None = None, chat_id: str | None = None, timeout: float = 10.0):
        self.token = token or os.environ["TELEGRAM_BOT_TOKEN"]
        self.chat_id = chat_id or os.environ["TELEGRAM_CHAT_ID"]
        self.timeout = timeout

    def enviar(self, texto: str) -> None:
        url = f"https://api.telegram.org/bot{self.token}/sendMessage"
        respuesta = httpx.post(
            url, json={"chat_id": self.chat_id, "text": texto}, timeout=self.timeout
        )
        respuesta.raise_for_status()

from datetime import timedelta

import pytest
from sqlmodel import select

from inventario import services
from inventario.models import Aviso, Latido
from inventario.vigia import enviar_con_reintentos, revisar_vencimientos


class NotificadorFalso:
    """Guarda lo que le piden enviar, sin mandar nada."""

    def __init__(self):
        self.enviados: list[str] = []

    def enviar(self, texto: str) -> None:
        self.enviados.append(texto)


class NotificadorQueFalla:
    """Falla las primeras `veces` llamadas y luego funciona."""

    def __init__(self, veces: int):
        self.veces = veces
        self.llamadas = 0

    def enviar(self, texto: str) -> None:
        self.llamadas += 1
        if self.llamadas <= self.veces:
            raise ConnectionError("Telegram no responde")


def _lab_con_lotes(session):
    hoy = services.hoy()
    ubi = services.crear_ubicacion(session, "Congelador -20 A")
    taq = services.crear_reactivo(session, "Taq polimerasa", "µL")
    etoh = services.crear_reactivo(session, "Etanol 96%", "mL")
    aga = services.crear_reactivo(session, "Agarosa", "g")
    services.agregar_lote(session, taq.id, ubi.id, "TAQ-2401", 500, hoy + timedelta(days=10))
    services.agregar_lote(session, etoh.id, ubi.id, "ETOH-2312", 2500, hoy + timedelta(days=20))
    services.agregar_lote(session, aga.id, ubi.id, "AGA-2405", 250, hoy + timedelta(days=200))


def test_avisa_solo_lotes_por_vencer(session):
    _lab_con_lotes(session)
    notificador = NotificadorFalso()
    avisados = revisar_vencimientos(session, notificador, dias=30)
    assert avisados == 2
    assert len(notificador.enviados) == 1
    assert "TAQ-2401" in notificador.enviados[0]
    assert "AGA-2405" not in notificador.enviados[0]


def test_es_idempotente_tres_corridas_un_mensaje(session):
    _lab_con_lotes(session)
    notificador = NotificadorFalso()
    resultados = [revisar_vencimientos(session, notificador, dias=30) for _ in range(3)]
    assert resultados == [2, 0, 0]
    assert len(notificador.enviados) == 1


def test_lote_nuevo_genera_aviso_nuevo_sin_repetir_los_viejos(session):
    _lab_con_lotes(session)
    notificador = NotificadorFalso()
    revisar_vencimientos(session, notificador, dias=30)
    services.agregar_lote(session, 1, 1, "TAQ-2402", 200, services.hoy() + timedelta(days=5))
    avisados = revisar_vencimientos(session, notificador, dias=30)
    assert avisados == 1
    assert len(notificador.enviados) == 2
    assert "TAQ-2402" in notificador.enviados[1]
    assert "ETOH-2312" not in notificador.enviados[1]


def test_sin_lotes_no_envia_pero_registra_latido(session):
    notificador = NotificadorFalso()
    assert revisar_vencimientos(session, notificador, dias=30) == 0
    assert notificador.enviados == []
    latido = session.exec(select(Latido).where(Latido.proceso == "vigia")).one()
    assert "lotes=0" in latido.detalle


def test_reintenta_con_espera_exponencial():
    notificador = NotificadorQueFalla(veces=2)
    esperas: list[float] = []
    intento = enviar_con_reintentos(
        notificador, "hola", intentos=5, espera_base=1.0, dormir=esperas.append
    )
    assert intento == 3
    assert esperas == [1.0, 2.0]


def test_reintentos_agotados_lanza_y_no_registra_aviso(session):
    _lab_con_lotes(session)
    notificador = NotificadorQueFalla(veces=99)
    with pytest.raises(ConnectionError):
        revisar_vencimientos(
            session, notificador, dias=30, intentos=3, espera_base=0, dormir=lambda s: None
        )
    assert notificador.llamadas == 3
    assert session.exec(select(Aviso)).all() == []

"""El vigía: revisa los lotes por vencer y avisa. Corre solo; nadie está mirando."""

import logging
import time
from collections.abc import Callable
from datetime import UTC, datetime
from typing import Protocol

from sqlmodel import Session, select

from inventario import services
from inventario.models import Aviso, Latido, Lote, Reactivo

log = logging.getLogger("inventario.vigia")


class Notificador(Protocol):
    def enviar(self, texto: str) -> None: ...


def enviar_con_reintentos(
    notificador: Notificador,
    texto: str,
    intentos: int = 5,
    espera_base: float = 1.0,
    dormir: Callable[[float], None] = time.sleep,
) -> int:
    """Intenta enviar hasta `intentos` veces con espera exponencial (1, 2, 4, 8… s).

    Devuelve el número del intento que funcionó. Si se agotan, relanza el último error.
    """
    for intento in range(1, intentos + 1):
        try:
            notificador.enviar(texto)
            return intento
        except Exception as exc:
            log.warning("envío falló (intento %d/%d): %s", intento, intentos, exc)
            if intento == intentos:
                raise
            dormir(espera_base * 2 ** (intento - 1))
    raise AssertionError("inalcanzable")


def formatear_aviso(session: Session, lotes: list[Lote], dias: int) -> str:
    lineas = [f"Reactivos que vencen en los próximos {dias} días:"]
    for lote in lotes:
        reactivo = session.get(Reactivo, lote.reactivo_id)
        lineas.append(
            f"- {lote.codigo} · {reactivo.nombre} · {lote.cantidad:g} {reactivo.unidad}"
            f" · vence {lote.vencimiento.isoformat()}"
        )
    return "\n".join(lineas)


def registrar_latido(session: Session, proceso: str, detalle: str) -> None:
    latido = session.exec(select(Latido).where(Latido.proceso == proceso)).first()
    ahora = datetime.now(UTC)
    if latido is None:
        latido = Latido(proceso=proceso, ultima_corrida=ahora, detalle=detalle)
    else:
        latido.ultima_corrida = ahora
        latido.detalle = detalle
    session.add(latido)
    session.commit()


def revisar_vencimientos(
    session: Session,
    notificador: Notificador,
    dias: int = 30,
    intentos: int = 5,
    espera_base: float = 1.0,
    dormir: Callable[[float], None] = time.sleep,
) -> int:
    """Avisa de los lotes que vencen en `dias` días y que aún no fueron avisados.

    Devuelve cuántos lotes se avisaron en esta corrida (0 si no había nada nuevo).
    Idempotente: correrla dos veces seguidas manda un solo aviso.
    """
    inicio = time.perf_counter()
    tipo = f"vence_{dias}d"

    lotes = services.lotes_por_vencer(session, dias)
    ya_avisados = set(session.exec(select(Aviso.lote_id).where(Aviso.tipo == tipo)))
    pendientes = [lote for lote in lotes if lote.id not in ya_avisados]

    if pendientes:
        texto = formatear_aviso(session, pendientes, dias)
        # Primero enviar, luego registrar. Si el proceso muere entre ambos, mañana
        # se repite el aviso: preferimos un duplicado a un silencio. Ver DECISIONES.md.
        enviar_con_reintentos(notificador, texto, intentos, espera_base, dormir)
        ahora = datetime.now(UTC)
        for lote in pendientes:
            session.add(Aviso(lote_id=lote.id, tipo=tipo, enviado_en=ahora))
        session.commit()

    duracion_ms = round((time.perf_counter() - inicio) * 1000)
    detalle = f"lotes={len(lotes)} nuevos={len(pendientes)} duracion_ms={duracion_ms}"
    registrar_latido(session, "vigia", detalle)
    log.info("vigia dias=%d %s", dias, detalle)
    return len(pendientes)

from datetime import datetime, timedelta, timezone

from sqlmodel import select

from inventario.models import Latido
from inventario.notificadores import NotificadorConsola, TelegramNotificador
from inventario.vigia import revisar_vencimientos


@app.command("vigia")
def vigia(
    dias: int = typer.Option(30, "--dias"),
    canal: str = typer.Option("consola", "--canal", help="consola | telegram"),
) -> None:
    """Revisa vencimientos y avisa una sola vez por lote. Pensado para correr solo, cada día."""
    notificador = TelegramNotificador() if canal == "telegram" else NotificadorConsola()
    with get_session() as s:
        avisados = revisar_vencimientos(s, notificador, dias=dias)
    typer.echo(f"avisados={avisados}")


@app.command("vigia-estado")
def vigia_estado(max_horas: int = typer.Option(26, "--max-horas")) -> None:
    """¿Sigue vivo el vigía? Muestra el latido y falla si es más viejo que --max-horas."""
    with get_session() as s:
        latido = s.exec(select(Latido).where(Latido.proceso == "vigia")).first()
    if latido is None:
        typer.echo("el vigía nunca corrió")
        raise typer.Exit(code=1)
    ultima = latido.ultima_corrida.replace(tzinfo=timezone.utc)
    edad = datetime.now(timezone.utc) - ultima
    typer.echo(
        f"última corrida {ultima.isoformat()} ({edad.total_seconds() / 3600:.1f} h) · {latido.detalle}"
    )
    if edad > timedelta(hours=max_horas):
        typer.echo("ALERTA: el vigía lleva demasiado sin correr")
        raise typer.Exit(code=2)

TELEGRAM_BOT_TOKEN=8123456789:AAF…
TELEGRAM_CHAT_ID=123456789

RUN uv sync --frozen
# El entorno que creó uv queda primero en el PATH: "inv" es el script instalado por pyproject
ENV PATH="/app/.venv/bin:$PATH"

CMD ["inv", "vigia"]

services:
  vigia:
    build: .
    command: ["inv", "vigia", "--canal", "consola"]
    environment:
      INVENTARIO_DB_URL: sqlite:////data/inventario.db
      INVENTARIO_TZ: America/Lima
    volumes:
      - datos:/data
volumes:
  datos:

# min hora día mes día-semana   comando
0 7 * * *  cd /Users/alexandra/inventario-lab && /usr/local/bin/docker run --rm -v "$PWD/inventario.db:/app/inventario.db" --env-file .env inventario inv vigia --canal telegram >> vigia.log 2>&1