use std::collections::BTreeMap;
use std::collections::HashMap;

pub type Timestamp = u64;
pub type Data = Vec<f64>;

pub struct DatapointView<'a> {
    pub timestamp: u64,
    pub data: &'a [f64],
}

impl<'a> DatapointView<'a> {
    pub fn new(time: Timestamp, data: &'a [f64]) -> DatapointView<'a> {
        DatapointView {
            timestamp: time,
            data: data,
        }
    }
}

struct DatasetManagerItem {
    description: String,
    data: BTreeMap<Timestamp, Vec<f64>>,
}

impl DatasetManagerItem {
    fn new() -> DatasetManagerItem {
        DatasetManagerItem {
            description: "".to_owned(),
            data: BTreeMap::new(),
        }
    }

    fn insert_new_point(&mut self, time: Timestamp, data: Vec<f64>) -> DatapointView {
        self.data.insert(time, data);
        let value = self.data.get(&time).unwrap();
        DatapointView::new(time, value)
    }
}
pub struct DatasetWriter <'a>{
    pub todo: HashMap<&'a str, Vec<DatapointView<'a>>>,
    base_path: String,
}

impl <'a> DatasetWriter<'a> {
    pub fn new(path: &str) -> DatasetWriter {
        DatasetWriter {
            todo: HashMap::new(),
            base_path: path.to_string(),
        }
    }

    pub fn enqueue_work(&mut self, dataset: &'a str, data: DatapointView<'a>) {
        match self.todo.get_mut(dataset) {
            Some(data_vec) => {
                data_vec.push(data);
            }
            _ => {
                self.todo.insert(dataset, vec![data]);
            }
        }
    }
}


pub struct DatasetManager<'a> {
    writer: DatasetWriter<'a>,
    datasets: HashMap<String, DatasetManagerItem>,
}
impl<'a> DatasetManager<'a> {
    pub fn new(writer: DatasetWriter) -> DatasetManager {
        DatasetManager {
            writer: writer,
            datasets: HashMap::new(),
        }
    }

    fn insert_new_dataset(&mut self, dataset_name: &str) {
        if !self.datasets.contains_key(dataset_name) {
            self.datasets
                .insert(dataset_name.to_owned(), DatasetManagerItem::new());
        }
    }

    pub fn insert_datapoint(&mut self, time: Timestamp, data: Data, dataset_name: &str) {
        self.insert_new_dataset(dataset_name);

        let dataset_ref = self.datasets.get_mut(dataset_name).unwrap();
        let datapoint_view = dataset_ref.insert_new_point(time, data);

        self.writer.enqueue_work(dataset_name, datapoint_view);
    }
}