use crate::{code_context_menus::CompletionsMenu, editor_settings::SnippetSortOrder};
use fuzzy::StringMatchCandidate;
use gpui::TestAppContext;
use language::CodeLabel;
use lsp::{CompletionItem, CompletionItemKind, LanguageServerId};
use project::{Completion, CompletionSource};
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use text::Anchor;

#[gpui::test]
async fn test_sort_matches_local_variable_over_global_variable(cx: &mut TestAppContext) {
    // Case 1: "foo"
    let completions = vec![
        CompletionBuilder::constant("foo_bar_baz", "7fffffff"),
        CompletionBuilder::variable("foo_bar_qux", "7ffffffe"),
        CompletionBuilder::constant("floorf64", "80000000"),
        CompletionBuilder::constant("floorf32", "80000000"),
        CompletionBuilder::constant("floorf16", "80000000"),
        CompletionBuilder::constant("floorf128", "80000000"),
    ];
    let matches = sort_matches("foo", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "foo_bar_qux");
    assert_eq!(matches[1], "foo_bar_baz");
    assert_eq!(matches[2], "floorf16");
    assert_eq!(matches[3], "floorf32");

    // Case 2: "foobar"
    let completions = vec![
        CompletionBuilder::constant("foo_bar_baz", "7fffffff"),
        CompletionBuilder::variable("foo_bar_qux", "7ffffffe"),
    ];
    let matches = sort_matches("foobar", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "foo_bar_qux");
    assert_eq!(matches[1], "foo_bar_baz");
}

#[gpui::test]
async fn test_sort_matches_local_variable_over_global_enum(cx: &mut TestAppContext) {
    // Case 1: "ele"
    let completions = vec![
        CompletionBuilder::constant("ElementType", "7fffffff"),
        CompletionBuilder::variable("element_type", "7ffffffe"),
        CompletionBuilder::constant("simd_select", "80000000"),
        CompletionBuilder::keyword("while let", "7fffffff"),
    ];
    let matches = sort_matches("ele", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "element_type");
    assert_eq!(matches[1], "ElementType");

    // Case 2: "eleme"
    let completions = vec![
        CompletionBuilder::constant("ElementType", "7fffffff"),
        CompletionBuilder::variable("element_type", "7ffffffe"),
        CompletionBuilder::constant("REPLACEMENT_CHARACTER", "80000000"),
    ];
    let matches = sort_matches("eleme", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "element_type");
    assert_eq!(matches[1], "ElementType");
}

#[gpui::test]
async fn test_sort_matches_capitalization(cx: &mut TestAppContext) {
    // Case 1: "Elem"
    let completions = vec![
        CompletionBuilder::constant("ElementType", "7fffffff"),
        CompletionBuilder::variable("element_type", "7ffffffe"),
    ];
    let matches = sort_matches("Elem", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "ElementType");
    assert_eq!(matches[1], "element_type");
}

#[gpui::test]
async fn test_sort_matches_for_unreachable(cx: &mut TestAppContext) {
    // Case 1: "unre"
    let completions = vec![
        CompletionBuilder::function("unreachable", "80000000"),
        CompletionBuilder::function("unreachable!(…)", "7fffffff"),
        CompletionBuilder::function("unchecked_rem", "80000000"),
        CompletionBuilder::function("unreachable_unchecked", "80000000"),
    ];
    let matches = sort_matches("unre", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "unreachable!(…)");

    // Case 2: "unrea"
    let completions = vec![
        CompletionBuilder::function("unreachable", "80000000"),
        CompletionBuilder::function("unreachable!(…)", "7fffffff"),
        CompletionBuilder::function("unreachable_unchecked", "80000000"),
    ];
    let matches = sort_matches("unrea", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "unreachable!(…)");

    // Case 3: "unreach"
    let completions = vec![
        CompletionBuilder::function("unreachable", "80000000"),
        CompletionBuilder::function("unreachable!(…)", "7fffffff"),
        CompletionBuilder::function("unreachable_unchecked", "80000000"),
    ];
    let matches = sort_matches("unreach", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "unreachable!(…)");

    // Case 4: "unreachabl"
    let completions = vec![
        CompletionBuilder::function("unreachable", "80000000"),
        CompletionBuilder::function("unreachable!(…)", "7fffffff"),
        CompletionBuilder::function("unreachable_unchecked", "80000000"),
    ];
    let matches = sort_matches("unreachable", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "unreachable!(…)");

    // Case 5: "unreachable"
    let completions = vec![
        CompletionBuilder::function("unreachable", "80000000"),
        CompletionBuilder::function("unreachable!(…)", "7fffffff"),
        CompletionBuilder::function("unreachable_unchecked", "80000000"),
    ];
    let matches = sort_matches("unreachable", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "unreachable!(…)");
}

