"""
Collecteur d'informations système pour un affichage déporté via le port série.
"""

import time
import argparse

import psutil
import serial


# Données de calibration par défaut
MAX_DISK_BANDWIDTH_BYTES = 1024 * 1024 * 550  # 550 Mo/s
MAX_NETWORK_BANDWIDTH_BYTES = 1024 * 1024 * 125  # 125 Mo/s


def monitor_resources(serial_port, serial_speed, refresh_speed,
                      max_disk_bandwidth_bytes, max_network_bandwidth_bytes):
    """
    Surveille l'état des ressources système et transmet les statistiques à un afficheur externe via le port série.
    :param serial_port: Le nom du port série à utiliser.
    :param serial_speed: La vitesse de communication à utiliser.
    :param refresh_speed: La vitesse de rafraichissement de l'afficheur externe.
    :param max_disk_bandwidth_bytes: Le débit maximum des disques en octets/s.
    :param max_network_bandwidth_bytes: Le débit maximum du réseau en octets/s.
    """

    # Ajuste les débits en fonction de la fenêtre de temps
    max_disk_bandwidth_bytes *= refresh_speed
    max_network_bandwidth_bytes *= refresh_speed

    # Démarrage à froid
    psutil.cpu_percent()
    psutil.virtual_memory()
    disk_io = psutil.disk_io_counters()
    previous_disk_io_bytes = disk_io.read_bytes + disk_io.write_bytes
    network_io = psutil.net_io_counters()
    previous_network_io_bytes = network_io.bytes_sent + network_io.bytes_recv

    # Ouvre le port série
    with serial.Serial(serial_port, serial_speed, timeout=1) as ser:
            
        # Tant que le script n'est pas tué (avec CTRL+C)
        while True:

            # Récupére l'utilisation du processeur en pourcentage
            cpu_percent = psutil.cpu_percent()
            
            # Récupére l'utilisation de la mémoire vive en pourcentage
            memory_percent = psutil.virtual_memory().percent
            
            # Récupére l'utilisation des disques en pourcentage
            disk_io = psutil.disk_io_counters()
            disk_io_bytes = disk_io.read_bytes + disk_io.write_bytes
            disk_percent = (disk_io_bytes - previous_disk_io_bytes) / max_disk_bandwidth_bytes * 100
            previous_disk_io_bytes = disk_io_bytes
            
            # Récupére l'utilisation du réseau en pourcentage
            network_io = psutil.net_io_counters()
            network_io_bytes = network_io.bytes_sent + network_io.bytes_recv
            network_percent = (network_io_bytes - previous_network_io_bytes) / max_network_bandwidth_bytes * 100
            previous_network_io_bytes = network_io_bytes

            # Affiche les stats (pour debug)
            print('cpu={:.1f}, memory={:.1f}, disk={:.1f}, network={:.1f}'.format(cpu_percent, memory_percent,
                                                                                  disk_percent, network_percent))

            # Envoi les stats via le port série à l'afficheur externe
            ser.write('{3} {2} {1} {0}\n'.format(int(cpu_percent / 100 * 255),
                                                 int(memory_percent / 100 * 255),
                                                 int(network_percent / 100 * 255),
                                                 int(disk_percent / 100 * 255)).encode())

            # Attends la prochaine fenêtre de rafraichissement
            time.sleep(refresh_speed)


# Programme principal
if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Monitor system resources and send them to an external display over a serial port.')
    parser.add_argument('serial_port', metavar='<SERIAL PORT>',
                        help='The serial port name/path to be used for communication.')
    parser.add_argument('serial_speed', metavar='<SERIAL SPEED>', type=int, nargs='?', default=115200,
                        help='The serial port speed to be used for communication (default 115200 bauds).')
    parser.add_argument('refresh_speed', metavar='<REFRESH SPEED>', type=int, nargs='?', default=1,
                        help='The number of seconds between each refresh (default 1 second).')
    parser.add_argument('max_disk_bandwidth_bytes', metavar='<MAX DISK BANDWIDTH>', type=int, nargs='?',
                        default=MAX_DISK_BANDWIDTH_BYTES,
                        help='The maximum bandwith of the disk in bytes/s (default 550MB/s).')
    parser.add_argument('max_network_bandwidth_bytes', metavar='<MAX_NETWORK BANDWIDTH>', type=int, nargs='?',
                        default=MAX_NETWORK_BANDWIDTH_BYTES,
                        help='The maximum bandwith of the network in bytes/s (default 125MB/s).')
    args = parser.parse_args()
    monitor_resources(args.serial_port, args.serial_speed, args.refresh_speed,
                      args.max_disk_bandwidth_bytes