uncomment 3.10.0

use crate::languages::config::{CommentSyntax, LanguageConfig};
use crate::ui;
use ahash::AHashMap;
use std::path::Path;
use std::sync::Arc;

/// Suffix that turns a `filenames` entry into a prefix rule: `Dockerfile.*` claims
/// `Dockerfile.prod` without naming dockerfile anywhere in detection code.
const FILENAME_WILDCARD_SUFFIX: &str = ".*";

pub struct LanguageRegistry {
    languages: AHashMap<String, Arc<LanguageConfig>>,
    extension_map: AHashMap<String, String>,
    /// Whole filenames a language claims, matched case-sensitively — `BUILD` and `build` are
    /// different files to Bazel, so folding the key would hand a `build` script to a Starlark parser.
    filename_map: AHashMap<String, String>,
    /// The `Dockerfile.*`-style entries as `(prefix including the dot, language)`, kept sorted
    /// longest-first so registration order never decides which of two overlapping prefixes wins.
    filename_prefixes: Vec<(String, String)>,
}

impl LanguageRegistry {
    pub fn new() -> Self {
        let mut registry = Self {
            languages: AHashMap::new(),
            extension_map: AHashMap::new(),
            filename_map: AHashMap::new(),
            filename_prefixes: Vec::new(),
        };

        registry.register_default_languages();
        registry
    }

    fn register_default_languages(&mut self) {
        let configs = vec![
            LanguageConfig::rust(),
            LanguageConfig::python(),
            LanguageConfig::javascript(),
            LanguageConfig::typescript(),
            LanguageConfig::tsx(),
            LanguageConfig::go(),
            LanguageConfig::gotmpl(),
            LanguageConfig::ruby(),
            LanguageConfig::php(),
            LanguageConfig::elixir(),
            LanguageConfig::toml(),
            LanguageConfig::csharp(),
            LanguageConfig::java(),
            LanguageConfig::c(),
            LanguageConfig::cpp(),
            LanguageConfig::json(),
            LanguageConfig::jsonc(),
            LanguageConfig::yaml(),
            LanguageConfig::hcl(),
            LanguageConfig::make(),
            LanguageConfig::shell(),
            LanguageConfig::haskell(),
            LanguageConfig::html(),
            LanguageConfig::css(),
            LanguageConfig::xml(),
            LanguageConfig::sql(),
            LanguageConfig::kotlin(),
            LanguageConfig::swift(),
            LanguageConfig::objc(),
            LanguageConfig::lua(),
            LanguageConfig::nix(),
            LanguageConfig::powershell(),
            LanguageConfig::proto(),
            LanguageConfig::ini(),
            LanguageConfig::dockerfile(),
            LanguageConfig::scala(),
            LanguageConfig::dart(),
            LanguageConfig::r(),
            LanguageConfig::julia(),
            LanguageConfig::zig(),
            LanguageConfig::clojure(),
            LanguageConfig::elm(),
            LanguageConfig::erlang(),
            LanguageConfig::vue(),
            LanguageConfig::svelte(),
            LanguageConfig::scss(),
            LanguageConfig::latex(),
            LanguageConfig::fish(),
            LanguageConfig::perl(),
            LanguageConfig::groovy(),
            LanguageConfig::ocaml(),
            LanguageConfig::fortran(),
            LanguageConfig::starlark(),
            LanguageConfig::properties(),
            LanguageConfig::markdown(),
        ];

        for config in configs {
            self.register_language(config);
        }
    }

    pub fn register_language(&mut self, config: LanguageConfig) {
        let config = Arc::new(config);
        let name_lower = config.name.to_lowercase();

        for extension in &config.extensions {
            let normalized_ext = extension.trim_start_matches('.').to_lowercase();
            self.extension_map.insert(normalized_ext, name_lower.clone());
        }

        for filename in &config.filenames {
            match filename.strip_suffix(FILENAME_WILDCARD_SUFFIX) {
                Some(prefix) => {
                    let prefix = format!("{prefix}.");
                    self.filename_prefixes.retain(|(existing, _)| *existing != prefix);
                    self.filename_prefixes.push((prefix, name_lower.clone()));
                }
                None => {
                    self.filename_map.insert(filename.clone(), name_lower.clone());
                }
            }
        }
        self.filename_prefixes
            .sort_by(|left, right| right.0.len().cmp(&left.0.len()).then_with(|| left.0.cmp(&right.0)));

        self.languages.insert(name_lower, config);
    }

    pub fn get_language(&self, name: &str) -> Option<&LanguageConfig> {
        self.languages.get(&name.to_lowercase()).map(Arc::as_ref)
    }

