use crate::backport::*;

use crate::error::{ErrorKind, Position};

use crate::identifier::Identifier;

use crate::{BuildMetadata, Comparator, Op, Prerelease, Version, VersionReq};

use core::str::FromStr;

/// Error parsing a SemVer version or version requirement.

///

/// # Example

///

/// ```

/// use semver::Version;

///

/// fn main() {

///     let err = Version::parse("1.q.r").unwrap_err();

///

///     // "unexpected character 'q' while parsing minor version number"

///     eprintln!("{}", err);

/// }

/// ```

pub struct Error {

    pub(crate) kind: ErrorKind,

}

impl FromStr for Version {

    type Err = Error;

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

        if text.is_empty() {

            return Err(Error::new(ErrorKind::Empty));

        }

        let mut pos = Position::Major;

        let (major, text) = numeric_identifier(text, pos)?;

        let text = dot(text, pos)?;

        pos = Position::Minor;

        let (minor, text) = numeric_identifier(text, pos)?;

        let text = dot(text, pos)?;

        pos = Position::Patch;

        let (patch, text) = numeric_identifier(text, pos)?;

        if text.is_empty() {

            return Ok(Version::new(major, minor, patch));

        }

        let (pre, text) = if let Some(text) = text.strip_prefix('-') {

            pos = Position::Pre;

            let (pre, text) = prerelease_identifier(text)?;

            if pre.is_empty() {

                return Err(Error::new(ErrorKind::EmptySegment(pos)));

            }

            (pre, text)

        } else {

            (Prerelease::EMPTY, text)

        };

        let (build, text) = if let Some(text) = text.strip_prefix('+') {

            pos = Position::Build;

            let (build, text) = build_identifier(text)?;

            if build.is_empty() {

                return Err(Error::new(ErrorKind::EmptySegment(pos)));

            }

            (build, text)

        } else {

            (BuildMetadata::EMPTY, text)

        };

        if let Some(unexpected) = text.chars().next() {

            return Err(Error::new(ErrorKind::UnexpectedCharAfter(pos, unexpected)));

        }

        Ok(Version {

            major,

            minor,

            patch,

            pre,

            build,

        })

    }

}

impl FromStr for VersionReq {

    type Err = Error;

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

        let text = text.trim_start_matches(' ');

        if let Some((ch, text)) = wildcard(text) {

            let rest = text.trim_start_matches(' ');

            if rest.is_empty() {

                #[cfg(not(no_const_vec_new))]

                return Ok(VersionReq::STAR);

                #[cfg(no_const_vec_new)] // rustc <1.39

                return Ok(VersionReq {

                    comparators: Vec::new(),

                });

            } else if rest.starts_with(',') {

                return Err(Error::new(ErrorKind::WildcardNotTheOnlyComparator(ch)));

            } else {

                return Err(Error::new(ErrorKind::UnexpectedAfterWildcard));

            }

        }

        let depth = 0;

        let mut comparators = Vec::new();

        let len = version_req(text, &mut comparators, depth)?;

        unsafe { comparators.set_len(len) }

        Ok(VersionReq { comparators })

    }

}

impl FromStr for Comparator {

    type Err = Error;

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

        let text = text.trim_start_matches(' ');

        let (comparator, pos, rest) = comparator(text)?;

        if !rest.is_empty() {

            let unexpected = rest.chars().next().unwrap();

            return Err(Error::new(ErrorKind::UnexpectedCharAfter(pos, unexpected)));

        }

        Ok(comparator)

    }

}

impl FromStr for Prerelease {

    type Err = Error;

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

        let (pre, rest) = prerelease_identifier(text)?;

        if !rest.is_empty() {

            return Err(Error::new(ErrorKind::IllegalCharacter(Position::Pre)));

        }

        Ok(pre)

    }

}

impl FromStr for BuildMetadata {

    type Err = Error;

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

        let (build, rest) = build_identifier(text)?;

        if !rest.is_empty() {

            return Err(Error::new(ErrorKind::IllegalCharacter(Position::Build)));

        }

        Ok(build)

    }

}

impl Error {

