use std::collections::HashMap;

use std::str::FromStr;

use serde::{Serialize};

    Error,
    ErrorKind,

    DateRange,

    RegularTimeSeries,

};
use crate::check_data::{
    SeriesMetaData,

use crate::serve_ts::{
    data_from_csv,

use crate::error:: {
    Error,
    ErrorKind,

pub struct UISpec(pub HashMap<Country, Vec<UIGraphicSpec>>);

pub struct UISpec(Vec<UIGraphicSpec>);

    type Error = Error;
    fn try_into(self) -> Result<UISpec, Error> {
        let countries: Vec<CountrySpec> = self.vec("ui::country")?; 

    type Error = keytree::Error;

        let mut h = HashMap::new();
        for country in countries {
            h.insert(country.key, country.value.0);
        }
        Ok(UISpec(h))

    fn try_into(self) -> Result<UISpec, Self::Error> {
        Ok(
            UISpec(self.vec("ui_spec::ui_graphic")?)
        )

pub struct CountrySpec {
    key: Country,
    value: ValueSpec,

/// ```
/// ui_graphic:
///     country:        Australia
///     index:          0
/// 
///     time_series:
///         data_type:  u
///         series:     AUSURAMS_a
///         transform:  ident
///     time_series:
///         data_type:  i
///         series:     _
///         transform:  ident
///     line:
///         x:          0
///         y:          1
/// ```
pub struct UIGraphicSpec {
    ///
    pub country:        Country,
    ///
    pub title:          String,
    ///
    pub index:          usize,
    ///
    pub time_series:    Vec<UITimeSeriesSpec>,
    ///
    pub line:           Vec<UILineSpec>,

impl<'a> TryInto<CountrySpec> for KeyTreeRef<'a> {
    type Error = Error;

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

    fn try_into(self) -> Result<CountrySpec, Error> {

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

        let country_str: String = self.at("country::key")?;

        let country_str: String = self.at("ui_graphic::country")?;

            CountrySpec {
                key: country,
                value: self.at("country::value")?,

            UIGraphicSpec {
                country,
                index:          self.at("ui_graphic::index")?,
                title:          self.at("ui_graphic::title")?,
                time_series:    self.vec("ui_graphic::time_series")?,
                line:           self.vec("ui_graphic::line")?,

pub struct ValueSpec(Vec<UIGraphicSpec>);

impl<'a> TryInto<ValueSpec> for KeyTreeRef<'a> {
    type Error = Error;
    fn try_into(self) -> Result<ValueSpec, Error> {
        Ok(ValueSpec(self.vec("value::graphic")?))
    }
}

/// ui:
///     country:
///         key:                    Australia
///         value:
///             graphic:
///                 title:          Unemployment and Inflation for Australia
///                 time_series:
///                     data_type:  u
///                     series:     AUSURAMS_a
///                     transform:  ident
///                 time_series:
///                     data_type:  i
///                     series:     _
///                     transform:  ident
///                 line:
///                     x:          0
///                     y:          1

/// line:
///     x:          0
///     y:          1

    type Error = Error;

    type Error = keytree::Error;

    fn try_into(self) -> Result<UILineSpec, Error> {

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

            Some(date) => Some(parse_date(&date)?),

            Some(date) => {
                Some(
                    parse_date(&date)
                        .map_err(|_|
keytree::Error::new(keytree::ErrorKind::User(Error::new(ErrorKind::ParseDate(date)).to_string())))?
                )
            },

fn parse_date(s: &str) -> Result<MonthlyDate, Error> {
    let year = s[..=4].parse::<usize>().map_err(|err| keytree::Error(Box::new(ErrorKind::User(err.to_string()))))?;
    let month = s[5..].parse::<usize>().map_err(|err| keytree::Error(Box::new(ErrorKind::User(err.to_string()))))?;
    Ok(MonthlyDate::ym(year, month))
}
#[test]
fn test_parse_date() {
    let s = "1999-03";
    assert!(
        parse_date(s),
        MonthlyDate(1999, 3),
    )

/// `Transform`s may include joining data, interpolation etc.
pub enum Transform {
    /// No-op
    Ident,

// Structs UIJson, UIGraphJson and  UILineJson encapsulate data to be converted to JSON.

impl FromStr for Transform {
    type Err = Error;

/// `UIJson` are a collection of `LineJson` convertible to JSON for a ui graphic.
#[derive(Serialize)]
pub struct UIJson {
    country: Country,
    graphics: Vec<UIGraphicJson>,
}
impl UIJson {
    /// Build a new `UIJson` from a `UISpec` specification.
    pub fn new(ui_spec: &UISpec, country: Country) -> Self {
        let ui_country_spec = ui_spec.0.get(&country).unwrap();
        let mut builder = UIJson {
            country: country,
            graphics: Vec::new(),
        };
        for graphic_spec in ui_country_spec {
            builder.graphics.push(UIGraphicJson::new(graphic_spec, country));

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "ident" => Ok(Transform::Ident),
            _ => Err(Error::new(ErrorKind::ParseTransform(s.into()))), 

        builder

}
/// `UIGraphicJson` is a JSON representation of a UI graph.
#[derive(Serialize)]
pub struct UIGraphicJson {
    title: String,
    lines: Vec<UILineJson>,

impl UIGraphicJson {
    pub fn new(graphic_spec: &UIGraphicSpec, country: Country) -> Self {
        let mut builder = UIGraphicJson {
            title: graphic_spec.title.clone(),
            lines: Vec::new(),
        };
        for line_spec in &graphic_spec.line {
            builder.lines.push(UILineJson::new(&line_spec, country));
        };

        builder
    }

/// ```
/// time_series:
///     data_type:  u
///     series:     AUSURAMS_a
///     transform:  ident
/// ```
pub struct UITimeSeriesSpec {
    start_date: Option<MonthlyDate>,
    end_date:   Option<MonthlyDate>,
    data_type:  DataType,
    series:     String,
    transform:  Transform,

/// `UILineJson` are two time-series
#[derive(Serialize)]
pub struct UILineJson {
    x: RegularTimeSeries<1>,
    y: RegularTimeSeries<1>,

    x_meta: SeriesMetaData,
    y_meta: SeriesMetaData,
}

/// ```
/// time_series:
///     data_type:  u
///     series:     AUSURAMS_a
///     transform:  ident
/// ```
impl<'a> TryInto<UITimeSeriesSpec> for KeyTreeRef<'a> {
    type Error = keytree::Error;

impl UILineJson {
    /// Build a new `UILineJson` from a `UILineSpec` specification.
    pub fn new(line_spec: &UILineSpec, country: Country) -> Self {

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

        let (mut x_data, x_meta) = data_from_csv(&line_spec.x, country, DataType::U);
        let range = DateRange::new(
            line_spec.start_date,
            line_spec.end_date,
        );
        x_data.with_range(&range);

        let data_type_str: String = self.at("time_series::data_type")?;
        let data_type = DataType::from_str(&data_type_str).unwrap();

        let (mut y_data, y_meta) = data_from_csv(&line_spec.y, country, DataType::Inf);
        y_data.with_range(&range);
        UILineJson {
            x: x_data,
            y: y_data,
            x_meta: x_meta,
            y_meta: y_meta,
        }
    }
}

        let transform_str: String = self.at("time_series::transform")?;
        let transform = Transform::from_str(&transform_str).unwrap();

/// ```
/// ui:
///     country:
///         key:                    Australia
///         value:
///             graphic:
///                 title:          Unemployment and Inflation for Australia
///                 line:
///                     x:          AUSURAMS_a
///                     y:          _
///                     start_date: _
///                     end_date:   _
///                 line:
/// ```
pub struct UIGraphicSpec {
    pub title: String,
    pub line: Vec<UILineSpec>,
}

        let start_date_str: Option<String> = self.op("time_series::start_date")?;
        let start_date = match start_date_str {
            Some(date) => Some(parse_date(&date)?),
            None => None,
        };

impl<'a> TryInto<UIGraphicSpec> for KeyTreeRef<'a> {
    type Error = Error;

        let end_date_str: Option<String> = self.op("time_series::end_date")?;
        let end_date = match end_date_str {
            Some(date) => Some(parse_date(&date)?),
            None => None,
        };

    fn try_into(self) -> Result<UIGraphicSpec, Error> {

            UIGraphicSpec {
                title: self.at("ui_graphic::title")?,
                line: self.vec("ui_graphic::line")?,

            UITimeSeriesSpec {
                data_type,
                start_date,
                end_date,
                series: self.at("time_series::series")?,
                transform,

fn parse_date(s: &str) -> Result<MonthlyDate, keytree::Error> {
    let year = s[..=4].parse::<usize>().map_err(|err| keytree::Error(Box::new(keytree::ErrorKind::User(err.to_string()))))?;
    let month = s[5..].parse::<usize>().map_err(|err| keytree::Error(Box::new(keytree::ErrorKind::User(err.to_string()))))?;
    Ok(MonthlyDate::ym(year, month))
}

#[test]
fn test_parse_date() {
    let s = "1999-03";
    assert!(
        parse_date(s),
        MonthlyDate(1999, 3),
    )
}

            country: country,

            country,

// pub mod serve_ui;

pub mod serve_ui;