data,

    countries_with_data,

    save_data_csv,
    save_data_json,
    save_series_meta,
    save_unemployment_data,
    title,
    to_tag,

    // let data = data("SVNCPHPLA01GPM");
    // fs::write("SVNCPHPLA01GPM.csv", &data);

    // save_data_csv("SVNCPHPLA01GPM");
    // save_series_meta("SVNCPHPLA01GPM");

    // println!("{}", Fred::tags_series("korea"));
    println!("{}", cpi_series(Country::SouthKorea));

    // println!("{}", Fred::tags_series("cpi;united kingdom"));

    // save_unemployment_data(&Country::SouthKorea);
    // for country in countries_with_data().iter() {
    //     println!("\n{}", country.to_string());
    //     save_unemployment_data(&country);
    // }
    // println!("{}", title("LFACTTTTKRA657N"));

    // println!("{}", cpi_series(Country::NewZealand));

    // save_data_csv("LRHUTTTTNZA156N");

    println!("{}", unemployment_series(Country::UnitedStates));

    // println!("{}", to_tag("unemployment", &Country::SouthKorea));

    // println!("{}", Fred::tags_series(&to_tag("cpi", &Country::SouthKorea)).seriess);
    

use std::fs;

use fred_api::response::SeriesItems;

/// Print data for a given `Series`.

/// Save FRED data to disk as json.

/// data("LRUNTTTTSIQ156S");

/// save_data_json("LRUNTTTTSIQ156S");

pub fn data(series_id: &str) -> String {
    let mut s = String::new();
    for obs in Fred::series_observations(series_id).observations {
        s.push_str(&format!(
            "{}, {}\n",
            obs.date,
            obs.value,
        ));

pub fn save_data_json(series_id: &str, path: &str) {
    let data = Fred::series_observations_json(series_id);
    let save_path = format!("./data/{}", path);
    fs::create_dir_all(&save_path).unwrap();
    fs::write(
        &format!(
            "{}/{}.json",
            save_path,
            series_id,
        ),
        &data,
    );
}
/// Save FRED data to disk as csv.
/// ```
/// save_data_csv("LRUNTTTTSIQ156S");
/// ```
/// To handle breaks the data is saved in a collection of files "LRUNTTTTSIQ156S_a.csv",
/// "LRUNTTTTSIQ156S_b.csv" etc.
/// 
pub fn save_data_csv(series_id: &str, path: &str) {
    let alphabet = "abcdefghijklmnopqrstuvwxyz";
    let mut chars = alphabet.chars();
    let mut contains_data = false; 
    let save_path = format!("./data/{}", path);
    
    let mut data = String::new();
    for obs in Fred::series_observations(series_id).observations.iter() {
        let value: Result<f32, _> = obs.value.parse();
        match value {
            Ok(val) => {
                contains_data = true;
                data.push_str(&obs.to_string());
                data.push('\n');
            },
            Err(val) => {
                if contains_data {
                    data.pop();
                         
                    fs::create_dir_all(&save_path).unwrap();
                    fs::write(
                        &format!(
                            "{}/{}_{}.csv",
                            save_path,
                            series_id,
                            chars.next().expect("Too many breaks"),
                        ),
                        &data,
                    );
                    data = String::new();
                    contains_data = false;
                }
            },
        }

    s.pop();
    s

    if contains_data {
        fs::create_dir_all(&save_path).unwrap();
        fs::write(
            &format!(
                "{}/{}_{}.csv",
                save_path,
                series_id,
                chars.next().expect("Too many breaks"),
            ),
            &data,
        );
    }

/// Save FRED series metadata including title to disk as json.
/// ```
/// save_series_meta("LRUNTTTTSIQ156S");
/// ```
pub fn save_series_meta(series_id: &str, path: &str) {
    let data = Fred::series(series_id).to_string();
    fs::write(
        &format!(
            "./data/{}/{}.meta",
            path,
            series_id,
        ),
        &data,
    );
}

            // TODO
            panic!()
            // deserialize error

            vec!(
                "Consumer Price Index: All Items for Korea",
                "Consumer Price Index: All items: Total: Total for the Republic of Korea",
                "Inflation, consumer prices for the Republic of Korea",
                "Consumer Price Index for Republic of Korea",
                "Consumer Price Index: Total All Items for the Republic of Korea",
            )

    Fred::tags_series(&to_tag("cpi", country)).seriess

    Fred::tags_series(&to_tag("cpi", &country)).seriess

pub fn unemployment_series(country: Country) -> String {

pub fn unemployment_series(country: &Country) -> SeriesItems {
    dbg!(country);
    dbg!(country.to_string());

                ),
            )
        }
        Country::SouthKorea => {
            (
                vec!(
                    "Male",
                    "Female",
                    "Youth",
                    "15-24",
                    "15-64",
                    "25-54",
                    "55-64",
                ),
                vec!(
                    "Rate",

        _ => panic!(),

        country => {
            println!("{:?}", country);
            panic!()
        }

    Fred::tags_series(&to_tag("unemployment", country)).seriess

    Fred::tags_series(&to_tag("unemployment", &country)).seriess

        .to_string()

fn to_tag(tag: &str, country: Country) -> String {

pub fn to_tag(tag: &str, country: &Country) -> String {

fn countries() -> Vec<Country> {

/// Save csv data and meta data to file, for a given `Country`.
pub fn save_unemployment_data(country: &Country) {
    for series in unemployment_series(country).iter() {
        let path = country.as_path();
        save_data_csv(&series.id, &path);
        save_series_meta(&series.id, &path);
        println!("{}", series.id)
    }
}
pub fn update_all_unemployment_data() {
    for country in countries_with_data().iter() {
        println!("\n{}", country.to_string());
        save_unemployment_data(&country);
    }
}
/// Return all the countries with good data as a `Vec`.
pub fn countries_with_data() -> Vec<Country> {

pub fn title(series_id: &str) -> String {
    let mut s = String::new();
    for series in Fred::series(series_id).seriess.iter() {
        s.push_str(&series.title)
    }
    s
}

#[derive(Clone, Copy, Debug)]

}
impl Country {
    /// Return the country name in lowercase with underscores replacing spaces.
    pub fn as_path(&self) -> String {
        self.to_string().to_lowercase().replace(' ', "_") 
    }

            Country::SouthKorea                     => "South Korea",

            Country::SouthKorea                     => "Korea",