use ide_db::SymbolKind;
use syntax::{
    ast::{self, HasAttrs, HasGenericParams, HasName},
    match_ast, AstNode, AstToken, NodeOrToken, SourceFile, SyntaxNode, SyntaxToken, TextRange,
    WalkEvent,
};

#[derive(Debug, Clone)]
pub struct StructureNode {
    pub parent: Option<usize>,
    pub label: String,
    pub navigation_range: TextRange,
    pub node_range: TextRange,
    pub kind: StructureNodeKind,
    pub detail: Option<String>,
    pub deprecated: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum StructureNodeKind {
    SymbolKind(SymbolKind),
    ExternBlock,
    Region,
}

// Feature: File Structure
//
// Provides a tree of the symbols defined in the file. Can be used to
//
// * fuzzy search symbol in a file (super useful)
// * draw breadcrumbs to describe the context around the cursor
// * draw outline of the file
//
// |===
// | Editor  | Shortcut
//
// | VS Code | kbd:[Ctrl+Shift+O]
// |===
//
// image::https://user-images.githubusercontent.com/48062697/113020654-b42fc800-917a-11eb-8388-e7dc4d92b02e.gif[]

pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
    let mut res = Vec::new();
    let mut stack = Vec::new();

    for event in file.syntax().preorder_with_tokens() {
        match event {
            WalkEvent::Enter(NodeOrToken::Node(node)) => {
                if let Some(mut symbol) = structure_node(&node) {
                    symbol.parent = stack.last().copied();
                    stack.push(res.len());
                    res.push(symbol);
                }
            }
            WalkEvent::Leave(NodeOrToken::Node(node)) => {
                if structure_node(&node).is_some() {
                    stack.pop().unwrap();
                }
            }
            WalkEvent::Enter(NodeOrToken::Token(token)) => {
                if let Some(mut symbol) = structure_token(token) {
                    symbol.parent = stack.last().copied();
                    stack.push(res.len());
                    res.push(symbol);
                }
            }
            WalkEvent::Leave(NodeOrToken::Token(token)) => {
                if structure_token(token).is_some() {
                    stack.pop().unwrap();
                }
            }
        }
    }
    res
}

fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
    fn decl<N: HasName + HasAttrs>(node: N, kind: StructureNodeKind) -> Option<StructureNode> {
        decl_with_detail(&node, None, kind)
    }

    fn decl_with_type_ref<N: HasName + HasAttrs>(
        node: &N,
        type_ref: Option<ast::Type>,
        kind: StructureNodeKind,
    ) -> Option<StructureNode> {
        let detail = type_ref.map(|type_ref| {
            let mut detail = String::new();
            collapse_ws(type_ref.syntax(), &mut detail);
            detail
        });
        decl_with_detail(node, detail, kind)
    }

    fn decl_with_detail<N: HasName + HasAttrs>(
        node: &N,
        detail: Option<String>,
        kind: StructureNodeKind,
    ) -> Option<StructureNode> {
        let name = node.name()?;

        Some(StructureNode {
            parent: None,
            label: name.text().to_string(),
            navigation_range: name.syntax().text_range(),
            node_range: node.syntax().text_range(),
            kind,
            detail,
            deprecated: node.attrs().filter_map(|x| x.simple_name()).any(|x| x == "deprecated"),
        })
    }

    fn collapse_ws(node: &SyntaxNode, output: &mut String) {
        let mut can_insert_ws = false;
        node.text().for_each_chunk(|chunk| {
            for line in chunk.lines() {
                let line = line.trim();
                if line.is_empty() {
                    if can_insert_ws {
                        output.push(' ');
                        can_insert_ws = false;
                    }
                } else {
                    output.push_str(line);
                    can_insert_ws = true;
                }
            }
        })
    }

    match_ast! {
        match node {
            ast::Fn(it) => {
                let mut detail = String::from("fn");
                if let Some(type_param_list) = it.generic_param_list() {
                    collapse_ws(type_param_list.syntax(), &mut detail);
                }
                let has_self_param = if let Some(param_list) = it.param_list() {
                    collapse_ws(param_list.syntax(), &mut detail);
                    param_list.self_param().is_some()
                } else {
                    false
                };
                if let Some(ret_type) = it.ret_type() {
                    detail.push(' ');
                    collapse_ws(ret_type.syntax(), &mut detail);
                }

                decl_with_detail(&it, Some(detail), StructureNodeKind::SymbolKind(if has_self_param {
                    SymbolKind::Method
                } else {
                    SymbolKind::Function
                }))
            },
            ast::Struct(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Struct)),
            ast::Union(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Union)),
            ast::Enum(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Enum)),
            ast::Variant(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Variant)),
            ast::Trait(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Trait)),
            ast::TraitAlias(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::TraitAlias)),
            ast::Module(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Module)),
            ast::Macro(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Macro)),
            ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::TypeAlias)),
            ast::RecordField(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Field)),
            ast::Const(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Const)),
            ast::Static(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Static)),
            ast::Impl(it) => {
                let target_type = it.self_ty()?;
                let target_trait = it.trait_();
                let label = match target_trait {
                    None => format!("impl {}", target_type.syntax().text()),
                    Some(t) => {
                        format!("impl {}{} for {}",
                            it.excl_token().map(|x| x.to_string()).unwrap_or_default(),
                            t.syntax().text(),
                            target_type.syntax().text(),
                        )
                    }
                };

                let node = StructureNode {
                    parent: None,
                    label,
                    navigation_range: target_type.syntax().text_range(),
                    node_range: it.syntax().text_range(),
                    kind: StructureNodeKind::SymbolKind(SymbolKind::Impl),
                    detail: None,
                    deprecated: false,
                };
                Some(node)
            },
            ast::LetStmt(it) => {
                let pat = it.pat()?;

                let mut label = String::new();
                collapse_ws(pat.syntax(), &mut label);

                let node = StructureNode {
                    parent: None,
                    label,
                    navigation_range: pat.syntax().text_range(),
                    node_range: it.syntax().text_range(),
                    kind: StructureNodeKind::SymbolKind(SymbolKind::Local),
                    detail: it.ty().map(|ty| ty.to_string()),
                    deprecated: false,
                };

                Some(node)
            },
            ast::ExternBlock(it) => {
                let mut label = "extern".to_owned();
                let abi = it.abi()?;
                if let Some(abi) = abi.string_token() {
                    label.push(' ');
                    label.push_str(abi.text());
                }
                Some(StructureNode {
                    parent: None,
                    label,
                    navigation_range: abi.syntax().text_range(),
                    node_range: it.syntax().text_range(),
                    kind: StructureNodeKind::ExternBlock,
                    detail: None,
                    deprecated: false,
                })
            },
            _ => None,
        }
    }
}

