//! Fast parsers for trusted (already validated) input.

//!

//! Using this in wrong way will lead to unexpected wrong result.

pub(crate) mod authority;

use core::cmp::Ordering;

use core::num::NonZeroUsize;

use crate::components::{RiReferenceComponents, Splitter};

use crate::format::eq_str_display;

use crate::normalize::{is_pct_case_normalized, NormalizedAsciiOnlyHost, NormalizednessCheckMode};

use crate::parser::str::{find_split2, find_split3, find_split4_hole, find_split_hole};

use crate::spec::Spec;

use crate::types::RiReferenceStr;

/// Eats a `scheme` and a following colon, and returns the rest and the scheme.

///

/// Returns `(rest, scheme)`.

///

/// This should be called at the head of an absolute IRIs/URIs.

#[must_use]

fn scheme_colon(i: &str) -> (&str, &str) {

    let (scheme, rest) =

        find_split_hole(i, b':').expect("[precondition] absolute IRIs must have `scheme` part");

    (rest, scheme)

}

/// Eats a `scheme` and a following colon if available, and returns the rest and the scheme.

///

/// This should be called at the head of an `IRI-reference` or similar.

#[must_use]

fn scheme_colon_opt(i: &str) -> (&str, Option<&str>) {

    match find_split4_hole(i, b':', b'/', b'?', b'#') {

        Some((scheme, b':', rest)) => (rest, Some(scheme)),

        _ => (i, None),

    }

}

/// Eats double slash and the following authority if available, and returns the authority.

///

/// This should be called at the head of an `IRI-reference`, or at the result of `scheme_colon`.

#[must_use]

fn slash_slash_authority_opt(i: &str) -> (&str, Option<&str>) {

    let s = match i.strip_prefix("//") {

        Some(rest) => rest,

        None => return (i, None),

    };

    // `i` might match `path-abempty` (which can start with `//`), but it is not

    // allowed as `relative-part`, so no need to care `path-abempty` rule here.

    // A slash, question mark, and hash character won't appear in `authority`.

    match find_split3(s, b'/', b'?', b'#') {

        Some((authority, rest)) => (rest, Some(authority)),

        None => ("", Some(s)),

    }

}

/// Eats a string until the query, and returns that part (excluding `?` for the query).

#[must_use]

fn until_query(i: &str) -> (&str, &str) {

    // `?` won't appear before the query part.

    match find_split2(i, b'?', b'#') {

        Some((before_query, rest)) => (rest, before_query),

        None => ("", i),

    }

}

/// Decomposes query and fragment, if available.

///

/// The string must starts with `?`, or `#`, or be empty.

#[must_use]

fn decompose_query_and_fragment(i: &str) -> (Option<&str>, Option<&str>) {

    match i.as_bytes().first().copied() {

        None => (None, None),

        Some(b'?') => {

            let rest = &i[1..];

            match find_split_hole(rest, b'#') {

                Some((query, fragment)) => (Some(query), Some(fragment)),

                None => (Some(rest), None),

            }

        }

        Some(c) => {

            debug_assert_eq!(c, b'#');

            (None, Some(&i[1..]))

        }

    }

}

/// Decomposes the given valid `IRI-reference`.

#[must_use]

