//! There's only one entry point in this crate: `load_cpuinfo()`. Call it, handle any errors, then
//! enjoy knowing more about your Raspberry Pi hardware!
//!
//! Hardware data is from https://www.raspberrypi.org/documentation/hardware/raspberrypi/revision-codes/README.md.

use std::{fs, path};
use std::io::{self, BufRead};

#[cfg(test)]
mod tests;

/// This is a board revision number (e.g. 1.0 for old style, 1 for new), not the top level revision code.
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum RevisionNum {
    /// Old-style x.y revisions
    Old(u8, u8),
    /// New-style integer revisions
    New(u8),
}

#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub enum MemorySize {
    MiB256,
    MiB512,
    MiB1024,
}

impl MemorySize {
    /// Returns the amount of RAM in MiB for when you want the actual number.
    pub fn mib(&self) -> u16 {
        match self {
            &MemorySize::MiB256 => 256,
            &MemorySize::MiB512 => 512,
            &MemorySize::MiB1024 => 1024,
        }
    }
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Manufacturer {
    SonyUK,
    SonyJapan,
    Egoman,
    Embest,
    Qisda,
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Model {
    A,
    APlus,
    B,
    BPlus,
    B2,
    Alpha,
    B3,
    CM1,
    Zero,
    CM3,
    ZeroW,
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Processor {
    BCM2835,
    BCM2836,
    BCM2837,
}

/// The top level aggregation of information about a particular hardware configuration.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct RaspberryPiInfo {
    /// The code from which the rest of the information was derived
    pub revision_code: u32,
    pub memory: MemorySize,
    pub mfg: Manufacturer,
    pub model: Model,
    pub revision_num: RevisionNum,
    pub processor: Processor,
}

/// Load RPi info from `/proc/cpuinfo`.
///
/// The outer `Result` is for any i/o errors (more likely a permission issue than any other error
/// for a procfs file).
///
/// The inner `Option` will be `None` if the contents of `/proc/cpuinfo` was not recognized as
/// any known Raspberry Pi model.
pub fn load_cpuinfo() -> io::Result<Option<RaspberryPiInfo>> {
    parse_cpuinfo_path(path::Path::new("/proc/cpuinfo"))
}

fn parse_cpuinfo_path(path: &path::Path) -> io::Result<Option<RaspberryPiInfo>> {
    let f = fs::File::open(path)?;
    let prefix = "Revision\t: ";

    for r in io::BufReader::new(f).lines() {
        let line = r?;
        if line.starts_with(prefix) {
            let hex_str = &line[prefix.len()..];
            let num = if let Ok(n) = u32::from_str_radix(hex_str, 16) {
                n
            } else {
                return Ok(None);
            };

            return Ok(parse_num(num));
        }
    }

    Ok(None)
}

fn parse_old_num(num: u32) -> Option<RaspberryPiInfo> {
    match num {
        0x2 | 0x3 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::Egoman,
            model: Model::B,
            revision_num: RevisionNum::Old(1, 0),
            processor: Processor::BCM2835,
        }),
        0x4 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::SonyUK,
            model: Model::B,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0x5 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::Qisda,
            model: Model::B,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0x6 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::Egoman,
            model: Model::B,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0x7 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::Egoman,
            model: Model::A,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0x8 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::SonyUK,
            model: Model::A,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0x9 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::Qisda,
            model: Model::A,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0xd => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::Egoman,
            model: Model::B,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0xe => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::SonyUK,
            model: Model::B,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0xf => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::Egoman,
            model: Model::B,
            revision_num: RevisionNum::Old(2, 0),
            processor: Processor::BCM2835,
        }),
        0x10 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::SonyUK,
            model: Model::BPlus,
            revision_num: RevisionNum::Old(1, 0),
            processor: Processor::BCM2835,
        }),
        0x11 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::SonyUK,
            model: Model::CM1,
            revision_num: RevisionNum::Old(1, 0),
            processor: Processor::BCM2835,
        }),
        0x12 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB256,
            mfg: Manufacturer::SonyUK,
            model: Model::APlus,
            revision_num: RevisionNum::Old(1, 1),
            processor: Processor::BCM2835,
        }),
        0x13 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::Embest,
            model: Model::BPlus,
            revision_num: RevisionNum::Old(1, 2),
            processor: Processor::BCM2835,
        }),
        0x14 => Some(RaspberryPiInfo {
            revision_code: num,
            memory: MemorySize::MiB512,
            mfg: Manufacturer::Embest,
            model: Model::CM1,
            revision_num: RevisionNum::Old(1, 0),
            processor: Processor::BCM2835,
        }),
        0x15 => Some(RaspberryPiInfo {
            revision_code: num, // Documented as "256/512" so who knows
            memory: MemorySize::MiB256,
            mfg: Manufacturer::Embest,
            model: Model::APlus,
            revision_num: RevisionNum::Old(1, 1),
            processor: Processor::BCM2835,
        }),
        _ => None,
    }
}

fn parse_num(num: u32) -> Option<RaspberryPiInfo> {
    if (num >> 23) & 0x1 != 1 {
        // bit 23 is not set; this is an old revision.
        return parse_old_num(num);
    }

    // bits 20-22
    let memory = match (num >> 20) & 0x7 {
        0 => MemorySize::MiB256,
        1 => MemorySize::MiB512,
        2 => MemorySize::MiB1024,
        _ => return None,
    };

    // bits 16-19
    let mfg = match (num >> 16) & 0xF {
        0 => Manufacturer::SonyUK,
        1 => Manufacturer::Egoman,
        2 => Manufacturer::Embest,
        3 => Manufacturer::SonyJapan,
        _ => return None,
    };

    // bits 12-15
    let processor = match (num >> 12) & 0xF {
        0 => Processor::BCM2835,
        1 => Processor::BCM2836,
        2 => Processor::BCM2837,
        _ => return None,
    };

    // bits 4-11
    let model = match (num >> 4) & 0xFF {
        0x0 => Model::A,
        0x1 => Model::B,
        0x2 => Model::APlus,
        0x3 => Model::BPlus,
        0x4 => Model::B2,
        0x5 => Model::Alpha,
        0x6 => Model::CM1,
        0x8 => Model::B3,
        0x9 => Model::Zero,
        0xa => Model::CM3,
        0xc => Model::ZeroW,
        _ => return None,
    };

    // bits 0-3
    let rev = num & 0xF;

    Some(RaspberryPiInfo {
        revision_code: num,
        memory,
        mfg,
        model,
        revision_num: RevisionNum::New(rev as u8),
        processor,
    })
}