Fechas por restaurante

"""Zona horaria por país y por local — la copia didáctica de shared/timezone.py de m-b-core.

Prioridad (guideline 6 de CLAUDE.md): Ubigeo.ZonaHoraria primero; el país solo
como fallback; nunca asumir por país cuando hay dato (México y Brasil tienen
varias zonas).
"""

from __future__ import annotations

from datetime import date, datetime
from zoneinfo import ZoneInfo

COUNTRY_TIMEZONES: dict[str, str] = {
    "AR": "America/Argentina/Buenos_Aires",
    "BO": "America/La_Paz",
    "BR": "America/Sao_Paulo",
    "CL": "America/Santiago",
    "CO": "America/Bogota",
    "EC": "America/Guayaquil",
    "MX": "America/Mexico_City",
    "PE": "America/Lima",
}

# Se usa cuando falta el país o no lo conocemos. Lima es el mercado más grande.
DEFAULT_TIMEZONE = "America/Lima"


def today_in_country(country_code: str) -> date:
    """Fecha de hoy en la zona del país (fallback por país)."""
    tz_name = COUNTRY_TIMEZONES.get(country_code.upper(), DEFAULT_TIMEZONE)
    return datetime.now(ZoneInfo(tz_name)).date()


def today_for_venue(zona_horaria: str | None, pais: str | None) -> date:
    """Fecha de hoy en la zona del local: ZonaHoraria → país → default."""
    if zona_horaria:
        tz_name = zona_horaria
    elif pais:
        tz_name = COUNTRY_TIMEZONES.get(pais.upper(), DEFAULT_TIMEZONE)
    else:
        tz_name = DEFAULT_TIMEZONE
    return datetime.now(ZoneInfo(tz_name)).date()

"""Resolución de zona horaria y "ahora" del restaurante.

Prioridad:
    1. Ubigeo.ZonaHoraria (string IANA de la BD, por restaurante)
    2. País (solo para datos legacy sin Ubigeo)

Los horarios (Reserva.Horario, ProgramacionReserva.HoraInicio) están guardados
en hora local del restaurante, SIN zona. Por eso `now_local()` devuelve un
datetime naive: para comparar naive contra naive en el mismo marco. Es una
decisión de m-b-core (availability_engine/timezones.py:47-50); tiene un
coste, ver `now_local_aware` y la práctica.
"""

from __future__ import annotations

from datetime import datetime
from zoneinfo import ZoneInfo

from shared.timezone import COUNTRY_TIMEZONES

from .models import DEFAULT_TIMEZONE


def tz_for(zona_horaria: str | None = None, pais: str | None = None) -> str:
    """IANA tz del restaurante: primero Ubigeo.ZonaHoraria, luego país, luego default."""
    if zona_horaria:
        return zona_horaria
    if pais:
        return COUNTRY_TIMEZONES.get(pais.upper(), DEFAULT_TIMEZONE)
    return DEFAULT_TIMEZONE


def now_local(zona_horaria: str | None = None, pais: str | None = None) -> datetime:
    """'Ahora' en la pared del restaurante, NAIVE (como m-b-core).

    Úsalo solo para comparar con horarios naive del legacy (Reserva.Horario).
    """
    tz = ZoneInfo(tz_for(zona_horaria, pais))
    return datetime.now(tz).replace(tzinfo=None)


def now_local_aware(zona_horaria: str | None = None, pais: str | None = None) -> datetime:
    """'Ahora' en la zona del restaurante, AWARE (lleva tzinfo).

    Úsalo para todo lo demás: guardar, comparar entre locales, calcular
    diferencias, serializar. Un aware nunca se confunde con un UTC naive.
    """
    return datetime.now(ZoneInfo(tz_for(zona_horaria, pais)))

from __future__ import annotations

from datetime import datetime

import pytest
from freezegun import freeze_time

from services.api.app.availability_engine.timezones import now_local, now_local_aware, tz_for


@pytest.mark.parametrize(
    "zona, pais, esperado",
    [
        ("America/Lima", "PE", "America/Lima"),
        (None, "CL", "America/Santiago"),  # fallback por país
        ("", "EC", "America/Guayaquil"),  # cadena vacía = falta
        ("America/Cancun", "MX", "America/Cancun"),  # Ubigeo gana al país
        (None, "MX", "America/Mexico_City"),  # sin Ubigeo, México cae a la capital
        (None, None, "America/Lima"),  # default
        (None, "XX", "America/Lima"),  # país desconocido → default
    ],
)
def test_tz_for(zona: str | None, pais: str | None, esperado: str):
    assert tz_for(zona, pais) == esperado


