//! The `TSPageSpec::TSCountrySpec::TSGraphicSpec` group of data-structures mirrors
//! `ts_spec.keytree`. Its main function is TSPageSpec::new(PageJson

//! The `TSSpec::TSPageSpec::TSGraphicSpec` group of data-structures mirrors
//! `ts_spec.keytree`. Its main function is TSSpec::new(PageJson

//! PageJson::new(ts_spec: TSPageSpec, checked_spec: Checked...)

//! PageJson::new(ts_spec: TSSpec, checked_spec: Checked...)

pub struct TSPageSpec(pub Vec<TSCountrySpec>);

/// The specification for HTML pages that present a series of time-series plots. The keytree
/// specification looks like
/// ```text
/// ts_spec:
///     page:
///         data_type:  u
///         country:    Australia
///         graphic:
///             series:
///                 id: AUSURANAA
///                 id: AUSURAQS
///                 id: AUSURHARMADSMEI
///                 id: AUSURHARMMDSMEI
/// ```
pub struct TSSpec(pub Vec<TSPageSpec>);

impl TSPageSpec {

impl TSSpec {

    pub fn new() -> TSPageSpec {
        TSPageSpec(Vec::new())

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

    pub fn push(&mut self, item: TSCountrySpec) {

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

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

impl IntoKeyTree for TSPageSpec {

impl IntoKeyTree for TSSpec {

        kt.push_key(0, "page");
        for country in &self.0 {
            kt.push_keytree(1, country.keytree());

        kt.push_key(0, "ts_spec");
        for page in &self.0 {
            kt.push_keytree(1, page.keytree());

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

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

    fn try_into(self) -> Result<TSPageSpec, Error> {
        let country_vec: Vec<TSCountrySpec> = self.vec("page::country")?;
        Ok(TSPageSpec(country_vec))

    fn try_into(self) -> Result<TSSpec, Error> {
        let page_vec: Vec<TSPageSpec> = self.vec("ts_spec::page")?;
        Ok(TSSpec(page_vec))

pub struct TSCountrySpec {
    pub name:       Country,

/// Component of `TSSpec`.
/// Mirrored with a keytree specification which is the `country:` key in
/// ```text
/// page:
///     country:
///         name:       Australia
///         graphic:
///             series:
///                 id: AUSURANAA
///                 id: AUSURAQS
///                 id: AUSURHARMADSMEI
///                 id: AUSURHARMMDSMEI
/// ```
pub struct TSPageSpec {
    pub country:    Country,
    pub data_type:  DataType,

impl TSCountrySpec {
    pub fn new(country: Country, graphics: Vec<TSGraphicSpec>) -> Self {
        TSCountrySpec {
            name: country,

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

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

impl IntoKeyTree for TSCountrySpec {

impl IntoKeyTree for TSPageSpec {

        kt.push_key(0, "country");
        kt.push_keyvalue(1, "name", &self.name.to_string());

        kt.push_key(0, "page");
        kt.push_keyvalue(1, "country", &self.country.to_string());
        kt.push_keyvalue(1, "data_type", &self.data_type.to_string());

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

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

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

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

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

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

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

        Ok(TSCountrySpec {
            name: country,

        Ok(TSPageSpec {
            country: country,
            data_type: data_type,

impl PageJson {
    // Build from a `TSSpec`.
    pub fn new(page_spec: TSSpec, data_root: &str) -> Self {
        let ts_spec = TSSpec::from_file("ts_spec.keytree");

        
        
        PageJson(HashMap::new())
    }
}

use keytree::serialize::IntoKeyTree;

// use keytree::serialize::IntoKeyTree;

use ui_data::serve_ts::*;

// use ui_data::serve_ts::*;

    checked.generate_ts_spec();

    checked.bootstrap_ts_spec();

    TSCountrySpec,

    PageKey,

    TSSpec,

    pub fn generate_ts_spec(&self) {

    pub fn bootstrap_ts_spec(&self) {

        let mut h: HashMap<Country, TSCountrySpec> = HashMap::new();

        let mut h: HashMap<PageKey, TSPageSpec> = HashMap::new();

            match h.get_mut(&series.country) {
                Some(country_spec) => {
                    country_spec.graphics[0].push(&series.id);

            match h.get_mut(&series.key()) {
                Some(page_spec) => {
                    page_spec.graphics[0].push(&series.id);

                    let ts_country_spec = TSCountrySpec::new(series.country, vec!(ts_graphic_spec));
                    h.insert(series.country, ts_country_spec); 

                    let ts_page_spec = TSPageSpec::new(series.key(), vec!(ts_graphic_spec));
                    h.insert(series.key(), ts_page_spec); 

        // Build TSPageSpec from the hashmap.

        // Build TSSpec from the hashmap.

        let mut ts_page_spec = TSPageSpec(Vec::new());
        for (country, country_spec) in h {
            ts_page_spec.push(country_spec);

        let mut ts_spec = TSSpec(Vec::new());
        for (key, page_spec) in h {
            ts_spec.push(page_spec);

        println!("{}", ts_page_spec.keytree())

        println!("{}", ts_spec.keytree())

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