use super::*;

pub(super) fn builder_for(doxygen_kind: String) -> Box<dyn TypeBuilder> {
    match doxygen_kind.as_str() {
        "namespace" => Box::new(NameSpaceBuilder::default()),
        "class" | "struct" => Box::new(ClassBuilder::default()),
        _ => Box::new(UnhandledBuilder),
    }
}

#[derive(Debug, Default)]
struct NameSpaceBuilder {
    name: Option<String>,
    members: Vec<String>,
    brief_description: Option<Description>,
    detailed_description: Option<Description>,
}

impl TypeBuilder for NameSpaceBuilder {
    fn build(self: Box<Self>) -> DoxygenType {
        let name = self.name.unwrap();

        DoxygenType::NameSpace(NameSpace {
            name,
            members: self.members,
            brief_description: self.brief_description.unwrap(),
            detailed_description: self.detailed_description.unwrap(),
        })
    }

    fn name(&mut self, value: String) {
        self.name = Some(value);
    }

    fn add_inner(&mut self, name: String, kind: String) {
        self.members.push(name);
    }

    fn add_member(&mut self, _section: String, _member: Member) {
        panic!("Adding member in namespace?");
    }

    fn brief_description(&mut self, description: Description) {
        self.brief_description = Some(description);
    }

    fn detailed_description(&mut self, description: Description) {
        self.brief_description = Some(description);
    }
}

#[derive(Debug, Default)]
struct UnhandledBuilder;

impl TypeBuilder for UnhandledBuilder {
    fn build(self: Box<Self>) -> DoxygenType {
        DoxygenType::Unhandled
    }

    fn name(&mut self, _value: String) {}

    fn add_inner(&mut self, _name: String, _kind: String) {}
    fn add_member(&mut self, _section: String, _member: Member) {}
    fn brief_description(&mut self, _description: Description) {}
    fn detailed_description(&mut self, _description: Description) {}
}

#[derive(Debug, Default)]
struct ClassBuilder {
    name: Option<String>,
    inners: Vec<(String, String)>,
    sections: HashMap<String, Vec<Member>>,
    brief_description: Option<Description>,
    detailed_description: Option<Description>,
}

impl TypeBuilder for ClassBuilder {
    fn build(self: Box<Self>) -> DoxygenType {
        let name = self.name.unwrap();

        DoxygenType::Class(Class {
            name,
            inners: self.inners,
            sections: self.sections,
            brief_description: self.brief_description.unwrap_or(Description::new()),
            detailed_description: self.detailed_description.unwrap_or(Description::new()),
        })
    }

    fn name(&mut self, value: String) {
        self.name = Some(value);
    }

    fn add_inner(&mut self, name: String, kind: String) {
        self.inners.push((name, kind));
    }

    fn add_member(&mut self, section: String, member: Member) {
        self.sections.entry(section).or_default().push(member);
    }

    fn brief_description(&mut self, description: Description) {
        self.brief_description = Some(description);
    }

    fn detailed_description(&mut self, description: Description) {
        self.brief_description = Some(description);
    }
}