use bstr::{BStr, BString, ByteSlice};

///
pub mod name {
    use bstr::BString;
    use std::convert::Infallible;

    /// The error used in [name()][super::name()] and [`name_partial()`][super::name_partial()]
    #[derive(Debug)]
    #[expect(missing_docs)]
    #[non_exhaustive]
    pub enum Error {
        InvalidByte { byte: BString },
        StartsWithSlash,
        RepeatedSlash,
        RepeatedDot,
        LockFileSuffix,
        ReflogPortion,
        Asterisk,
        StartsWithDot,
        EndsWithDot,
        EndsWithSlash,
        Empty,
        SomeLowercase,
        Reserved { name: BString },
    }

    impl std::fmt::Display for Error {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                Error::InvalidByte { byte } => write!(f, "Reference name contains invalid byte: {byte:?}"),
                Error::StartsWithSlash => write!(f, "Reference name cannot start with a slash"),
                Error::RepeatedSlash => write!(f, "Reference name cannot contain repeated slashes"),
                Error::RepeatedDot => write!(f, "Reference name cannot contain repeated dots"),
                Error::LockFileSuffix => write!(f, "Reference name cannot end with '.lock'"),
                Error::ReflogPortion => write!(f, "Reference name cannot contain '@{{'"),
                Error::Asterisk => write!(f, "Reference name cannot contain '*'"),
                Error::StartsWithDot => write!(f, "Reference name cannot start with a dot"),
                Error::EndsWithDot => write!(f, "Reference name cannot end with a dot"),
                Error::EndsWithSlash => write!(f, "Reference name cannot end with a slash"),
                Error::Empty => write!(f, "Reference name cannot be empty"),
                Error::SomeLowercase => write!(f, "Standalone references must be all uppercased, like 'HEAD'"),
                Error::Reserved { name } => write!(f, "Reference name is reserved and cannot be used: {name:?}"),
            }
        }
    }

    impl std::error::Error for Error {}

    impl From<crate::tag::name::Error> for Error {
        fn from(err: crate::tag::name::Error) -> Self {
            match err {
                crate::tag::name::Error::InvalidByte { byte } => Error::InvalidByte { byte },
                crate::tag::name::Error::StartsWithSlash => Error::StartsWithSlash,
                crate::tag::name::Error::RepeatedSlash => Error::RepeatedSlash,
                crate::tag::name::Error::RepeatedDot => Error::RepeatedDot,
                crate::tag::name::Error::LockFileSuffix => Error::LockFileSuffix,
                crate::tag::name::Error::ReflogPortion => Error::ReflogPortion,
                crate::tag::name::Error::Asterisk => Error::Asterisk,
                crate::tag::name::Error::StartsWithDot => Error::StartsWithDot,
                crate::tag::name::Error::EndsWithDot => Error::EndsWithDot,
                crate::tag::name::Error::EndsWithSlash => Error::EndsWithSlash,
                crate::tag::name::Error::Empty => Error::Empty,
            }
        }
    }

    impl From<Infallible> for Error {
        fn from(_: Infallible) -> Self {
            unreachable!("this impl is needed to allow passing a known valid partial path as parameter")
        }
    }
}

/// Validate a reference name running all the tests in the book. This disallows lower-case references like `lower`, but also allows
/// ones like `HEAD`, and `refs/lower`.
pub fn name(path: &BStr) -> Result<&BStr, name::Error> {
    match validate(path, Mode::Complete)? {
        None => Ok(path),
        Some(_) => {
            unreachable!("Without sanitization, there is no chance a sanitized version is returned.")
        }
    }
}

/// Validate a reference name for use as a local branch.
///
/// This is like [`name()`], but also rejects `refs/heads/HEAD`, matching Git's branch-specific validation.
pub fn branch_name(path: &BStr) -> Result<&BStr, name::Error> {
    let path = name(path)?;
    if path == "refs/heads/HEAD" {
        return Err(name::Error::Reserved { name: path.into() });
    }
    Ok(path)
}

/// Validate a partial reference name. As it is assumed to be partial, names like `some-name` is allowed
/// even though these would be disallowed with when using [`name()`].
pub fn name_partial(path: &BStr) -> Result<&BStr, name::Error> {
    match validate(path, Mode::Partial)? {
        None => Ok(path),
        Some(_) => {
            unreachable!("Without sanitization, there is no chance a sanitized version is returned.")
        }
    }
}

/// Sanitize `path` into a nonempty partial reference name which would also pass [`name_partial()`].
///
/// Return `-` if `path` is empty or sanitization leaves no name, as with input consisting only of `/` separators.
/// This fallback is specific to Gitoxide: Git's sanitizer does not replace empty results. It ensures callers
/// always receive a nonempty valid name without needing to handle an empty result themselves.
pub fn name_partial_or_sanitize(path: &BStr) -> BString {
    let mut name = validate(path, Mode::PartialSanitize)
        .expect("sanitization mode never returns validation errors")
        .expect("sanitization mode always rebuilds the name");
    if name.is_empty() {
        name.push(b'-');
    }
    name
}

enum Mode {
    Complete,
    Partial,
    /// like Partial, but instead of failing, a sanitized version is returned.
    PartialSanitize,
}

fn validate(path: &BStr, mode: Mode) -> Result<Option<BString>, name::Error> {
    let mut out = crate::tag::name_inner(
        path,
        match mode {
            Mode::Complete | Mode::Partial => crate::tag::Mode::Validate,
            Mode::PartialSanitize => crate::tag::Mode::Sanitize,
        },
    )?;
    // `@` alone is shorthand for `HEAD` in revspecs, so Git refuses it as a reference name.
    // Git substitutes it with `-` when sanitizing it, which is what we do here too. Note that `@` stays
    // valid as a component, which is why `refs/heads/@` and a tag named `@` are both fine.
    if out.as_ref().map_or(path, |b| b.as_bstr()) == "@" {
        match out.as_mut() {
            Some(out) => out[0] = b'-',
            None => return Err(name::Error::Reserved { name: path.into() }),
        }
    }
    if let Mode::Complete = mode {
        let input = out.as_ref().map_or(path, |b| b.as_bstr());
        let saw_slash = input.find_byte(b'/').is_some();
        if !saw_slash && !input.iter().all(|c| c.is_ascii_uppercase() || *c == b'_') {
            return Err(name::Error::SomeLowercase);
        }
    }
    Ok(out)
}