ako 0.0.3

use alloc::string::String;
use core::ops::Not;

use crate::calendar::Iso;
use crate::error::ErrorKind;
use crate::fmt::rw::{self, ReadDigits};
use crate::fmt::{format, parse};
use crate::{
    Calendar, Date, DateTime, Moment, Month, Offset, PlainDateTime, PlainTime, Year, YearMonth,
};

// Moment: Format
impl Moment {
    /// Formats this moment, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::Moment;
    /// #
    /// let epoch = Moment::from_unix_seconds(0).format_rfc3339();
    ///
    /// assert_eq!(epoch, "1970-01-01T00:00:00Z");
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 32)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        self.on(Iso).write_rfc3339(output);
    }
}

// Moment: Parse
impl Moment {
    /// Parses a moment, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        Ok(DateTime::read_rfc3339(input)?.into())
    }
}

// Year: Format
impl<C: Calendar> Year<C> {
    /// Formats this year, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::Year;
    /// # fn main() -> ako::Result<()> {
    /// let year = Year::iso(2038)?.format_rfc3339();
    ///
    /// assert_eq!(year, "2038");
    /// # Ok(()) }
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 4)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        let y = self.number();

        if (0..=9999).contains(&y) {
            rw::write_two_digit_i32(output, (y / 100) as u8);
            rw::write_two_digit_i32(output, (y % 100) as u8);
        } else if y.is_negative() {
            output.push('-');
            rw::write_i32(output, None, -y);
        } else {
            output.push('+');
            rw::write_i32(output, None, y);
        }
    }
}

// Year: Parse
impl Year<Iso> {
    /// Parses an ISO year, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[allow(unsafe_code)]
    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        // the first character may be a leading `-` or `+`
        // this indicates the sign of the year number
        // we allow an optional `+`
        let negative = rw::read_sign_is_negative(input, false)?;

        let (mut number, _) = rw::read_i32_in_range(
            input,
            negative.not().then_some(ReadDigits::AtLeast(4)),
            Iso::MIN_YEAR.number(),
            Iso::MAX_YEAR.number(),
        )?;

        if negative {
            number = -number;
        }

        // SAFETY: year number is already validated
        Ok(unsafe { Self::unchecked_of(Iso, number) })
    }
}

// Month: Format
impl<C: Calendar> Month<C> {
    /// Formats this month, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::calendar::Iso;
    /// #
    /// let month = Iso::MARCH.format_rfc3339();
    ///
    /// assert_eq!(month, "03");
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 2)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        rw::write_two_digit_i32(output, self.number());
    }
}

// Month: Parse
impl Month<Iso> {
    /// Parses an ISO month, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[allow(unsafe_code)]
    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        let (number, _) = rw::read_i32_in_range(input, 2, 1, 12)?;

        // SAFETY: month number is pre-validated
        Ok(unsafe { Self::unchecked_of(Iso, number as u8) })
    }
}

// YearMonth: Format
impl<C: Calendar> YearMonth<C> {
    /// Formats this year-month, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::YearMonth;
    /// # fn main() -> ako::Result<()> {
    /// let ym = YearMonth::iso(2025, 3)?.format_rfc3339();
    ///
    /// assert_eq!(ym, "2025-03");
    /// # Ok(()) }
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 7)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        self.year().write_rfc3339(output);
        output.push('-');
        self.month().write_rfc3339(output);
    }
}

// YearMonth: Parse
impl YearMonth<Iso> {
    /// Parses an ISO year-month, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        let year = Year::read_rfc3339(input)?;

        rw::read_ensure_u8(input, b'-')?;

        let month = Month::read_rfc3339(input)?;

        Ok(Self {
            calendar: Iso,
            year: year.number(),
            month: month.number(),
        })
    }
}

// Date: Format
impl<C: Calendar> Date<C> {
    /// Formats this date, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::Date;
    /// # fn main() -> ako::Result<()> {
    /// let date = Date::iso(2038, 3, 15)?.format_rfc3339();
    ///
    /// assert_eq!(date, "2038-03-15");
    /// # Ok(()) }
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 10)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        let (year, month, day) = Iso.date_components(self.as_days_since_ako_epoch());

        year.write_rfc3339(output);
        output.push('-');
        month.write_rfc3339(output);
        output.push('-');
        rw::write_two_digit_i32(output, day);
    }
}

