mod id;

use id::ID;
use std::{
    collections::HashMap,
    fmt,
};

#[derive(Clone)]
enum Field {
    ID(ID),
}

struct Record {
    data: HashMap<String, Field>,
}

impl Record {
    fn new(data: HashMap<String, Field>) -> Self {
        Self {
            data: data,
        }
    }

    fn len(&self) -> usize {
        self.data.len()
    }

    fn get(&self, name: &str) -> Field {
        match self.data.get(name) {
            Some(data) => data.clone(),
            None => unreachable!(),
        }
    }
}

impl fmt::Display for Field {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Field::ID(id) => write!(f, "{}", id),
        }
    }
}

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

    #[test]
    fn new_record() {
        let data: HashMap<String, Field> = HashMap::new();
        let rec = Record::new(data);
        assert_eq!(rec.len(), 0);
    }

    #[test]
    fn new_record_more_data() {
        let a = ID::new();
        let b = ID::new();
        let c = ID::new();
        let mut data: HashMap<String, Field> = HashMap::new();
        data.insert("a".to_string(), Field::ID(a.clone()));
        data.insert("b".to_string(), Field::ID(b.clone()));
        data.insert("c".to_string(), Field::ID(c.clone()));
        let rec = Record::new(data);
        assert_eq!(rec.len(), 3);
        assert_eq!(rec.get("a").to_string(), a.to_string(), "record a");
        assert_eq!(rec.get("b").to_string(), b.to_string(), "record b");
        assert_eq!(rec.get("c").to_string(), c.to_string(), "record c");
    }
}