// Copyright 2013-2014 The Rust Project Developers.

// Copyright 2018 The Uuid Project Developers.

//

// See the COPYRIGHT file at the top-level directory of this distribution.

//

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

// option. This file may not be copied, modified, or distributed

// except according to those terms.

//! [`Uuid`] parsing constructs and utilities.

//!

//! [`Uuid`]: ../struct.Uuid.html

use crate::{

    error::*,

    std::{convert::TryFrom, str},

    Uuid,

};

#[cfg(feature = "std")]

use crate::std::string::String;

impl str::FromStr for Uuid {

    type Err = Error;

    fn from_str(uuid_str: &str) -> Result<Self, Self::Err> {

        Uuid::parse_str(uuid_str)

    }

}

impl TryFrom<&'_ str> for Uuid {

    type Error = Error;

    fn try_from(uuid_str: &'_ str) -> Result<Self, Self::Error> {

        Uuid::parse_str(uuid_str)

    }

}

#[cfg(feature = "std")]

impl TryFrom<String> for Uuid {

    type Error = Error;

    fn try_from(uuid_str: String) -> Result<Self, Self::Error> {

        Uuid::try_from(uuid_str.as_ref())

    }

}

impl Uuid {

    /// Parses a `Uuid` from a string of hexadecimal digits with optional

    /// hyphens.

    ///

    /// Any of the formats generated by this module (simple, hyphenated, urn,

    /// Microsoft GUID) are supported by this parsing function.

    ///

    /// Prefer [`try_parse`] unless you need detailed user-facing diagnostics.

    /// This method will be eventually deprecated in favor of `try_parse`.

    ///

    /// # Examples

    ///

    /// Parse a hyphenated UUID:

    ///

    /// ```

    /// # use uuid::{Uuid, Version, Variant};

    /// # fn main() -> Result<(), uuid::Error> {

    /// let uuid = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")?;

    ///

    /// assert_eq!(Some(Version::Random), uuid.get_version());

    /// assert_eq!(Variant::RFC4122, uuid.get_variant());

    /// # Ok(())

    /// # }

    /// ```

    ///

    /// [`try_parse`]: #method.try_parse

    pub fn parse_str(input: &str) -> Result<Uuid, Error> {

        try_parse(input.as_bytes())

            .map(Uuid::from_bytes)

            .map_err(InvalidUuid::into_err)

    }

    /// Parses a `Uuid` from a string of hexadecimal digits with optional

    /// hyphens.

    ///

    /// This function is similar to [`parse_str`], in fact `parse_str` shares

    /// the same underlying parser. The difference is that if `try_parse`

    /// fails, it won't generate very useful error messages. The `parse_str`

    /// function will eventually be deprecated in favor of `try_parse`.

    ///

    /// To parse a UUID from a byte stream instead of a UTF8 string, see

    /// [`try_parse_ascii`].

    ///

    /// # Examples

    ///

    /// Parse a hyphenated UUID:

    ///

    /// ```

    /// # use uuid::{Uuid, Version, Variant};

    /// # fn main() -> Result<(), uuid::Error> {

    /// let uuid = Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000")?;

    ///

    /// assert_eq!(Some(Version::Random), uuid.get_version());

    /// assert_eq!(Variant::RFC4122, uuid.get_variant());

    /// # Ok(())

    /// # }

    /// ```

    ///

    /// [`parse_str`]: #method.parse_str

    /// [`try_parse_ascii`]: #method.try_parse_ascii

    pub const fn try_parse(input: &str) -> Result<Uuid, Error> {

        Self::try_parse_ascii(input.as_bytes())

    }

    /// Parses a `Uuid` from a string of hexadecimal digits with optional

    /// hyphens.

    ///

    /// The input is expected to be a string of ASCII characters. This method

    /// can be more convenient than [`try_parse`] if the UUID is being

    /// parsed from a byte stream instead of from a UTF8 string.

    ///

    /// # Examples

    ///

    /// Parse a hyphenated UUID:

    ///

    /// ```

    /// # use uuid::{Uuid, Version, Variant};

    /// # fn main() -> Result<(), uuid::Error> {

    /// let uuid = Uuid::try_parse_ascii(b"550e8400-e29b-41d4-a716-446655440000")?;

    ///

    /// assert_eq!(Some(Version::Random), uuid.get_version());

    /// assert_eq!(Variant::RFC4122, uuid.get_variant());

    /// # Ok(())

    /// # }

    /// ```

    ///

    /// [`try_parse`]: #method.try_parse

