#![allow(dead_code)]

    data_from_file,

            _ => Err(parse_transform1(s)),

            _ => Err(parse_transform1(file!(), line!(), s)),

            _ => Err(parse_transform2(s)),

            _ => {
                Err(parse_transform2(file!(), line!(), s))
            },

            Err(data_type_mismatch(&self.data_type.to_string(), &data_type.to_string()))

            Err(
                data_type_mismatch(
                    file!(),
                    line!(), 
                    &self.data_type.to_string(),
                    &data_type.to_string()
                )
            )

        let series_spec = data_spec.get_series_spec(&self.series_id);
        series_spec.time_series_data(root_path)

        let series_spec = match data_spec.get_series_spec(&self.series_id) {
            Some(series_spec) => series_spec,
            None => {
                return Err(
                    series_id_not_in_dataspec(
                        file!(),
                        line!(),
                        &self.series_id.to_string()
                    )
                )
            },
        };
        data_from_file(
            series_spec.country,
            series_spec.data_type,
            series_spec.series_id,
            root_path
        )

#![allow(dead_code)]

use keytree::{KeyTree, KeyTreeRef};

use keytree::{
    KeyTree,
    KeyTreeRef,
};

    data_from_file,

    meta_from_file,

use crate::error::{
    Error,
};

use crate::error::*;
// --- Client-facing data-structures --------------------------------------------------------------
/// `(DataType, Country)` key to lookup data or spec.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct PageKey {
    ///
    pub country:    Country,
    ///
    pub data_type:  DataType,
    ///
    pub index: usize,
}
impl PageKey {
    /// Return a new `PageKey`.
    pub fn new(country: Country, data_type: DataType, index: usize) -> Self {
        PageKey { country, data_type, index }
    }
}
impl<'a> TryInto<PageKey> for KeyTreeRef<'a> {
    type Error = keytree::Error;

// -- "ts_spec.keytree" ---------------------------------------------------------------------------

    fn try_into(self) -> Result<PageKey, Self::Error> {
        Ok(PageKey {
            index:      self.value("key::index")?,
            data_type:  self.value("key::data_type")?,
            country:    self.value("key::country")?,
        })
    }
}

/// Top-level time-series specification data-structure.
///
/// It can be serialized into something like,
/// ```text
/// ts_spec:
///     page:
///         data_type:  u
///         country:    Australia
///         graphic:
///             series:
///                 id: AUSURANAA
///                 id: AUSURAQS
///                 id: AUSURHARMADSMEI
///                 id: AUSURHARMMDSMEI
/// ```

/// Represents a series of graphics to be plotted on one page. A `PageKey` is a combination of
/// `Country` and `DataType`. It is served to the client as one chunk of JSON.
// GraphicJson. Json holds the JSON serialization as a String. PageJson is the largest component
// that is serializable into JSON.

pub struct TSSpec(pub Vec<TSPageSpec>);

pub struct TSData(pub HashMap<PageKey, String>);

impl TSSpec {

impl TSData {

