"""Simulador de rutas de reparto urbano de BITLogística (datos sintéticos).

Lo usa solo el Caso práctico 2 del capítulo. Genera, minuto a minuto, lo que reporta el
GPS del vehículo de un conductor que reparte paquetes en Bogotá: la velocidad y si está
detenido en un cliente. Con eso se sabe a qué minuto llegó a cada parada.

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

1. Cada ruta sale entre las 7 y las 9 de la mañana y tiene de 20 a 30 paradas. Entre una
   parada y la siguiente hay en promedio 1.8 km.
2. La velocidad depende de la hora: más lenta en las horas pico (7 a 9 y 17 a 19).
3. Cada conductor tiene su propio ritmo: algunos manejan y entregan más rápido que otros.
4. En cada ruta hay de 2 a 4 trancones: durante 20 a 50 minutos la velocidad cae a un
   tercio. Desde el GPS se nota que está pasando, pero no cuándo termina.
5. En cada parada el conductor se detiene unos 5 minutos; en edificios con recepción,
   de 10 a 15.
6. El GPS reporta la velocidad con algo de ruido, y a veces 0 por un semáforo.
"""

import numpy as np
import pandas as pd

HORA_PICO = [(7, 9), (17, 19)]          # horas en que la ciudad va más lenta
VELOCIDAD_BASE = 24.0                   # km/h fuera de hora pico, sin trancón


def factor_hora(hora):
    """1.0 fuera de hora pico y 0.65 en hora pico."""
    for inicio, fin in HORA_PICO:
        if inicio <= hora < fin:
            return 0.65
    return 1.0


def simular_ruta(rng):
    """Simula una ruta completa.

    Devuelve dos cosas:
    - una tabla con una fila por minuto: velocidad del GPS (km/h), si está detenido en un
      cliente (1 o 0), el número de la próxima parada, los km que faltan para llegar a ella
      y si hay un trancón (esta última columna solo sirve para dibujar: en la operación
      nadie la conoce, y la red no la recibe);
    - una tabla con una fila por parada: distancia desde la parada anterior (km) y minuto
      de llegada.
    """
    # 1. Plan de la ruta: hora de salida, paradas y distancias entre ellas.
    salida = int(rng.integers(7 * 60, 9 * 60))                     # minuto del día
    n_paradas = int(rng.integers(20, 31))
    distancias = rng.gamma(shape=3.0, scale=0.6, size=n_paradas)   # km, media 1.8
    edificio = rng.random(n_paradas) < 0.2                        # paradas con recepción

    # 2. Ritmo del conductor: velocidad y tiempo de entrega propios.
    ritmo_manejo = rng.uniform(0.85, 1.15)
    ritmo_entrega = rng.uniform(0.8, 1.25)

    # 3. Trancones: de 2 a 4, cada uno con su inicio y su duración en minutos de la ruta.
    trancones = []
    for _ in range(int(rng.integers(2, 5))):
        inicio = int(rng.integers(0, 420))
        trancones.append((inicio, inicio + int(rng.integers(20, 51))))

    # 4. Minuto a minuto: avanzar, llegar, entregar y seguir.
    filas, llegadas = [], []
    parada, avance, entregando = 0, 0.0, 0                          # avance: km del tramo actual
    minuto = 0
    while parada < n_paradas:
        hora = (salida + minuto) / 60
        llego_ahora = False
        if entregando > 0:                                           # detenido en un cliente
            velocidad, en_cliente = 0.0, 1
            entregando -= 1
            if entregando == 0:
                parada += 1                                          # sale hacia la siguiente
        else:
            en_trancon = any(inicio <= minuto < fin for inicio, fin in trancones)
            velocidad = VELOCIDAD_BASE * factor_hora(hora) * ritmo_manejo
            velocidad *= 0.33 if en_trancon else 1.0
            velocidad *= rng.uniform(0.8, 1.2)                       # variación de cada minuto
            if rng.random() < 0.08:                                  # semáforo en rojo
                velocidad = 0.0
            en_cliente = 0
            avance += velocidad / 60                                 # km recorridos en este minuto
            if avance >= distancias[parada]:                         # llegó al cliente
                llegadas.append(minuto)
                llego_ahora = True
                avance = 0.0
                base = rng.uniform(10, 15) if edificio[parada] else rng.lognormal(np.log(5), 0.3)
                entregando = max(1, int(round(base * ritmo_entrega)))
        gps = max(0.0, velocidad + rng.normal(0, 1.0)) if velocidad > 0 else 0.0
        proxima = min(parada, n_paradas - 1)
        if en_cliente or llego_ahora:
            faltan_km = 0.0
        else:
            faltan_km = max(0.0, distancias[proxima] - avance)
        filas.append({"minuto": minuto, "hora": round(hora, 3), "velocidad": round(gps, 1),
                      "en_cliente": en_cliente, "proxima_parada": proxima,
                      "km_a_la_proxima": round(faltan_km, 3),
                      "en_trancon": int(any(inicio <= minuto < fin for inicio, fin in trancones))})
        minuto += 1

    gps = pd.DataFrame(filas)
    paradas = pd.DataFrame({"parada": np.arange(n_paradas), "distancia_km": np.round(distancias, 2),
                            "edificio": edificio, "llegada": llegadas})
    return gps, paradas


def simular_rutas(n_rutas, semilla):
    """Simula ``n_rutas`` rutas con una semilla fija: dos listas de tablas (GPS y paradas)."""
    rng = np.random.default_rng(semilla)
    gps, paradas = [], []
    for _ in range(n_rutas):
        g, p = simular_ruta(rng)
        gps.append(g)
        paradas.append(p)
    return gps, paradas