#[gpui::test]
async fn test_sort_matches_variable_and_constants_over_function(cx: &mut TestAppContext) {
    // Case 1: "var" as variable
    let completions = vec![
        CompletionBuilder::function("var", "7fffffff"),
        CompletionBuilder::variable("var", "7fffffff"),
    ];
    let matches = sort_matches("var", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "var");
    assert_eq!(matches[1], "var");

    // Case 2: "var" as constant
    let completions = vec![
        CompletionBuilder::function("var", "7fffffff"),
        CompletionBuilder::constant("var", "7fffffff"),
    ];
    let matches = sort_matches("var", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "var");
    assert_eq!(matches[1], "var");
}

#[gpui::test]
async fn test_sort_matches_for_jsx_event_handler(cx: &mut TestAppContext) {
    // Case 1: "on"
    let completions = vec![
        CompletionBuilder::function("onCut?", "12"),
        CompletionBuilder::function("onPlay?", "12"),
        CompletionBuilder::function("color?", "12"),
        CompletionBuilder::function("defaultValue?", "12"),
        CompletionBuilder::function("style?", "12"),
        CompletionBuilder::function("className?", "12"),
    ];
    let matches = sort_matches("on", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "onCut?");
    assert_eq!(matches[1], "onPlay?");

    // Case 2: "ona"
    let completions = vec![
        CompletionBuilder::function("onAbort?", "12"),
        CompletionBuilder::function("onAuxClick?", "12"),
        CompletionBuilder::function("onPlay?", "12"),
        CompletionBuilder::function("onLoad?", "12"),
        CompletionBuilder::function("onDrag?", "12"),
        CompletionBuilder::function("onPause?", "12"),
        CompletionBuilder::function("onPaste?", "12"),
        CompletionBuilder::function("onAnimationEnd?", "12"),
        CompletionBuilder::function("onAbortCapture?", "12"),
        CompletionBuilder::function("onChange?", "12"),
        CompletionBuilder::function("onWaiting?", "12"),
        CompletionBuilder::function("onCanPlay?", "12"),
    ];
    let matches = sort_matches("ona", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "onAbort?");
    assert_eq!(matches[1], "onAuxClick?");
}

#[gpui::test]
async fn test_sort_matches_for_snippets(cx: &mut TestAppContext) {
    // Case 1: "prin"
    let completions = vec![
        CompletionBuilder::constant("println", "80000000"),
        CompletionBuilder::snippet("println!(…)", "80000000"),
    ];
    let matches = sort_matches("prin", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "println!(…)");
}

