use std::convert::TryFrom;
use std::error::Error;
use std::fmt;
use std::str::from_utf8_unchecked;

use serde::{ser, de};

use parse::{ParseUintError, parse_uint, Parseable};


/// Rust release.
#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Release {
    major: u16,
    minor: u16,
    patch: u16,
}
impl Release {
    /// Converts this `Release` into a version triple.
    pub fn triple(self) -> (u16, u16, u16) {
        (self.major, self.minor, self.patch)
    }

    /// Converts this `Release` into a version pair, discarding the patch number.
    pub fn pair(self) -> (u16, u16) {
        (self.major, self.minor)
    }

    /// The major version for this release.
    pub fn major(self) -> u16 {
        self.major
    }

    /// The minor version for this release.
    pub fn minor(self) -> u16 {
        self.major
    }

    /// The patch version for this release.
    pub fn patch(self) -> u16 {
        self.patch
    }

    /// Writes the release to a buffer.
    pub(crate) fn write_to(&self, buf: &mut [u8]) -> usize {
        let len = self.major.write_to(buf);
        buf[len] = b'.';
        let len = self.minor.write_to(&mut buf[len + 1..]) + len + 1;
        buf[len] = b'.';
        self.patch.write_to(&mut buf[len + 1..]) + len + 1
    }
}
impl<T: Into<u16>> From<(T, T, T)> for Release {
    fn from(triple: (T, T, T)) -> Release {
        let (major, minor, patch) = (triple.0.into(), triple.1.into(), triple.2.into());
        Release {
            major,
            minor,
            patch,
        }
    }
}
impl fmt::Debug for Release {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self, f)
    }
}
impl fmt::Display for Release {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut buf = *b"65535.65535.65535";
        let len = self.write_to(&mut buf);
        f.pad(unsafe { from_utf8_unchecked(&buf[..len]) })
    }
}

impl<'a> TryFrom<&'a str> for Release {
    type Error = ParseReleaseError<'a>;
    fn try_from(s: &'a str) -> Result<Release, ParseReleaseError<'a>> {
        Release::try_from(s.as_bytes())
    }
}
impl<'a> TryFrom<&'a [u8]> for Release {
    type Error = ParseReleaseError<'a>;
    fn try_from(bytes: &'a [u8]) -> Result<Release, ParseReleaseError<'a>> {
        if let Some(idx) = bytes.iter().position(|b| *b == b'.') {
            let (major, rest) = bytes.split_at(idx);
            let rest = &rest[1..];
            if let Some(idx) = rest.iter().position(|b| *b == b'.') {
                let (minor, rest) = rest.split_at(idx);
                if rest[1..].contains(&b'.') {
                    return Err(ParseReleaseError::Format(bytes));
                }


                let patch = &rest[1..];
                let minor = match parse_uint(minor) {
                    Err(ParseUintError::Empty) => Err(ParseReleaseError::Format(bytes)),
                    Err(ParseUintError::BadByte(_)) => Err(ParseReleaseError::Number(minor)),
                    Err(ParseUintError::Overflow) => Err(ParseReleaseError::Overflow(minor)),
                    Ok(n) => Ok(n),
                }?;
                let patch = match parse_uint(patch) {
                    Err(ParseUintError::Empty) => Err(ParseReleaseError::Format(bytes)),
                    Err(ParseUintError::BadByte(_)) => Err(ParseReleaseError::Number(patch)),
                    Err(ParseUintError::Overflow) => Err(ParseReleaseError::Overflow(patch)),
                    Ok(n) => Ok(n),
                }?;
                let major = match parse_uint(major) {
                    Err(ParseUintError::Empty) => Err(ParseReleaseError::Format(bytes)),
                    Err(ParseUintError::BadByte(_)) => Err(ParseReleaseError::Number(major)),
                    Err(ParseUintError::Overflow) => Err(ParseReleaseError::Overflow(major)),
                    Ok(0) => Err(ParseReleaseError::Before1 { minor, patch }),
                    Ok(n) => Ok(n),
                }?;
                return Ok(Release {
                    major,
                    minor,
                    patch,
                });
            }
        }
        Err(ParseReleaseError::Format(bytes))
    }
}

impl ser::Serialize for Release {
    fn serialize<S: ser::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
        s.collect_str(self)
    }
}
impl<'de> de::Deserialize<'de> for Release {
    fn deserialize<D: de::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        struct ReleaseVisitor;
        impl<'de> de::Visitor<'de> for ReleaseVisitor {
            type Value = Release;
            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
                f.write_str("a date of a Rust release")
            }
            fn visit_str<E: de::Error>(self, value: &str) -> Result<Release, E> {
                Release::try_from(value)
                    .map_err(|_| E::invalid_value(de::Unexpected::Str(value), &self))
            }
            fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<Release, E> {
                Release::try_from(value)
                    .map_err(|_| E::invalid_value(de::Unexpected::Bytes(value), &self))
            }
        }
        d.deserialize_any(ReleaseVisitor)
    }
}

