use crate::deserialize::util::{get_as_bool_or, unwrap_single_member_hash};
use crate::spec::tree_enum_spec::{
    EnumRuleChild, EnumRuleChildKind, TreeEnumBuildSpec, TreeEnumRule,
};
use yaml_rust2::Yaml;

fn deserialize_hash_enum_rule(rule: &str, props: &Yaml) -> TreeEnumRule {
    if get_as_bool_or(&props["child"], true) {
        let kind = match props["kind"].as_str().unwrap() {
            "int" => EnumRuleChildKind::Int,
            "long" => EnumRuleChildKind::Long,
            "double" => EnumRuleChildKind::Double,
            "string" => EnumRuleChildKind::String,
            "boolean" => EnumRuleChildKind::Boolean,
            _ => panic!("Invalid kind: {}", props["kind"].as_str().unwrap()),
        };
        TreeEnumRule::new(rule, Some(Box::new(EnumRuleChild::new(Box::new(kind)))))
    } else {
        // no child
        TreeEnumRule::new(rule, None)
    }
}

fn deserialize_string_enum_rule(rule: &str) -> TreeEnumRule {
    TreeEnumRule::new(
        rule,
        Some(Box::new(EnumRuleChild::new(Box::new(
            EnumRuleChildKind::Node,
        )))),
    )
}

pub fn deserialize_tree_enum(name: &str, props: &Yaml) -> TreeEnumBuildSpec {
    let rules = props["rules"]
        .as_vec()
        .unwrap()
        .iter()
        .map(|rule_yaml| {
            if let Some(rule) = rule_yaml.as_str() {
                deserialize_string_enum_rule(rule)
            } else {
                let (rule, props) = unwrap_single_member_hash(rule_yaml);
                deserialize_hash_enum_rule(&rule, props)
            }
        })
        .map(Box::new)
        .collect();

    TreeEnumBuildSpec::new(name, rules)
}