"""Simulador de los sonidos de la bodega de BITLogística en Funza (datos sintéticos).

Lo usa solo el Caso práctico 2 del capítulo. Genera audio a 16 000 muestras por segundo:
clips de 1 segundo con su etiqueta (normal, alarma o golpe) y turnos continuos de varios
minutos con la lista de los sonidos que ocurrieron y su instante.

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

1. El fondo siempre suena: ruido de máquinas, zumbido eléctrico de 60 Hz (la red eléctrica de
   Colombia), ventilación y voces lejanas.
2. La alarma de reversa es un pitido de 0.43 a 0.54 s con su tono principal entre 1 000 y
   1 300 Hz y dos armónicos débiles, más un eco corto. Cada montacargas tiene su tono; los
   tonos de prueba no aparecen al entrenar ni al validar, pero
   están dentro del mismo rango: son montacargas nuevos del mismo tipo.
3. El golpe de una caja es una ráfaga de ruido de 30 a 120 ms con una resonancia grave de
   60 a 150 Hz que se apaga rápido.
4. Sonidos inofensivos (la red no debe avisar): pito de un carro, timbre de celular, puerta
   que se cierra y carro de mano. Aparecen en todas las particiones.
5. Sonido nuevo: la cinta de embalaje que se rasga. Solo aparece en los turnos de prueba
   «con sonido nuevo», para medir qué pasa cuando la red oye algo que nunca escuchó.
6. Cada sonido se mezcla con el fondo con una relación señal-ruido al azar entre −5 y +20 dB.
7. En los clips, un sonido puede quedar cortado por el borde: así se ve en la operación,
   cuando la ventana de 1 s se desliza por el turno y corta los sonidos largos.
"""

import numpy as np
from scipy.signal import butter, sosfilt

TASA = 16000                                   # muestras por segundo
CLASES = ("normal", "alarma", "golpe")
TONOS = {                                      # tono principal de la alarma de cada montacargas (Hz)
    "entrenamiento": (1000, 1060, 1120, 1180, 1240, 1300),
    "validacion": (1030, 1150, 1270),
    "prueba": (1090, 1210, 1285),
}
INOFENSIVOS = ("pito", "timbre", "puerta", "carro de mano")
NUEVO = "cinta"                                # solo en los turnos de prueba con sonido nuevo
FILTRO_VOCES = butter(2, [300, 3000], btype="bandpass", fs=TASA, output="sos")
FILTRO_CINTA = butter(2, [1500, 6000], btype="bandpass", fs=TASA, output="sos")


def tiempo(n):
    """Instante en segundos de cada una de las n muestras."""
    return np.arange(n, dtype=np.float32) / TASA


def tono(t, frecuencia):
    return np.sin(2 * np.pi * frecuencia * t)


def fondo(n, rng):
    """1. Fondo de la bodega: ruido, zumbido de 60 Hz, ventilación y voces lejanas."""
    t = tiempo(n)
    x = rng.normal(0, .013, n).astype(np.float32)                # máquinas
    x += .006 * tono(t, 60) + .002 * tono(t, 120)                # zumbido eléctrico
    x += .005 * tono(t, 96) * (.65 + .35 * tono(t, 1.7))         # ventilación
    voces = sosfilt(FILTRO_VOCES, rng.normal(0, .008, n)).astype(np.float32)
    x += voces * (.55 + .45 * tono(t, 4))                        # unas 4 sílabas por segundo
    return x