pub(crate) fn decompose_iri_reference<S: Spec>(

    i: &RiReferenceStr<S>,

) -> RiReferenceComponents<'_, S> {

    /// Inner function to avoid unnecessary monomorphizations on `S`.

    fn decompose(i: &str) -> Splitter {

        let len = i.len();

        let (i, scheme_end) = {

            let (i, scheme) = scheme_colon_opt(i);

            let end = scheme.and_then(|s| NonZeroUsize::new(s.len()));

            (i, end)

        };

        let (i, authority_end) = {

            // 2: "//".len()

            let start = len - i.len() + 2;

            // `authority` does not contain the two slashes of `://'.

            let (i, authority) = slash_slash_authority_opt(i);

            let end = authority.and_then(|s| NonZeroUsize::new(start + s.len()));

            (i, end)

        };

        let (i, _path) = until_query(i);

        let (query_start, fragment_start) = {

            // This could theoretically be zero if `len` is `usize::MAX` and

            // `i` has neither a query nor a fragment. However, this is

            // practically impossible.

            let after_first_prefix = NonZeroUsize::new((len - i.len()).wrapping_add(1));

            let (query, fragment) = decompose_query_and_fragment(i);

            match (query.is_some(), fragment) {

                (true, Some(fragment)) => {

                    (after_first_prefix, NonZeroUsize::new(len - fragment.len()))

                }

                (true, None) => (after_first_prefix, None),

                (false, Some(_fragment)) => (None, after_first_prefix),

                (false, None) => (None, None),

            }

        };

        Splitter::new(scheme_end, authority_end, query_start, fragment_start)

    }

    RiReferenceComponents {

        iri: i,

        splitter: decompose(i.as_str()),

    }

}

Unexecuted instantiation: iri_string::parser::trusted::decompose_iri_reference::<iri_string::spec::UriSpec>

Unexecuted instantiation: iri_string::parser::trusted::decompose_iri_reference::<_>

/// Extracts `scheme` part from an IRI reference.

///

/// # Precondition

///

/// The given string must be a valid IRI reference.

#[inline]

#[must_use]

pub(crate) fn extract_scheme(i: &str) -> Option<&str> {

    scheme_colon_opt(i).1

}

/// Extracts `scheme` part from an absolute IRI.

///

/// # Precondition

///

/// The given string must be a valid absolute IRI.

#[inline]

#[must_use]

pub(crate) fn extract_scheme_absolute(i: &str) -> &str {

    scheme_colon(i).1

}

/// Extracts `authority` part from an IRI reference.

///

/// # Precondition

///

/// The given string must be a valid IRI reference.

#[inline]

#[must_use]

pub(crate) fn extract_authority(i: &str) -> Option<&str> {

    let (i, _scheme) = scheme_colon_opt(i);

    slash_slash_authority_opt(i).1

}

/// Extracts `authority` part from an absolute IRI.

///

/// # Precondition

///

/// The given string must be a valid absolute IRI.

#[inline]

#[must_use]

pub(crate) fn extract_authority_absolute(i: &str) -> Option<&str> {

    let (i, _scheme) = scheme_colon(i);

    slash_slash_authority_opt(i).1

}

/// Extracts `authority` part from a relative IRI.

///

/// # Precondition

///

/// The given string must be a valid relative IRI.

#[inline]

#[must_use]

pub(crate) fn extract_authority_relative(i: &str) -> Option<&str> {

    slash_slash_authority_opt(i).1

}

/// Extracts `path` part from an IRI reference.

///

/// # Precondition

///

/// The given string must be a valid IRI reference.

#[inline]

#[must_use]

pub(crate) fn extract_path(i: &str) -> &str {

    let (i, _scheme) = scheme_colon_opt(i);

    let (i, _authority) = slash_slash_authority_opt(i);

    until_query(i).1

}

/// Extracts `path` part from an absolute IRI.

///

/// # Precondition

///

/// The given string must be a valid absolute IRI.

#[inline]

#[must_use]

pub(crate) fn extract_path_absolute(i: &str) -> &str {

    let (i, _scheme) = scheme_colon(i);

    let (i, _authority) = slash_slash_authority_opt(i);

    until_query(i).1

}

/// Extracts `path` part from a relative IRI.

///

/// # Precondition

///

/// The given string must be a valid relative IRI.

#[inline]

#[must_use]

pub(crate) fn extract_path_relative(i: &str) -> &str {

    let (i, _authority) = slash_slash_authority_opt(i);

    until_query(i).1

}

/// Extracts `query` part from an IRI reference.

///

/// # Precondition

///

/// The given string must be a valid IRI reference.

#[inline]

#[must_use]

pub(crate) fn extract_query(i: &str) -> Option<&str> {

    let (i, _before_query) = until_query(i);

    decompose_query_and_fragment(i).0

}

/// Extracts `query` part from an `absolute-IRI` string.

