# ============================================================
# COMUNICACIONES 1
# Unidad 6.2: FTTH y redes FTTx
# Resolución de ejercicios propuestos
# Google Colab / Python
# ============================================================

import math

# ------------------------------------------------------------
# FUNCIONES AUXILIARES
# ------------------------------------------------------------

def mostrar_titulo(titulo):
    print("\n" + "=" * 72)
    print(titulo)
    print("=" * 72)


def validar_positivo(valor, nombre):
    if valor <= 0:
        raise ValueError(f"{nombre} debe ser mayor que cero.")


def validar_no_negativo(valor, nombre):
    if valor < 0:
        raise ValueError(f"{nombre} no puede ser negativo.")


def dbm_a_mw(P_dBm):
    """
    Convierte potencia desde dBm a mW.

    Fórmula:
    P_mW = 10^(P_dBm/10)
    """
    return 10 ** (P_dBm / 10)


def mw_a_dbm(P_mW):
    """
    Convierte potencia desde mW a dBm.

    Fórmula:
    P_dBm = 10*log10(P_mW)
    """
    validar_positivo(P_mW, "P_mW")
    return 10 * math.log10(P_mW)


# ============================================================
# EJERCICIO 1: PÉRDIDA IDEAL DE UN SPLITTER
# ============================================================
# Fórmula:
# A_splitter_ideal = 10 * log10(N)
#
# Donde:
# N = cantidad de salidas del splitter

def calcular_perdida_ideal_splitter(N):
    """
    Calcula la pérdida ideal de un splitter 1:N en dB.
    """
    validar_positivo(N, "N")

    A_splitter_ideal = 10 * math.log10(N)
    return A_splitter_ideal


# ============================================================
# EJERCICIO 2: PRESUPUESTO ÓPTICO FTTH
# ============================================================
# Fórmulas:
# A_fibra = alpha * L
# A_conectores = N_c * A_c
# A_empalmes = N_e * A_e
# A_total = A_fibra + A_conectores + A_empalmes + A_splitter + M

def calcular_presupuesto_ftth(
    longitud_km,
    alpha_db_km,
    cantidad_conectores,
    perdida_conector_db,
    cantidad_empalmes,
    perdida_empalme_db,
    perdida_splitter_db,
    margen_db
):
    """
    Calcula la pérdida total de un enlace FTTH.

    Incluye:
    - pérdida por longitud de fibra;
    - pérdida por conectores;
    - pérdida por empalmes;
    - pérdida de splitter;
    - margen de diseño.
    """

    validar_no_negativo(longitud_km, "longitud_km")
    validar_no_negativo(alpha_db_km, "alpha_db_km")
    validar_no_negativo(cantidad_conectores, "cantidad_conectores")
    validar_no_negativo(perdida_conector_db, "perdida_conector_db")
    validar_no_negativo(cantidad_empalmes, "cantidad_empalmes")
    validar_no_negativo(perdida_empalme_db, "perdida_empalme_db")
    validar_no_negativo(perdida_splitter_db, "perdida_splitter_db")
    validar_no_negativo(margen_db, "margen_db")

    A_fibra = alpha_db_km * longitud_km
    A_conectores = cantidad_conectores * perdida_conector_db
    A_empalmes = cantidad_empalmes * perdida_empalme_db

    A_total = (
        A_fibra
        + A_conectores
        + A_empalmes
        + perdida_splitter_db
        + margen_db
    )

    return A_fibra, A_conectores, A_empalmes, A_total


# ============================================================
# EJERCICIO 3: POTENCIA RECIBIDA EN LA ONT
# ============================================================
# Fórmula:
# P_RX = P_TX - A_total

def calcular_potencia_recibida(P_TX_dBm, A_total_dB):
    """
    Calcula la potencia óptica recibida en dBm.
    """
    validar_no_negativo(A_total_dB, "A_total_dB")

    P_RX_dBm = P_TX_dBm - A_total_dB
    return P_RX_dBm


# ============================================================
# EJERCICIO 4: MARGEN DEL ENLACE
# ============================================================
# Fórmula:
# Margen = P_RX - S_RX

def calcular_margen_enlace(P_RX_dBm, sensibilidad_RX_dBm):
    """
    Calcula el margen óptico del enlace en dB.
    """
    margen_db = P_RX_dBm - sensibilidad_RX_dBm
    return margen_db


def evaluar_margen(margen_db):
    """
    Evalúa el margen del enlace.
    """
    if margen_db > 3:
        return "Enlace con margen adecuado."
    elif margen_db >= 0:
        return "Enlace funcional, pero con margen reducido."
    else:
        return "Enlace no recomendado: potencia recibida menor que la sensibilidad."


