use std::collections::BTreeMap;
use std::collections::HashMap;
use std::borrow::Cow;

pub type Timestamp = u64;
pub type Data = Vec<f64>;
pub type DataCow<'set> = Cow<'set, [f64]>;

#[derive(Debug)]
pub struct DatapointView<'set> {
    pub timestamp: u64,
    pub data: DataCow<'set>,
}

impl<'set> DatapointView<'set> {
    pub fn new(timestamp: Timestamp, data: DataCow<'set>) -> Self {
        DatapointView { timestamp, data }
    }
}

#[derive(Debug)]
pub struct DatasetView<'set> {
    pub name: &'set str,
    pub description: &'set str,
    pub data: &'set BTreeMap<Timestamp, Data>,
}

impl<'set> DatasetView<'set> {
    pub fn earliest_datapoint(&self) -> Option<DatapointView> {
        let (time, data) = self.data.iter().next()?;
        let datapoint = DatapointView::new(*time, Cow::from(data));

        Some(datapoint)
    }
}

#[derive(Debug, Default)]
struct DatasetManagerItem<'set> {
    description: String,
    data: BTreeMap<Timestamp, DataCow<'set>>,
}

impl<'set> DatasetManagerItem<'set> {
    fn insert_new_point(&mut self, time: Timestamp, data: Data) -> DatapointView {
        let cow = Cow::from(data);
        self.data.insert(time, cow.clone());
        DatapointView::new(time, cow)
    }
}

#[derive(Debug)]
pub struct DatasetWriter<'set, 'keys> {
    pub todo: HashMap<&'keys str, Vec<DatapointView<'set>>>,
    base_path: String,
}

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

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

#[derive(Debug)]
pub struct DatasetManager<'mgr> {
    writer: DatasetWriter<'mgr, 'mgr>,
    datasets: HashMap<&'mgr str, DatasetManagerItem<'mgr>>,
}

impl<'mgr> DatasetManager<'mgr> {
    pub fn new(writer: DatasetWriter<'mgr, 'mgr>) -> DatasetManager<'mgr> {
        DatasetManager {
            writer: writer,
            datasets: HashMap::new(),
        }
    }

    pub fn insert_datapoint(&'mgr mut self, time: Timestamp, data: Data, dataset_name: &'mgr str) {
        let item = self.datasets.entry(dataset_name)
            .or_insert_with(|| DatasetManagerItem::default());

        let datapoint_view = item.insert_new_point(time, data);
        self.writer.enqueue_work(dataset_name, datapoint_view);
    }
}