use std::{
    fmt,
    fs::File,
    collections::HashMap,
    io::{self, Read},
};

pub struct CPUInfo {
    pub model_name: String,
    pub cores: u16,
}

#[derive(Debug)]
pub enum Error {
    UnsupportedSystem,
    //ExecFailed(io::Error),
    IO(io::Error),
    Unknown,
}


impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        use self::Error::*;
        match *self {
            UnsupportedSystem => write!(fmt, "System is not supported"),
            //ExecFailed(ref e) => write!(fmt, "Execution failed: {}", e),
            IO(ref e) => write!(fmt, "IO error: {}", e),
            Unknown => write!(fmt, "An unknown error occurred"),
        }
    }
}

impl std::error::Error for Error {
    fn description(&self) -> &str {
        use self::Error::*;
        match *self {
            UnsupportedSystem => "unsupported system",
            //ExecFailed(_) => "execution failed",
            IO(_) => "io error",
            Unknown => "unknown error",
        }
    }

    fn cause(&self) -> Option<&std::error::Error> {
        use self::Error::*;
        match *self {
            UnsupportedSystem => None,
            //ExecFailed(ref e) => Some(e),
            IO(ref e) => Some(e),
            Unknown => None,
        }
    }
}

impl From<io::Error> for Error {
    fn from(e: io::Error) -> Error {
        Error::IO(e)
    }
}

pub fn get_cpu() -> Result<CPUInfo, Error> {
    if cfg!(target_os = "linux") {
        let mut s = String::new();
        File::open("/proc/cpuinfo")?.read_to_string(&mut s)?;
        let mut cpuinfo_hashmap = HashMap::new();
        for line in s.lines() {
            let mut split_line = line.split_whitespace();
            let label = split_line.next();
            let value = split_line.next();
            if value.is_some() && label.is_some() {
                let label = label.unwrap().split(':').nth(0).ok_or(Error::Unknown)?;
                let value = value.unwrap().to_string();
                cpuinfo_hashmap.insert(label, value.to_string());
            }
        }

        Ok(CPUInfo {
            model_name: {
                let m = cpuinfo_hashmap.get("model name").ok_or(Error::Unknown)?;
                m.to_string()
            },
            cores: {
                let c = cpuinfo_hashmap.get("siblings").ok_or(Error::Unknown)?;
                let cores: u16 = c.parse::<u16>().unwrap();
                cores
            },
        })
    } else {
        Err(Error::UnsupportedSystem)
    }
}

fn main() {
        let cpu = get_cpu().expect("error getting cpu");
        println!("CPU: {} {}", cpu.model_name, cpu.cores)
}