/// Error encountered when parsing a [`Release`].
///
/// [`Release`]: struct.Release.html
#[derive(Clone, Copy, Eq, PartialEq, Hash)]
pub enum ParseReleaseError<'a> {
    /// The string wasn't in the format `"major.minor.patch"`.
    Format(&'a [u8]),

    /// The given number was not valid.
    Number(&'a [u8]),

    /// The given number was too large fit in a `u16`.
    Overflow(&'a [u8]),

    /// The given release occurred before Rust 1.0.0.
    Before1 {
        minor: u16,
        patch: u16,
    },
}
impl<'a> fmt::Debug for ParseReleaseError<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ParseReleaseError::Format(bytes) => {
                f.debug_tuple("ParseReleaseError::Format")
                    .field(&String::from_utf8_lossy(bytes))
                    .finish()
            }
            ParseReleaseError::Number(bytes) => {
                f.debug_tuple("ParseReleaseError::Number")
                    .field(&String::from_utf8_lossy(bytes))
                    .finish()
            }
            ParseReleaseError::Overflow(bytes) => {
                f.debug_tuple("ParseReleaseError::Overflow")
                    .field(&String::from_utf8_lossy(bytes))
                    .finish()
            }
            ParseReleaseError::Before1 { ref minor, ref patch } => {
                f.debug_tuple("ParseReleaseError::Before1")
                    .field(minor)
                    .field(patch)
                    .finish()
            }
        }
    }
}
impl<'a> fmt::Display for ParseReleaseError<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ParseReleaseError::Format(bytes) => {
                write!(
                    f,
                    "could not parse {:?} as \"major.minor.patch\"",
                    String::from_utf8_lossy(bytes)
                )
            }
            ParseReleaseError::Number(bytes) => {
                write!(
                    f,
                    "could not parse {:?} as a positive number",
                    String::from_utf8_lossy(bytes)
                )
            }
            ParseReleaseError::Overflow(bytes) => {
                write!(
                    f,
                    "could not parse {:?}; was greater than 65535",
                    String::from_utf8_lossy(bytes)
                )
            }
            ParseReleaseError::Before1 { ref minor, ref patch } => {
                write!(
                    f,
                    "0.{}.{} ocurred before Rust 1.0.0",
                    minor, patch
                )
            }
        }
    }
}
impl<'a> Error for ParseReleaseError<'a> {
    fn description(&self) -> &str {
        match *self {
            ParseReleaseError::Format(_) => "could not parse as \"major.minor.patch\"",
            ParseReleaseError::Number(_) => "could not parse part of release as a positive number",
            ParseReleaseError::Overflow(_) => {
                "could not parse part of release because the number was greater than 65535"
            }
            ParseReleaseError::Before1 { .. } => {
                "version ocurred before Rust 1.0.0"
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use std::convert::TryFrom;

    use serde_test::{assert_tokens, assert_de_tokens, Token};

    use super::{Release, ParseReleaseError};

    #[test]
    fn format() {
        assert_eq!(
            Release::try_from("1.20"),
            Err(ParseReleaseError::Format(b"1.20"))
        );
        assert_eq!(
            Release::try_from("1.20.0.0"),
            Err(ParseReleaseError::Format(b"1.20.0.0"))
        );
        assert_eq!(Release::try_from("1"), Err(ParseReleaseError::Format(b"1")));
    }

    #[test]
    fn number() {
        assert_eq!(
            Release::try_from("oops.20.0"),
            Err(ParseReleaseError::Number(b"oops"))
        );
        assert_eq!(
            Release::try_from("1.oops.0"),
            Err(ParseReleaseError::Number(b"oops"))
        );
        assert_eq!(
            Release::try_from("1.20.oops"),
            Err(ParseReleaseError::Number(b"oops"))
        );
    }

    #[test]
    fn overflow() {
        assert_eq!(
            Release::try_from("123456.0.0"),
            Err(ParseReleaseError::Overflow(b"123456"))
        );
    }

    #[test]
    fn before_10() {
        assert_eq!(
            Release::try_from("0.1.oops"),
            Err(ParseReleaseError::Number(b"oops"))
        );
        assert_eq!(
            Release::try_from("0.1.123456"),
            Err(ParseReleaseError::Overflow(b"123456"))
        );
        assert_eq!(
            Release::try_from("0.1.0"),
            Err(ParseReleaseError::Before1 { minor: 1, patch: 0 })
        );
    }

    #[test]
    fn parse_display() {
        assert_eq!(
            Release::try_from("12345.6789.0").unwrap().to_string(),
            "12345.6789.0"
        );
    }

    #[test]
    fn serde() {
        assert_tokens(&Release::try_from("1.20.0").unwrap(), &[
            Token::Str("1.20.0"),
        ]);
    }

    #[test]
    fn de() {
        assert_de_tokens(&Release::try_from(&b"1.20.0"[..]).unwrap(), &[
            Token::Bytes(b"1.20.0"),
        ]);
    }
}