address 0.21.0

use crate::ParseError::InvalidIPv6Address;
use crate::{IPv6Address, ParseError, impl_parse};
use std::net::Ipv6Addr;
use std::str::FromStr;

impl IPv6Address {
    //! Parse

    /// The maximum length of an IPv6 address string.
    /// (ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255)
    const MAX_STR_LEN: usize = 45;

    /// Parses an [IPv6Address] from the `text`.
    pub fn parse(text: &[u8]) -> Result<Self, ParseError> {
        if text.len() > Self::MAX_STR_LEN {
            return Err(InvalidIPv6Address);
        }
        let text: &str = std::str::from_utf8(text).map_err(|_| InvalidIPv6Address)?;
        Ok(Ipv6Addr::from_str(text)
            .map_err(|_| InvalidIPv6Address)?
            .into())
    }

    /// Parses the bracketed IPv6 address text, ignoring an optional numeric zone.
    ///
    /// Returns `None` if the address is not bracketed. A bracketed but invalid interior, the zone
    /// included, is `Some(Err(InvalidIPv6Address))`: the brackets declare the version, so callers
    /// propagate it rather than substituting their own error.
    pub(crate) fn parse_bracketed(text: &[u8]) -> Option<Result<Self, ParseError>> {
        let text: &[u8] = text.strip_prefix(b"[")?.strip_suffix(b"]")?;
        if let Some(text) = Self::strip_zone(text) {
            Some(Self::parse(text))
        } else {
            Some(Err(InvalidIPv6Address))
        }
    }

    /// Strips the ignored zone suffix from the `text`, the inner text of a bracketed IPv6 address.
    ///
    /// Returns the text unchanged if there is no `%`. The zone must be a decimal `u32`, with no
    /// sign; leading zeros are allowed, matching the scope ids accepted by the standard library
    /// socket parser. Returns `None` if the zone is invalid.
    ///
    /// The digit check runs first, so the zone is known to be ASCII before it is read as a string.
    ///
    /// # Examples
    /// `fe80::1%1` -> `Some("fe80::1")`
    /// `fe80::1`   -> `Some("fe80::1")`
    /// `fe80::1%`  -> `None`
    fn strip_zone(text: &[u8]) -> Option<&[u8]> {
        if let Some(percent) = text.iter().position(|c| *c == b'%') {
            let zone: &[u8] = &text[percent + 1..];
            let valid: bool = !zone.is_empty() && zone.iter().all(|c| c.is_ascii_digit());
            if !valid {
                return None;
            }
            let zone: &str = unsafe { std::str::from_utf8_unchecked(zone) };
            let _: u32 = u32::from_str(zone).ok()?;
            Some(&text[..percent])
        } else {
            Some(text)
        }
    }
}

impl_parse!(
    IPv6Address,
    "The embedded IPv4 form is accepted. (`::ffff:1.2.3.4`)",
    "Brackets & zones are not accepted; see [`SocketAddressV6`](crate::SocketAddressV6)."
);

#[cfg(test)]
mod tests {
    use crate::ParseError::InvalidIPv6Address;
    use crate::{IPv6Address, ParseError};
    use std::str::FromStr;

    type TestCase<'a> = (&'a [u8], Result<IPv6Address, ParseError>);

    #[test]
    fn parse() {
        let over_max: Vec<u8> = vec![b'0'; IPv6Address::MAX_STR_LEN + 1];
        let test_cases: &[TestCase] = &[
            (b"", Err(InvalidIPv6Address)),
            (b"::", Ok(IPv6Address::UNSPECIFIED)),
            (b"::1", Ok(IPv6Address::LOCALHOST)),
            (b"[::1]", Err(InvalidIPv6Address)),
            (b"[fe80::1]", Err(InvalidIPv6Address)),
            (b"[fe80::1%1]", Err(InvalidIPv6Address)),
            (b"fe80::1%1", Err(InvalidIPv6Address)),
            (b"fe80::1%0", Err(InvalidIPv6Address)),
            (b"::\xFF", Err(InvalidIPv6Address)),
            (b"\xFF\xFF", Err(InvalidIPv6Address)),
            (over_max.as_slice(), Err(InvalidIPv6Address)),
        ];

        for (input, expected) in test_cases {
            let result: Result<IPv6Address, ParseError> = IPv6Address::parse(input);
            assert_eq!(result, *expected, "parse input={:?}", input);

            let Ok(text) = std::str::from_utf8(input) else {
                continue;
            };

            let result: Result<IPv6Address, ParseError> = IPv6Address::from_str(text);
            assert_eq!(result, *expected, "from_str input={}", text);

            let result: Result<IPv6Address, ParseError> = IPv6Address::try_from(text);
            assert_eq!(result, *expected, "try_from(&str) input={}", text);
        }
    }

    #[test]
    fn strip_zone() {
        let test_cases: &[(&str, Option<&str>)] = &[
            ("::1", Some("::1")),
            ("::1%1", Some("::1")),
            ("::1%0", Some("::1")),
            ("::1%01", Some("::1")),
            ("::1%4294967295", Some("::1")),
            ("::1%", None),
            ("::1%eth0", None),
            ("::1%+1", None),
            ("::1%4294967296", None),
            ("::1%1%2", None),
        ];

        for (input, expected) in test_cases {
            let result: Option<&[u8]> = IPv6Address::strip_zone(input.as_bytes());
            let expected: Option<&[u8]> = expected.map(str::as_bytes);
            assert_eq!(result, expected, "input={}", input);
        }
    }

    #[test]
    fn round_trip() {
        let canonical: &[&str] = &[
            "::",
            "::1",
            "1::",
            "1::1",
            "1:0:0:1::",
            "1:2:3:4:5:6:7:8",
            "fe80::1",
            "::ffff:1.2.3.4",
            "2001:db8::8a2e:370:7334",
            "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
        ];

        for input in canonical {
            let value: IPv6Address = input.parse().unwrap();
            assert_eq!(value.to_string(), *input, "input={}", input);
        }
    }
}