use bstr::{BString, ByteSlice};
use git_transport::client::Capabilities;

// Note that arguments suffixed by spaces take another value.
const BUILTIN_V2_COMMAND_ARGUMENT_NAMES: &[(&str, &[&str])] = &[
    ("ls-refs", &["symrefs", "peel", "ref-prefix "]),
    (
        "fetch",
        &[
            "want ", // hex oid
            "have ", // hex oid
            "done",
            "thin-pack",
            "no-progress",
            "include-tag",
            "ofs-delta",
            // Shallow feature/capability
            "shallow ", // hex oid
            "deepen ",  // commit depth
            "deepen-relative",
            "deepen-since ", // time-stamp
            "deepen-not ",   // rev
            // filter feature/capability
            "filter ", // filter-spec
            // ref-in-want feature
            "want-ref ", // ref path
            "sideband-all",
            // packfile-uris feature
            "packfile-uris ", // protocols
        ],
    ),
];

#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
pub enum Command {
    LsRefs,
    Fetch,
}

impl Command {
    pub fn as_str(&self) -> &'static str {
        match self {
            Command::LsRefs => "ls-refs",
            Command::Fetch => "fetch",
        }
    }

    fn all_argument_prefixes(&self) -> &'static [&'static str] {
        let name = self.as_str();
        BUILTIN_V2_COMMAND_ARGUMENT_NAMES
            .iter()
            .find_map(|(n, v)| if *n == name { Some(v) } else { None })
            .expect("command to be found")
    }
    fn all_features(&self) -> impl Iterator<Item = &str> {
        self.all_argument_prefixes()
            .iter()
            .filter(|s| !(s.ends_with(' ') || s.ends_with('=')))
            .copied()
    }

    pub(crate) fn collect_initial_features<'a>(
        &'a self,
        _version: git_transport::Protocol,
        capabilities: &'a Capabilities,
    ) -> impl Iterator<Item = (&str, Option<&str>)> + 'a {
        match Command::LsRefs {
            Command::Fetch => unimplemented!("collect for fetch"),
            Command::LsRefs => self
                .all_features()
                .filter(move |feature| {
                    if *feature == "symrefs" {
                        capabilities.iter().any(|c| c.name() == b"symref".as_bstr())
                    } else {
                        true
                    }
                })
                .map(|s| (s, None))
                .chain(Some(("agent", Some(concat!("git/oxide-", env!("CARGO_PKG_VERSION")))))),
        }
    }
    /// Panics if the given arguments and features don't match what's statically known. It's considered a bug in the delegate.
    pub(crate) fn validate_argument_prefixes_or_panic(
        &self,
        version: git_transport::Protocol,
        server: &Capabilities,
        arguments: &[BString],
        features: &[(&str, Option<&str>)],
    ) {
        let allowed = self.all_argument_prefixes();
        for arg in arguments {
            if allowed.iter().any(|allowed| arg.starts_with(allowed.as_bytes())) {
                continue;
            }
            panic!("{}: argument {} is not known or allowed", self.as_str(), arg);
        }
        match version {
            git_transport::Protocol::V1 => {
                for (feature, _) in features {
                    if server
                        .iter()
                        .any(|c| feature.starts_with(c.name().to_str_lossy().as_ref()))
                    {
                        continue;
                    }
                    panic!("{}: capability {} is not supported", self.as_str(), feature);
                }
            }
            git_transport::Protocol::V2 => {
                if let Some(allowed) = server.iter().find_map(|c| {
                    if c.name() == self.as_str().as_bytes().as_bstr() {
                        c.values().map(|v| v.map(|f| f.to_string()).collect::<Vec<_>>())
                    } else {
                        None
                    }
                }) {
                    for (feature, _) in features {
                        if allowed.iter().any(|allowed| feature.starts_with(allowed)) {
                            continue;
                        }
                        panic!("{}: V2 feature/capability {} is not supported", self.as_str(), feature);
                    }
                }
            }
        }
    }
}