    fn new(kind: ErrorKind) -> Self {

        Error { kind }

    }

}

impl Op {

    const DEFAULT: Self = Op::Caret;

}

fn numeric_identifier(input: &str, pos: Position) -> Result<(u64, &str), Error> {

    let mut len = 0;

    let mut value = 0u64;

    while let Some(&digit) = input.as_bytes().get(len) {

        if digit < b'0' || digit > b'9' {

            break;

        }

        if value == 0 && len > 0 {

            return Err(Error::new(ErrorKind::LeadingZero(pos)));

        }

        match value

            .checked_mul(10)

            .and_then(|value| value.checked_add((digit - b'0') as u64))

        {

            Some(sum) => value = sum,

            None => return Err(Error::new(ErrorKind::Overflow(pos))),

        }

        len += 1;

    }

    if len > 0 {

        Ok((value, &input[len..]))

    } else if let Some(unexpected) = input[len..].chars().next() {

        Err(Error::new(ErrorKind::UnexpectedChar(pos, unexpected)))

    } else {

        Err(Error::new(ErrorKind::UnexpectedEnd(pos)))

    }

}

fn wildcard(input: &str) -> Option<(char, &str)> {

    if let Some(rest) = input.strip_prefix('*') {

        Some(('*', rest))

    } else if let Some(rest) = input.strip_prefix('x') {

        Some(('x', rest))

    } else if let Some(rest) = input.strip_prefix('X') {

        Some(('X', rest))

    } else {

        None

    }

}

fn dot(input: &str, pos: Position) -> Result<&str, Error> {

    if let Some(rest) = input.strip_prefix('.') {

        Ok(rest)

    } else if let Some(unexpected) = input.chars().next() {

        Err(Error::new(ErrorKind::UnexpectedCharAfter(pos, unexpected)))

    } else {

        Err(Error::new(ErrorKind::UnexpectedEnd(pos)))

    }

}

fn prerelease_identifier(input: &str) -> Result<(Prerelease, &str), Error> {

    let (string, rest) = identifier(input, Position::Pre)?;

    let identifier = unsafe { Identifier::new_unchecked(string) };

    Ok((Prerelease { identifier }, rest))

}

fn build_identifier(input: &str) -> Result<(BuildMetadata, &str), Error> {

    let (string, rest) = identifier(input, Position::Build)?;

    let identifier = unsafe { Identifier::new_unchecked(string) };

    Ok((BuildMetadata { identifier }, rest))

}

fn identifier(input: &str, pos: Position) -> Result<(&str, &str), Error> {

    let mut accumulated_len = 0;

    let mut segment_len = 0;

    let mut segment_has_nondigit = false;

    loop {

        match input.as_bytes().get(accumulated_len + segment_len) {

            Some(b'A'..=b'Z') | Some(b'a'..=b'z') | Some(b'-') => {

                segment_len += 1;

                segment_has_nondigit = true;

            }

            Some(b'0'..=b'9') => {

                segment_len += 1;

            }

            boundary => {

                if segment_len == 0 {

                    if accumulated_len == 0 && boundary != Some(&b'.') {

                        return Ok(("", input));

                    } else {

                        return Err(Error::new(ErrorKind::EmptySegment(pos)));

                    }

                }

                if pos == Position::Pre

                    && segment_len > 1

                    && !segment_has_nondigit

                    && input[accumulated_len..].starts_with('0')

                {

                    return Err(Error::new(ErrorKind::LeadingZero(pos)));

                }

                accumulated_len += segment_len;

                if boundary == Some(&b'.') {

                    accumulated_len += 1;

                    segment_len = 0;

                    segment_has_nondigit = false;

                } else {

                    return Ok(input.split_at(accumulated_len));

                }

            }

        }

    }

}

