use crate::types::*;

use serde_derive::{Deserialize, Serialize};
use structopt::StructOpt;

use std::collections::{HashMap, HashSet};

pub(crate) type Inlines = HashMap<Language, HashMap<EntityKind, HashSet<ChildrenKind>>>;

#[derive(Debug, Clone, Serialize)]
pub(crate) struct Config {
    pub(super) from: String,
    pub(super) to: String,
    pub(super) pandoc_filters: Vec<String>,
    /// Tells us in which language, which entity types should inline which children entity type in
    /// their documentation.
    ///
    /// e.g. in C++, classes should inline their children methods documentation.
    pub(super) inlines: Inlines,
}

impl Config {
    pub(crate) fn from_merge(mut cli: ProvidedConfig, mut conf: ProvidedConfig) -> Self {
        conf.pandoc_filters.append(&mut cli.pandoc_filters);
        Self {
            from: cli
                .from
                .or(conf.from)
                .unwrap_or_else(|| String::from("markdown-raw_tex")),
            to: cli.to.or(conf.to).unwrap_or_else(|| String::from("html")),
            pandoc_filters: conf.pandoc_filters,
            inlines: conf.inlines.unwrap_or_else(default_inlines),
        }
    }
}

fn default_inlines() -> Inlines {
    let mut clang = HashMap::new();
    let mut clang_inline_children = HashSet::new();
    clang_inline_children.insert(ChildrenKind(String::from("variables")));
    clang_inline_children.insert(ChildrenKind(String::from("fields")));
    clang_inline_children.insert(ChildrenKind(String::from("functions")));
    clang_inline_children.insert(ChildrenKind(String::from("methods")));
    clang_inline_children.insert(ChildrenKind(String::from("type-aliases")));
    clang.insert(
        EntityKind(String::from("struct")),
        clang_inline_children.clone(),
    );
    clang.insert(
        EntityKind(String::from("class")),
        clang_inline_children.clone(),
    );
    clang.insert(EntityKind(String::from("namespace")), clang_inline_children);

    let mut clang_inline_in_enum = HashSet::new();
    clang_inline_in_enum.insert(ChildrenKind(String::from("enum-constants")));
    clang.insert(EntityKind(String::from("enum")), clang_inline_in_enum);

    let mut inlines = HashMap::new();
    inlines.insert(Language::Clang, clang);

    inlines
}

impl Default for Config {
    fn default() -> Self {
        Config::from_merge(ProvidedConfig::default(), ProvidedConfig::default())
    }
}

#[derive(Debug, Clone, Default, StructOpt, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub(crate) struct ProvidedConfig {
    #[structopt(long = "generator-from")]
    pub(super) from: Option<String>,
    #[structopt(long = "generator-to")]
    pub(super) to: Option<String>,
    #[structopt(long = "generator-pandoc-filters", number_of_values = 1)]
    #[serde(default)]
    pub(super) pandoc_filters: Vec<String>,
    #[structopt(skip)]
    pub(super) inlines: Option<Inlines>,
}