"""Simulador de viajes refrigerados de BITLogística (datos sintéticos).

Lo usa solo el Caso práctico 1 del capítulo. Genera, minuto a minuto, lo que registraría
el sensor de un furgón que reparte medicamentos que deben viajar entre 2 y 8 °C:
la temperatura dentro del furgón, la temperatura exterior y si la puerta está abierta.

Reglas de la simulación (todas las cifras son inventadas, con órdenes de magnitud plausibles):

1. El termostato mantiene el furgón cerca de 5 °C: el compresor se enciende al llegar
   a 5.6 °C y se apaga al bajar a 4.4 °C. Por eso la temperatura sube y baja en ciclos.
2. Por las paredes entra calor en proporción a la diferencia con el exterior, que depende
   de la ciudad y de la hora del día.
3. En cada entrega la puerta se abre de 1 a 6 minutos y entra calor de golpe; después el
   compresor lo recupera.
4. En el 20 % de los viajes el compresor empieza a fallar en un minuto al azar: pierde
   potencia poco a poco y, cuando ya no alcanza, la temperatura sube sin parar.
5. El sensor tiene un ruido pequeño y redondea a 0.1 °C, como uno real.
6. La carga se compromete con una **excursión**: más de 10 minutos seguidos por encima de 8 °C.
"""

import numpy as np
import pandas as pd

# Temperatura exterior media y amplitud entre el día y la noche, en °C.
CIUDADES = {
    "Bogotá": (14, 5), "Medellín": (22, 5), "Cali": (24, 5),
    "Bucaramanga": (24, 5), "Barranquilla": (29, 4), "Cartagena": (29, 3),
}
DURACION = 600                            # minutos por viaje (10 horas de reparto)
ENCENDER, APAGAR = 5.6, 4.4               # el termostato enciende y apaga el compresor
LIMITE = 8.0                              # temperatura máxima permitida para la carga
MINUTOS_EXCURSION = 10                    # minutos seguidos por encima del límite que la comprometen
PROBABILIDAD_FALLA = 0.2                  # fracción de viajes en que el compresor empieza a fallar


def simular_viaje(rng):
    """Simula un viaje de 600 minutos.

    Devuelve dos cosas:
    - una tabla con una fila por minuto: temperatura, exterior y puerta (1 = abierta);
    - un diccionario con la información del viaje: ciudad, hora de salida, entregas,
      si el compresor falla, en qué minuto empieza la falla y en qué minuto empieza la
      excursión (o ``None`` si no hay).
    """
    # 1. Ciudad, hora de salida y temperatura exterior de cada minuto.
    ciudad = list(CIUDADES)[int(rng.integers(0, len(CIUDADES)))]
    media, amplitud = CIUDADES[ciudad]
    salida = int(rng.integers(5 * 60, 9 * 60))                      # entre las 5 y las 9 de la mañana
    hora = (salida + np.arange(DURACION)) / 60                      # hora del día de cada minuto
    exterior = media + amplitud * np.sin((hora - 9) / 24 * 2 * np.pi)  # más calor al mediodía
    exterior = exterior + rng.normal(0, 0.3, DURACION)              # pequeñas variaciones

    # 2. Entregas: entre 6 y 15 paradas, con la puerta abierta de 1 a 6 minutos en cada una.
    puerta = np.zeros(DURACION)
    paradas = rng.choice(np.arange(20, DURACION - 10), size=int(rng.integers(6, 16)), replace=False)
    for parada in paradas:
        puerta[parada:parada + int(rng.integers(1, 7))] = 1

    # 3. Características del furgón y, si falla, cuándo empieza y qué tan rápido pierde potencia.
    aislamiento = rng.uniform(0.006, 0.010)                         # fracción del calor que entra por minuto
    potencia_nominal = rng.uniform(0.40, 0.50)                      # °C que enfría por minuto encendido
    falla = bool(rng.random() < PROBABILIDAD_FALLA)
    inicio_falla = int(rng.integers(150, 520)) if falla else None
    perdida = rng.uniform(0.004, 0.012)                             # fracción de potencia que pierde por minuto

    # 4. Minuto a minuto: entra calor, el termostato decide y el compresor enfría.
    temperatura = np.zeros(DURACION)
    t = rng.uniform(4.5, 5.5)                                       # temperatura al salir
    encendido = False
    for minuto in range(DURACION):
        potencia = potencia_nominal
        if falla and minuto >= inicio_falla:                         # la potencia baja con el tiempo
            minutos_fallando = minuto - inicio_falla
            potencia = max(0.0, potencia_nominal * (1 - perdida * minutos_fallando))
        if t >= ENCENDER:
            encendido = True
        elif t <= APAGAR:
            encendido = False
        calor_paredes = aislamiento * (exterior[minuto] - t)
        calor_puerta = 0.02 * puerta[minuto] * (exterior[minuto] - t)  # solo con la puerta abierta
        t = t + calor_paredes + calor_puerta - (potencia if encendido else 0.0)
        temperatura[minuto] = t

    # 5. Lo que registra el sensor: un poco de ruido y redondeo a 0.1 °C.
    sensor = np.round(temperatura + rng.normal(0, 0.08, DURACION), 1)

    # 6. Excursión: primer minuto de un tramo de 10 minutos seguidos por encima de 8 °C.
    minuto_excursion = None
    seguidos = 0
    for minuto in range(DURACION):
        seguidos = seguidos + 1 if temperatura[minuto] > LIMITE else 0
        if seguidos == MINUTOS_EXCURSION:
            minuto_excursion = minuto - MINUTOS_EXCURSION + 1
            break

    tabla = pd.DataFrame({"minuto": np.arange(DURACION), "temperatura": sensor,
                          "exterior": np.round(exterior, 1), "puerta": puerta.astype(int)})
    informacion = {"ciudad": ciudad, "salida": f"{salida // 60:02d}:{salida % 60:02d}",
                   "entregas": len(paradas), "falla": falla, "inicio_falla": inicio_falla,
                   "minuto_excursion": minuto_excursion}
    return tabla, informacion


def simular_flota(n_viajes, semilla):
    """Simula ``n_viajes`` viajes con una semilla fija.

    Devuelve la lista de tablas minuto a minuto y una tabla con una fila por viaje.
    """
    rng = np.random.default_rng(semilla)
    viajes, filas = [], []
    for numero in range(n_viajes):
        tabla, informacion = simular_viaje(rng)
        viajes.append(tabla)
        filas.append({"viaje": numero, **informacion})
    return viajes, pd.DataFrame(filas)
