pub struct Json(BTreeMap<(Country, DataType, usize), (Vec<SeriesJson>, Vec<GraphicJson>)>);

pub struct Json(BTreeMap<(Country, DataType, usize), PageValue>);
impl Json {
    pub fn into_ts_data(&self) -> Result<TSData, Error> {
        let mut map: BTreeMap<(Country, DataType, usize), String> = BTreeMap::new();
        for (key, value) in self.0.iter() {
            let json = serde_json::to_string(&value)
                .map_err(|_| {
                    failed_to_serialize_to_json(
                        file!(),
                        line!(),
                    )
                
                })?;
            map.insert(*key, json);
        }
        Ok(TSData(map))
    }
}
pub struct TSData(pub BTreeMap<(Country, DataType, usize), String>); 
// The JSON that is served for a given page.
#[derive(Debug, Serialize)]
pub struct PageValue {
    country:    Country,
    data_type:  DataType,
    index:      usize,
    seriess:    Vec<SeriesJson>,
    graphics:   Vec<GraphicJson>,
    first_date: MonthlyDate,
    last_date:  MonthlyDate,
    max:        f32,
    min:        f32,
    height:     f32,
}

                height_opt,

            // Iterate over graphics on one page

            // Build series data from series specification.
            // We want to build a BTreeMap<SeriesId, SeriesJson> from a BTreeMap<SeriesId, SeriesSpec>
            for (i, (series_id, series_spec)) in seriess.iter().enumerate() {
                m_series.insert(
                    series_id.clone(),
                    (
                        i,
                        page_spec.into_series_json(series_id, *country, root_path)?,
                    )
                );
            }
            //Build graphics from graphics specification.

                    height_opt,

                // Iterate over series_ids and build series_json first. There is a one-to-one
                // correspondence between SeriesSpec and SeriesJson so we can use the indices in
                // SeriesSpec to build GraphicJson.
                // Push SeriesJson Vec<SeriesJson>
                for (i, series_id) in series_ids.iter().enumerate() {
                    m_series.insert(
                        series_id.clone(),
                        (
                            i,
                            page_spec.into_series_json(series_id, *country, root_path)?,
                        )
                    );
                }

                // Construct indices for series in GraphicJson

                // We have

                    let series_ref = match m_series.get(series_id) {
                        Some((series_ref, _)) => series_ref,

                    // dbg!(&series_id);
                    let ix = match m_series.get(series_id) {
                        Some((ix, _)) => ix,

                    graphic_json.series_ref.push(*series_ref);

                    // dbg!(ix);
                    graphic_json.series_ref.push(*ix);

            // collection of SeriesJsons and the collection of GraphicsJsons into Json.

            // collection of SeriesJsons and the collection of GraphicJsons into Json.

            json.insert((*country, *data_type, *index), (v_series, v_graphics));

            let first_date = v_series.iter()
                .map(|series_json| series_json.rts.first_date())
                .min()
                .unwrap();
            let last_date = v_series.iter()
                .map(|series_json| series_json.rts.last_date())
                .max()
                .unwrap();
            let max = v_series.iter()
                .map(|series_json| series_json.rts.max(0))
                .fold(f32::NEG_INFINITY, |a, b| a.max(b));
            let min = v_series.iter()
                .map(|series_json| series_json.rts.min(0))
                .fold(f32::INFINITY, |a, b| a.min(b));
            let height = match height_opt {
                Some(h) => *h,
                None => GRAPHIC_HEIGHT,
            };
            let page_value = PageValue {
                country:    *country,
                data_type:  *data_type,
                index:      *index,
                seriess:    v_series,
                graphics:   v_graphics,
                first_date: MonthlyDate(first_date),
                last_date:  MonthlyDate(last_date),
                max:        max,
                min:        min,
                height:     height,
            };
            json.insert((*country, *data_type, *index), page_value);

    pub height_opt: Option<f32>,

                height_opt: self.opt_value("page::height")?,

    pub height_opt: Option<f32>,

                height_opt:     self.opt_value("graphic::height")?,

        }
        if let Some(h) = &self.height_opt {
            kt.push_value(1, "height", h);

        ts_spec.into_json(&root_dir).unwrap();

        ts_spec.into_json(&root_dir).unwrap().into_ts_data();

#[derive(Clone, Serialize)]

#[derive(Clone, Debug, Serialize)]

                height_opt: None, 

                height_opt: None,

                    height_opt: None,

        "[ui_date:06:{}:{}] Could not find graphic reference [{}] in series.",

        "[ui_data:06:{}:{}] Could not find graphic reference [{}] in series.",

pub fn failed_to_serialize_to_json(
    code_file: &str,
    code_line: u32) -> Error
{
    Error(format!(
        "[ui_data:07:{}:{}] Failed to serialize to json.",
        code_file,
        code_line,
    ))
}