# ============================================================
# EJERCICIO 5: CAPACIDAD MEDIA CONCEPTUAL POR USUARIO
# ============================================================
# Fórmula:
# C_usuario_promedio = C_PON / N

def calcular_capacidad_media_usuario(C_PON_Gbps, cantidad_usuarios):
    """
    Calcula la capacidad media conceptual por usuario.

    C_PON_Gbps: capacidad total del puerto PON en Gbit/s.
    cantidad_usuarios: cantidad de usuarios conectados.
    """
    validar_positivo(C_PON_Gbps, "C_PON_Gbps")
    validar_positivo(cantidad_usuarios, "cantidad_usuarios")

    C_usuario_Gbps = C_PON_Gbps / cantidad_usuarios
    C_usuario_Mbps = C_usuario_Gbps * 1000

    return C_usuario_Gbps, C_usuario_Mbps


# ============================================================
# EJERCICIO 6: SOBRESUSCRIPCIÓN COMERCIAL
# ============================================================
# Fórmula:
# R_s = suma(C_planes) / C_PON

def calcular_sobresuscripcion(cantidad_usuarios, plan_Mbps, C_PON_Mbps):
    """
    Calcula la relación de sobresuscripción comercial.

    cantidad_usuarios: cantidad de clientes.
    plan_Mbps: velocidad comercial de cada cliente en Mbit/s.
    C_PON_Mbps: capacidad descendente disponible del puerto PON en Mbit/s.
    """
    validar_positivo(cantidad_usuarios, "cantidad_usuarios")
    validar_positivo(plan_Mbps, "plan_Mbps")
    validar_positivo(C_PON_Mbps, "C_PON_Mbps")

    suma_planes_Mbps = cantidad_usuarios * plan_Mbps
    R_s = suma_planes_Mbps / C_PON_Mbps

    return suma_planes_Mbps, R_s


# ============================================================
# EJERCICIO 7: CANTIDAD DE PUERTOS PON NECESARIOS
# ============================================================
# Fórmula:
# N_puertos = ceil(N_clientes / N_split)

def calcular_puertos_pon_necesarios(N_clientes, N_split):
    """
    Calcula la cantidad mínima de puertos PON necesarios.
    """
    validar_positivo(N_clientes, "N_clientes")
    validar_positivo(N_split, "N_split")

    N_puertos = math.ceil(N_clientes / N_split)
    capacidad_total_clientes = N_puertos * N_split
    puertos_clientes_libres = capacidad_total_clientes - N_clientes

    return N_puertos, capacidad_total_clientes, puertos_clientes_libres


# ============================================================
# TABLA AUXILIAR DE PÉRDIDAS PRÁCTICAS TÍPICAS DE SPLITTERS
# ============================================================

perdidas_splitter_tipicas = {
    2: 3.5,
    4: 7.0,
    8: 10.5,
    16: 13.5,
    32: 17.0,
    64: 20.5
}


# ============================================================
# RESOLUCIÓN DE LOS EJERCICIOS PROPUESTOS
# ============================================================

# ------------------------------------------------------------
# EJERCICIO 1
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 1: Pérdida ideal de un splitter")

N_splitter = 32

A_splitter_ideal = calcular_perdida_ideal_splitter(N_splitter)

print(f"Splitter                         : 1:{N_splitter}")
print(f"Pérdida ideal                    : {A_splitter_ideal:.2f} dB")

if N_splitter in perdidas_splitter_tipicas:
    print(f"Pérdida práctica típica aprox.   : {perdidas_splitter_tipicas[N_splitter]:.2f} dB")


# ------------------------------------------------------------
# EJERCICIO 2
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 2: Presupuesto óptico FTTH")

longitud_km = 12
alpha_db_km = 0.35
cantidad_conectores = 4
perdida_conector_db = 0.5
cantidad_empalmes = 8
perdida_empalme_db = 0.1
perdida_splitter_db = 17
margen_db = 3

A_fibra, A_conectores, A_empalmes, A_total = calcular_presupuesto_ftth(
    longitud_km,
    alpha_db_km,
    cantidad_conectores,
    perdida_conector_db,
    cantidad_empalmes,
    perdida_empalme_db,
    perdida_splitter_db,
    margen_db
)

