use std::fs::File;
use std::io::{self, BufRead, BufReader, Write, BufWriter};

// I/O bufferise : evite un appel systeme par ligne (essentiel en systeme/perf)
fn lire_fichier_ligne_par_ligne(chemin: &str) -> io::Result<Vec<String>> {
    let fichier = File::open(chemin)?;
    let lecteur = BufReader::new(fichier);
    let mut lignes = Vec::new();
    for ligne in lecteur.lines() {
        lignes.push(ligne?);
    }
    Ok(lignes)
}

fn ecrire_fichier_bufferise(chemin: &str, donnees: &[String]) -> io::Result<()> {
    let fichier = File::create(chemin)?;
    let mut ecrivain = BufWriter::new(fichier);
    for ligne in donnees {
        writeln!(ecrivain, "{}", ligne)?;
    }
    Ok(()) // BufWriter flush automatiquement au Drop, mais un flush explicite est plus sur
}

// Layout memoire precis avec #[repr] pour interoperabilite bas niveau
#[repr(C)]
struct EnTeteMessage {
    version: u8,
    type_message: u8,
    longueur: u16, // layout identique a une struct C, exploitable en reseau/FFI
}

// Manipulation de bytes bruts : encodage/decodage binaire manuel (protocole reseau)
fn encoder_u32_big_endian(valeur: u32) -> [u8; 4] {
    valeur.to_be_bytes() // big-endian : standard pour les protocoles reseau
}

fn decoder_u32_big_endian(octets: &[u8; 4]) -> u32 {
    u32::from_be_bytes(*octets)
}

// Programmation sans allocation (no_std serait le vrai niveau embarque, ici on reste std
// mais on illustre l'evitement d'allocations sur un chemin critique)
fn somme_sans_allocation(donnees: &[i32]) -> i64 {
    let mut total = 0i64;
    for &v in donnees { // pas d'iterateur d'allocation, boucle directe sur le slice
        total += v as i64;
    }
    total
}

fn main() -> io::Result<()> {
    let donnees = vec!["ligne1".to_string(), "ligne2".to_string()];
    // ecrire_fichier_bufferise("sortie.txt", &donnees)?;
    // let relu = lire_fichier_ligne_par_ligne("sortie.txt")?;

    let octets = encoder_u32_big_endian(1_234_567);
    println!("{:?}", octets);
    println!("{}", decoder_u32_big_endian(&octets));

    println!("taille EnTeteMessage: {}", std::mem::size_of::<EnTeteMessage>());

    let nombres = vec![1, 2, 3, 4, 5];
    println!("{}", somme_sans_allocation(&nombres));

    // Gestion d'arguments et de signaux systeme (base d'un vrai outil CLI/systeme)
    let args: Vec<String> = std::env::args().collect();
    println!("arguments: {:?}", args);

    // Variables d'environnement
    if let Ok(chemin) = std::env::var("PATH") {
        println!("PATH configure ({} caracteres)", chemin.len());
    }

    // Process : lancer et attendre un sous-processus (comme exec/fork en C)
    let sortie = std::process::Command::new("echo")
        .arg("bonjour depuis un sous-processus")
        .output();
    if let Ok(sortie) = sortie {
        println!("{}", String::from_utf8_lossy(&sortie.stdout));
    }

    Ok(())
}

# Cibler des plateformes sans OS (embarque) : necessite no_std, hors du perimetre std ici
rustup target add thumbv7em-none-eabihf

# Optimisations agressives pour binaire systeme (taille et vitesse)
# Cargo.toml:
# [profile.release]
# opt-level = 3
# lto = true
# codegen-units = 1
# panic = "abort"   # supprime le support de deroulement de pile, binaire plus petit