enum Header {
    Cpu = 0,
    Usr,
    Sys,
    Iowait,
    Idle,
    Other,
}

#[derive(Debug)]
enum HeaderValue<'a> {
    Cpu(&'a str),
    Usr(f32),
    Sys(f32),
    Iowait(f32),
    Idle(f32),
    Other(f32),
}

fn main() {
    let str = "
Linux 4.9.68-1-lts (xxx)    13/03/18        _x86_64_        (8 CPU)

Average:     CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
Average:     all    2.80    0.00    1.01    0.13    0.00    0.16    0.00    0.00    0.00   95.92
Average:       0    6.78    0.00    1.26    0.75    0.00    0.25    0.00    0.08    0.00   90.95
Average:       1    1.25    0.00    0.75    0.25    0.10    0.75    0.00    0.03    0.00   97.00
Average:       2    1.75    0.00    1.75    0.00    0.00    0.25    0.00    0.00    0.00   96.25
Average:       3    1.75    0.00    0.75    0.00    0.00    0.00    0.00    0.00    0.00   97.51
Average:       4    7.07    0.00    0.51    0.00    0.00    0.00    0.00    0.00    0.00   92.42
Average:       5    1.26    0.00    0.50    0.00    0.20    0.00    0.00    0.00    0.00   98.24
Average:       6    1.77    0.00    1.52    0.00    0.00    0.00    0.00    0.00    0.00   96.71
Average:       7    0.76    0.00    1.01    0.00    0.00    0.00    0.00    0.00    0.00   98.23
";

    println!("{}", str);

    let mut headers_parsed = false;

    let mut headers_idx: Vec<Header> = vec![];

    let mut cpus_values: Vec<Vec<HeaderValue>> = vec![];

    for line in str.lines() {
        if line.starts_with("Average") {
            let cols: Vec<&str> = line.split(' ').filter(|c| *c != "").collect();
            if headers_parsed {
                let mut all_values: Vec<HeaderValue> = vec![
                    HeaderValue::Cpu(""),
                    HeaderValue::Usr(0.0f32),
                    HeaderValue::Sys(0.0f32),
                    HeaderValue::Iowait(0.0f32),
                    HeaderValue::Idle(0.0f32),
                    HeaderValue::Other(0.0f32),
                ];

                for (idx, val) in cols.iter().skip(1).enumerate() {
                    let header = &headers_idx[idx];
                    let fval = match val.parse::<f32>() {
                        // unneeded for Cpu
                        Ok(v) => v,
                        _ => 0.0f32,
                    };
                    match *header {
                        Header::Cpu => {
                            all_values[Header::Cpu as usize] = HeaderValue::Cpu(val);
                        }
                        Header::Usr => {
                            all_values[Header::Usr as usize] = HeaderValue::Usr(fval);
                        }
                        Header::Sys => {
                            all_values[Header::Sys as usize] = HeaderValue::Sys(fval);
                        }
                        Header::Iowait => {
                            all_values[Header::Iowait as usize] = HeaderValue::Iowait(fval);
                        }
                        Header::Idle => {
                            all_values[Header::Idle as usize] = HeaderValue::Idle(fval);
                        }
                        Header::Other => {
                            if let HeaderValue::Other(prev_fval) =
                                all_values[Header::Other as usize]
                            {
                                all_values[Header::Other as usize] =
                                    HeaderValue::Other(fval + prev_fval);
                            }
                        }
                    };
                }
                cpus_values.push(all_values);
            } else {
                headers_idx.reserve(cols.len());
                unsafe {
                    headers_idx.set_len(cols.len());
                }
                for (idx, head) in cols.iter().skip(1).enumerate() {
                    let header = match head.to_lowercase().as_ref() {
                        "cpu" => Header::Cpu,
                        "%usr" => Header::Usr,
                        "%sys" => Header::Sys,
                        "%iowait" => Header::Iowait,
                        "%idle" => Header::Idle,
                        _ => Header::Other,
                    };
                    headers_idx[idx] = header;
                }

                headers_parsed = true;
            }
        }
    }

    for values in cpus_values.iter() {
        println!("{:?}", values);
    }
}