//! FIXME: write short doc here

use hir::{db::AstDatabase, InFile};
use ra_syntax::{
    ast::{self, DocCommentsOwner},
    match_ast, AstNode, SyntaxKind, SyntaxNode,
};

use crate::{
    db::RootDatabase,
    display::{ShortLabel, ToNav},
    expand::descend_into_macros,
    references::{classify_name_ref, NameKind::*},
    FilePosition, NavigationTarget, RangeInfo,
};

pub(crate) fn goto_definition(
    db: &RootDatabase,
    position: FilePosition,
) -> Option<RangeInfo<Vec<NavigationTarget>>> {
    let file = db.parse_or_expand(position.file_id.into())?;
    let original_token =
        file.token_at_offset(position.offset).find(|it| it.kind() == SyntaxKind::IDENT)?;
    let token = descend_into_macros(db, position.file_id, original_token.clone());

    let nav_targets = match_ast! {
        match (token.value.parent()) {
            ast::NameRef(name_ref) => {
                reference_definition(db, token.with_value(&name_ref)).to_vec()
            },
            ast::Name(name) => {
                name_definition(db, token.with_value(&name))?
            },
            _ => return None,
        }
    };

    Some(RangeInfo::new(original_token.text_range(), nav_targets))
}

#[derive(Debug)]
pub(crate) enum ReferenceResult {
    Exact(NavigationTarget),
    Approximate(Vec<NavigationTarget>),
}

impl ReferenceResult {
    fn to_vec(self) -> Vec<NavigationTarget> {
        use self::ReferenceResult::*;
        match self {
            Exact(target) => vec![target],
            Approximate(vec) => vec,
        }
    }
}

pub(crate) fn reference_definition(
    db: &RootDatabase,
    name_ref: InFile<&ast::NameRef>,
) -> ReferenceResult {
    use self::ReferenceResult::*;

    let name_kind = classify_name_ref(db, name_ref).map(|d| d.kind);
    match name_kind {
        Some(Macro(it)) => return Exact(it.to_nav(db)),
        Some(Field(it)) => return Exact(it.to_nav(db)),
        Some(TypeParam(it)) => return Exact(it.to_nav(db)),
        Some(AssocItem(it)) => return Exact(it.to_nav(db)),
        Some(Local(it)) => return Exact(it.to_nav(db)),
        Some(Def(def)) => match NavigationTarget::from_def(db, def) {
            Some(nav) => return Exact(nav),
            None => return Approximate(vec![]),
        },
        Some(SelfType(imp)) => {
            // FIXME: ideally, this should point to the type in the impl, and
            // not at the whole impl. And goto **type** definition should bring
            // us to the actual type
            return Exact(imp.to_nav(db));
        }
        None => {}
    };

    // Fallback index based approach:
    let navs = crate::symbol_index::index_resolve(db, name_ref.value)
        .into_iter()
        .map(|s| s.to_nav(db))
        .collect();
    Approximate(navs)
}

pub(crate) fn name_definition(
    db: &RootDatabase,
    name: InFile<&ast::Name>,
) -> Option<Vec<NavigationTarget>> {
    let parent = name.value.syntax().parent()?;

    if let Some(module) = ast::Module::cast(parent.clone()) {
        if module.has_semi() {
            let src = name.with_value(module);
            if let Some(child_module) = hir::Module::from_declaration(db, src) {
                let nav = child_module.to_nav(db);
                return Some(vec![nav]);
            }
        }
    }

    if let Some(nav) = named_target(db, name.with_value(&parent)) {
        return Some(vec![nav]);
    }

    None
}