// Date: Parse
impl Date<Iso> {
    /// Parses an ISO date, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        let year_month = YearMonth::read_rfc3339(input)?;

        rw::read_ensure_u8(input, b'-')?;

        let days = year_month.days() as i32;
        let (day, _) = rw::read_i32_in_range(input, 2, 1, days)?;

        Self::iso(year_month.year, year_month.month, day as u8)
    }
}

// PlainTime: Format
impl PlainTime {
    /// Formats this time, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::PlainTime;
    /// #
    /// let time = PlainTime::of(5, 0, 15).format_rfc3339();
    ///
    /// assert_eq!(time, "05:00:15");
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 20)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        let (hour, minute, second, nsec) = self.components();

        rw::write_two_digit_i32(output, hour);
        output.push(':');
        rw::write_two_digit_i32(output, minute);
        output.push(':');
        rw::write_two_digit_i32(output, second);

        if nsec > 0 {
            output.push('.');
            rw::write_i32(output, 9, nsec as i32);
        }
    }
}

// PlainTime: Parse
impl PlainTime {
    /// Parses a time without a time-zone, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        let (hour, _) = rw::read_i32_in_range(input, 2, 0, 23)?;

        rw::read_ensure_u8(input, b':')?;

        let (minute, _) = rw::read_i32_in_range(input, 2, 0, 59)?;

        rw::read_ensure_u8(input, b':')?;

        let second = match rw::read_i32(input, 2)? {
            Some((num, _)) if (0..=59).contains(&num) => num,

            Some((num, _)) if hour == 23 && minute == 23 && num == 60 => {
                // From RFC 3339

                // When required insertion of a leap second occurs as an extra second at the end of a day in UTC,
                // represented by a timestamp of the form YYYY-MM-DDT23:59:60Z.

                // We intentionally do not support representing a leap second and
                // instead, clamp the second value down to 59.

                // This is what several other time libraries do.

                59
            }

            _ => {
                return Err(ErrorKind::OutOfRange.into());
            }
        };

        // check for fractional nanoseconds
        let nanosecond = if input.first().is_some_and(|byte| *byte == b'.') {
            *input = &input[1..];

            let (fs, len) = rw::read_i32_in_range(input, ReadDigits::AtLeast(1), 0, 999_999_999)?;

            if len == 3 {
                // milliseconds
                (fs as u32) * 1_000_000
            } else if len <= 6 {
                // microseconds
                (fs as u32) * 1_000
            } else {
                fs as u32
            }
        } else {
            0
        };

        // components have been pre-checked
        Ok(Self::of_nanosecond(
            hour as u8,
            minute as u8,
            second as u8,
            nanosecond,
        ))
    }
}

// PlainDateTime: Format
impl<C: Calendar> PlainDateTime<C> {
    /// Formats this date-time, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use ako::Date;
    /// # fn main() -> ako::Result<()> {
    /// let dt = Date::iso(2028, 5, 12)?.with_time((17, 2, 3)).format_rfc3339();
    ///
    /// assert_eq!(dt, "2028-05-12T17:02:03");
    /// # Ok(()) }
    /// ```
    ///
    pub fn format_rfc3339(self) -> String {
        format(self, Self::write_rfc3339, 20)
    }

    #[inline]
    fn write_rfc3339(self, output: &mut String) {
        self.date.write_rfc3339(output);

        output.push('T');

        self.time.write_rfc3339(output);
    }
}

// PlainDateTime: Parse
impl PlainDateTime<Iso> {
    /// Parses an ISO date-time, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        let date = Date::read_rfc3339(input)?;

        rw::read_ensure_one_of_u8(input, b"Tt ")?;

        let time = PlainTime::read_rfc3339(input)?;

        Ok(Self { date, time })
    }
}