#[gpui::test]
async fn test_sort_matches_for_exact_match(cx: &mut TestAppContext) {
    // Case 1: "set_text"
    let completions = vec![
        CompletionBuilder::function("set_text", "7fffffff"),
        CompletionBuilder::function("set_placeholder_text", "7fffffff"),
        CompletionBuilder::function("set_text_style_refinement", "7fffffff"),
        CompletionBuilder::function("set_context_menu_options", "7fffffff"),
        CompletionBuilder::function("select_to_next_word_end", "7fffffff"),
        CompletionBuilder::function("select_to_next_subword_end", "7fffffff"),
        CompletionBuilder::function("set_custom_context_menu", "7fffffff"),
        CompletionBuilder::function("select_to_end_of_excerpt", "7fffffff"),
        CompletionBuilder::function("select_to_start_of_excerpt", "7fffffff"),
        CompletionBuilder::function("select_to_start_of_next_excerpt", "7fffffff"),
        CompletionBuilder::function("select_to_end_of_previous_excerpt", "7fffffff"),
    ];
    let matches = sort_matches("set_text", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "set_text");
    assert_eq!(matches[1], "set_text_style_refinement");
    assert_eq!(matches[2], "set_context_menu_options");
}

#[gpui::test]
async fn test_sort_matches_for_prefix_matches(cx: &mut TestAppContext) {
    // Case 1: "set"
    let completions = vec![
        CompletionBuilder::function("select_to_beginning", "7fffffff"),
        CompletionBuilder::function("set_collapse_matches", "7fffffff"),
        CompletionBuilder::function("set_autoindent", "7fffffff"),
        CompletionBuilder::function("set_all_diagnostics_active", "7fffffff"),
        CompletionBuilder::function("select_to_end_of_line", "7fffffff"),
        CompletionBuilder::function("select_all", "7fffffff"),
        CompletionBuilder::function("select_line", "7fffffff"),
        CompletionBuilder::function("select_left", "7fffffff"),
        CompletionBuilder::function("select_down", "7fffffff"),
    ];
    let matches = sort_matches("set", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "set_autoindent");
    assert_eq!(matches[1], "set_collapse_matches");
    assert_eq!(matches[2], "set_all_diagnostics_active");
}

#[gpui::test]
async fn test_sort_matches_for_await(cx: &mut TestAppContext) {
    // Case 1: "awa"
    let completions = vec![
        CompletionBuilder::keyword("await", "7fffffff"),
        CompletionBuilder::function("await.ne", "80000010"),
        CompletionBuilder::function("await.eq", "80000010"),
        CompletionBuilder::function("await.or", "7ffffff8"),
        CompletionBuilder::function("await.zip", "80000006"),
        CompletionBuilder::function("await.xor", "7ffffff8"),
        CompletionBuilder::function("await.and", "80000006"),
        CompletionBuilder::function("await.map", "80000006"),
        CompletionBuilder::function("await.take", "7ffffff8"),
    ];
    let matches = sort_matches("awa", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "await");

    // Case 2: "await"
    let completions = vec![
        CompletionBuilder::keyword("await", "7fffffff"),
        CompletionBuilder::function("await.ne", "80000010"),
        CompletionBuilder::function("await.eq", "80000010"),
        CompletionBuilder::function("await.or", "7ffffff8"),
        CompletionBuilder::function("await.zip", "80000006"),
        CompletionBuilder::function("await.xor", "7ffffff8"),
        CompletionBuilder::function("await.and", "80000006"),
        CompletionBuilder::function("await.map", "80000006"),
        CompletionBuilder::function("await.take", "7ffffff8"),
    ];
    let matches = sort_matches("await", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "await");
}

