cal-core 0.2.73

use cal_billing::code_deck::CodeDeck;
use itertools::Itertools;
use phf_codegen::Map;
use std::collections::HashMap;
use std::env;
use std::fs::File;
use std::io::{BufWriter, Write};
use std::path::Path;

pub fn main() {
    let data: Vec<CodeDeck> = serde_json::from_str(include_str!("json/codes.json")).unwrap();
    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codes.rs");
    let mut file = BufWriter::new(File::create(&path).unwrap());


    let decks = &data
        .iter()
        .filter(|cd| match &cd.codes {
            None => false,
            Some(_c) => true,
        })
        .into_group_map_by(|cd| cd.name.contains("Term"));

    for (is_term, decks) in decks {
        let mut code_builder = Map::new();
        let mut key_hash = HashMap::new();
        for deck in decks {
            if let Some(codes) = &deck.codes {
                for code in codes {
                    let key = format!("{}:{}", code.called.clone(), code.caller.clone());

                    let mut code_name = code.code
                        .replace(" ", "")
                        .replace("&", "And")
                        .replace(".", "")
                        .replace("[", "")
                        .replace("]", "")
                        .replace(")", "")
                        .replace("(", "")
                        .replace("-", "")
                        .replace("/", "_");

                    if code_name.starts_with("03") {
                        code_name = code_name.replace("03", "");
                    }

                    if code_name.starts_with("116") {
                        code_name = code_name.replace("116", "");
                    }

                    let country_name = &code
                        .country
                        .replace(".", "")
                        .replace(" and ", " And ")
                        .replace(" ", "");

                    let value = [
                        "CodeCache { ",
                        format!("code: CodeName::{}, ", code_name).as_str(),
                        format!("category: Category::{}, ", &code.category).as_str(),
                        format!("country: Country::{}, ", country_name).as_str(),
                        format!("country_code: CountryCode::{} ", &code.country_code).as_str(),
                        "}",
                    ]
                        .join(" ");
                    if !key_hash.contains_key(&key) {
                        code_builder.entry(key.clone(), value.as_str());
                        key_hash.insert(key.clone(), code.code.clone());
                    }
                }
            }
        }

        let deck_type = match is_term {
            true => "TERM",
            false => "ORIG",
        };

        write!(
            &mut file,
            "pub static {}: phf::Map<&'static str, CodeCache> = {}",
            format!("{}_CODES", deck_type),
            code_builder.build()
        )
            .unwrap();

        write!(&mut file, ";\n").unwrap();
    }
}