    pub const fn try_parse_ascii(input: &[u8]) -> Result<Uuid, Error> {

        match try_parse(input) {

            Ok(bytes) => Ok(Uuid::from_bytes(bytes)),

            // If parsing fails then we don't know exactly what went wrong

            // In this case, we just return a generic error

            Err(_) => Err(Error(ErrorKind::ParseOther)),

        }

    }

}

const fn try_parse(input: &'_ [u8]) -> Result<[u8; 16], InvalidUuid<'_>> {

    match (input.len(), input) {

        // Inputs of 32 bytes must be a non-hyphenated UUID

        (32, s) => parse_simple(s, true),

        // Hyphenated UUIDs may be wrapped in various ways:

        // - `{UUID}` for braced UUIDs

        // - `urn:uuid:UUID` for URNs

        // - `UUID` for a regular hyphenated UUID

        (36, s)

        | (38, [b'{', s @ .., b'}'])

        | (45, [b'u', b'r', b'n', b':', b'u', b'u', b'i', b'd', b':', s @ ..]) => {

            parse_hyphenated(s)

        }

        // Any other shaped input is immediately invalid

        _ => Err(InvalidUuid(input, RequestedUuid::Any)),

    }

}

#[inline]

#[allow(dead_code)]

pub(crate) const fn parse_braced(input: &'_ [u8]) -> Result<[u8; 16], InvalidUuid<'_>> {

    if let (38, [b'{', s @ .., b'}']) = (input.len(), input) {

        parse_hyphenated(s)

    } else {

        Err(InvalidUuid(input, RequestedUuid::Braced))

    }

}

#[inline]

#[allow(dead_code)]

pub(crate) const fn parse_urn(input: &'_ [u8]) -> Result<[u8; 16], InvalidUuid<'_>> {

    if let (45, [b'u', b'r', b'n', b':', b'u', b'u', b'i', b'd', b':', s @ ..]) =

        (input.len(), input)

    {

        parse_hyphenated(s)

    } else {

        Err(InvalidUuid(input, RequestedUuid::Urn))

    }

}

#[inline]

pub(crate) const fn parse_simple(

    s: &'_ [u8],

    speculative: bool,

) -> Result<[u8; 16], InvalidUuid<'_>> {

    // This length check here removes all other bounds

    // checks in this function

    if s.len() != 32 {

        return Err(InvalidUuid(

            s,

            if speculative {

                RequestedUuid::Any

            } else {

                RequestedUuid::Simple

            },

        ));

    }

    // Copy the hex characters into a fixed-size array so the decoder's

    // bounds are statically known.

    let mut hex = [0u8; 32];

    let mut i = 0;

    while i < 32 {

        hex[i] = s[i];

        i += 1;

    }

    match decode_hex32(&hex) {

        Some(buf) => Ok(buf),

        None => Err(InvalidUuid(

            s,

            if speculative {

                RequestedUuid::Any

            } else {

                RequestedUuid::Simple

            },

        )),

    }

}

#[inline]

pub(crate) const fn parse_hyphenated(s: &'_ [u8]) -> Result<[u8; 16], InvalidUuid<'_>> {

    // This length check here removes all other bounds

    // checks in this function

    if s.len() != 36 {

        return Err(InvalidUuid(s, RequestedUuid::Hyphenated));

    }

    // The hex characters are split into five groups separated by hyphens.

    // The indexes we're interested in are:

    //

    // uuid     : 936da01f-9abd-4d9d-80c7-02af85c822a8

    //            |   |   ||   ||   ||   ||   |   |

    // hyphens  : |   |   8|  13|  18|  23|   |   |

    // positions: 0   4    9   14   19   24  28  32

    // First, ensure the hyphens appear in the right places

    match [s[8], s[13], s[18], s[23]] {

        [b'-', b'-', b'-', b'-'] => {}

        _ => return Err(InvalidUuid(s, RequestedUuid::Hyphenated)),

    }

    // Gather the hex characters, skipping the four hyphens, so they're

    // contiguous for the decoder.

    let mut hex = [0u8; 32];

    let mut i = 0;

    while i < 8 {

        hex[i] = s[i];

        i += 1;

    }

    while i < 12 {

        hex[i] = s[i + 1];

        i += 1;

    }

    while i < 16 {

        hex[i] = s[i + 2];

        i += 1;

    }

    while i < 20 {

        hex[i] = s[i + 3];

        i += 1;

    }

    while i < 32 {

        hex[i] = s[i + 4];

        i += 1;

    }

    match decode_hex32(&hex) {

        Some(buf) => Ok(buf),

        None => Err(InvalidUuid(s, RequestedUuid::Hyphenated)),

    }

}

/// Decodes 32 hexadecimal ASCII characters into 16 bytes, returning `None` if

/// any character is not a valid hexadecimal digit.

#[inline]

const fn decode_hex32(hex: &[u8; 32]) -> Option<[u8; 16]> {

    let mut nibbles = [0u8; 32];

    let mut bad = 0u8;

    let mut i = 0;

    while i < 32 {

        let c = hex[i];

        // '0'..='9' map to 0..=9; 'a'..='f' and 'A'..='F' (via `| 0x20`) map to

        // 0..=5, offset by 10 to land in 10..=15.

        let digit = c.wrapping_sub(b'0');

        let alpha = (c | 0x20).wrapping_sub(b'a');

        let is_digit = digit < 10;

        let is_alpha = alpha < 6;

        nibbles[i] = if is_digit {

            digit

        } else {

            alpha.wrapping_add(10)

        };

        bad |= if is_digit | is_alpha { 0 } else { 1 };

        i += 1;

    }

    if bad != 0 {

        return None;

    }

    let mut buf = [0u8; 16];

    let mut j = 0;

    while j < 16 {

        buf[j] = (nibbles[j * 2] << 4) | nibbles[j * 2 + 1];

        j += 1;

    }

    Some(buf)

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::{

        fmt::*,

        std::{str::FromStr, string::ToString},

        tests::some_uuid_iter,

    };

    #[test]

    fn test_parse_valid() {

        let from_hyphenated = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap();

        let from_simple = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8").unwrap();

        let from_urn = Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap();

        let from_guid = Uuid::parse_str("{67e55044-10b1-426f-9247-bb680e5fe0c8}").unwrap();

        assert_eq!(from_hyphenated, from_simple);

        assert_eq!(from_hyphenated, from_urn);

        assert_eq!(from_hyphenated, from_guid);

        assert!(Uuid::parse_str("00000000000000000000000000000000").is_ok());

        assert!(Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok());

        assert!(Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").is_ok());

        assert!(Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8").is_ok());

        assert!(Uuid::parse_str("01020304-1112-2122-3132-414243444546").is_ok());

        assert!(Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok());

        assert!(Uuid::parse_str("{6d93bade-bd9f-4e13-8914-9474e1e3567b}").is_ok());

        // Nil

        let nil = Uuid::nil();

        assert_eq!(

            Uuid::parse_str("00000000000000000000000000000000").unwrap(),

            nil

        );

        assert_eq!(

            Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap(),

            nil

        );

    }

    #[test]

    fn test_parse_invalid() {

        // Invalid

        assert_eq!(

            Uuid::parse_str(""),

            Err(Error(ErrorKind::ParseLength { len: 0 }))

        );

        assert_eq!(

            Uuid::parse_str("{}"),

            Err(Error(ErrorKind::ParseGroupCount { count: 1 }))

        );

        assert_eq!(

            Uuid::parse_str("!"),

            Err(Error(ErrorKind::ParseChar {

                character: '!',

                index: 0,

            }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45"),

            Err(Error(ErrorKind::ParseGroupLength {

                group: 4,

                len: 13,

                index: 25,

            }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"),

            Err(Error(ErrorKind::ParseGroupLength {

                group: 3,

                len: 3,

                index: 20,

            }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"),

            Err(Error(ErrorKind::ParseChar {

                character: 'G',

                index: 20,

            }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2F4faaFB6BFF329BF39FA1E4"),

            Err(Error(ErrorKind::ParseGroupCount { count: 2 }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faaFB6BFF329BF39FA1E4"),

            Err(Error(ErrorKind::ParseGroupCount { count: 3 }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"),

            Err(Error(ErrorKind::ParseGroupCount { count: 4 }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faa"),

            Err(Error(ErrorKind::ParseGroupCount { count: 3 }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4"),

            Err(Error(ErrorKind::ParseChar {

                character: 'X',

                index: 18,

            }))

        );

        assert_eq!(

            Uuid::parse_str("{F9168C5E-CEB2-4faa9B6BFF329BF39FA1E41"),

            Err(Error(ErrorKind::ParseChar {

                character: '{',

                index: 0,

            }))

        );

        assert_eq!(

            Uuid::parse_str("{F9168C5E-CEB2-4faa9B6BFF329BF39FA1E41}"),

            Err(Error(ErrorKind::ParseGroupCount { count: 3 }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4"),

            Err(Error(ErrorKind::ParseGroupLength {

                group: 1,

                len: 3,

                index: 10,

            }))

        );

        // // (group, found, expecting)

        assert_eq!(

            Uuid::parse_str("01020304-1112-2122-3132-41424344"),

            Err(Error(ErrorKind::ParseGroupLength {

                group: 4,

                len: 8,

                index: 25,

            }))

        );

        assert_eq!(

            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c"),

            Err(Error(ErrorKind::ParseLength { len: 31 }))

        );

        assert_eq!(

            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c88"),

            Err(Error(ErrorKind::ParseLength { len: 33 }))

        );

        assert_eq!(

            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0cg8"),

            Err(Error(ErrorKind::ParseChar {

                character: 'g',

                index: 31,

            }))

        );

        assert_eq!(

            Uuid::parse_str("67e5504410b1426%9247bb680e5fe0c8"),

            Err(Error(ErrorKind::ParseChar {

                character: '%',

                index: 15,

            }))

        );

        assert_eq!(

            Uuid::parse_str("231231212212423424324323477343246663"),

            Err(Error(ErrorKind::ParseGroupCount { count: 1 }))

        );

        assert_eq!(

            Uuid::parse_str("{00000000000000000000000000000000}"),

            Err(Error(ErrorKind::ParseGroupCount { count: 1 }))

        );

        assert_eq!(

            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c"),

            Err(Error(ErrorKind::ParseLength { len: 31 }))

        );

        assert_eq!(

            Uuid::parse_str("67e550X410b1426f9247bb680e5fe0cd"),

            Err(Error(ErrorKind::ParseChar {

                character: 'X',

                index: 6,

            }))

        );

        assert_eq!(

            Uuid::parse_str("67e550-4105b1426f9247bb680e5fe0c"),

            Err(Error(ErrorKind::ParseGroupCount { count: 2 }))

        );

        assert_eq!(

            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4"),

            Err(Error(ErrorKind::ParseGroupLength {

                group: 3,

                len: 5,

                index: 20,

            }))

        );

        assert_eq!(

            Uuid::parse_str("\u{bcf3c}"),

            Err(Error(ErrorKind::ParseChar {

                character: '\u{bcf3c}',

                index: 0,

            }))

        );

        assert_eq!(

            Uuid::parse_str("\u{130}"),

            Err(Error(ErrorKind::ParseChar {

                character: '\u{130}',

                index: 0,

            }))

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseLength { len: 0 })),

            Hyphenated::from_str("")

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseGroupCount { count: 1 })),

            Hyphenated::from_str("550e8400e29b41d4a716446655440000")

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseChar {

                character: '-',

                index: 8

            })),

            Simple::from_str("550e8400-e29b-41d4-a716-446655440000")

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseChar {

                character: '5',

                index: 0

            })),

            Urn::from_str("550e8400-e29b-41d4-a716-446655440000")

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseChar {

                character: ':',

                index: 0

            })),

            Urn::from_str(":550e8400-e29b-41d4-a716-446655440000")

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseChar {

                character: '5',

                index: 0

            })),

            Braced::from_str("550e8400-e29b-41d4-a716-446655440000")

        );

        assert_eq!(

            Err(Error(ErrorKind::ParseChar {

                character: '{',

                index: 1

            })),

            Braced::from_str("{{550e8400-e29b-41d4-a716-446655440000}}")

        );

        // Unicode

        assert_eq!(

            Uuid::from_str("{6e0----------9=4O-0e5\u{14}e0c4\u{ec2f}8}"),

            Err(Error(ErrorKind::ParseChar {

                character: '=',

                index: 15,

            }))

        );

        assert_eq!(

            Uuid::from_str("urn:uuid:urae0c8"),

            Err(Error(ErrorKind::ParseChar {

                character: 'u',

                index: 9,

            }))

        );

    }

    #[test]

    fn test_roundtrip_default() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.to_string();

            let uuid_out = Uuid::parse_str(&orig_str).unwrap();

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_roundtrip_hyphenated() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.hyphenated().to_string();

            let uuid_out = Uuid::parse_str(&orig_str).unwrap();

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_roundtrip_simple() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.simple().to_string();

            let uuid_out = Uuid::parse_str(&orig_str).unwrap();

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_roundtrip_urn() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.urn().to_string();

            let uuid_out = Uuid::parse_str(&orig_str).unwrap();

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_roundtrip_braced() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.braced().to_string();

            let uuid_out = Uuid::parse_str(&orig_str).unwrap();

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_roundtrip_parse_urn() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.urn().to_string();

            let uuid_out = Uuid::from_bytes(parse_urn(orig_str.as_bytes()).unwrap());

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_roundtrip_parse_braced() {

        for uuid_orig in some_uuid_iter() {

            let orig_str = uuid_orig.braced().to_string();

            let uuid_out = Uuid::from_bytes(parse_braced(orig_str.as_bytes()).unwrap());

            assert_eq!(uuid_orig, uuid_out);

        }

    }

    #[test]

    fn test_try_parse_ascii_non_utf8() {

        assert!(Uuid::try_parse_ascii(b"67e55044-10b1-426f-9247-bb680e5\0e0c8").is_err());

    }

}