fn named_target(db: &RootDatabase, node: InFile<&SyntaxNode>) -> Option<NavigationTarget> {
    match_ast! {
        match (node.value) {
            ast::StructDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::EnumDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::EnumVariant(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::FnDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::TypeAliasDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::ConstDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::StaticDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::TraitDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::RecordFieldDef(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::Module(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    it.short_label(),
                ))
            },
            ast::MacroCall(it) => {
                Some(NavigationTarget::from_named(
                    db,
                    node.with_value(&it),
                    it.doc_comment_text(),
                    None,
                ))
            },
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use test_utils::covers;

    use crate::mock_analysis::analysis_and_position;

    fn check_goto(fixture: &str, expected: &str) {
        let (analysis, pos) = analysis_and_position(fixture);

        let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
        assert_eq!(navs.len(), 1);
        let nav = navs.pop().unwrap();
        nav.assert_match(expected);
    }

    #[test]
    fn goto_definition_works_in_items() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            enum E { X(Foo<|>) }
            ",
            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
        );
    }

    #[test]
    fn goto_definition_works_at_start_of_item() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            enum E { X(<|>Foo) }
            ",
            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
        );
    }

    #[test]
    fn goto_definition_resolves_correct_name() {
        check_goto(
            "
            //- /lib.rs
            use a::Foo;
            mod a;
            mod b;
            enum E { X(Foo<|>) }
            //- /a.rs
            struct Foo;
            //- /b.rs
            struct Foo;
            ",
            "Foo STRUCT_DEF FileId(2) [0; 11) [7; 10)",
        );
    }

    #[test]
    fn goto_definition_works_for_module_declaration() {
        check_goto(
            "
            //- /lib.rs
            mod <|>foo;
            //- /foo.rs
            // empty
            ",
            "foo SOURCE_FILE FileId(2) [0; 10)",
        );

        check_goto(
            "
            //- /lib.rs
            mod <|>foo;
            //- /foo/mod.rs
            // empty
            ",
            "foo SOURCE_FILE FileId(2) [0; 10)",
        );
    }

    #[test]
    fn goto_definition_works_for_macros() {
        covers!(goto_definition_works_for_macros);
        check_goto(
            "
            //- /lib.rs
            macro_rules! foo {
                () => {
                    {}
                };
            }

            fn bar() {
                <|>foo!();
            }
            ",
            "foo MACRO_CALL FileId(1) [0; 50) [13; 16)",
        );
    }

    #[test]
    fn goto_definition_works_for_macros_from_other_crates() {
        covers!(goto_definition_works_for_macros);
        check_goto(
            "
            //- /lib.rs
            use foo::foo;
            fn bar() {
                <|>foo!();
            }

            //- /foo/lib.rs
            #[macro_export]
            macro_rules! foo {
                () => {
                    {}
                };
            }
            ",
            "foo MACRO_CALL FileId(2) [0; 66) [29; 32)",
        );
    }

    #[test]
    fn goto_definition_works_for_macros_in_use_tree() {
        check_goto(
            "
            //- /lib.rs
            use foo::foo<|>;

            //- /foo/lib.rs
            #[macro_export]
            macro_rules! foo {
                () => {
                    {}
                };
            }
            ",
            "foo MACRO_CALL FileId(2) [0; 66) [29; 32)",
        );
    }

    #[test]
    fn goto_definition_works_for_macro_defined_fn_with_arg() {
        check_goto(
            "
            //- /lib.rs
            macro_rules! define_fn {
                ($name:ident) => (fn $name() {})
            }

            define_fn!(
                foo
            )

            fn bar() {
               <|>foo();
            }
            ",
            "foo FN_DEF FileId(1) [80; 83) [80; 83)",
        );
    }

    #[test]
    fn goto_definition_works_for_macro_defined_fn_no_arg() {
        check_goto(
            "
            //- /lib.rs
            macro_rules! define_fn {
                () => (fn foo() {})
            }

            define_fn!();

            fn bar() {
               <|>foo();
            }
            ",
            "foo FN_DEF FileId(1) [39; 42) [39; 42)",
        );
    }

    #[test]
    fn goto_definition_works_for_methods() {
        covers!(goto_definition_works_for_methods);
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            impl Foo {
                fn frobnicate(&self) {  }
            }

            fn bar(foo: &Foo) {
                foo.frobnicate<|>();
            }
            ",
            "frobnicate FN_DEF FileId(1) [27; 52) [30; 40)",
        );
    }

    #[test]
    fn goto_definition_works_for_fields() {
        covers!(goto_definition_works_for_fields);
        check_goto(
            "
            //- /lib.rs
            struct Foo {
                spam: u32,
            }

            fn bar(foo: &Foo) {
                foo.spam<|>;
            }
            ",
            "spam RECORD_FIELD_DEF FileId(1) [17; 26) [17; 21)",
        );
    }

    #[test]
    fn goto_definition_works_for_record_fields() {
        covers!(goto_definition_works_for_record_fields);
        check_goto(
            "
            //- /lib.rs
            struct Foo {
                spam: u32,
            }

            fn bar() -> Foo {
                Foo {
                    spam<|>: 0,
                }
            }
            ",
            "spam RECORD_FIELD_DEF FileId(1) [17; 26) [17; 21)",
        );
    }

    #[test]
    fn goto_definition_works_for_ufcs_inherent_methods() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            impl Foo {
                fn frobnicate() {  }
            }

            fn bar(foo: &Foo) {
                Foo::frobnicate<|>();
            }
            ",
            "frobnicate FN_DEF FileId(1) [27; 47) [30; 40)",
        );
    }

    #[test]
    fn goto_definition_works_for_ufcs_trait_methods_through_traits() {
        check_goto(
            "
            //- /lib.rs
            trait Foo {
                fn frobnicate();
            }

            fn bar() {
                Foo::frobnicate<|>();
            }
            ",
            "frobnicate FN_DEF FileId(1) [16; 32) [19; 29)",
        );
    }

    #[test]
    fn goto_definition_works_for_ufcs_trait_methods_through_self() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            trait Trait {
                fn frobnicate();
            }
            impl Trait for Foo {}

            fn bar() {
                Foo::frobnicate<|>();
            }
            ",
            "frobnicate FN_DEF FileId(1) [30; 46) [33; 43)",
        );
    }

    #[test]
    fn goto_definition_on_self() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            impl Foo {
                pub fn new() -> Self {
                    Self<|> {}
                }
            }
            ",
            "impl IMPL_BLOCK FileId(1) [12; 73)",
        );

        check_goto(
            "
            //- /lib.rs
            struct Foo;
            impl Foo {
                pub fn new() -> Self<|> {
                    Self {}
                }
            }
            ",
            "impl IMPL_BLOCK FileId(1) [12; 73)",
        );

        check_goto(
            "
            //- /lib.rs
            enum Foo { A }
            impl Foo {
                pub fn new() -> Self<|> {
                    Foo::A
                }
            }
            ",
            "impl IMPL_BLOCK FileId(1) [15; 75)",
        );

        check_goto(
            "
            //- /lib.rs
            enum Foo { A }
            impl Foo {
                pub fn thing(a: &Self<|>) {
                }
            }
            ",
            "impl IMPL_BLOCK FileId(1) [15; 62)",
        );
    }

    #[test]
    fn goto_definition_on_self_in_trait_impl() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            trait Make {
                fn new() -> Self;
            }
            impl Make for Foo {
                fn new() -> Self {
                    Self<|> {}
                }
            }
            ",
            "impl IMPL_BLOCK FileId(1) [49; 115)",
        );

        check_goto(
            "
            //- /lib.rs
            struct Foo;
            trait Make {
                fn new() -> Self;
            }
            impl Make for Foo {
                fn new() -> Self<|> {
                    Self {}
                }
            }
            ",
            "impl IMPL_BLOCK FileId(1) [49; 115)",
        );
    }

    #[test]
    fn goto_definition_works_when_used_on_definition_name_itself() {
        check_goto(
            "
            //- /lib.rs
            struct Foo<|> { value: u32 }
            ",
            "Foo STRUCT_DEF FileId(1) [0; 25) [7; 10)",
        );

        check_goto(
            r#"
            //- /lib.rs
            struct Foo {
                field<|>: string,
            }
            "#,
            "field RECORD_FIELD_DEF FileId(1) [17; 30) [17; 22)",
        );

        check_goto(
            "
            //- /lib.rs
            fn foo_test<|>() {
            }
            ",
            "foo_test FN_DEF FileId(1) [0; 17) [3; 11)",
        );

        check_goto(
            "
            //- /lib.rs
            enum Foo<|> {
                Variant,
            }
            ",
            "Foo ENUM_DEF FileId(1) [0; 25) [5; 8)",
        );

        check_goto(
            "
            //- /lib.rs
            enum Foo {
                Variant1,
                Variant2<|>,
                Variant3,
            }
            ",
            "Variant2 ENUM_VARIANT FileId(1) [29; 37) [29; 37)",
        );

        check_goto(
            r#"
            //- /lib.rs
            static inner<|>: &str = "";
            "#,
            "inner STATIC_DEF FileId(1) [0; 24) [7; 12)",
        );

        check_goto(
            r#"
            //- /lib.rs
            const inner<|>: &str = "";
            "#,
            "inner CONST_DEF FileId(1) [0; 23) [6; 11)",
        );

        check_goto(
            r#"
            //- /lib.rs
            type Thing<|> = Option<()>;
            "#,
            "Thing TYPE_ALIAS_DEF FileId(1) [0; 24) [5; 10)",
        );

        check_goto(
            r#"
            //- /lib.rs
            trait Foo<|> {
            }
            "#,
            "Foo TRAIT_DEF FileId(1) [0; 13) [6; 9)",
        );

        check_goto(
            r#"
            //- /lib.rs
            mod bar<|> {
            }
            "#,
            "bar MODULE FileId(1) [0; 11) [4; 7)",
        );
    }

    #[test]
    fn goto_from_macro() {
        check_goto(
            "
            //- /lib.rs
            macro_rules! id {
                ($($tt:tt)*) => { $($tt)* }
            }
            fn foo() {}
            id! {
                fn bar() {
                    fo<|>o();
                }
            }
            mod confuse_index { fn foo(); }
            ",
            "foo FN_DEF FileId(1) [52; 63) [55; 58)",
        );
    }

    #[test]
    fn goto_through_format() {
        check_goto(
            "
            //- /lib.rs
            #[macro_export]
            macro_rules! format {
                ($($arg:tt)*) => ($crate::fmt::format($crate::__export::format_args!($($arg)*)))
            }
            #[rustc_builtin_macro]
            #[macro_export]
            macro_rules! format_args {
                ($fmt:expr) => ({ /* compiler built-in */ });
                ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
            }
            pub mod __export {
                pub use crate::format_args;
                fn foo() {} // for index confusion
            }
            fn foo() -> i8 {}
            fn test() {
                format!(\"{}\", fo<|>o())
            }
            ",
            "foo FN_DEF FileId(1) [398; 415) [401; 404)",
        );
    }

    #[test]
    fn goto_for_type_param() {
        check_goto(
            "
            //- /lib.rs
            struct Foo<T> {
                t: <|>T,
            }
            ",
            "T TYPE_PARAM FileId(1) [11; 12)",
        );
    }
}