use crate::types::Entity;

use clang::{EntityKind, Usr};
use thiserror::Error;

use std::collections::BTreeMap;
use std::convert::TryFrom;

// TODO: factor out hardcoded strings

#[derive(Debug)]
pub(super) struct Children {
    namespaces: Option<BTreeMap<Usr, Described<Namespace>>>,
    variables: Option<BTreeMap<Usr, Described<Variable>>>,
    structs: Option<BTreeMap<Usr, Described<Struct>>>,
    functions: Option<BTreeMap<Usr, Described<Function>>>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum ClangEntityKind {
    Namespace,
    Variable(VariableKind),
    Struct(StructKind),
    Function(FunctionKind),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum VariableKind {
    Variable,
    Field,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum StructKind {
    Struct,
    Class,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum FunctionKind {
    Function,
    Method,
}

#[derive(Debug, Error)]
#[error("Unsupported Clang entity kind: {:?}", _0)]
pub(super) struct TryFromEntityKindError(String);

impl TryFrom<EntityKind> for ClangEntityKind {
    type Error = TryFromEntityKindError;

    fn try_from(kind: EntityKind) -> Result<ClangEntityKind, TryFromEntityKindError> {
        Ok(match kind {
            EntityKind::Namespace => ClangEntityKind::Namespace,
            EntityKind::VarDecl => ClangEntityKind::Variable(VariableKind::Variable),
            EntityKind::FieldDecl => ClangEntityKind::Variable(VariableKind::Field),
            EntityKind::FunctionDecl => ClangEntityKind::Function(FunctionKind::Function),
            EntityKind::Method | EntityKind::Constructor => {
                ClangEntityKind::Function(FunctionKind::Method)
            }
            EntityKind::StructDecl => ClangEntityKind::Struct(StructKind::Struct),
            EntityKind::ClassDecl => ClangEntityKind::Struct(StructKind::Class),
            kind => return Err(TryFromEntityKindError(format!("{:?}", kind))),
        })
    }
}

pub(super) trait ClangEntity {
    fn kind(&self) -> &'static str;

    fn get_member_namespaces(&mut self) -> Option<&mut BTreeMap<Usr, Described<Namespace>>> {
        None
    }
    fn get_member_variables(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
        None
    }
    fn get_member_structs(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
        None
    }
    fn get_member_functions(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
        None
    }

    fn into_children(self) -> Children
    where
        Self: Sized,
    {
        Children {
            namespaces: None,
            variables: None,
            structs: None,
            functions: None,
        }
    }
}

/*
pub(super) trait FromNamespaceParent: ClangEntity + Sized {
    fn from_namespace_parent<'a>(
        parent: &'a mut Described<Namespace>,
        name: &Usr,
    ) -> Option<&'a mut Described<Self>>;
}
*/

pub(super) trait NamespaceParentManipulation<T: ClangEntity + Sized> {
    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<T>>>;
}

impl<U> NamespaceParentManipulation<Namespace> for U
where
    U: ClangEntity,
{
    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Namespace>>> {
        self.get_member_namespaces()
    }
}

impl<U> NamespaceParentManipulation<Variable> for U
where
    U: ClangEntity,
{
    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
        self.get_member_variables()
    }
}

impl<U> NamespaceParentManipulation<Function> for U
where
    U: ClangEntity,
{
    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
        self.get_member_functions()
    }
}

impl<U> NamespaceParentManipulation<Struct> for U
where
    U: ClangEntity,
{
    fn get_members_mut(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
        self.get_member_structs()
    }
}

impl<T: ClangEntity> From<Described<T>> for Entity {
    fn from(entity: Described<T>) -> Self {
        let mut children = BTreeMap::new();

        let kind = String::from(entity.entity.kind());
        let clang_children = entity.entity.into_children();

        if let Some(namespaces) = clang_children.namespaces {
            children.insert(
                String::from("namespace"),
                namespaces
                    .into_iter()
                    .map(|(usr, namespace)| (usr.0, namespace.into()))
                    .collect(),
            );
        }

        if let Some(variables) = clang_children.variables {
            children.insert(
                String::from("variable"),
                variables
                    .into_iter()
                    .map(|(usr, variable)| (usr.0, variable.into()))
                    .collect(),
            );
        }

        if let Some(structs) = clang_children.structs {
            children.insert(
                String::from("struct"),
                structs
                    .into_iter()
                    .map(|(usr, the_struct)| (usr.0, the_struct.into()))
                    .collect(),
            );
        }

        if let Some(functions) = clang_children.functions {
            children.insert(
                String::from("function"),
                functions
                    .into_iter()
                    .map(|(usr, function)| (usr.0, function.into()))
                    .collect(),
            );
        }

        Entity {
            name: entity.description.name,
            language: String::from("clang"),
            kind,
            brief_description: entity.description.brief,
            documentation: entity.description.detailed,
            children,
        }
    }
}

#[derive(Debug, Clone, Default)]
pub(super) struct Description {
    pub(super) name: String,
    pub(super) brief: String,
    pub(super) detailed: String,
}

#[derive(Debug, Clone)]
pub(super) struct Described<T> {
    pub(super) description: Description,
    pub(super) entity: T,
}

#[derive(Debug, Clone)]
pub(super) struct Namespace {
    pub(super) member_namespaces: BTreeMap<Usr, Described<Namespace>>,
    pub(super) member_variables: BTreeMap<Usr, Described<Variable>>,
    pub(super) member_structs: BTreeMap<Usr, Described<Struct>>,
    pub(super) member_functions: BTreeMap<Usr, Described<Function>>,
}

impl ClangEntity for Namespace {
    fn kind(&self) -> &'static str {
        "namespace"
    }

    fn get_member_namespaces(&mut self) -> Option<&mut BTreeMap<Usr, Described<Namespace>>> {
        Some(&mut self.member_namespaces)
    }
    fn get_member_variables(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
        Some(&mut self.member_variables)
    }
    fn get_member_structs(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
        Some(&mut self.member_structs)
    }
    fn get_member_functions(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
        Some(&mut self.member_functions)
    }

    fn into_children(self) -> Children {
        Children {
            namespaces: Some(self.member_namespaces),
            variables: Some(self.member_variables),
            structs: Some(self.member_structs),
            functions: Some(self.member_functions),
        }
    }
}

/*
impl FromNamespaceParent for Namespace {
    fn from_namespace_parent<'a>(
        parent: &'a mut Described<Namespace>,
        name: &Usr,
    ) -> Option<&'a mut Described<Self>> {
        parent.entity.member_namespaces.get_mut(name)
    }
}
*/

#[derive(Debug, Clone)]
pub(super) struct Variable {
    pub(super) kind: VariableKind,
    pub(super) r#type: String,
}

impl ClangEntity for Variable {
    fn kind(&self) -> &'static str {
        match self.kind {
            VariableKind::Variable => "variable",
            VariableKind::Field => "field",
        }
    }
}

