use std::str::FromStr;

    DateRange,

        let range = MonthlyDate::range(&self.start_date, &self.end_date);

        let range = DateRange::new(&self.start_date, &self.end_date);

                xy_data.with_range(&range);

                xy_data.with_range(&range.0);

}
/// Transforms from a TimeSeries<1> to another TimeSeries<1>.
pub enum Transform1 {
    /// No-op
    Ident,

impl FromStr for Transform1 {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "ident" => Ok(Transform1::Ident),
            _ => Err(parse_transform1(file!(), line!(), s)),
        }
    }
}
/// Transforms from two TimeSeries<1> to a TimeSeries<2>.
pub enum Transform2 {
    ///
    Zip,
}
impl FromStr for Transform2 {
    type Err = Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "zip" => Ok(Transform2::Zip),
            _ => {
                Err(parse_transform2(file!(), line!(), s))
            },
        }
    }
}

#![allow(dead_code)]

// #![allow(dead_code)]

use std::str::FromStr;

    DateRange,

// --- 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;
    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")?,
        })
    }
}
/// 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.
#[derive(Debug)]
pub struct TSData(pub HashMap<PageKey, String>);
impl TSData {
    /// 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 new() -> TSData {
        TSData(HashMap::new())
    }
    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);
            },
        }
    }
}
/// Converts specification data into `TSData`.
pub struct Json(Vec<PageJson>);
impl Json {
    pub (crate) fn into_data(&self) -> Result<TSData, Error> {
        let mut ts_data = TSData::new();
        for page_json in &self.0 {
            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_data.insert(&key, value);
        }
        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);
    }
}
#[derive(Debug)]
/// 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()
        }
    }
    pub (crate) fn push(&mut self, graphic_json: GraphicJson) {
        self.graphics.push(graphic_json);
    }
    pub (crate) fn max(&self) -> f32 {
        self.graphics.iter()
            .map(|graphic| graphic.max())
            .fold(f32::NEG_INFINITY, |a, b| a.max(b))
    }
    pub (crate) fn min(&self) -> f32 {
        self.graphics.iter()
            .map(|graphic| graphic.min())
            .fold(f32::INFINITY, |a, b| a.min(b))
    }
    pub (crate) fn first_date(&self) -> MonthlyDate {
        match self.graphics.iter()
            .map(|graphic| graphic.first_date().0)
            .min()
        {
            Some(date) => MonthlyDate(date),
            None => {
                // No data in series?
                eprintln!("Could not calculate first date.");
                panic!()
            },
        }
    }
    pub (crate) fn last_date(&self) -> MonthlyDate {
        match self.graphics.iter()
            .map(|graphic| graphic.last_date().0)
            .max()
        {
            Some(date) => MonthlyDate(date),
            None => {
                // No data in series?
                eprintln!("Could not calculate last date.");
                panic!()
            },
        }
    }
}
impl Serialize for PageJson {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut page_json = serializer.serialize_struct("Json", 6)?;
        page_json.serialize_field("country", &self.country)?;
        page_json.serialize_field("data_type", &self.data_type)?;
        page_json.serialize_field("index", &self.index)?;
        page_json.serialize_field("max", &self.max())?;
        page_json.serialize_field("min", &self.min())?;
        page_json.serialize_field("first_date", &self.first_date())?;
        page_json.serialize_field("last_date", &self.last_date())?;
        page_json.serialize_field("graphics", &self.graphics)?;
        page_json.serialize_field("height", &GRAPHIC_HEIGHT)?;
        page_json.end()
    }
}

