import psutil
import time
import threading

# Almacenar los contadores iniciales para calcular la diferencia
_initial_counters = None

def get_net_usage():
    """Obtiene el tráfico de red desde el inicio del proceso y lo devuelve en KB."""
    global _initial_counters
    
    # 1. Obtener los contadores actuales
    net_io = psutil.net_io_counters()
    
    if _initial_counters is None:
        _initial_counters = net_io
        # Devuelve 0 para la primera lectura ya que no hay diferencia que calcular
        return 0.0, 0.0

    # 2. Calcular la diferencia (tráfico total desde el inicio de la app)
    bytes_sent = net_io.bytes_sent - _initial_counters.bytes_sent
    bytes_recv = net_io.bytes_recv - _initial_counters.bytes_recv
    
    # 3. Convertir a Kilobytes (1024 bytes = 1 KB)
    kb_sent = bytes_sent / 1024
    kb_recv = bytes_recv / 1024
    
    return kb_sent, kb_recv

def start_network_monitoring_thread(root_app):
    """Inicia un hilo que monitorea el tráfico de red y actualiza la UI."""
    
    def monitor_loop():
        # Ejecutar continuamente mientras la aplicación esté viva
        while root_app.winfo_exists():
            kb_sent, kb_recv = get_net_usage()
            
            # Usar after() para actualizar la interfaz de usuario de forma segura
            root_app.after(
                0, 
                root_app.update_net_status, 
                kb_sent, 
                kb_recv
            )
            
            # Esperar 2 segundos antes de la próxima actualización
            time.sleep(2) 

    # Crear y lanzar el hilo de monitoreo
    thread = threading.Thread(target=monitor_loop, daemon=True)
    thread.start()