use std::collections::BTreeSet;

const FILTERED_GIT_PROVIDER_HOSTNAMES: &[&str] = &[
    "dev.azure.com",
    "bitbucket.org",
    "chromium.googlesource.com",
    "codeberg.org",
    "gitea.com",
    "gitee.com",
    "github.com",
    "gist.github.com",
    "gitlab.com",
    "sourcehut.org",
    "git.sr.ht",
];

pub fn parse_ssh_config_hosts(config: &str) -> BTreeSet<String> {
    parse_host_blocks(config)
        .into_iter()
        .flat_map(HostBlock::non_git_provider_hosts)
        .collect()
}

struct HostBlock {
    aliases: BTreeSet<String>,
    hostname: Option<String>,
}

impl HostBlock {
    fn non_git_provider_hosts(self) -> impl Iterator<Item = String> {
        let hostname = self.hostname;
        let hostname_ref = hostname.as_deref().map(is_git_provider_domain);
        self.aliases
            .into_iter()
            .filter(move |alias| !hostname_ref.unwrap_or_else(|| is_git_provider_domain(alias)))
    }
}

fn parse_host_blocks(config: &str) -> Vec<HostBlock> {
    let mut blocks = Vec::new();
    let mut aliases = BTreeSet::new();
    let mut hostname = None;
    let mut needs_continuation = false;

    for line in config.lines() {
        let line = line.trim_start();

        if needs_continuation {
            needs_continuation = line.trim_end().ends_with('\\');
            parse_hosts(line, &mut aliases);
            continue;
        }

        let Some((keyword, value)) = split_keyword_and_value(line) else {
            continue;
        };

        if keyword.eq_ignore_ascii_case("host") {
            if !aliases.is_empty() {
                blocks.push(HostBlock { aliases, hostname });
                aliases = BTreeSet::new();
                hostname = None;
            }
            parse_hosts(value, &mut aliases);
            needs_continuation = line.trim_end().ends_with('\\');
        } else if keyword.eq_ignore_ascii_case("hostname") {
            hostname = value.split_whitespace().next().map(ToOwned::to_owned);
        }
    }

    if !aliases.is_empty() {
        blocks.push(HostBlock { aliases, hostname });
    }

    blocks
}

fn parse_hosts(line: &str, hosts: &mut BTreeSet<String>) {
    hosts.extend(
        line.split_whitespace()
            .map(|field| field.trim_end_matches('\\'))
            .filter(|field| !field.starts_with("!"))
            .filter(|field| !field.contains("*"))
            .filter(|field| *field != "\\")
            .filter(|field| !field.is_empty())
            .map(|field| field.to_owned()),
    );
}

fn split_keyword_and_value(line: &str) -> Option<(&str, &str)> {
    let keyword_end = line.find(char::is_whitespace).unwrap_or(line.len());
    let keyword = &line[..keyword_end];
    if keyword.is_empty() {
        return None;
    }

    let value = line[keyword_end..].trim_start();
    Some((keyword, value))
}

fn is_git_provider_domain(host: &str) -> bool {
    let host = host.to_ascii_lowercase();
    FILTERED_GIT_PROVIDER_HOSTNAMES.contains(&host.as_str())
}

#[cfg(test)]
mod tests {
    use super::*;
    use indoc::indoc;

    #[test]
    fn test_thank_you_bjorn3() {
        let hosts = indoc! {"
            Host *
              AddKeysToAgent yes
              UseKeychain yes
              IdentityFile ~/.ssh/id_ed25519

            Host whatever.*
            User another

            Host !not_this
            User not_me

            Host something
              HostName whatever.tld

            Host linux bsd host3
              User bjorn

            Host rpi
              user rpi
              hostname rpi.local

            Host \\
                   somehost \\
                   anotherhost
              Hostname 192.168.3.3
        "};

        let expected_hosts = BTreeSet::from_iter([
            "something".to_owned(),
            "linux".to_owned(),
            "host3".to_owned(),
            "bsd".to_owned(),
            "rpi".to_owned(),
            "somehost".to_owned(),
            "anotherhost".to_owned(),
        ]);

        assert_eq!(expected_hosts, parse_ssh_config_hosts(hosts));
    }

    #[test]
    fn filters_git_provider_domains_from_hostname() {
        let hosts = indoc! {"
            Host github-personal
              HostName github.com

            Host gitlab-work
              HostName GITLAB.COM

            Host local
              HostName example.com
        "};

        assert_eq!(
            BTreeSet::from_iter(["local".to_owned()]),
            parse_ssh_config_hosts(hosts)
        );
    }

    #[test]
    fn falls_back_to_host_when_hostname_is_absent() {
        let hosts = indoc! {"
            Host github.com bitbucket.org keep-me
              User git
        "};

        assert_eq!(
            BTreeSet::from_iter(["keep-me".to_owned()]),
            parse_ssh_config_hosts(hosts)
        );
    }

    #[test]
    fn does_not_fuzzy_match_host_aliases() {
        let hosts = indoc! {"
            Host GitHub GitLab Bitbucket GITHUB github
              User git
        "};

        assert_eq!(
            BTreeSet::from_iter([
                "Bitbucket".to_owned(),
                "GITHUB".to_owned(),
                "GitHub".to_owned(),
                "GitLab".to_owned(),
                "github".to_owned(),
            ]),
            parse_ssh_config_hosts(hosts)
        );
    }

    #[test]
    fn uses_hostname_before_host_filtering() {
        let hosts = indoc! {"
            Host github.com keep-me
              HostName example.com
        "};

        assert_eq!(
            BTreeSet::from_iter(["github.com".to_owned(), "keep-me".to_owned()]),
            parse_ssh_config_hosts(hosts)
        );
    }
}