    #[must_use]
    pub fn get_language_arc(&self, name: &str) -> Option<Arc<LanguageConfig>> {
        self.languages.get(&name.to_lowercase()).cloned()
    }

    pub fn detect_language(&self, file_path: &Path) -> Option<&LanguageConfig> {
        let language_name = self.detect_language_name(file_path)?;
        self.languages.get(language_name).map(Arc::as_ref)
    }

    #[must_use]
    pub fn detect_language_arc(&self, file_path: &Path) -> Option<Arc<LanguageConfig>> {
        let language_name = self.detect_language_name(file_path)?;
        self.languages.get(language_name).cloned()
    }

    /// A language that claims the whole filename is consulted before any extension rule, so
    /// `BUILD.bazel` is Starlark because Starlark claims that name — not because something happens to
    /// claim `.bazel`. Extensionless names like `BUILD` have no other way in at all.
    fn detect_language_name(&self, file_path: &Path) -> Option<&str> {
        let file_name = file_path.file_name()?.to_str()?;

        if let Some(name) = self.filename_map.get(file_name) {
            return Some(name);
        }

        if let Some((_, name)) = self
            .filename_prefixes
            .iter()
            .find(|(prefix, _)| file_name.starts_with(prefix.as_str()))
        {
            return Some(name);
        }

        if file_name.ends_with(".d.ts") || file_name.ends_with(".d.mts") || file_name.ends_with(".d.cts") {
            return Some("typescript");
        }

        let extension = file_path.extension()?.to_str()?.to_lowercase();
        self.extension_map.get(&extension).map(String::as_str)
    }

    pub fn detect_language_by_extension(&self, extension: &str) -> Option<&LanguageConfig> {
        let normalized_ext = extension.trim_start_matches('.').to_lowercase();
        let language_name = self.extension_map.get(&normalized_ext)?;
        self.languages.get(language_name).map(Arc::as_ref)
    }

    pub fn get_supported_languages(&self) -> Vec<String> {
        self.languages.keys().cloned().collect()
    }

    pub fn get_supported_extensions(&self) -> Vec<String> {
        self.extension_map.keys().cloned().collect()
    }

    pub fn is_supported_extension(&self, extension: &str) -> bool {
        let normalized_ext = extension.trim_start_matches('.').to_lowercase();
        self.extension_map.contains_key(&normalized_ext)
    }

    pub fn is_supported_language(&self, name: &str) -> bool {
        self.languages.contains_key(&name.to_lowercase())
    }

    pub fn language_for_extension(&self, extension: &str) -> Option<String> {
        let normalized_ext = extension.trim_start_matches('.').to_lowercase();
        self.extension_map.get(&normalized_ext).cloned()
    }

    pub fn extensions_for_language(&self, name: &str) -> Option<Vec<String>> {
        self.get_language(name).map(|config| config.extensions.clone())
    }

    pub fn get_all_languages(&self) -> impl Iterator<Item = (&String, &LanguageConfig)> {
        self.languages.iter().map(|(name, config)| (name, config.as_ref()))
    }

    /// Add every language a config file declared, and report back the ones that could not be added.
    ///
    /// A declaration is only usable if a grammar can be found for it, either because the name is a
    /// built-in language or because `tree-sitter-language-pack` ships one under that name. The rest
    /// are returned, sorted, rather than dropped in silence: the section would otherwise have no
    /// effect whatsoever — neither its extensions nor its filenames registered, so not even a file
    /// collected — and nothing would say why. See [`warn_languages_without_a_grammar`] for the
    /// caller-side report.
    pub fn register_configured_languages(
        &mut self,
        config_languages: &std::collections::HashMap<String, crate::config::LanguageConfig>,
    ) -> Vec<String> {
        let mut without_a_grammar = Vec::new();

        for config in config_languages.values() {
            let name_lower = config.name.to_lowercase();
            let (tslp_name, comment_syntax) = if let Some(existing_config) = self.languages.get(&name_lower) {
                (existing_config.tslp_name.clone(), existing_config.comment_syntax)
            } else if tree_sitter_language_pack::has_language(&name_lower) {
                let syntax = CommentSyntax::for_tree_sitter_language(&name_lower);
                (name_lower.clone(), syntax)
            } else {
                without_a_grammar.push(config.name.clone());
                continue;
            };

            let language_config = LanguageConfig {
                name: config.name.clone(),
                extensions: config.extensions.clone(),
                filenames: config.filenames.clone(),
                comment_types: config.comment_nodes.clone(),
                doc_comment_types: config.doc_comment_nodes.clone(),
                tslp_name,
                comment_syntax,
            };
            self.register_language(language_config);
        }

        // `config_languages` is a HashMap, so sort for a message that does not reorder per process.
        without_a_grammar.sort();
        without_a_grammar.dedup();
        without_a_grammar
    }
}