/*
impl FromNamespaceParent for Variable {
    fn from_namespace_parent<'a>(
        parent: &'a mut Described<Namespace>,
        name: &Usr,
    ) -> Option<&'a mut Described<Self>> {
        parent.entity.member_variables.get_mut(name)
    }
}
*/

#[derive(Debug, Clone)]
pub(super) struct Struct {
    //pub(super) member_types: Vec<Usr>,
    pub(super) kind: StructKind,
    pub(super) member_variables: BTreeMap<Usr, Described<Variable>>,
    pub(super) member_structs: BTreeMap<Usr, Described<Struct>>,
    pub(super) member_functions: BTreeMap<Usr, Described<Function>>,
}

impl ClangEntity for Struct {
    fn kind(&self) -> &'static str {
        match self.kind {
            StructKind::Struct => "struct",
            StructKind::Class => "class",
        }
    }

    fn get_member_variables(&mut self) -> Option<&mut BTreeMap<Usr, Described<Variable>>> {
        Some(&mut self.member_variables)
    }
    fn get_member_structs(&mut self) -> Option<&mut BTreeMap<Usr, Described<Struct>>> {
        Some(&mut self.member_structs)
    }
    fn get_member_functions(&mut self) -> Option<&mut BTreeMap<Usr, Described<Function>>> {
        Some(&mut self.member_functions)
    }

    fn into_children(self) -> Children {
        Children {
            namespaces: None,
            variables: Some(self.member_variables),
            structs: Some(self.member_structs),
            functions: Some(self.member_functions),
        }
    }
}

/*
impl FromNamespaceParent for Struct {
    fn from_namespace_parent<'a>(
        parent: &'a mut Described<Namespace>,
        name: &Usr,
    ) -> Option<&'a mut Described<Self>> {
        parent.entity.member_structs.get_mut(name)
    }
}
*/

#[derive(Debug, Clone)]
pub(super) struct Function {
    pub(super) kind: FunctionKind,
    pub(super) arguments: Vec<FunctionArgument>,
    pub(super) return_type: String,
}

impl ClangEntity for Function {
    fn kind(&self) -> &'static str {
        match self.kind {
            FunctionKind::Function => "function",
            FunctionKind::Method => "method",
        }
    }
}

/*
impl FromNamespaceParent for Function {
    fn from_namespace_parent<'a>(
        parent: &'a mut Described<Namespace>,
        name: &Usr,
    ) -> Option<&'a mut Described<Self>> {
        parent.entity.member_functions.get_mut(name)
    }
}
*/

#[derive(Debug, Clone)]
pub(super) struct FunctionArgument {
    pub(super) name: String,
    pub(super) r#type: String,
}