// Offset: Format
impl Offset {
    /// Formats this UTC time-zone offset, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    pub fn format_rfc3339(&self) -> String {
        format(self, Self::write_rfc3339, 6)
    }

    #[inline]
    fn write_rfc3339(&self, output: &mut String) {
        if self.is_utc() {
            output.push('Z');
        } else {
            let (hours, minutes, seconds) = self.components();

            output.push(if hours.is_negative() { '-' } else { '+' });

            rw::write_two_digit_i32(output, hours.unsigned_abs());
            output.push(':');
            rw::write_two_digit_i32(output, minutes.unsigned_abs());

            if seconds != 0 {
                output.push(':');
                rw::write_two_digit_i32(output, seconds.unsigned_abs());
            }
        }
    }
}

// Offset: Parse
impl Offset {
    /// Parses a UTC time-zone offset, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        if input
            .first()
            .copied()
            .is_some_and(|byte| byte == b'Z' || byte == b'z')
        {
            // UTC
            *input = &input[1..];
            return Ok(Self::UTC);
        }

        let negative = rw::read_sign_is_negative(input, true)?;

        let (mut hour, _) = rw::read_i32_in_range(input, 2, 0, 23)?;

        rw::read_ensure_u8(input, b':')?;

        let (mut minute, _) = rw::read_i32_in_range(input, 2, 0, 59)?;

        let mut second = if !input.is_empty() {
            rw::read_ensure_u8(input, b':')?;

            let (second, _) = rw::read_i32_in_range(input, 2, 0, 59)?;

            second
        } else {
            0
        };

        if negative {
            hour = -hour;
            minute = -minute;
            second = -second;
        }

        Self::of(hour as i8, minute as i8, second as i8)
    }
}

// DateTime: Format
impl<C: Calendar> DateTime<C> {
    /// Formats this date and time, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn format_rfc3339(&self) -> String {
        format(self, Self::write_rfc3339, 20)
    }

    #[inline]
    fn write_rfc3339(&self, output: &mut String) {
        let (date, time, offset) = self.components();

        date.write_rfc3339(output);
        output.push('T');
        time.write_rfc3339(output);
        offset.write_rfc3339(output);
    }
}

// DateTime: Parse
impl DateTime<Iso> {
    /// Parses a date and time, according to the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339.html)
    /// and [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standards.
    ///
    pub fn parse_rfc3339<S: AsRef<str>>(s: S) -> crate::Result<Self> {
        parse(s.as_ref(), Self::read_rfc3339)
    }

    #[inline]
    fn read_rfc3339(input: &mut &[u8]) -> crate::Result<Self> {
        let dt = PlainDateTime::read_rfc3339(input)?;
        let offset = Offset::read_rfc3339(input)?;

        Ok(dt.assume_offset(offset))
    }
}

#[cfg(test)]
mod tests {
    use test_case::test_case;

    use crate::{Moment, Year};

    #[test_case(1, "1970-01-01T00:00:01Z")]
    #[test_case(1726509578, "2024-09-16T17:59:38Z")]
    #[test_case(-2186632822, "1900-09-16T17:59:38Z")]
    #[test_case(-68487746422, "-201-09-16T17:59:38Z")]
    #[test_case(16842189578, "2503-09-16T17:59:38Z")]
    fn expect_rfc3339_moment(unix: i64, text: &'static str) -> crate::Result<()> {
        let m = Moment::from_unix_seconds(unix);
        let output = m.format_rfc3339();
        let parsed = Moment::parse_rfc3339(text)?;

        assert_eq!(output, text);
        assert_eq!(unix, parsed.to_unix_seconds());

        Ok(())
    }

    #[test_case(1970, "1970")]
    #[test_case(2024, "2024")]
    #[test_case(1900, "1900")]
    #[test_case(-201, "-201")]
    #[test_case(2503, "2503")]
    fn expect_rfc3339_year(year: i32, text: &'static str) -> crate::Result<()> {
        let y = Year::iso(year)?;
        let output = y.format_rfc3339();
        let parsed = Year::parse_rfc3339(text)?;

        assert_eq!(output, text);
        assert_eq!(year, parsed.number());

        Ok(())
    }
}