# ============================================================
# COMUNICACIONES 1
# Unidad 3: Cable de par trenzado UTP/STP
# Resolución de ejercicios propuestos
# Google Colab / Python
# ============================================================

import math

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

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


def convertir_segundos_a_ns(t_segundos):
    """
    Convierte segundos a nanosegundos.
    """
    return t_segundos * 1e9


def mostrar_resultado(titulo):
    """
    Imprime un separador para organizar la salida.
    """
    print("\n" + "=" * 70)
    print(titulo)
    print("=" * 70)


# ------------------------------------------------------------
# EJERCICIO 1: PÉRDIDA DE INSERCIÓN
# ------------------------------------------------------------
# Fórmula:
# IL_dB = 10 * log10(Pin / Pout)
#
# Donde:
# IL_dB = pérdida de inserción en dB
# Pin   = potencia de entrada
# Pout  = potencia de salida

def calcular_perdida_insercion_db(Pin, Pout):
    """
    Calcula la pérdida de inserción en dB.

    Pin y Pout deben estar en la misma unidad:
    W, mW, uW, etc.
    """
    validar_positivo(Pin, "Pin")
    validar_positivo(Pout, "Pout")

    IL_dB = 10 * math.log10(Pin / Pout)
    return IL_dB


# ------------------------------------------------------------
# EJERCICIO 2: ACR
# ------------------------------------------------------------
# Fórmula:
# ACR_dB = NEXT_dB - IL_dB
#
# Donde:
# ACR_dB  = relación atenuación-diafonía
# NEXT_dB = diafonía de extremo cercano
# IL_dB   = pérdida de inserción

def calcular_acr_db(NEXT_dB, IL_dB):
    """
    Calcula el ACR en dB.
    """
    ACR_dB = NEXT_dB - IL_dB
    return ACR_dB


# ------------------------------------------------------------
# EJERCICIO 3: RETARDO DE PROPAGACIÓN
# ------------------------------------------------------------
# Fórmulas:
# v = VF * c
# tp = L / v
#
# Donde:
# v  = velocidad de propagación
# VF = factor de velocidad del cable
# c  = velocidad de la luz en el vacío
# L  = longitud del cable
# tp = retardo de propagación

def calcular_velocidad_propagacion(VF):
    """
    Calcula la velocidad de propagación en el cable.

    VF es el factor de velocidad del cable.
    """
    validar_positivo(VF, "VF")

    c = 3e8  # velocidad de la luz en m/s
    v = VF * c
    return v


def calcular_retardo_propagacion(longitud_m, VF):
    """
    Calcula el retardo de propagación de un cable.

    longitud_m: longitud del cable en metros
    VF        : factor de velocidad del cable
    """
    validar_positivo(longitud_m, "longitud_m")
    validar_positivo(VF, "VF")

    v = calcular_velocidad_propagacion(VF)
    tp = longitud_m / v
    return tp, v


# ------------------------------------------------------------
# EJERCICIO 4: RETURN LOSS
# ------------------------------------------------------------
# Fórmula:
# RL_dB = 10 * log10(Pincidente / Preflejada)
#
# Donde:
# RL_dB       = pérdida de retorno
# Pincidente  = potencia incidente
# Preflejada  = potencia reflejada

def calcular_return_loss_db(P_incidente, P_reflejada):
    """
    Calcula el return loss en dB.
    """
    validar_positivo(P_incidente, "P_incidente")
    validar_positivo(P_reflejada, "P_reflejada")

    RL_dB = 10 * math.log10(P_incidente / P_reflejada)
    return RL_dB


# ------------------------------------------------------------
# OPCIONAL: COEFICIENTE DE REFLEXIÓN
# ------------------------------------------------------------
# Fórmula:
# Gamma = (ZL - Z0) / (ZL + Z0)

def calcular_coeficiente_reflexion(ZL, Z0):
    """
    Calcula el coeficiente de reflexión.

    ZL = impedancia de carga
    Z0 = impedancia característica de la línea
    """
    validar_positivo(ZL, "ZL")
    validar_positivo(Z0, "Z0")

    gamma = (ZL - Z0) / (ZL + Z0)
    return gamma


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

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

mostrar_resultado("EJERCICIO 1: Pérdida de inserción")

Pin = 2      # mW
Pout = 0.5   # mW

IL_dB = calcular_perdida_insercion_db(Pin, Pout)

print(f"Potencia de entrada Pin : {Pin} mW")
print(f"Potencia de salida Pout : {Pout} mW")
print(f"Pérdida de inserción    : {IL_dB:.2f} dB")


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

mostrar_resultado("EJERCICIO 2: ACR")

NEXT_dB = 38   # dB
IL_dB_ej2 = 21 # dB

ACR_dB = calcular_acr_db(NEXT_dB, IL_dB_ej2)

print(f"NEXT                  : {NEXT_dB:.2f} dB")
print(f"Pérdida de inserción  : {IL_dB_ej2:.2f} dB")
print(f"ACR                   : {ACR_dB:.2f} dB")


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

mostrar_resultado("EJERCICIO 3: Retardo de propagación")

longitud_m = 100   # metros
VF = 0.66          # factor de velocidad

tp, velocidad = calcular_retardo_propagacion(longitud_m, VF)

print(f"Longitud del cable           : {longitud_m} m")
print(f"Factor de velocidad VF       : {VF}")
print(f"Velocidad de propagación     : {velocidad:.2e} m/s")
print(f"Retardo de propagación       : {tp:.3e} s")
print(f"Retardo de propagación       : {convertir_segundos_a_ns(tp):.2f} ns")


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

mostrar_resultado("EJERCICIO 4: Return Loss")

P_incidente = 1      # mW
P_reflejada = 0.01   # mW

RL_dB = calcular_return_loss_db(P_incidente, P_reflejada)

print(f"Potencia incidente  : {P_incidente} mW")
print(f"Potencia reflejada  : {P_reflejada} mW")
print(f"Return Loss         : {RL_dB:.2f} dB")


# ------------------------------------------------------------
# EJERCICIO OPCIONAL: COEFICIENTE DE REFLEXIÓN
# ------------------------------------------------------------

mostrar_resultado("EJERCICIO OPCIONAL: Coeficiente de reflexión")

Z0 = 100   # ohm, valor típico conceptual para par trenzado balanceado
ZL = 120   # ohm, carga no adaptada

gamma = calcular_coeficiente_reflexion(ZL, Z0)

print(f"Impedancia característica Z0 : {Z0} ohm")
print(f"Impedancia de carga ZL       : {ZL} ohm")
print(f"Coeficiente de reflexión Γ   : {gamma:.4f}")

if abs(gamma) == 0:
    print("La línea está perfectamente adaptada.")
else:
    print("Existe desadaptación de impedancia y, por lo tanto, puede haber reflexiones.")