#[gpui::test]
async fn test_sort_matches_for_python_init(cx: &mut TestAppContext) {
    // Case 1: "__in"
    let completions = vec![
        CompletionBuilder::function("__init__", "05.0003.__init__"),
        CompletionBuilder::function("__init__", "05.0003"),
        CompletionBuilder::function("__instancecheck__", "05.0005.__instancecheck__"),
        CompletionBuilder::function("__init_subclass__", "05.0004.__init_subclass__"),
        CompletionBuilder::function("__instancecheck__", "05.0005"),
        CompletionBuilder::function("__init_subclass__", "05.0004"),
    ];
    let matches = sort_matches("__in", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "__init__");
    assert_eq!(matches[1], "__init__");

    // Case 2: "__ini"
    let completions = vec![
        CompletionBuilder::function("__init__", "05.0004.__init__"),
        CompletionBuilder::function("__init__", "05.0004"),
        CompletionBuilder::function("__init_subclass__", "05.0003.__init_subclass__"),
        CompletionBuilder::function("__init_subclass__", "05.0003"),
    ];
    let matches = sort_matches("__ini", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "__init__");
    assert_eq!(matches[1], "__init__");

    // Case 3: "__init"
    let completions = vec![
        CompletionBuilder::function("__init__", "05.0000.__init__"),
        CompletionBuilder::function("__init__", "05.0000"),
        CompletionBuilder::function("__init_subclass__", "05.0001.__init_subclass__"),
        CompletionBuilder::function("__init_subclass__", "05.0001"),
    ];
    let matches = sort_matches("__init", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "__init__");
    assert_eq!(matches[1], "__init__");

    // Case 4: "__init_"
    let completions = vec![
        CompletionBuilder::function("__init__", "11.9999.__init__"),
        CompletionBuilder::function("__init__", "11.9999"),
        CompletionBuilder::function("__init_subclass__", "05.0000.__init_subclass__"),
        CompletionBuilder::function("__init_subclass__", "05.0000"),
    ];
    let matches = sort_matches("__init_", &completions, SnippetSortOrder::Top, cx).await;
    assert_eq!(matches[0], "__init__");
    assert_eq!(matches[1], "__init__");
}

#[gpui::test]
async fn test_sort_matches_for_rust_into(cx: &mut TestAppContext) {
    // Case 1: "int"
    let completions = vec![
        CompletionBuilder::function("into", "80000004"),
        CompletionBuilder::function("try_into", "80000004"),
        CompletionBuilder::snippet("println", "80000004"),
        CompletionBuilder::function("clone_into", "80000004"),
        CompletionBuilder::function("into_searcher", "80000000"),
        CompletionBuilder::snippet("eprintln", "80000004"),
    ];
    let matches = sort_matches("int", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "into");

    // Case 2: "into"
    let completions = vec![
        CompletionBuilder::function("into", "80000004"),
        CompletionBuilder::function("try_into", "80000004"),
        CompletionBuilder::function("clone_into", "80000004"),
        CompletionBuilder::function("into_searcher", "80000000"),
        CompletionBuilder::function("split_terminator", "7fffffff"),
        CompletionBuilder::function("rsplit_terminator", "7fffffff"),
    ];
    let matches = sort_matches("into", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "into");
}

#[gpui::test]
async fn test_sort_matches_for_variable_over_function(cx: &mut TestAppContext) {
    // Case 1: "serial"
    let completions = vec![
        CompletionBuilder::function("serialize", "80000000"),
        CompletionBuilder::function("serialize", "80000000"),
        CompletionBuilder::variable("serialization_key", "7ffffffe"),
        CompletionBuilder::function("serialize_version", "80000000"),
        CompletionBuilder::function("deserialize", "80000000"),
    ];
    let matches = sort_matches("serial", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "serialization_key");
    assert_eq!(matches[1], "serialize");
    assert_eq!(matches[2], "serialize");
    assert_eq!(matches[3], "serialize_version");
    assert_eq!(matches[4], "deserialize");
}

#[gpui::test]
async fn test_sort_matches_for_local_methods_over_library(cx: &mut TestAppContext) {
    // Case 1: "setis"
    let completions = vec![
        CompletionBuilder::variable("setISODay", "16"),
        CompletionBuilder::variable("setISOWeek", "16"),
        CompletionBuilder::variable("setISOWeekYear", "16"),
        CompletionBuilder::function("setISOWeekYear", "16"),
        CompletionBuilder::variable("setIsRefreshing", "11"),
        CompletionBuilder::function("setFips", "16"),
    ];
    let matches = sort_matches("setis", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "setIsRefreshing");
    assert_eq!(matches[1], "setISODay");
    assert_eq!(matches[2], "setISOWeek");
}