fn op(input: &str) -> (Op, &str) {

    let bytes = input.as_bytes();

    if bytes.first() == Some(&b'=') {

        (Op::Exact, &input[1..])

    } else if bytes.first() == Some(&b'>') {

        if bytes.get(1) == Some(&b'=') {

            (Op::GreaterEq, &input[2..])

        } else {

            (Op::Greater, &input[1..])

        }

    } else if bytes.first() == Some(&b'<') {

        if bytes.get(1) == Some(&b'=') {

            (Op::LessEq, &input[2..])

        } else {

            (Op::Less, &input[1..])

        }

    } else if bytes.first() == Some(&b'~') {

        (Op::Tilde, &input[1..])

    } else if bytes.first() == Some(&b'^') {

        (Op::Caret, &input[1..])

    } else {

        (Op::DEFAULT, input)

    }

}

fn comparator(input: &str) -> Result<(Comparator, Position, &str), Error> {

    let (mut op, text) = op(input);

    let default_op = input.len() == text.len();

    let text = text.trim_start_matches(' ');

    let mut pos = Position::Major;

    let (major, text) = numeric_identifier(text, pos)?;

    let mut has_wildcard = false;

    let (minor, text) = if let Some(text) = text.strip_prefix('.') {

        pos = Position::Minor;

        if let Some((_, text)) = wildcard(text) {

            has_wildcard = true;

            if default_op {

                op = Op::Wildcard;

            }

            (None, text)

        } else {

            let (minor, text) = numeric_identifier(text, pos)?;

            (Some(minor), text)

        }

    } else {

        (None, text)

    };

    let (patch, text) = if let Some(text) = text.strip_prefix('.') {

        pos = Position::Patch;

        if let Some((_, text)) = wildcard(text) {

            if default_op {

                op = Op::Wildcard;

            }

            (None, text)

        } else if has_wildcard {

            return Err(Error::new(ErrorKind::UnexpectedAfterWildcard));

        } else {

            let (patch, text) = numeric_identifier(text, pos)?;

            (Some(patch), text)

        }

    } else {

        (None, text)

    };

    let (pre, text) = if patch.is_some() && text.starts_with('-') {

        pos = Position::Pre;

        let text = &text[1..];

        let (pre, text) = prerelease_identifier(text)?;

        if pre.is_empty() {

            return Err(Error::new(ErrorKind::EmptySegment(pos)));

        }

        (pre, text)

    } else {

        (Prerelease::EMPTY, text)

    };

    let text = if patch.is_some() && text.starts_with('+') {

        pos = Position::Build;

        let text = &text[1..];

        let (build, text) = build_identifier(text)?;

        if build.is_empty() {

            return Err(Error::new(ErrorKind::EmptySegment(pos)));

        }

        text

    } else {

        text

    };

    let text = text.trim_start_matches(' ');

    let comparator = Comparator {

        op,

        major,

        minor,

        patch,

        pre,

    };

    Ok((comparator, pos, text))

}

fn version_req(input: &str, out: &mut Vec<Comparator>, depth: usize) -> Result<usize, Error> {

    let (comparator, pos, text) = match comparator(input) {

        Ok(success) => success,

        Err(mut error) => {

            if let Some((ch, mut rest)) = wildcard(input) {

                rest = rest.trim_start_matches(' ');

                if rest.is_empty() || rest.starts_with(',') {

                    error.kind = ErrorKind::WildcardNotTheOnlyComparator(ch);

                }

            }

            return Err(error);

        }

    };

    if text.is_empty() {

        out.reserve_exact(depth + 1);

        unsafe { out.as_mut_ptr().add(depth).write(comparator) }

        return Ok(depth + 1);

    }

    let text = if let Some(text) = text.strip_prefix(',') {

        text.trim_start_matches(' ')

    } else {

        let unexpected = text.chars().next().unwrap();

        return Err(Error::new(ErrorKind::ExpectedCommaFound(pos, unexpected)));

    };

    const MAX_COMPARATORS: usize = 32;

    if depth + 1 == MAX_COMPARATORS {

        return Err(Error::new(ErrorKind::ExcessiveComparators));

    }

    // Recurse to collect parsed Comparator objects on the stack. We perform a

    // single allocation to allocate exactly the right sized Vec only once the

    // total number of comparators is known.

    let len = version_req(text, out, depth + 1)?;

    unsafe { out.as_mut_ptr().add(depth).write(comparator) }

    Ok(len)

}