@freeze_time("2026-08-18 00:30:00")  # UTC — en Lima son las 19:30 del 17
def test_now_local_es_naive_y_en_la_pared_de_lima():
    ahora = now_local("America/Lima")
    assert ahora.tzinfo is None
    assert ahora == datetime(2026, 8, 17, 19, 30)


@freeze_time("2026-08-18 00:30:00")
def test_now_local_aware_lleva_la_zona():
    ahora = now_local_aware(None, "CL")
    assert ahora.tzinfo is not None
    assert (ahora.hour, ahora.day) == (20, 17)  # Santiago en agosto: UTC-4
    offset = ahora.utcoffset()
    assert offset is not None and offset.total_seconds() == -4 * 3600

"""Reglas puras de disponibilidad. Reciben `ahora` explícito: nunca lo calculan.

Guideline 2 de m-b-core: cada regla es una función pura con entradas explícitas.
Guideline 6: la zona es la del restaurante. Si una función necesita "ahora",
lo recibe por parámetro; el que la llama decide (y el test también).
"""

from __future__ import annotations

from datetime import date, datetime, timedelta

from services.api.app.availability_engine.models import MINUTES_PER_SLOT, Horario, Local
from services.api.app.availability_engine.timezones import tz_for

ANTICIPACION_MINUTOS = 60  # una reserva necesita al menos 1 h de anticipación


def es_hoy(local: Local, fecha: date, ahora: datetime) -> bool:
    """¿`fecha` es "hoy" para este restaurante?

    `ahora` debe ser un datetime NAIVE en la pared del restaurante (now_local)
    o AWARE en cualquier zona: si es aware lo convertimos a la zona del local.
    """
    if ahora.tzinfo is not None:
        from zoneinfo import ZoneInfo

        ahora = ahora.astimezone(ZoneInfo(tz_for(local.zona_horaria, local.pais)))
    return ahora.date() == fecha

"""Tests puros: `ahora` se inyecta. Nada de datetime.now() dentro del test."""

from __future__ import annotations

from datetime import UTC, date, datetime
from zoneinfo import ZoneInfo

import pytest

from services.api.app.availability_engine.models import Horario, Local
from services.api.app.disponibilidad.rules import es_hoy, slots_disponibles

LIMA = Local(id=11, nombre="Lima", pais="PE", zona_horaria="America/Lima")
SANTIAGO = Local(id=873, nombre="Santiago", pais="CL", zona_horaria=None)  # fallback por país
QUITO = Local(id=2246, nombre="Quito", pais="EC", zona_horaria="America/Guayaquil")
CANCUN = Local(id=9001, nombre="Cancún", pais="MX", zona_horaria="America/Cancun")
CDMX = Local(id=9002, nombre="CDMX", pais="MX", zona_horaria=None)  # país → Mexico_City


# --- la trampa de las 19:00 -------------------------------------------------
# 2026-08-17 19:30 en Lima  ==  2026-08-18 00:30 en UTC.
# Un servidor en UTC que pregunte "¿qué día es hoy?" con datetime.now() dice 18.
LIMA_1930 = datetime(2026, 8, 17, 19, 30, tzinfo=ZoneInfo("America/Lima"))


def test_a_las_1930_de_lima_todavia_es_17_para_lima():
    assert es_hoy(LIMA, date(2026, 8, 17), LIMA_1930) is True


def test_el_mismo_instante_en_utc_ya_es_18_pero_es_hoy_convierte():
    mismo_instante_utc = LIMA_1930.astimezone(UTC)
    assert mismo_instante_utc.date() == date(2026, 8, 18)  # UTC "cree" que es mañana
    assert es_hoy(LIMA, date(2026, 8, 17), mismo_instante_utc) is True  # la regla no


def test_naive_utc_como_si_fuera_lima_da_la_respuesta_equivocada():
    # Lo que pasa en el motor si alguien pasa datetime.now() naive desde Cloud Run (UTC):
    naive_utc = LIMA_1930.astimezone(UTC).replace(tzinfo=None)  # 2026-08-18 00:30, sin zona
    assert es_hoy(LIMA, date(2026, 8, 17), naive_utc) is False  # BUG reproducido a propósito

def _parse_hhmm(hhmm: str, fecha: date) -> datetime:
    h, m = int(hhmm[:2]), int(hhmm[3:5])
    return datetime(fecha.year, fecha.month, fecha.day, h, m)