///

/// # Precondition

///

/// The given string must be a valid `absolute-IRI` string.

#[must_use]

pub(crate) fn extract_query_absolute_iri(i: &str) -> Option<&str> {

    let (i, _before_query) = until_query(i);

    if i.is_empty() {

        None

    } else {

        debug_assert_eq!(

            i.as_bytes().first(),

            Some(&b'?'),

            "`absolute-IRI` string must not have `fragment part"

        );

        Some(&i[1..])

    }

}

/// Splits an IRI string into the prefix and the fragment part.

///

/// A leading `#` character is truncated if the fragment part exists.

///

/// # Precondition

///

/// The given string must be a valid IRI reference.

#[inline]

#[must_use]

pub(crate) fn split_fragment(iri: &str) -> (&str, Option<&str>) {

    // It is completely OK to find the first `#` character from valid IRI to get fragment part,

    // because the spec says that there are no `#` characters before the fragment part.

    //

    // > ```

    // > scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

    // > ```

    // >

    // > --- [RFC 3986, section 3.1. Scheme](https://tools.ietf.org/html/rfc3986#section-3.1)

    //

    // > The authority component is preceded by a double slash ("//") and is terminated by the

    // > next slash ("/"), question mark ("?"), or number sign ("#") character, or by the end

    // > of the URI.

    // >

    // > --- [RFC 3986, section 3.2. Authority](https://tools.ietf.org/html/rfc3986#section-3.2)

    //

    // > The path is terminated by the first question mark ("?") or number sign ("#")

    // > character, or by the end of the URI.

    // >

    // > --- [RFC 3986, section 3.3. Path](https://tools.ietf.org/html/rfc3986#section-3.3)

    //

    // > The query component is indicated by the first question mark ("?") character and

    // > terminated by a number sign ("#") character or by the end of the URI.

    // >

    // > --- [RFC 3986, section 3.4. Query](https://tools.ietf.org/html/rfc3986#section-3.4)

    match find_split_hole(iri, b'#') {

        Some((prefix, fragment)) => (prefix, Some(fragment)),

        None => (iri, None),

    }

}

/// Returns the fragment part of the given IRI.

///

/// A leading `#` character of the fragment is truncated.

#[inline]

#[must_use]

pub(crate) fn extract_fragment(iri: &str) -> Option<&str> {

    split_fragment(iri).1

}

/// Returns `Ok(_)` if the string is normalized.

///

/// If this function returns `true`, normalization input and output will be identical.

///

/// In this function, "normalized" means that any of the normalization below

/// won't change the input on normalization:

///

/// * syntax-based normalization,

/// * case normalization,

/// * percent-encoding normalization, and

/// * path segment normalizaiton.

///

/// Note that scheme-based normalization is not considered.

#[must_use]