/// GraphicJson is the largest component that is serializable into JSON.
#[derive(Debug)]
pub struct GraphicJson {
    ///
    pub height: Option<f32>,
    ///
    pub series: Vec<(RegularTimeSeries<1>, SeriesMetaData)>,
}
impl GraphicJson {
    pub (crate) fn new() -> Self {
        GraphicJson {
            height: None,
            series: Vec::new(),
    
        }
    }
    pub (crate) fn push(&mut self, time_series: RegularTimeSeries<1>, meta: SeriesMetaData) {
        self.series.push((time_series, meta))
    }
    /// Calculate the maximum value of all series in `Self`.
    pub (crate) fn max(&self) -> f32 {
        self.series.iter()
            .map(|(ts, _)| ts.max(0))
            .fold(f32::NEG_INFINITY, |a, b| a.max(b))
    }
    /// Calculate the minimum value of all series in `Self`.
    pub (crate) fn min(&self) -> f32 {
        self.series.iter()
            .map(|(ts, _)| ts.min(0))
            .fold(f32::INFINITY, |a, b| a.min(b))
    }
    /// Return first date in all series.
    pub (crate) fn first_date(&self) -> MonthlyDate {
        match self.series.iter()
            .map(|(ts, _)| ts.first_date())
            .min()
        {
            Some(date) => MonthlyDate(date),
            None => {
                // No data in series?
                eprintln!("Could not calculate first date.");
                panic!()
            }
        }
    }
    /// Return last date of in all series.
    pub (crate) fn last_date(&self) -> MonthlyDate {
        match self.series.iter()
            .map(|(ts, _)| ts.last_date())
            .max()
        {
            Some(date) => MonthlyDate(date),
            None => {
                // No data in series?
                eprintln!("Could not calculate first date.");
                panic!()
            }
        }
    }
    pub (crate) fn height(&self) -> f32 {
        match self.height {
            Some(h) => h,
            None => GRAPHIC_HEIGHT,
        }
    }
}
impl Serialize for GraphicJson {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut graphic_json = serializer.serialize_struct("GraphicJson", 6)?;
        graphic_json.serialize_field("height", &self.height())?;
        graphic_json.serialize_field("series", &self.series)?;
        graphic_json.serialize_field("max", &self.max())?;
        graphic_json.serialize_field("min", &self.min())?;
        graphic_json.serialize_field("first_date", &self.first_date())?;
        graphic_json.serialize_field("last_date", &self.last_date())?;
        graphic_json.end()
    }
}

    // 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()
    }

    series:     Vec<SeriesSpec>,

        series:     Vec<SeriesSpec>,

        PageSpec { country, data_type, index, graphics }

        PageSpec { country, data_type, index, series, graphics }

                series:     self.vec_at("page::series")?,

    }
}
/// Specifies what text a graphic displays.
pub enum TextSpec {
    /// Specifies that graphic displays Links to series.
    Link,
    /// Specifies that graphics displays metadata.
    Meta,
    /// Specifies that graphics do not display text.
    None,
}
impl FromStr for TextSpec {
    type Err = Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "link" => Ok(TextSpec::Link),
            "meta" => Ok(TextSpec::Meta),
            _ => Err(keytree_error(file!(), line!(), "Failed to parse to Text")),
        }

    title:      Option<String>,

    seriess:    Vec<self::SeriesSpec>,

    series_id:  Vec<SeriesId>,
    fid:        Vec<String>,
    text:       TextSpec,

    pub (crate) fn new() -> Self {

    pub (crate) fn empty() -> Self {

            height: None,
            seriess: Vec::new(),

            title:      None,
            height:     None,
            series_id:  Vec::new(),
            fid:        Vec::new(),
            text:       TextSpec::None,

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

    // pub (crate) fn push(
    //     &mut self,
    //     title:          Option<Title>,
    //     height:         Option<f32>,
    //     transform_spec: Vec<TransformSpec>)
    // {
    //     let graph_spec = GraphSpec {
    //         title,
    //         height,
    //         transform_spec,
    //     };
    //     self.seriess.push(series_spec)
    // }

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

            GraphicSpec {
                title:          self.opt_value("graphic::title")?,
                height:         self.opt_value("graphic::height")?,
                series_id:      self.vec_value("graphic::series_id")?,
                fid:            self.vec_value("graphic::fid")?,
                text:           self.value("graphic::text")?,

#[derive(Debug)]

    date_range: DateRange,
    transforms: Vec<Transform>,
    fid:        Option<FID>,

    pub fn new(data_type: DataType, series_id: SeriesId) -> Self {

    pub fn new(
        data_type:  DataType,
        series_id:  SeriesId,
        date_range: DateRange,
        transforms: Vec<Transform>, 
        fid:        Option<FID>,
    ) -> Self {

            date_range,
            transforms,
            fid,

        let first_date = self.opt_value("series::first_date")?;
        let last_date = self.opt_value("series::last_date")?;
        let date_range = DateRange::new(&first_date, &last_date);

            SeriesSpec{
                data_type: self.value("series::data_type")?,
                series_id: self.value("series::series_id")?,

            SeriesSpec {
                data_type:  self.value("series::data_type")?,
                series_id:  self.value("series::series_id")?,
                date_range,
                transforms: self.vec_value("series::transform")?,
                fid:        self.opt_value("series::fid")?,

}
// === Transforms ==================================================================================
/// Transforms from a TimeSeries<1> to another TimeSeries<1>.
#[derive(Debug)]
pub enum Transform {
    ///
    ToMonthly,
    ///
    ToQuarterly,
    /// Year on year percentage change.
    YearOnYear,

impl FromStr for Transform {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "to_monthly"    => Ok(Transform::ToMonthly),
            "to_quarterly"  => Ok(Transform::ToQuarterly),
            "yoy"           => Ok(Transform::YearOnYear),
            _               => Err(parse_transform1(file!(), line!(), s)),
        }
    }
}
    
/// SeriesIdentifierAfterTransform
#[derive(Debug)]
pub struct FID(String);

impl FID {
    pub (crate) fn new(series_id: &SeriesId, f: Vec<Transform>) -> Self {
        let mut s = format!(
            "{}_",
            series_id,
        );
        for transform in f {
            match transform {
                Transform::ToMonthly    => { s.push('m') },
                Transform::ToQuarterly  => { s.push('q') },
                Transform::YearOnYear   => { s.push('y') },
            }
        }
        FID(s)
    }
}

impl FromStr for FID {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(FID(String::from(s)))
    }
}

use ui_data::ui::*;

// use ui_data::ui::*;

        let ts_spec = ts::Spec::from_file("ts_spec.keytree").unwrap();

        // let ts_spec = ts::Spec::from_file("ts_spec.keytree").unwrap();

        let ts_data = TSData::from_spec(&ts_spec, &root_dir).unwrap();

        // let ts_data = TSData::from_spec(&ts_spec, &root_dir).unwrap();

        dbg!(&ts_data);

        // dbg!(&ts_data);

pub mod ui;

// pub mod ui;

    DateRange,

use crate::error::Error;

#[derive(Serialize)]

#[derive(Clone, Serialize)]

impl MonthlyDate {
    /// Create a time_series::DateRange.
    pub fn range(
        date_opt1: &Option<MonthlyDate>,
        date_opt2: &Option<MonthlyDate>) -> time_series::DateRange
    {
        time_series::DateRange::new(
            date_opt1.as_ref().map(|date| date.0),
            date_opt2.as_ref().map(|date| date.0),
        )
    }
}

/// `DateRange` newtype.
#[derive(Debug)]
pub struct DateRange(time_series::DateRange);

impl DateRange {

    /// Create a time_series::DateRange.
    pub fn new(
        first_date: &Option<MonthlyDate>,
        last_date: &Option<MonthlyDate>) -> DateRange
    {
        DateRange(
            time_series::DateRange::new(
                &first_date.clone().map(|d| d.0),
                &last_date.clone().map(|d| d.0),
            )
        )
    }
    ///
    pub fn first_date(&self) -> Option<MonthlyDate> {
        self.0.first_date().map(|date| MonthlyDate(date))
    }
    ///
    pub fn last_date(&self) -> Option<MonthlyDate> {
        self.0.last_date().map(|date| MonthlyDate(date))
    }
}

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

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

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

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

        for ((data_type, country), series_specs) in self.map.iter() {

    //     for ((data_type, country), series_specs) in self.map.iter() {

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

    //         let mut graphic_spec = ts::GraphicSpec::empty();

            for series_spec in series_specs {
                let ts_series_spec = ts::SeriesSpec::new(
                    series_spec.data_type,
                    series_spec.series_id.clone()
                );
                ts_graphic_spec.push(ts_series_spec);
            };

    //         let series_id = series_spec.series_id;
    //         let f = Vec::new();
    //         for series_spec in series_specs {
    //             let series_spec = ts::SeriesSpec::new(
    //                 series_spec.data_type,
    //                 series_id,
    //                 DateRange::new(&None, &None),
    //                 f, 
    //                 FID::new(series_id, f), 
    //             );
    //             graphic_spec.push(series_spec);
    //         };

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

    //         let page_spec = ts::PageSpec::new(
    //             *country,
    //             *data_type,
    //             0,
    //             Vec::new(),
    //             vec!(graphic_spec),
    //         );

            ts_spec.push(ts_page_spec); 
        }
        ts_spec
    }

    //         spec.push(ts_page_spec); 
    //     }
    //     spec
    // }

        for date_point in rts.iter(DateRange::new(None, None)) {

        for date_point in rts.iter(DateRange::new(&None, &None).0) {