fn structure_token(token: SyntaxToken) -> Option<StructureNode> {
    if let Some(comment) = ast::Comment::cast(token) {
        let text = comment.text().trim();

        if let Some(region_name) =
            text.strip_prefix("// region:").map(str::trim).filter(|it| !it.is_empty())
        {
            return Some(StructureNode {
                parent: None,
                label: region_name.to_owned(),
                navigation_range: comment.syntax().text_range(),
                node_range: comment.syntax().text_range(),
                kind: StructureNodeKind::Region,
                detail: None,
                deprecated: false,
            });
        }
    }

    None
}

#[cfg(test)]
mod tests {
    use expect_test::{expect, Expect};

    use super::*;

    fn check(ra_fixture: &str, expect: Expect) {
        let file = SourceFile::parse(ra_fixture, span::Edition::CURRENT).ok().unwrap();
        let structure = file_structure(&file);
        expect.assert_debug_eq(&structure)
    }

    #[test]
    fn test_negative_trait_bound() {
        let txt = r#"impl !Unpin for Test {}"#;
        check(
            txt,
            expect![[r#"
        [
            StructureNode {
                parent: None,
                label: "impl !Unpin for Test",
                navigation_range: 16..20,
                node_range: 0..23,
                kind: SymbolKind(
                    Impl,
                ),
                detail: None,
                deprecated: false,
            },
        ]
        "#]],
        );
    }

    #[test]
    fn test_file_structure() {
        check(
            r#"
struct Foo {
    x: i32
}

mod m {
    fn bar1() {}
    fn bar2<T>(t: T) -> T {}
    fn bar3<A,
        B>(a: A,
        b: B) -> Vec<
        u32
    > {}
}

enum E { X, Y(i32) }
type T = ();
static S: i32 = 92;
const C: i32 = 92;
trait Tr {}
trait Alias = Tr;

impl E {}

impl fmt::Debug for E {}

macro_rules! mc {
    () => {}
}

#[macro_export]
macro_rules! mcexp {
    () => {}
}

/// Doc comment
macro_rules! mcexp {
    () => {}
}

#[deprecated]
fn obsolete() {}

#[deprecated(note = "for awhile")]
fn very_obsolete() {}

// region: Some region name
// endregion

// region: dontpanic
mod m {
fn f() {}
// endregion
fn g() {}
}

extern "C" {}

fn let_statements() {
    let x = 42;
    let mut y = x;
    let Foo {
        ..
    } = Foo { x };
    if let None = Some(x) {}
    _ = ();
    let _ = g();
}
"#,
            expect![[r#"
                [
                    StructureNode {
                        parent: None,
                        label: "Foo",
                        navigation_range: 8..11,
                        node_range: 1..26,
                        kind: SymbolKind(
                            Struct,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            0,
                        ),
                        label: "x",
                        navigation_range: 18..19,
                        node_range: 18..24,
                        kind: SymbolKind(
                            Field,
                        ),
                        detail: Some(
                            "i32",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "m",
                        navigation_range: 32..33,
                        node_range: 28..158,
                        kind: SymbolKind(
                            Module,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            2,
                        ),
                        label: "bar1",
                        navigation_range: 43..47,
                        node_range: 40..52,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            2,
                        ),
                        label: "bar2",
                        navigation_range: 60..64,
                        node_range: 57..81,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn<T>(t: T) -> T",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            2,
                        ),
                        label: "bar3",
                        navigation_range: 89..93,
                        node_range: 86..156,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn<A, B>(a: A, b: B) -> Vec< u32 >",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "E",
                        navigation_range: 165..166,
                        node_range: 160..180,
                        kind: SymbolKind(
                            Enum,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            6,
                        ),
                        label: "X",
                        navigation_range: 169..170,
                        node_range: 169..170,
                        kind: SymbolKind(
                            Variant,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            6,
                        ),
                        label: "Y",
                        navigation_range: 172..173,
                        node_range: 172..178,
                        kind: SymbolKind(
                            Variant,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "T",
                        navigation_range: 186..187,
                        node_range: 181..193,
                        kind: SymbolKind(
                            TypeAlias,
                        ),
                        detail: Some(
                            "()",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "S",
                        navigation_range: 201..202,
                        node_range: 194..213,
                        kind: SymbolKind(
                            Static,
                        ),
                        detail: Some(
                            "i32",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "C",
                        navigation_range: 220..221,
                        node_range: 214..232,
                        kind: SymbolKind(
                            Const,
                        ),
                        detail: Some(
                            "i32",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "Tr",
                        navigation_range: 239..241,
                        node_range: 233..244,
                        kind: SymbolKind(
                            Trait,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "Alias",
                        navigation_range: 251..256,
                        node_range: 245..262,
                        kind: SymbolKind(
                            TraitAlias,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "impl E",
                        navigation_range: 269..270,
                        node_range: 264..273,
                        kind: SymbolKind(
                            Impl,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "impl fmt::Debug for E",
                        navigation_range: 295..296,
                        node_range: 275..299,
                        kind: SymbolKind(
                            Impl,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "mc",
                        navigation_range: 314..316,
                        node_range: 301..333,
                        kind: SymbolKind(
                            Macro,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "mcexp",
                        navigation_range: 364..369,
                        node_range: 335..386,
                        kind: SymbolKind(
                            Macro,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "mcexp",
                        navigation_range: 417..422,
                        node_range: 388..439,
                        kind: SymbolKind(
                            Macro,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "obsolete",
                        navigation_range: 458..466,
                        node_range: 441..471,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: true,
                    },
                    StructureNode {
                        parent: None,
                        label: "very_obsolete",
                        navigation_range: 511..524,
                        node_range: 473..529,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: true,
                    },
                    StructureNode {
                        parent: None,
                        label: "Some region name",
                        navigation_range: 531..558,
                        node_range: 531..558,
                        kind: Region,
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "m",
                        navigation_range: 598..599,
                        node_range: 573..636,
                        kind: SymbolKind(
                            Module,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            22,
                        ),
                        label: "dontpanic",
                        navigation_range: 573..593,
                        node_range: 573..593,
                        kind: Region,
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            22,
                        ),
                        label: "f",
                        navigation_range: 605..606,
                        node_range: 602..611,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            22,
                        ),
                        label: "g",
                        navigation_range: 628..629,
                        node_range: 612..634,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "extern \"C\"",
                        navigation_range: 638..648,
                        node_range: 638..651,
                        kind: ExternBlock,
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: None,
                        label: "let_statements",
                        navigation_range: 656..670,
                        node_range: 653..813,
                        kind: SymbolKind(
                            Function,
                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            27,
                        ),
                        label: "x",
                        navigation_range: 683..684,
                        node_range: 679..690,
                        kind: SymbolKind(
                            Local,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            27,
                        ),
                        label: "mut y",
                        navigation_range: 699..704,
                        node_range: 695..709,
                        kind: SymbolKind(
                            Local,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            27,
                        ),
                        label: "Foo { .. }",
                        navigation_range: 718..740,
                        node_range: 714..753,
                        kind: SymbolKind(
                            Local,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                    StructureNode {
                        parent: Some(
                            27,
                        ),
                        label: "_",
                        navigation_range: 803..804,
                        node_range: 799..811,
                        kind: SymbolKind(
                            Local,
                        ),
                        detail: None,
                        deprecated: false,
                    },
                ]
            "#]],
        );
    }
}