    pub (crate) fn new() -> TSSpec {
        TSSpec(Vec::new())

    /// Build time-series data from a time-series specification.
    pub fn from_spec(spec: &Spec, root_path: &str) -> Result<Self, Error> {
        spec
            .into_data(root_path)

    pub (crate) fn push(&mut self, item: TSPageSpec) {
        self.0.push(item)

    pub (crate) fn new() -> TSData {
        TSData(HashMap::new())

    /// Read from file.
    pub fn from_file(path: &str) -> Self {
        let ts_spec = fs::read_to_string(path).unwrap();
        let kt = KeyTree::parse(&ts_spec).unwrap();
        kt.to_ref().try_into().unwrap()

    pub (crate) fn insert(&mut self, key: &PageKey, value: String) {
        match self.0.get_mut(key) {
            Some(_) => {
                println!("Tried to insert page_key: {:?} twice.", key);
                panic!();
            },
            None => {
                self.0.insert(*key, value);
            },
        }

}

    /// ts_spec:
    ///     page:
    ///         data_type:  u
    ///         country:    Australia
    ///         graphic:
    ///             series:
    ///                 id: AUSURANAA
    ///                 id: AUSURAQS
    ///                 id: AUSURHARMADSMEI
    ///                 id: AUSURHARMMDSMEI
    pub fn into_json(
        &self,
        data_spec: &DataSpec,
        root_path: &str) -> Result<TSJson, Error>
    {
        let mut ts_json = TSJson::new();

/// Converts specification data into `TSData`.
pub struct Json(Vec<PageJson>);

impl Json {

        for page_spec in &self.0 {
            let key = page_spec.key();

    pub (crate) fn into_data(&self) -> Result<TSData, Error> {

            let mut value: Vec<GraphicJson> = Vec::new();

        let mut ts_data = TSData::new();

        for page_json in &self.0 {

            for graphic in &page_spec.graphics {
                let json = graphic.into_json(data_spec, root_path)?;
                value.push(json);

            let key = PageKey::new(
                page_json.country,
                page_json.data_type,
                page_json.index
            );
            let value = match serde_json::to_string(&page_json) {
                Ok(s) => s,
                Err(err) => {
                    eprintln!("{}", err.to_string());
                    panic!();
                },

            ts_json.insert(&key, value);

            ts_data.insert(&key, value);

        Ok(ts_json)

        Ok(ts_data)
    }
    pub (crate) fn new() -> Self {
        Json(Vec::new())
    }
    pub (crate) fn push(&mut self, page_json: PageJson) {
        self.0.push(page_json);

impl IntoKeyTree for TSSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        kt.push_key(0, "ts_spec");
        for page in &self.0 {
            kt.push_keytree(1, page.keytree());

#[derive(Debug, Serialize)]
/// Serializable into JSON data for a time-series HTML page.
pub struct PageJson {
    country:    Country,
    data_type:  DataType,
    index:      usize,
    graphics:   Vec<GraphicJson>,
}
impl PageJson {
    pub (crate) fn new(country: Country, data_type: DataType, index: usize) -> Self {
        PageJson {
            country, data_type, index, graphics: Vec::new()

        kt

}

impl<'a> TryInto<TSSpec> for KeyTreeRef<'a> {
    type Error = keytree::Error;
    fn try_into(self) -> Result<TSSpec, Self::Error> {
        let page_vec: Vec<TSPageSpec> = self.vec_at("ts_spec::page")?;
        Ok(TSSpec(page_vec))

    pub (crate) fn push(&mut self, graphic_json: GraphicJson) {
        self.graphics.push(graphic_json);

/// Component of `TSSpec`.
///
/// Mirrored with a keytree specification which is the `country:` key in
/// ```
/// page:
///     country:    Australia
///     data_type:  u
///     index:      0
///     graphic:
///         series:
///             series_id: AUSURANAA
///             data_type: u
///         series:
///             data_type: u
///             series_id: AUSURAQS
///         series:
///             data_type: u
///             series_id: AUSURHARMADSMEI
///         series:
///             data_type:  u
///             series_id: AUSURHARMMDSMEI
/// ```
#[derive(Debug)]
pub struct TSPageSpec {

/// GraphicJson is the largest component that is serializable into JSON.
#[derive(Debug, Serialize)]
pub struct GraphicJson {

    pub country:    Country,
    ///
    pub data_type:  DataType,
    ///
    pub index:      usize,

    pub height: Option<f32>,

    pub graphics:   Vec<TSGraphicSpec>,

    pub series: Vec<(RegularTimeSeries<1>, SeriesMetaData)>,

impl TSPageSpec {
    pub (crate) fn new(key: PageKey, graphics: Vec<TSGraphicSpec>) -> Self {
        TSPageSpec {
            country:    key.country,
            data_type:  key.data_type,
            index:      key.index, 
            graphics:   graphics,

impl GraphicJson {
    pub (crate) fn new() -> Self {
        GraphicJson {
            height: None,
            series: Vec::new(),

    pub (crate) fn push(&mut self, ts_graphic_spec: TSGraphicSpec) {
        self.graphics.push(ts_graphic_spec)

    pub (crate) fn push(&mut self, time_series: RegularTimeSeries<1>, meta: SeriesMetaData) {
        self.series.push((time_series, meta))

}

    pub (crate) fn key(&self) -> PageKey {
        PageKey {
            country:    self.country,
            data_type:  self.data_type,
            index:      self.index,

// === Time-series Specification ==================================================================
/// Time-series specification.
/// ```
/// ts_spec:
///     page:
///         country:            Australia
///         data_type:          u
///         index:              0
///         graphic:
///             series:
///                 data_type:  u
///                 series_id:  AUSURAMS
///             series:
///                 data_type:  u
///                 series_id:  AUSURANAA
/// ```
pub struct Spec(Vec<PageSpec>);
impl Spec {
    // The Spec components do not map well to Json components.
    // 1. Json is not serializable - it is a HashMap which maps PageKeys to Strings to serve.
    // 2. PageJson does not exists. PageSpec.into_json creates a Vec<GraphicJson>.
    pub (crate) fn into_data(&self, root_path: &str) -> Result<TSData, Error> {
        let mut json = Json::new();
        for page_spec in &self.0 {
            let mut page_json = PageJson::new(
                page_spec.country,
                page_spec.data_type,
                page_spec.index,
            );
            
            for graphic_spec in &page_spec.graphics {
                let mut graphic_json = GraphicJson::new();
                for series_spec in &graphic_spec.seriess {
                    let rts = data_from_file(
                        page_spec.country,
                        series_spec.data_type,
                        series_spec.series_id.clone(),
                        root_path,
                    )?;
                    let meta = meta_from_file(
                        page_spec.country,
                        series_spec.data_type,
                        series_spec.series_id.clone(),
                        root_path,
                    );
                    graphic_json.push(rts, meta);
                }
                page_json.push(graphic_json);
            }
            json.push(page_json);

        // Now we have a Json datastructure which we can iterate over the pages, serialize, generate
        // keys, and build a TSData Hashmap.
        json.into_data()

}

impl IntoKeyTree for TSPageSpec {
    fn keytree(&self) -> KeyTreeString {

    /// Read in ts specification from file.
    /// ```
    /// let ts_spec = ts::Spec::from_file("ts_spec.keytree");
    /// ```
    pub fn from_file(path: &str) -> Result<Self, Error> {
        let source_spec = match fs::read_to_string(path) {
            Ok(ss) => ss,
            Err(err) => { return Err(
                failed_to_read_file(
                    file!(),
                    line!(),
                    &err.to_string()
                ))
            },
        };
        let kt = KeyTree::parse(&source_spec).unwrap();
        kt.to_ref().try_into().map_err(|err: keytree::error::Error| {
            keytree_error(file!(), line!(), &err.to_string())
        }) 
    }

        let mut kt = KeyTreeString::new();

    pub (crate) fn new() -> Self {
        Spec(Vec::new())
    }

        kt.push_key(0, "page");
        kt.push_value(1, "country", &self.country.to_string());
        kt.push_value(1, "data_type", &self.data_type.to_string());
        kt.push_value(1, "index", &self.index.to_string());
        for graphic in &self.graphics {
            kt.push_keytree(1, graphic.keytree());
        }
        kt

    pub (crate) fn push(&mut self, page_spec: PageSpec) {
        self.0.push(page_spec)

impl<'a> TryInto<TSPageSpec> for KeyTreeRef<'a> {

impl<'a> TryInto<Spec> for KeyTreeRef<'a> {

    fn try_into(self) -> Result<TSPageSpec, Self::Error> {
        Ok(TSPageSpec {
            country:    self.value("page::country")?,
            data_type:  self.value("page::data_type")?,
            index:      self.value("page::index")?,
            graphics:   self.vec_at("page::graphic")?,
        })

    fn try_into(self) -> Result<Spec, keytree::Error> {
        Ok(Spec(self.vec_at("ts_spec::page")?))

/// Component of `TSSpec`.

// There are two important functions that need to be built.
// 1. SeriesSpec.into_json(). This is done in lib.rs.
// 2. PageJason.into_data()
/// Component of time-series specification.

/// graphic:
///     series:
///         series_id: AUSURANAA
///         data_type: u
///     series:
///         data_type: u
///         series_id: AUSURAQS
///     series:
///         data_type: u
///         series_id: AUSURHARMADSMEI
///     series:
///         data_type:  u
///         series_id: AUSURHARMMDSMEI

/// page:
///     country:            Australia
///     data_type:          u
///     index:              0
///     graphic:
///         series:
///             data_type:  u
///             series_id:  AUSURAMS
///         series:
///             data_type:  u
///             series_id:  AUSURANAA

#[derive(Debug)]
pub struct TSGraphicSpec {
    /// Height in pixels of the graphic.
    pub height: Option<f32>,
    /// e.g. [ AUSURHARMADSMEI, ... ]
    pub series: Vec<TSSeriesSpec>, 

pub struct PageSpec {
    country:    Country,
    data_type:  DataType,
    index:      usize,
    graphics:   Vec<GraphicSpec>,

impl TSGraphicSpec {

    pub (crate) fn new() -> Self {
        TSGraphicSpec {
            height: None,
            series: Vec::new(),
        }
    }

impl PageSpec {

    pub (crate) fn push(&mut self, series: TSSeriesSpec) {
        self.series.push(series)

    ///
    pub fn new(
        country:    Country,
        data_type:  DataType,
        index:      usize,
        graphics:   Vec<GraphicSpec>) -> Self
    { 
        PageSpec { country, data_type, index, graphics }

    pub (crate) fn into_json(
        &self,
        data_spec: &DataSpec,
        root_path: &str) -> Result<GraphicJson, Error>
     {

}

        let mut series_json = SeriesJson::new();
      
        for (series_id, _) in &data_spec.reverse {

impl<'a> TryInto<PageSpec> for KeyTreeRef<'a> {
    type Error = keytree::Error;

            let series_spec = data_spec.get_series_spec(series_id);
            
            let ts = series_spec.time_series_data(root_path)?;
            let meta = series_spec.meta(root_path);
            series_json.push(ts, meta);
        } 

    fn try_into(self) -> Result<PageSpec, keytree::Error> {

            GraphicJson {
                height: self.height,
                series: series_json,

            PageSpec {
                country:    self.value("page::country")?, 
                data_type:  self.value("page::data_type")?,
                index:      self.value("page::index")?,
                graphics:   self.vec_at("page::graphic")?,

impl IntoKeyTree for TSGraphicSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();

/// Component of time-series specification.
/// ```
/// graphic:
///     series:
///         data_type:  u
///         series_id:  AUSURAMS
///     series:
///         data_type:  u
///         series_id:  AUSURANAA
/// ```
pub struct GraphicSpec {
    height:     Option<f32>,
    seriess:    Vec<self::SeriesSpec>,
}

        kt.push_key(0, "graphic");
        if let Some(height) = self.height {
            kt.push_value(1, "height", &height.to_string());
        };
        for series in &self.series {
            kt.push_keytree(1, series.keytree());

impl GraphicSpec {
    pub (crate) fn new() -> Self {
        GraphicSpec {
            height: None,
            seriess: Vec::new(),

        kt

    }
    pub (crate) fn push(&mut self, series_spec: self::SeriesSpec) {
        self.seriess.push(series_spec)

impl<'a> TryInto<TSGraphicSpec> for KeyTreeRef<'a> {

impl<'a> TryInto<GraphicSpec> for KeyTreeRef<'a> {

    fn try_into(self) -> Result<TSGraphicSpec, Self::Error> {

    fn try_into(self) -> Result<GraphicSpec, keytree::Error> {

            TSGraphicSpec {
                height: self.opt_value("graphic::height")?,
                series: self.vec_at("graphic::series")?,

            GraphicSpec{
                height:     self.opt_value("graphic::height")?,
                seriess:    self.vec_at("graphic::series")?,

/// Component of `TSGraphicSpec`.
/// ```text

// This is differentiated from lib::SeriesSpec in that is is just for interacting with 
// 
/// Component of time-series specification.
/// ```

///     data_type: u
///     series_id: AUSURHARMADSMEI

///     data_type:  u
///     series_id:  AUSURAMS

#[derive(Debug)]
pub struct TSSeriesSpec {
    ///

pub struct SeriesSpec {

impl TSSeriesSpec {
    /// Return a new `TSSeries`.

impl SeriesSpec {
    /// 

        TSSeriesSpec {

        SeriesSpec {

impl<'a> TryInto<TSSeriesSpec> for KeyTreeRef<'a> {

impl<'a> TryInto<SeriesSpec> for KeyTreeRef<'a> {

    fn try_into(self) -> Result<TSSeriesSpec, Self::Error> {

    fn try_into(self) -> Result<SeriesSpec, keytree::Error> {

            TSSeriesSpec {

            SeriesSpec{

    }
}
impl IntoKeyTree for TSSeriesSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        kt.push_key(0, "series");
        kt.push_value(1, "data_type", &self.data_type.to_string());
        kt.push_value(1, "series_id", &self.series_id.to_string());
        kt

// --- Client-facing data-structures --------------------------------------------------------------

/// Represents a series of graphics to be plotted on one page. A `PageKey` is a combination of
/// `Country` and `DataType`. It is served to the client as one chunk of JSON.
#[derive(Debug)]
pub struct TSJson(pub HashMap<PageKey, String>);
impl TSJson {
    pub (crate) fn new() -> TSJson {
        TSJson(HashMap::new())
    }
    pub (crate) fn insert(&mut self, key: &PageKey, value: Vec<GraphicJson>) {
        match self.0.get_mut(key) {
            Some(_) => {
                println!("Tried to insert page_key: {:?} twice.", key);
                panic!();
            },
            None => {
                self.0.insert(
                    *key,
                    serde_json::to_string(&value).unwrap(),
                );
            },
        }
    }
}
/// Respresents a graphic to be served to the client as JSON.
#[derive(Debug, Serialize)]
pub struct GraphicJson {
    ///
    pub height: Option<f32>,
    ///
    pub series: SeriesJson,
}
/// `SeriesJson` is a time-series to be served to the client as JSON.
#[derive(Debug, Serialize)]
pub struct SeriesJson(Vec<(RegularTimeSeries<1>, SeriesMetaData)>);
impl SeriesJson {
    /// Create a new, empty `SeriesJson`.
    pub fn new() -> Self {
        SeriesJson(Vec::new())
    }
    /// Push time-series data and associated meta-data onto `SeriesJson`.
    pub fn push(&mut self, ts: RegularTimeSeries<1>, meta: SeriesMetaData) {
        self.0.push((ts, meta));
    }
}
/// `(DataType, Country)` key to lookup data or spec.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct PageKey {
    ///
    pub country:    Country,
    ///
    pub data_type:  DataType,
    ///
    pub index: usize,
}
impl PageKey {
    /// Return a new `PageKey`.
    pub fn new(country: Country, data_type: DataType, index: usize) -> Self {
        PageKey { country, data_type, index }
    }
}
impl<'a> TryInto<PageKey> for KeyTreeRef<'a> {
    type Error = keytree::Error;
    fn try_into(self) -> Result<PageKey, Self::Error> {
        Ok(PageKey {
            index:      self.value("key::index")?,
            data_type:  self.value("key::data_type")?,
            country:    self.value("key::country")?,
        })
    }
}

#![allow(unused_imports)]
use std::time::SystemTime;
use time::{
    Duration,
    OffsetDateTime,
};

    
    let data_spec = DataSpec::from_file("source_data.keytree").unwrap();
    let ts_spec = TSSpec::from_file("ts_spec.keytree");

  
    // Step 1
        // println!("{}", DataSelector::from_file("series_selector.keytree")
        //     .into_data_spec()
        //     .unwrap()
        //     .keytree());

    let ts_json = ts_spec.into_json(&data_spec, &root_dir);
}

        // println!("{}", DataSelector::from_file("germany_selector.keytree")
        //     .into_data_spec()
        //     .unwrap()
        //     .keytree());
        // println!("{}", DataSelector::from_file("austria_selector.keytree")
        //     .into_data_spec()
        //     .unwrap()
        //     .keytree());
    // (paste this)
    // Step 2
        let data_spec =  DataSpec::from_file("source_data.keytree").unwrap();
        // data_spec.update_write(&root_dir).unwrap();

    // Step 3

        // println!("{}", data_spec.generic_ts_spec().keytree());
        // (paste this)
    // Step 4
        let ts_spec = ts::Spec::from_file("ts_spec.keytree").unwrap();
        
        let ts_data = TSData::from_spec(&ts_spec, &root_dir).unwrap();
        dbg!(&ts_data);
    // Fred::series_observations("AUSURTOTMDSMEI").unwrap();
    // JSON does have "." as first value. What should we do? drop_until_parsable ? Or just define
    // dates?
    // We have to know where the parsing happens.
    // It happens in "TimeSeries::<1>::from_csv(&path)"
}

//! to resume.

//! to resume. To update the data files due to a change of the DataSpec,
//! ```
//! let date = OffsetDateTime::now_utc() - Duration::days(3);
//! data_spec
//!     .update_write(date.into(), &root_dir)
//!     .unwrap();
//! ```

//! let ts_json = ts_spec.into_json(&data_spec, "/full/path/to/data");

//! let ts_json = ts_spec.into_json(&data_spec, "/full/path/to/data").unwrap();

use std::file;

use std::line;
use std::path::Path;

use walkdir::WalkDir;

    DatePoint,
    DateRange,

    TSGraphicSpec,
    TSPageSpec,
    TSSeriesSpec,
    TSSpec,

    PageSpec,
    Spec,

/// Return the pathname of a data file.
pub fn data_path(
    root_path: &str,
    data_type: DataType,
    country: Country,
    series_id: SeriesId,
    extension: &str) -> String 
{
    format!(
        "{}/{}/{}/{}.{}",
        root_path,
        data_type,
        country.as_path(),
        series_id,
        extension,
    )
}

        let year = s[..4].parse().map_err(|_| parse_date("failed"))?;
        let month = s[5..7].parse().map_err(|_| parse_date("failed"))?;

        let year = s[..4].parse().map_err(|_| parse_date(file!(), line!(), "failed"))?;
        let month = s[5..7].parse().map_err(|_| parse_date(file!(), line!(), "failed"))?;

            _       => Err(parse_datatype(s)),

            _       => Err(parse_datatype(file!(), line!(), s)),

pub fn title(series_id: &SeriesId) -> String {

pub fn title(series_id: &str) -> Result<String, Error> {
    let sid = SeriesId::from_str(series_id).unwrap();

    let seriess = match Fred::series(&series_id.to_string()) {

    let seriess = match Fred::series(&sid.to_string()) {

        Err(err) => {
            println!("{}", err);
            panic!();
        },

        Err(err) => { return Err(fred_error(file!(), line!(), &err.to_string())) },

    s

    Ok(s)

    pub fn get_series_spec(&self, series_id: &SeriesId) -> SeriesSpec {
        let key = self.reverse.get(&series_id).unwrap();
        let seriess = self.map.get(&key).unwrap();
        (*seriess.iter().find(|series| &series.series_id == series_id).unwrap()).clone()
    }

    pub fn get_series_spec(&self, series_id: &SeriesId) -> Option<SeriesSpec> {

    /// Test if a key `(DataType, Country)` has a `SeriesId`.
    pub fn key_has_series_id(&self, key: (DataType, Country), series_id: &SeriesId) -> Result<bool, Error> {
        let series_specs = match self.map.get(&key) {
            Some(series_specs) => series_specs,
            None => { return Err(key_not_in_dataspec(&key.0.to_string(), &key.1.to_string())) },

        let key = match self.reverse.get(&series_id) {
            Some(key) => key,
            None => { return None },

        Ok(series_specs.iter().any(|series| &series.series_id == series_id))

        let seriess = self.map.get(&key).unwrap();      
        match seriess.iter().find(|&series| {
            &series.series_id == series_id
        }) {
            Some(series_spec) => Some(series_spec.clone()),
            None => None,
        } 

    /// Build a generic `TSSpec` from `Self`.
    pub fn generic_ts_spec(&self) -> TSSpec {

    /// Build a generic `Spec` from `Self`.
    pub fn generic_ts_spec(&self) -> ts::Spec {

        let mut ts_spec = TSSpec::new();

        let mut ts_spec = ts::Spec::new();

            let mut ts_graphic_spec = TSGraphicSpec::new();

            let mut ts_graphic_spec = ts::GraphicSpec::new();

                let ts_series_spec = TSSeriesSpec::new(

                let ts_series_spec = ts::SeriesSpec::new(

            let ts_page_spec = TSPageSpec::new(page_key, vec!(ts_graphic_spec));

            let ts_page_spec = ts::PageSpec::new(
                *country,
                *data_type,
                0,
                vec!(ts_graphic_spec),
            );

            Err(err) => { return Err(failed_to_read_file(&err.to_string())) },

            Err(err) => { return Err(
                failed_to_read_file(
                    file!(),
                    line!(),
                    &err.to_string()
                ))
            },

        kt.to_ref().try_into().map_err(|err: keytree::error::Error| keytree_error(&err.to_string())) 

        kt.to_ref().try_into().map_err(|err: keytree::error::Error| {
            keytree_error(file!(), line!(), &err.to_string())
        }) 

    pub fn write(&self, root_path: &str) {

    pub fn write(&self, root_path: &str) -> Result<(), Error> {

                series_spec.write_data(root_path);
                series_spec.write_meta(root_path); 

                series_spec.write_data(root_path)?;
                series_spec.write_meta(root_path)?; 
            }
        }
        Ok(())
    }
    // Need to keep a record of all files and remove files that shouldn't exist.
    // 
    // i.e. its not sufficient to check if a file exists. We need to check if a file remains. So we
    // need to create a file list.
    /// Only make requests and updata data to Fred for files that are in `DataSpec` but do not exist
    /// as data files.
    pub fn update_write(&self, root_path: &str) -> Result<(), Error> {
        for (_, series_specs) in &self.map {
            for series_spec in series_specs {
                if !series_spec.exists(root_path)? {
                    series_spec.write_data(root_path)?;
                    series_spec.write_meta(root_path)?;
                }
            }
        }
        self.remove_old(root_path)?;
        Ok(())
    }
    /// Run through data files, query and remove any files that are not in directory.
    pub fn remove_old(&self, root_path: &str) -> Result<(), Error> {
        for entry in WalkDir::new(root_path) {
            let entry = entry.unwrap();
            if entry.file_type().is_dir() { continue };
   
            let pathbuf = entry.path(); 
            let mut path_iter = pathbuf.iter().rev().map(|os_str| os_str.to_str().unwrap());
            let mut file_parts = path_iter.next().unwrap().split('.');
            let file_stem = file_parts.next().unwrap();
            let file_ext = file_parts.next().unwrap();
            if (file_ext != "csv") && (file_ext != "meta") {
                println!("Unknown file [{}]", pathbuf.to_str().unwrap());
                panic!();

            let series_id = SeriesId::new(file_stem);
            match self.get_series_spec(&series_id) {
                Some(_) => {},
                None => {
                    match fs::remove_file(entry.path()) {
                        Ok(_) => {},
                        Err(_) => {
                            return Err(file_error(file!(), line!()))
                         },
                    }
                },
            };

        Ok(())

    pub fn resume_write(&self, series_id: &str, root_path: &str) {

    pub fn resume_write(&self, series_id: &str, root_path: &str) -> Result<(), Error> {

        for ((data_type, country), series_specs) in self

        for (_, series_specs) in self

            .skip_while(|((data_type, country), series_specs)| {
                 match self.key_has_series_id((*data_type, *country), &sid) {
                    Err(err) => {
                        println!("{}", err);
                        panic!();
                    },
                    Ok(is_true) => !is_true,

            .skip_while(|_| {
                match self.get_series_spec(&sid) {
                    Some(series_spec) => sid != series_spec.series_id,
                    None => true,

                series_spec.write_data(root_path);
                series_spec.write_meta(root_path); 

                series_spec.write_data(root_path)?;
                series_spec.write_meta(root_path)?;

        Ok(())

#[derive(Clone)]

#[derive(Clone, Debug)]

    /// Check if a file exists. 
    pub fn exists(&self, root_path: &str) -> Result<bool, Error> {
        
        let csv_path = data_path(
            root_path,
            self.data_type,
            self.country,
            self.series_id.clone(),
            "csv",
        );
        let meta_path = data_path(
            root_path,
            self.data_type,
            self.country,
            self.series_id.clone(),
            "meta",
        );
        Ok(
            Path::new(&csv_path).exists() &&
            Path::new(&meta_path).exists()
        )
    }

            None => { return Err(series_id_not_in_dataspec(&series_id.to_string())) },

            None => { return Err(
                series_id_not_in_dataspec(
                    file!(),
                    line!(),
                    &series_id.to_string()
                )
            )},

    /// Return the meta data for a `SeriesSpec`.
    pub fn meta(&self, root_path: &str) -> SeriesMetaData {

    /// Use `Self` to make a Fred request for series data, and return a `RegularTimeSeries`.
    pub fn into_time_series(&self) -> Result<RegularTimeSeries<1>, Error> {
        // Select the observation data from the FRED data.
    
        let observations = match Fred::series_observations(&self.series_id.to_string()) {
            Ok(series_obs) => series_obs.observations,
            Err(err) => { return Err(fred_error(file!(), line!(), &err.to_string())) },
        };

        let path = &format!(
            "{}/{}/{}/{}.meta",
            root_path,
            self.data_type,
            self.country.as_path(),
            self.series_id,
        );

        // We need to build a RegularTimeSeries here, and then use RegularTimeSeries here
        // to build csv file.
        // Data is parsed into a RegularTimeSeries

        let meta_str = fs::read_to_string(path).unwrap();
        let kt = KeyTree::parse(&meta_str).unwrap();
        kt.to_ref().try_into().unwrap()
    }

        // Want power to drop_first

    /// Return the time-series data for `series_id`.
    pub fn time_series_data(&self, root_path: &str) -> Result<RegularTimeSeries<1>, Error> { 

        let mut v = Vec::new();

        let path = &format!(
            "{}/{}/{}/{}.csv",
            root_path,
            self.data_type,
            self.country.as_path(),
            self.series_id,
        );

        // Drop the first n items
        let skip = match self.drop_first {
            None => 0,
            Some(n) => n,
        };
        for (i, obs) in observations.iter().enumerate().skip(skip) { 
            let date = MonthlyDate::from_str(&obs.date)?;
            let value: f32 = match obs.value.parse() {
                Ok(n) => n,
                Err(_) => {
                    let err = parse_fred_value_failed(
                        file!(),
                        line!(),
                        &self.data_type.to_string(),
                        &self.country.to_string(),
                        &self.series_id.to_string(),
                        &format!(
                            "{}, {}",
                            obs.date,
                            obs.value,
                        ),
                        i + 1,
                    );
                    self.soft_parse(observations, err);
                    unreachable!();
                },
            };

        match TimeSeries::<1>::from_csv(&path) {
            Ok(ts) => {
                match ts.try_into() {
                    Ok(rts) => Ok(rts),
                    Err(err) => Err(from_time_series(&err.to_string())),
                }

            let date_point = DatePoint::<1>::new(date.0, [value]);
            v.push(date_point) 
        }
        let ts = TimeSeries::new(v);
        let rts = match ts.try_into() {
            Ok(rts) => {
                rts
            },
            Err(_) => {
                let err = expected_regular_time_series(
                    file!(),
                    line!(), 
                    &self.data_type.to_string(),
                    &self.country.to_string(),
                    &self.series_id.to_string(),
                );
                self.soft_parse(observations, err);
                unreachable!();

            Err(err) => Err(from_time_series(&err.to_string())),

        };
        Ok(rts)
    }
    /// Parse observations into string for debugging and exit.
    pub fn soft_parse(&self, observations: fred_api::Observations, err: Error) {
        for (i, obs) in observations.iter().enumerate() {
            eprintln!(
                "{} {}, {}",
                i + 1,
                obs.date,
                obs.value,
            )

        eprintln!("{}", err);
        std::process::exit(1);

    /// Fetches data as specified in `source_data.keytree` and saves to disk.
    pub fn write_data(&self, root_path: &str) -> Result<(), Error> {

        let rts = self.into_time_series()?;

    /// Fetches data as specified in `checked_data.keytree` and saves to disk.
    pub fn write_data(&self, root_path: &str) {

        let mut csv = String::new();
        for date_point in rts.iter(DateRange::new(None, None)) {
            let date = date_point.date();
            let date_str = format!(
                "{}-{:02}-01",
                date.year(),
                date.month(),
            );

        // Select the observation data from the FRED data.
    
        let observations = match Fred::series_observations(&self.series_id.to_string()) {
            Ok(series_obs) => series_obs.observations,
            Err(err) => {
                println!("{}", err);
                panic! ();
            },
        };
    
        let mut data = String::new();
    
        for obs in observations.iter() { 
            data.push_str(&obs.to_string());
            data.push('\n');

            let line = format!(
                "{}, {}\n",
                date_str,
                date_point.value(0),
            ); 
            csv.push_str(&line);

        fs::create_dir_all(&dir_path).unwrap();

        if let Err(err) = fs::create_dir_all(&dir_path) {
            return Err(
                failed_to_create_dir(
                    file!(),
                    line!(),
                    &err.to_string()
                )
            )
        }

        println!("Writing {}", filename);
        fs::write(filename, &data).unwrap();

        println!(
            "Writing {}", filename);
        if let Err(_) = fs::write(filename, &csv) {
            return Err(
                failed_to_write_file(
                    file!(),
                    line!(),
                    filename,
                )
            )
        };
        Ok(())

    /// Fetches data as specified in `checked_data.keytree` and saves meta_data to disk.
    pub fn write_meta(&self, root_path: &str) {

    /// Fetches data as specified in `source_data.keytree` and saves meta_data to disk.
    pub fn write_meta(&self, root_path: &str) -> Result<(), Error> {

            Err(err) => {
                println!("{}", err);
                panic! ();
            },

            Err(err) => { return Err(
                fred_error(
                    file!(),
                    line!(),
                    &err.to_string()
                )
            )},

        Ok(())

//            self.time_stamp = Some(TimeStamp::now());

/// Read csv data from file and return a time-series.
pub fn data_from_file(
    country:    Country,
    data_type:  DataType,
    series_id:  SeriesId,
    root_path: &str) -> Result<RegularTimeSeries<1>, Error>
{ 
    let path = data_path(
        root_path,
        data_type,
        country,
        series_id.clone(),
        "csv"
    );
    match TimeSeries::<1>::from_csv(&path) {
        Ok(ts) => {
            match ts.try_into() {
                Ok(rts) => Ok(rts),
                Err(err) => {
                    Err(time_series_from_csv_failed(
                        file!(),
                        line!(),
                        &data_type.to_string(),
                        &country.to_string(),
                        &series_id.to_string(),
                        &err.to_string(),
                    ))
                },
            }
        },
        Err(err) => Err(time_series_from_csv_failed(
            file!(),
            line!(),
            &data_type.to_string(),
            &country.to_string(),
            &series_id.to_string(),
            &err.to_string(),
        ))
    }
}
/// Return the meta data for a `SeriesSpec`.
pub fn meta_from_file(
    country:    Country,
    data_type:  DataType,
    series_id:  SeriesId,
    root_path: &str) -> SeriesMetaData
{
    let path = data_path(
        root_path,
        data_type,
        country,
        series_id.clone(),
        "meta"
    );
         
    let meta_str = fs::read_to_string(path).unwrap();
    let kt = KeyTree::parse(&meta_str).unwrap();
    kt.to_ref().try_into().unwrap()
}

walkdir = "2.3.2"