def slots_disponibles(local: Local, horario: Horario, ahora: datetime) -> list[str]:
    """Slots 'HH:MM' cada MINUTES_PER_SLOT entre apertura y cierre.

    Si `horario.fecha` es hoy para el restaurante, se descartan los slots que
    ya pasaron o que no llegan a ANTICIPACION_MINUTOS. Fechas futuras: todos.
    (Decisión de m-b-core: Anticipacion solo aplica a "hoy".)
    """
    if ahora.tzinfo is not None:
        from zoneinfo import ZoneInfo

        ahora = ahora.astimezone(ZoneInfo(tz_for(local.zona_horaria, local.pais))).replace(
            tzinfo=None
        )
    inicio = _parse_hhmm(horario.apertura, horario.fecha)
    fin = _parse_hhmm(horario.cierre, horario.fecha)
    hoy = ahora.date() == horario.fecha
    limite = ahora + timedelta(minutes=ANTICIPACION_MINUTOS)

    slots: list[str] = []
    t = inicio
    while t < fin:
        if not hoy or t >= limite:
            slots.append(t.strftime("%H:%M"))
        t += timedelta(minutes=MINUTES_PER_SLOT)
    return slots

HORARIO_HOY = Horario(apertura="12:00", cierre="14:00", fecha=date(2026, 8, 17))


def test_futuro_devuelve_todos_los_slots():
    ahora = datetime(2026, 8, 10, 9, 0)  # naive, pared de Lima, una semana antes
    slots = slots_disponibles(LIMA, HORARIO_HOY, ahora)
    assert slots == ["12:00", "12:15", "12:30", "12:45", "13:00", "13:15", "13:30", "13:45"]


def test_hoy_descarta_lo_que_no_llega_a_la_anticipacion():
    ahora = datetime(2026, 8, 17, 12, 20)  # naive, pared de Lima
    slots = slots_disponibles(LIMA, HORARIO_HOY, ahora)
    assert slots == ["13:30", "13:45"]  # 13:20 es el límite (12:20 + 60 min)


def test_hoy_con_ahora_aware_en_utc_se_convierte_a_la_pared_del_local():
    ahora_utc = datetime(2026, 8, 17, 17, 20, tzinfo=UTC)  # = 12:20 Lima
    assert slots_disponibles(LIMA, HORARIO_HOY, ahora_utc) == ["13:30", "13:45"]

# --- varias zonas, un instante ------------------------------------------------
INSTANTE = datetime(2026, 8, 18, 4, 30, tzinfo=UTC)  # 23:30 Lima/Quito, 00:30 Santiago (invierno CL)


@pytest.mark.parametrize(
    "local, esperado",
    [
        (LIMA, date(2026, 8, 17)),  # UTC-5
        (QUITO, date(2026, 8, 17)),  # UTC-5
        (SANTIAGO, date(2026, 8, 18)),  # UTC-4 en agosto → ya es mañana
        (CANCUN, date(2026, 8, 17)),  # UTC-5 fijo (Quintana Roo, sin DST)
        (CDMX, date(2026, 8, 17)),  # UTC-6
    ],
)
def test_que_dia_es_depende_del_restaurante(local: Local, esperado: date):
    assert es_hoy(local, esperado, INSTANTE) is True


# --- Santiago: verano vs invierno -----------------------------------------------
@pytest.mark.parametrize(
    "instante_utc, hora_pared",
    [
        (datetime(2026, 8, 17, 12, 0, tzinfo=UTC), "08:00"),  # agosto: UTC-4
        (datetime(2026, 12, 17, 12, 0, tzinfo=UTC), "09:00"),  # diciembre: UTC-3 (DST)
    ],
)
def test_santiago_cambia_de_offset_por_horario_de_verano(instante_utc: datetime, hora_pared: str):
    local_dt = instante_utc.astimezone(ZoneInfo("America/Santiago"))
    assert local_dt.strftime("%H:%M") == hora_pared

def test_comparar_aware_con_naive_explota_y_eso_es_bueno():
    aware = datetime(2026, 8, 17, 12, 0, tzinfo=ZoneInfo("America/Lima"))
    naive = datetime(2026, 8, 17, 12, 0)
    with pytest.raises(TypeError):
        _ = aware < naive

[tool.ruff.lint]
select = ["E", "W", "F", "I", "B", "C4", "UP", "DTZ"]   # ← DTZ nuevo

"""Ejemplo a propósito de lo que ruff DTZ debe atrapar. Se borra después."""

from datetime import date, datetime, timedelta


def hoy_del_servidor() -> date:
    return date.today()  # ¿hoy dónde? En Cloud Run: en Londres.


def ahora_del_servidor() -> datetime:
    return datetime.now()  # naive, UTC en prod, tu laptop en dev


def ahora_lima_a_ojo() -> datetime:
    return datetime.utcnow() + timedelta(hours=-5)  # libro/reservation_detail.py:891