impl Default for LanguageRegistry {
    fn default() -> Self {
        Self::new()
    }
}

/// Report the declared languages [`LanguageRegistry::register_configured_languages`] could not add.
///
/// Called once per run, from the entry point that builds the collection registry, because the
/// per-file registries are built from the same declarations and would repeat it for every file.
pub fn warn_languages_without_a_grammar(names: &[String]) {
    if names.is_empty() {
        return;
    }

    anstream::eprintln!(
        "{} no tree-sitter grammar is known for the configured language(s) {}; their [languages] \
         section is ignored, so files with those extensions are not processed.",
        ui::warn("warning:"),
        ui::accent(names.join(", "))
    );
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn test_registry_creation() {
        let registry = LanguageRegistry::new();
        assert!(!registry.languages.is_empty());
        assert!(!registry.extension_map.is_empty());
    }

    #[test]
    fn test_language_detection_by_path() {
        let registry = LanguageRegistry::new();

        let rust_file = PathBuf::from("src/main.rs");
        let detected = registry.detect_language(&rust_file);
        assert!(detected.is_some());
        assert_eq!(detected.unwrap().name, "rust");

        let python_file = PathBuf::from("script.py");
        let detected = registry.detect_language(&python_file);
        assert!(detected.is_some());
        assert_eq!(detected.unwrap().name, "python");

        let go_file = PathBuf::from("main.go");
        let detected = registry.detect_language(&go_file);
        assert!(detected.is_some());
        assert_eq!(detected.unwrap().name, "go");

        let unknown_file = PathBuf::from("file.unknown");
        let detected = registry.detect_language(&unknown_file);
        assert!(detected.is_none());
    }

    #[test]
    fn test_language_detection_by_extension() {
        let registry = LanguageRegistry::new();

        assert_eq!(registry.detect_language_by_extension("rs").unwrap().name, "rust");
        assert_eq!(registry.detect_language_by_extension("py").unwrap().name, "python");
        assert_eq!(registry.detect_language_by_extension("js").unwrap().name, "javascript");
        assert_eq!(registry.detect_language_by_extension("ts").unwrap().name, "typescript");

        assert_eq!(registry.detect_language_by_extension("sh").unwrap().name, "shell");

        assert_eq!(registry.detect_language_by_extension("bash").unwrap().name, "shell");

        assert_eq!(registry.detect_language_by_extension("zsh").unwrap().name, "shell");

        assert_eq!(registry.detect_language_by_extension("go").unwrap().name, "go");
        assert_eq!(registry.detect_language_by_extension("html").unwrap().name, "html");
        assert_eq!(registry.detect_language_by_extension("sql").unwrap().name, "sql");
        assert_eq!(registry.detect_language_by_extension("ps1").unwrap().name, "powershell");

        assert!(registry.detect_language_by_extension("unknown").is_none());
    }

    #[test]
    fn test_supported_languages() {
        let registry = LanguageRegistry::new();
        let languages = registry.get_supported_languages();

        assert!(languages.contains(&"rust".to_string()));
        assert!(languages.contains(&"python".to_string()));
        assert!(languages.contains(&"javascript".to_string()));
        assert!(languages.contains(&"typescript".to_string()));
        assert!(languages.contains(&"go".to_string()));
        assert!(languages.contains(&"java".to_string()));
        assert!(languages.contains(&"c".to_string()));
        assert!(languages.contains(&"cpp".to_string()));
        assert!(languages.contains(&"shell".to_string()));
        assert!(languages.contains(&"haskell".to_string()));
        assert!(languages.contains(&"html".to_string()));
        assert!(languages.contains(&"css".to_string()));
        assert!(languages.contains(&"xml".to_string()));
        assert!(languages.contains(&"sql".to_string()));
        assert!(languages.contains(&"kotlin".to_string()));
        assert!(languages.contains(&"swift".to_string()));
        assert!(languages.contains(&"objc".to_string()));
        assert!(languages.contains(&"lua".to_string()));
        assert!(languages.contains(&"nix".to_string()));
        assert!(languages.contains(&"powershell".to_string()));
        assert!(languages.contains(&"proto".to_string()));
        assert!(languages.contains(&"ini".to_string()));
    }

    #[test]
    fn test_supported_extensions() {
        let registry = LanguageRegistry::new();

        assert!(registry.is_supported_extension("rs"));
        assert!(registry.is_supported_extension("py"));
        assert!(registry.is_supported_extension("js"));
        assert!(registry.is_supported_extension("ts"));
        assert!(registry.is_supported_extension("go"));
        assert!(registry.is_supported_extension("java"));
        assert!(registry.is_supported_extension("c"));
        assert!(registry.is_supported_extension("cpp"));
        assert!(registry.is_supported_extension("sh"));
        assert!(registry.is_supported_extension("bash"));
        assert!(registry.is_supported_extension("zsh"));
        assert!(registry.is_supported_extension("hs"));
        assert!(registry.is_supported_extension("html"));
        assert!(registry.is_supported_extension("css"));
        assert!(registry.is_supported_extension("xml"));
        assert!(registry.is_supported_extension("sql"));
        assert!(registry.is_supported_extension("kt"));
        assert!(registry.is_supported_extension("swift"));
        assert!(registry.is_supported_extension("m"));
        assert!(registry.is_supported_extension("lua"));
        assert!(registry.is_supported_extension("nix"));
        assert!(registry.is_supported_extension("ps1"));
        assert!(registry.is_supported_extension("proto"));
        assert!(registry.is_supported_extension("ini"));

        assert!(registry.is_supported_extension("h"));
        assert!(registry.is_supported_extension("hpp"));
        assert!(registry.is_supported_extension("hh"));
        assert!(registry.is_supported_extension("hxx"));
        assert!(registry.is_supported_extension("h++"));

        assert!(!registry.is_supported_extension("unknown"));
    }

    #[test]
    fn test_case_insensitive_extension_detection() {
        let registry = LanguageRegistry::new();

        assert_eq!(registry.detect_language_by_extension("RS").unwrap().name, "rust");
        assert_eq!(registry.detect_language_by_extension("PY").unwrap().name, "python");

        assert!(registry.is_supported_extension("RS"));
        assert!(registry.is_supported_extension("PY"));
    }

    #[test]
    fn test_language_registration() {
        let mut registry = LanguageRegistry::new();
        let initial_count = registry.languages.len();

        let custom_config = LanguageConfig::new("custom", vec!["cst"], vec!["comment"], vec!["doc_comment"], "rust");

        registry.register_language(custom_config);

        assert_eq!(registry.languages.len(), initial_count + 1);
        assert!(registry.is_supported_language("custom"));
        assert!(registry.is_supported_extension("cst"));
        assert_eq!(registry.language_for_extension("cst"), Some("custom".to_string()));
    }

    /// The `.*` form is part of the data, not a rule about dockerfile: any language can use it, and
    /// the longer of two overlapping prefixes wins regardless of the order they were registered in.
    #[test]
    fn a_wildcard_filename_entry_claims_names_by_prefix() {
        let mut registry = LanguageRegistry::new();
        registry.register_language(
            LanguageConfig::new("envfile", vec![], vec!["comment"], vec![], "bash").with_filenames(vec!["env.*"]),
        );
        registry.register_language(
            LanguageConfig::new("envfile-local", vec![], vec!["comment"], vec![], "bash")
                .with_filenames(vec!["env.local.*"]),
        );

        assert_eq!(
            registry.detect_language_name(&PathBuf::from("env.staging")),
            Some("envfile")
        );
        assert_eq!(
            registry.detect_language_name(&PathBuf::from("env.local.staging")),
            Some("envfile-local")
        );
        // A bare `env` is not `env.`-prefixed, so nothing claims it.
        assert_eq!(registry.detect_language_name(&PathBuf::from("env")), None);
    }

    #[test]
    fn test_extensions_for_language() {
        let registry = LanguageRegistry::new();

        let rust_extensions = registry.extensions_for_language("rust").unwrap();
        assert_eq!(rust_extensions, vec!["rs"]);

        let go_extensions = registry.extensions_for_language("go").unwrap();
        assert_eq!(go_extensions, vec!["go"]);

        let python_extensions = registry.extensions_for_language("python").unwrap();
        assert!(python_extensions.contains(&"py".to_string()));
        assert!(python_extensions.contains(&"pyw".to_string()));
        assert!(python_extensions.contains(&"pyi".to_string()));

        assert!(registry.extensions_for_language("unknown").is_none());
    }

    #[test]
    fn test_get_all_languages() {
        let registry = LanguageRegistry::new();
        let all_languages: Vec<_> = registry.get_all_languages().collect();

        assert!(!all_languages.is_empty());
        assert!(all_languages.iter().any(|(name, _)| *name == "rust"));
        assert!(all_languages.iter().any(|(name, _)| *name == "python"));
    }
}