#[gpui::test]
async fn test_sort_matches_for_prioritize_not_exact_match(cx: &mut TestAppContext) {
    // Case 1: "item"
    let completions = vec![
        CompletionBuilder::function("Item", "16"),
        CompletionBuilder::variable("Item", "16"),
        CompletionBuilder::variable("items", "11"),
        CompletionBuilder::function("ItemText", "16"),
    ];
    let matches = sort_matches("item", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "items");
    assert_eq!(matches[1], "Item");
    assert_eq!(matches[2], "Item");
    assert_eq!(matches[3], "ItemText");
}

#[gpui::test]
async fn test_sort_matches_for_tailwind_classes(cx: &mut TestAppContext) {
    let completions = vec![
        CompletionBuilder::function("rounded-full", "15788"),
        CompletionBuilder::variable("rounded-t-full", "15846"),
        CompletionBuilder::variable("rounded-b-full", "15731"),
        CompletionBuilder::function("rounded-tr-full", "15866"),
    ];
    // Case 1: "rounded-full"
    let matches = sort_matches(
        "rounded-full",
        &completions,
        SnippetSortOrder::default(),
        cx,
    )
    .await;
    assert_eq!(matches[0], "rounded-full");
    // Case 2: "roundedfull"
    let matches = sort_matches("roundedfull", &completions, SnippetSortOrder::default(), cx).await;
    assert_eq!(matches[0], "rounded-full");
}

struct CompletionBuilder;

impl CompletionBuilder {
    fn constant(label: &str, sort_text: &str) -> Completion {
        Self::new(label, sort_text, CompletionItemKind::CONSTANT)
    }

    fn function(label: &str, sort_text: &str) -> Completion {
        Self::new(label, sort_text, CompletionItemKind::FUNCTION)
    }

    fn variable(label: &str, sort_text: &str) -> Completion {
        Self::new(label, sort_text, CompletionItemKind::VARIABLE)
    }

    fn keyword(label: &str, sort_text: &str) -> Completion {
        Self::new(label, sort_text, CompletionItemKind::KEYWORD)
    }

    fn snippet(label: &str, sort_text: &str) -> Completion {
        Self::new(label, sort_text, CompletionItemKind::SNIPPET)
    }

    fn new(label: &str, sort_text: &str, kind: CompletionItemKind) -> Completion {
        Completion {
            replace_range: Anchor::MIN..Anchor::MAX,
            new_text: label.to_string(),
            label: CodeLabel {
                text: label.to_string(),
                runs: Default::default(),
                filter_range: 0..label.len(),
            },
            documentation: None,
            source: CompletionSource::Lsp {
                insert_range: None,
                server_id: LanguageServerId(0),
                lsp_completion: Box::new(CompletionItem {
                    label: label.to_string(),
                    kind: Some(kind),
                    sort_text: Some(sort_text.to_string()),
                    ..Default::default()
                }),
                lsp_defaults: None,
                resolved: false,
            },
            icon_path: None,
            insert_text_mode: None,
            confirm: None,
        }
    }
}

async fn sort_matches(
    query: &str,
    completions: &Vec<Completion>,
    snippet_sort_order: SnippetSortOrder,
    cx: &mut TestAppContext,
) -> Vec<String> {
    let candidates: Arc<[StringMatchCandidate]> = completions
        .iter()
        .enumerate()
        .map(|(id, completion)| StringMatchCandidate::new(id, &completion.label.text))
        .collect();
    let cancel_flag = Arc::new(AtomicBool::new(false));
    let background_executor = cx.executor();
    let matches = fuzzy::match_strings(
        &candidates,
        query,
        query.chars().any(|c| c.is_uppercase()),
        100,
        &cancel_flag,
        background_executor,
    )
    .await;
    let sorted_matches = CompletionsMenu::sort_string_matches(
        matches,
        Some(query),
        snippet_sort_order,
        &completions,
    );
    sorted_matches.into_iter().map(|m| m.string).collect()
}