def sonido(nombre, rng, frecuencia=None, repetir=False):
    """Genera la onda de un sonido. Con ``repetir`` la alarma suena dos veces (pitido, pausa, pitido)."""
    if nombre == "alarma":                                       # 2.
        n = int(TASA * rng.uniform(.43, .54))
        t = tiempo(n)
        x = tono(t, frecuencia) + .22 * tono(t, 2 * frecuencia) + .08 * tono(t, 3 * frecuencia)
        borde = min(100, n // 2)                                 # bordes suaves, sin clic
        x[:borde] *= np.linspace(0, 1, borde)
        x[-borde:] *= np.linspace(1, 0, borde)
        demora = int(TASA * .018)                                # eco a 18 ms
        x[demora:] += rng.uniform(.07, .22) * x[:-demora].copy()
        if repetir:
            pausa = np.zeros(TASA - n, dtype=np.float32)
            x = np.concatenate((x, pausa, x))
    elif nombre in ("golpe", "puerta"):                          # 3. y la puerta, más suave y grave
        duracion = rng.uniform(.03, .12) if nombre == "golpe" else rng.uniform(.08, .16)
        t = tiempo(int(TASA * duracion))
        ruido = 1.0 if nombre == "golpe" else .20
        grave = rng.uniform(60, 150) if nombre == "golpe" else rng.uniform(40, 75)
        x = (ruido * rng.normal(size=len(t)) + .8 * tono(t, grave)) * np.exp(-5 * t / duracion)
    elif nombre == "pito":
        t = tiempo(int(TASA * rng.uniform(.48, .85)))
        f = rng.uniform(400, 500)
        x = tono(t, f) + .45 * tono(t, 2 * f)
    elif nombre == "timbre":
        t = tiempo(int(TASA * rng.uniform(.35, .65)))
        x = np.where((t % .20) < .10, tono(t, 880), tono(t, 1470))
    elif nombre == "carro de mano":
        t = tiempo(int(TASA * rng.uniform(.4, .85)))
        x = .30 * rng.normal(size=len(t)) + tono(t, 170) * (.6 + .4 * tono(t, 17))
    elif nombre == "cinta":                                      # 5. rasgado: chasquidos agudos rápidos
        t = tiempo(int(TASA * rng.uniform(.5, .9)))
        chasquidos = (np.sin(2 * np.pi * rng.uniform(20, 35) * t) > .6).astype(np.float32)
        x = sosfilt(FILTRO_CINTA, rng.normal(size=len(t))) * (.3 + chasquidos)
    else:
        raise ValueError(f"Sonido desconocido: {nombre}")
    return np.asarray(x, dtype=np.float32)


def mezclar(audio, senal, inicio, snr):
    """6. Suma la señal al fondo con la relación señal-ruido pedida (en dB). Devuelve el fin."""
    if inicio < 0:                                               # empieza antes del clip: se corta
        senal = senal[-inicio:]
        inicio = 0
    fin = min(inicio + len(senal), len(audio))
    senal = senal[:fin - inicio]
    tramo = audio[inicio:fin]
    energia_fondo = float(np.mean(tramo ** 2))
    activos = senal[np.abs(senal) > .01 * np.max(np.abs(senal))]     # sin contar los silencios
    energia_senal = float(np.mean(activos ** 2))
    factor = np.sqrt(energia_fondo / max(energia_senal, 1e-12) * 10 ** (snr / 10))
    tramo += factor * senal
    return fin


def simular_clips(cantidad, semilla, particion):
    """Clips de 1 s. Las clases se alternan para que haya la misma cantidad de cada una."""
    rng = np.random.default_rng(semilla)
    clips = np.empty((cantidad, TASA), dtype=np.float32)
    etiquetas, detalles = [], []
    for i in range(cantidad):
        clase = CLASES[i % len(CLASES)]
        evento = clase
        if clase == "normal":                       # 75 % con un sonido inofensivo, 25 % solo fondo
            evento = str(rng.choice(INOFENSIVOS)) if rng.random() < .75 else "fondo"
        audio = fondo(TASA, rng)
        frecuencia = int(rng.choice(TONOS[particion])) if evento == "alarma" else None
        snr = float(rng.uniform(-5, 20)) if evento != "fondo" else None
        if evento != "fondo":
            senal = sonido(evento, rng, frecuencia)
            # 7. Los sonidos inofensivos pueden quedar cortados por el borde del clip, como
            #    pasa con la ventana que se desliza por el turno. La alarma y el golpe quedan
            #    por lo menos en su mitad dentro del clip.
            mitad = len(senal) // 2
            inicio = int(rng.integers(-mitad, TASA - mitad))
            mezclar(audio, senal, inicio, snr)
        clips[i] = audio
        etiquetas.append(CLASES.index(clase))
        detalles.append({"evento": evento, "frecuencia": frecuencia, "snr": snr})
    return clips, np.asarray(etiquetas), detalles


def simular_turno(segundos, semilla, particion, con_sonido_nuevo=False):
    """Un tramo continuo de turno. Cada 6 a 12 s ocurre un sonido; se devuelve la lista."""
    rng = np.random.default_rng(semilla)
    audio = fondo(segundos * TASA, rng)
    opciones = ["alarma", "golpe", *INOFENSIVOS] + ([NUEVO, NUEVO] if con_sonido_nuevo else [])
    eventos = []
    segundo = 2.0
    while segundo < segundos - 3:
        evento = str(rng.choice(opciones))
        frecuencia = int(rng.choice(TONOS[particion])) if evento == "alarma" else None
        snr = float(rng.uniform(-5, 20))
        inicio = int(segundo * TASA)
        fin = mezclar(audio, sonido(evento, rng, frecuencia, repetir=True), inicio, snr)
        eventos.append({"evento": evento, "inicio": inicio / TASA, "fin": fin / TASA,
                        "frecuencia": frecuencia, "snr": snr})
        segundo += float(rng.uniform(6, 12))
    return audio, eventos