print(f"Longitud de fibra                : {longitud_km} km")
print(f"Atenuación de fibra              : {alpha_db_km} dB/km")
print(f"Pérdida por fibra                : {A_fibra:.2f} dB")
print(f"Cantidad de conectores           : {cantidad_conectores}")
print(f"Pérdida por conector             : {perdida_conector_db} dB")
print(f"Pérdida por conectores           : {A_conectores:.2f} dB")
print(f"Cantidad de empalmes             : {cantidad_empalmes}")
print(f"Pérdida por empalme              : {perdida_empalme_db} dB")
print(f"Pérdida por empalmes             : {A_empalmes:.2f} dB")
print(f"Pérdida del splitter             : {perdida_splitter_db:.2f} dB")
print(f"Margen de diseño                 : {margen_db:.2f} dB")
print(f"Pérdida total del enlace         : {A_total:.2f} dB")


# ------------------------------------------------------------
# EJERCICIO 3
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 3: Potencia recibida en la ONT")

P_TX_dBm = 3

P_RX_dBm = calcular_potencia_recibida(P_TX_dBm, A_total)

print(f"Potencia transmitida por OLT      : {P_TX_dBm:.2f} dBm")
print(f"Pérdida total del enlace          : {A_total:.2f} dB")
print(f"Potencia recibida en ONT          : {P_RX_dBm:.2f} dBm")
print(f"Potencia recibida en ONT          : {dbm_a_mw(P_RX_dBm):.6f} mW")


# ------------------------------------------------------------
# EJERCICIO 4
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 4: Margen del enlace")

sensibilidad_RX_dBm = -28

margen_enlace = calcular_margen_enlace(P_RX_dBm, sensibilidad_RX_dBm)

print(f"Potencia recibida en ONT          : {P_RX_dBm:.2f} dBm")
print(f"Sensibilidad mínima ONT           : {sensibilidad_RX_dBm:.2f} dBm")
print(f"Margen del enlace                 : {margen_enlace:.2f} dB")
print(f"Evaluación                        : {evaluar_margen(margen_enlace)}")


# ------------------------------------------------------------
# EJERCICIO 5
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 5: Capacidad media conceptual por usuario")

C_PON_Gbps = 2.5
cantidad_usuarios = 32

C_usuario_Gbps, C_usuario_Mbps = calcular_capacidad_media_usuario(
    C_PON_Gbps,
    cantidad_usuarios
)

print(f"Capacidad total PON               : {C_PON_Gbps:.2f} Gbit/s")
print(f"Cantidad de usuarios              : {cantidad_usuarios}")
print(f"Capacidad media conceptual        : {C_usuario_Gbps:.6f} Gbit/s")
print(f"Capacidad media conceptual        : {C_usuario_Mbps:.2f} Mbit/s")
print("Nota: en una red real se usa multiplexación estadística.")


# ------------------------------------------------------------
# EJERCICIO 6
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 6: Sobresuscripción comercial")

cantidad_usuarios = 32
plan_Mbps = 300
C_PON_Mbps = 2500

suma_planes_Mbps, R_s = calcular_sobresuscripcion(
    cantidad_usuarios,
    plan_Mbps,
    C_PON_Mbps
)

print(f"Cantidad de usuarios              : {cantidad_usuarios}")
print(f"Plan comercial por usuario        : {plan_Mbps} Mbit/s")
print(f"Capacidad descendente PON         : {C_PON_Mbps} Mbit/s")
print(f"Suma de planes comerciales        : {suma_planes_Mbps} Mbit/s")
print(f"Relación de sobresuscripción      : {R_s:.2f}:1")


# ------------------------------------------------------------
# EJERCICIO 7
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 7: Cantidad de puertos PON necesarios")

N_clientes = 640
N_split = 32

N_puertos, capacidad_total_clientes, clientes_libres = calcular_puertos_pon_necesarios(
    N_clientes,
    N_split
)

print(f"Cantidad de clientes              : {N_clientes}")
print(f"Split ratio                       : 1:{N_split}")
print(f"Puertos PON necesarios            : {N_puertos}")
print(f"Capacidad total de clientes       : {capacidad_total_clientes}")
print(f"Capacidad libre para clientes     : {clientes_libres}")


# ============================================================
# RESUMEN FINAL
# ============================================================

mostrar_titulo("RESUMEN DE RESULTADOS")

print(f"Ejercicio 1 - Pérdida ideal splitter 1:{N_splitter} : {A_splitter_ideal:.2f} dB")
print(f"Ejercicio 2 - Pérdida total FTTH                   : {A_total:.2f} dB")
print(f"Ejercicio 3 - Potencia recibida ONT                : {P_RX_dBm:.2f} dBm")
print(f"Ejercicio 4 - Margen del enlace                    : {margen_enlace:.2f} dB")
print(f"Ejercicio 5 - Capacidad media usuario              : {C_usuario_Mbps:.2f} Mbit/s")
print(f"Ejercicio 6 - Sobresuscripción                     : {R_s:.2f}:1")
print(f"Ejercicio 7 - Puertos PON necesarios               : {N_puertos}")