use std::collections::HashMap;
use serde::Deserialize;

/// Represents a configuration file.
#[derive(Debug, PartialEq, Deserialize)]
pub struct Config {
    /// The mapping from relay name to relay virtual address
    relays: HashMap<String, u32>,
    /// The mapping from sensor name to sensor metadata
    sensors: HashMap<String, SensorRecord>
}

/// Represents the metadata for a sensor.
#[derive(Debug, PartialEq, Deserialize)]
pub struct SensorRecord {
    /// The virtual address for the sensor.
    v_addr: u32,
    /// The name of the unit for this sensor (e.g. C for Celsius).
    unit: String,
    /// The path to the lookup table file that this sensor goes with.
    lookup_table_path: String
}

#[cfg(test)]
mod tests {
    use super::*;
    use toml;

    #[test]
    fn toml_test() {
        let input = r#"
        [relays]
        a = 0
        b = 1
        c = 2

        [sensors]
        d = { v_addr = 0, unit = "C", lookup_table_path = "./d.lu" }
        e = { v_addr = 1, unit = "C", lookup_table_path = "./e.lu" }
        f = { v_addr = 2, unit = "C", lookup_table_path = "./f.lu" }
        "#;

        let relays: Vec<(String, u32)> = vec![
            ("a".into(), 0 ), ("b".into(), 1 ), ("c".into(), 2 )
        ];
        let sensors: Vec<(String, SensorRecord)> = vec![
            ("d".into(), SensorRecord { v_addr: 0, unit: "C".into(), lookup_table_path: "./d.lu".into() }),
            ("e".into(), SensorRecord { v_addr: 1, unit: "C".into(), lookup_table_path: "./e.lu".into() }),
            ("f".into(), SensorRecord { v_addr: 2, unit: "C".into(), lookup_table_path: "./f.lu".into() })
        ];
        let expected = Config {
            relays: relays.into_iter().collect(),
            sensors: sensors.into_iter().collect()
        };
        let actual: Config = toml::from_str(input).unwrap();

        assert_eq!(expected, actual);
    }
}