use collections::HashMap;
use language::BufferSnapshot;
use std::ops::Range;
use util::RangeExt;

use crate::{
    declaration::Identifier,
    excerpt::{EditPredictionExcerpt, EditPredictionExcerptText},
};

#[derive(Debug, Clone)]
pub struct Reference {
    pub identifier: Identifier,
    pub range: Range<usize>,
    pub region: ReferenceRegion,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum ReferenceRegion {
    Breadcrumb,
    Nearby,
}

pub fn references_in_excerpt(
    excerpt: &EditPredictionExcerpt,
    excerpt_text: &EditPredictionExcerptText,
    snapshot: &BufferSnapshot,
) -> HashMap<Identifier, Vec<Reference>> {
    let mut references = references_in_range(
        excerpt.range.clone(),
        excerpt_text.body.as_str(),
        ReferenceRegion::Nearby,
        snapshot,
    );

    for ((_, range), text) in excerpt
        .parent_declarations
        .iter()
        .zip(excerpt_text.parent_signatures.iter())
    {
        references.extend(references_in_range(
            range.clone(),
            text.as_str(),
            ReferenceRegion::Breadcrumb,
            snapshot,
        ));
    }

    let mut identifier_to_references: HashMap<Identifier, Vec<Reference>> = HashMap::default();
    for reference in references {
        identifier_to_references
            .entry(reference.identifier.clone())
            .or_insert_with(Vec::new)
            .push(reference);
    }
    identifier_to_references
}

/// Finds all nodes which have a "variable" match from the highlights query within the offset range.
pub fn references_in_range(
    range: Range<usize>,
    range_text: &str,
    reference_region: ReferenceRegion,
    buffer: &BufferSnapshot,
) -> Vec<Reference> {
    let mut matches = buffer
        .syntax
        .matches(range.clone(), &buffer.text, |grammar| {
            grammar
                .highlights_config
                .as_ref()
                .map(|config| &config.query)
        });

    let mut references = Vec::new();
    let mut last_added_range = None;
    while let Some(mat) = matches.peek() {
        let config = matches.grammars()[mat.grammar_index]
            .highlights_config
            .as_ref();

        if let Some(config) = config {
            for capture in mat.captures {
                if config.identifier_capture_indices.contains(&capture.index) {
                    let node_range = capture.node.byte_range();

                    // sometimes multiple highlight queries match - this deduplicates them
                    if Some(node_range.clone()) == last_added_range {
                        continue;
                    }

                    if !range.contains_inclusive(&node_range) {
                        continue;
                    }

                    let identifier_text =
                        &range_text[node_range.start - range.start..node_range.end - range.start];

                    references.push(Reference {
                        identifier: Identifier {
                            name: identifier_text.into(),
                            language_id: mat.language.id(),
                        },
                        range: node_range.clone(),
                        region: reference_region,
                    });
                    last_added_range = Some(node_range);
                }
            }
        }

        matches.advance();
    }
    references
}

#[cfg(test)]
mod test {
    use gpui::{TestAppContext, prelude::*};
    use indoc::indoc;
    use language::{BufferSnapshot, Language, LanguageConfig, LanguageMatcher, tree_sitter_rust};

    use crate::reference::{ReferenceRegion, references_in_range};

    #[gpui::test]
    fn test_identifier_node_truncated(cx: &mut TestAppContext) {
        let code = indoc! { r#"
            fn main() {
                add(1, 2);
            }

            fn add(a: i32, b: i32) -> i32 {
                a + b
            }
        "# };
        let buffer = create_buffer(code, cx);

        let range = 0..35;
        let references = references_in_range(
            range.clone(),
            &code[range],
            ReferenceRegion::Breadcrumb,
            &buffer,
        );
        assert_eq!(references.len(), 2);
        assert_eq!(references[0].identifier.name.as_ref(), "main");
        assert_eq!(references[1].identifier.name.as_ref(), "add");
    }

    fn create_buffer(text: &str, cx: &mut TestAppContext) -> BufferSnapshot {
        let buffer =
            cx.new(|cx| language::Buffer::local(text, cx).with_language(rust_lang().into(), cx));
        buffer.read_with(cx, |buffer, _| buffer.snapshot())
    }

    fn rust_lang() -> Language {
        Language::new(
            LanguageConfig {
                name: "Rust".into(),
                matcher: LanguageMatcher {
                    path_suffixes: vec!["rs".to_string()],
                    ..Default::default()
                },
                ..Default::default()
            },
            Some(tree_sitter_rust::LANGUAGE.into()),
        )
        .with_highlights_query(include_str!("../../languages/src/rust/highlights.scm"))
        .unwrap()
        .with_outline_query(include_str!("../../languages/src/rust/outline.scm"))
        .unwrap()
    }
}