pub(crate) fn is_normalized<S: Spec>(i: &str, mode: NormalizednessCheckMode) -> bool {

    let (i, scheme) = scheme_colon(i);

    let (after_authority, authority) = slash_slash_authority_opt(i);

    let (_after_path, path) = until_query(after_authority);

    // Syntax-based normalization: uppercase chars in `scheme` should be

    // converted to lowercase.

    if scheme.bytes().any(|b| b.is_ascii_uppercase()) {

        return false;

    }

    // Case normalization: ASCII alphabets in US-ASCII only `host` should be

    // normalized to lowercase.

    // Case normalization: ASCII alphabets in percent-encoding triplet should be

    // normalized to uppercase.

    // Percent-encoding normalization: unresreved characters should be decoded

    // in `userinfo`, `host`, `path`, `query`, and `fragments`.

    // Path segment normalization: the path should not have dot segments (`.`

    // and/or `..`).

    //

    // Note that `authority` can have percent-encoded `userinfo`.

    if let Some(authority) = authority {

        let authority_components = authority::decompose_authority(authority);

        // Check `host`.

        let host = authority_components.host();

        let host_is_normalized = if is_ascii_only_host(host) {

            eq_str_display(host, &NormalizedAsciiOnlyHost::new(host))

        } else {

            // If the host is not ASCII-only, conversion to lowercase is not performed.

            is_pct_case_normalized::<S>(host)

        };

        if !host_is_normalized {

            return false;

        }

        // Check pencent encodings in `userinfo`.

        if let Some(userinfo) = authority_components.userinfo() {

            if !is_pct_case_normalized::<S>(userinfo) {

                return false;

            }

        }

    }

    // Check `path`.

    //

    // Syntax-based normalization: Dot segments might be removed.

    // Note that we don't have to care `%2e` and `%2E` since `.` is unreserved

    // and they will be decoded if not normalized.

    // Also note that WHATWG serialization will use `/.//` as a path prefix if

    // the path is absolute and won't modify the path if the path is relative.

    //

    // Percent-encoding normalization: unresreved characters should be decoded

    // in `path`, `query`, and `fragments`.

    let path_span_no_dot_segments = if authority.is_some() {

        Some(path)

    } else {

        match mode {

            NormalizednessCheckMode::Default => Some(path.strip_prefix("/.//").unwrap_or(path)),

            NormalizednessCheckMode::Rfc3986 => Some(path),

            NormalizednessCheckMode::PreserveAuthoritylessRelativePath => {

                if path.starts_with('/') {

                    // Absolute.

                    Some(path.strip_prefix("/.//").unwrap_or(path))

                } else {

                    // Relative. Treat the path as "opaque". No span to check.

                    None

                }

            }

        }

    };

    if let Some(path_span_no_dot_segments) = path_span_no_dot_segments {

        if path_span_no_dot_segments

            .split('/')

            .any(|segment| matches!(segment, "." | ".."))

        {

            return false;

        }

    }

    is_pct_case_normalized::<S>(after_authority)

}

/// Decodes two hexdigits into a byte.

///

/// # Preconditions

///

/// The parameters `upper` and `lower` should be an ASCII hexadecimal digit.

#[must_use]

pub(super) fn hexdigits_to_byte([upper, lower]: [u8; 2]) -> u8 {

    let i_upper = match (upper & 0xf0).cmp(&0x40) {

        Ordering::Less => upper - b'0',

        Ordering::Equal => upper - (b'A' - 10),

        Ordering::Greater => upper - (b'a' - 10),

    };

    let i_lower = match (lower & 0xf0).cmp(&0x40) {

        Ordering::Less => lower - b'0',

        Ordering::Equal => lower - (b'A' - 10),

        Ordering::Greater => lower - (b'a' - 10),

    };

    (i_upper << 4) + i_lower

}

/// Converts the first two hexdigit bytes in the buffer into a byte.

///

/// # Panics

///

/// Panics if the string does not start with two hexdigits.

#[must_use]

pub(crate) fn take_xdigits2(s: &str) -> (u8, &str) {

    let mut bytes = s.bytes();

    let upper_xdigit = bytes

        .next()

        .expect("[validity] at least two bytes should follow the `%` in a valid IRI reference");

    let lower_xdigit = bytes

        .next()

        .expect("[validity] at least two bytes should follow the `%` in a valid IRI reference");

    let v = hexdigits_to_byte([upper_xdigit, lower_xdigit]);

    (v, &s[2..])

}

/// Returns true if the given `host`/`ihost` string consists of only US-ASCII characters.

///

/// # Precondition

///

/// The given string should be valid `host` or `host ":" port` string.

#[must_use]

pub(crate) fn is_ascii_only_host(mut host: &str) -> bool {

    while let Some((i, c)) = host

        .char_indices()

        .find(|(_i, c)| !c.is_ascii() || *c == '%')

    {

        if c != '%' {

            // Non-ASCII character found.

            debug_assert!(!c.is_ascii());

            return false;

        }

        // Percent-encoded character found.

        let after_pct = &host[(i + 1)..];

        let (byte, rest) = take_xdigits2(after_pct);

        if !byte.is_ascii() {

            return false;

        }

        host = rest;

    }

    // Neither non-ASCII characters nor percent-encoded characters found.

    true

}