// Copyright (c) 2017 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
use crate::core::TextCodec;

use crate::util::error::Error;
use chrono::{DateTime as ChronoDateTime, FixedOffset, Utc};
use minidom::{IntoAttributeValue, Node};
use std::str::FromStr;

/// Text codec for
/// [XEP-0082](https://xmpp.org/extensions/xep-0082.html)-compliant formatting
/// of dates and times.
pub struct Xep0082;

impl TextCodec<ChronoDateTime<FixedOffset>> for Xep0082 {
    fn decode(s: &str) -> Result<ChronoDateTime<FixedOffset>, Error> {
        Ok(ChronoDateTime::parse_from_rfc3339(s)?)
    }

    fn encode(value: ChronoDateTime<FixedOffset>) -> Option<String> {
        if value.offset().utc_minus_local() == 0 {
            Some(value.format("%Y-%m-%dT%H:%M:%SZ").to_string())
        } else {
            Some(value.to_rfc3339())
        }
    }
}

impl TextCodec<ChronoDateTime<Utc>> for Xep0082 {
    fn decode(s: &str) -> Result<ChronoDateTime<Utc>, Error> {
        Ok(ChronoDateTime::<FixedOffset>::parse_from_rfc3339(s)?.into())
    }

    fn encode(value: ChronoDateTime<Utc>) -> Option<String> {
        Some(value.format("%Y-%m-%dT%H:%M:%SZ").to_string())
    }
}

impl<T> TextCodec<Option<T>> for Xep0082
where
    Xep0082: TextCodec<T>,
{
    fn decode(s: &str) -> Result<Option<T>, Error> {
        Ok(Some(Self::decode(s)?))
    }

    fn encode(value: Option<T>) -> Option<String> {
        value.and_then(Self::encode)
    }
}

/// Implements the DateTime profile of XEP-0082, which represents a
/// non-recurring moment in time, with an accuracy of seconds or fraction of
/// seconds, and includes a timezone.
#[derive(Debug, Clone, PartialEq)]
pub struct DateTime(pub ChronoDateTime<FixedOffset>);

impl DateTime {
    /// Retrieves the associated timezone.
    pub fn timezone(&self) -> FixedOffset {
        self.0.timezone()
    }

    /// Returns a new `DateTime` with a different timezone.
    pub fn with_timezone(&self, tz: FixedOffset) -> DateTime {
        DateTime(self.0.with_timezone(&tz))
    }

    /// Formats this `DateTime` with the specified format string.
    pub fn format(&self, fmt: &str) -> String {
        format!("{}", self.0.format(fmt))
    }
}

impl FromStr for DateTime {
    type Err = Error;

    fn from_str(s: &str) -> Result<DateTime, Error> {
        Ok(DateTime(ChronoDateTime::parse_from_rfc3339(s)?))
    }
}

impl crate::core::FromXmlText for DateTime {
    fn from_xml_text(s: &str) -> Result<Self, Error> {
        Self::from_str(s)
    }
}

impl crate::core::IntoXmlText for DateTime {
    fn into_xml_text(self) -> String {
        self.0.to_rfc3339()
    }
}

impl IntoAttributeValue for DateTime {
    fn into_attribute_value(self) -> Option<String> {
        Some(self.0.to_rfc3339())
    }
}

impl From<DateTime> for Node {
    fn from(date: DateTime) -> Node {
        Node::Text(date.0.to_rfc3339())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::{Datelike, TimeZone, Timelike};

    // DateTime’s size doesn’t depend on the architecture.
    #[test]
    fn test_size() {
        assert_size!(DateTime, 16);
    }

    #[test]
    fn test_codec_parses_datetime_zulu_as_utc() {
        let dt: ChronoDateTime<Utc> = Xep0082::decode("1969-07-21T02:56:15Z").unwrap();
        assert_eq!(dt.year(), 1969);
        assert_eq!(dt.month(), 7);
        assert_eq!(dt.day(), 21);
        assert_eq!(dt.hour(), 2);
        assert_eq!(dt.minute(), 56);
        assert_eq!(dt.second(), 15);
        assert_eq!(dt.nanosecond(), 0);
    }

    #[test]
    fn test_codec_parses_datetime_zulu_as_fixed_offset() {
        let dt: ChronoDateTime<FixedOffset> = Xep0082::decode("1969-07-21T02:56:15Z").unwrap();
        assert_eq!(dt.year(), 1969);
        assert_eq!(dt.month(), 7);
        assert_eq!(dt.day(), 21);
        assert_eq!(dt.hour(), 2);
        assert_eq!(dt.minute(), 56);
        assert_eq!(dt.second(), 15);
        assert_eq!(dt.nanosecond(), 0);
        assert_eq!(dt.timezone(), FixedOffset::east_opt(0).unwrap());
    }

    #[test]
    fn test_codec_parses_datetime_offset_as_utc() {
        let dt: ChronoDateTime<Utc> = Xep0082::decode("1969-07-20T21:56:15-05:00").unwrap();
        assert_eq!(dt.year(), 1969);
        assert_eq!(dt.month(), 7);
        assert_eq!(dt.day(), 21);
        assert_eq!(dt.hour(), 2);
        assert_eq!(dt.minute(), 56);
        assert_eq!(dt.second(), 15);
        assert_eq!(dt.nanosecond(), 0);
    }

    #[test]
    fn test_codec_parses_datetime_offset_as_fixed_offset() {
        let dt: ChronoDateTime<FixedOffset> = Xep0082::decode("1969-07-20T21:56:15-05:00").unwrap();
        assert_eq!(dt.year(), 1969);
        assert_eq!(dt.month(), 7);
        assert_eq!(dt.day(), 20);
        assert_eq!(dt.hour(), 21);
        assert_eq!(dt.minute(), 56);
        assert_eq!(dt.second(), 15);
        assert_eq!(dt.nanosecond(), 0);
        assert_eq!(dt.timezone(), FixedOffset::west_opt(5 * 3600).unwrap());
    }

    #[test]
    fn test_codec_serialises_utc_datetime_with_zulu() {
        let dt = Utc.with_ymd_and_hms(1969, 7, 21, 2, 56, 15).unwrap();
        let s = Xep0082::encode(dt).unwrap();
        assert_eq!(s, "1969-07-21T02:56:15Z");
    }

    #[test]
    fn test_codec_serialises_offset_datetime_with_nonzero_offset_as_offset() {
        let dt = FixedOffset::west_opt(5 * 3600)
            .unwrap()
            .with_ymd_and_hms(1969, 7, 20, 21, 56, 15)
            .unwrap();
        let s = Xep0082::encode(dt).unwrap();
        assert_eq!(s, "1969-07-20T21:56:15-05:00");
    }

    #[test]
    fn test_codec_serialises_offset_datetime_with_zero_offset_as_zulu() {
        let dt = FixedOffset::west_opt(0)
            .unwrap()
            .with_ymd_and_hms(1969, 7, 21, 2, 56, 15)
            .unwrap();
        let s = Xep0082::encode(dt).unwrap();
        assert_eq!(s, "1969-07-21T02:56:15Z");
    }

    #[test]
    fn test_simple() {
        let date: DateTime = "2002-09-10T23:08:25Z".parse().unwrap();
        assert_eq!(date.0.year(), 2002);
        assert_eq!(date.0.month(), 9);
        assert_eq!(date.0.day(), 10);
        assert_eq!(date.0.hour(), 23);
        assert_eq!(date.0.minute(), 08);
        assert_eq!(date.0.second(), 25);
        assert_eq!(date.0.nanosecond(), 0);
        assert_eq!(date.0.timezone(), FixedOffset::east_opt(0).unwrap());
    }

    #[test]
    fn test_invalid_date() {
        // There is no thirteenth month.
        let error = DateTime::from_str("2017-13-01T12:23:34Z").unwrap_err();
        let message = match error {
            Error::ChronoParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message.to_string(), "input is out of range");

        // Timezone ≥24:00 aren’t allowed.
        let error = DateTime::from_str("2017-05-27T12:11:02+25:00").unwrap_err();
        let message = match error {
            Error::ChronoParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message.to_string(), "input is out of range");

        // Timezone without the : separator aren’t allowed.
        let error = DateTime::from_str("2017-05-27T12:11:02+0100").unwrap_err();
        let message = match error {
            Error::ChronoParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message.to_string(), "input contains invalid characters");

        // No seconds, error message could be improved.
        let error = DateTime::from_str("2017-05-27T12:11+01:00").unwrap_err();
        let message = match error {
            Error::ChronoParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message.to_string(), "input contains invalid characters");

        // TODO: maybe we’ll want to support this one, as per XEP-0082 §4.
        let error = DateTime::from_str("20170527T12:11:02+01:00").unwrap_err();
        let message = match error {
            Error::ChronoParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message.to_string(), "input contains invalid characters");

        // No timezone.
        let error = DateTime::from_str("2017-05-27T12:11:02").unwrap_err();
        let message = match error {
            Error::ChronoParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message.to_string(), "premature end of input");
    }

    #[test]
    fn test_serialise() {
        let date =
            DateTime(ChronoDateTime::parse_from_rfc3339("2017-05-21T20:19:55+01:00").unwrap());
        let attr = date.into_attribute_value();
        assert_eq!(attr, Some(String::from("2017-05-21T20:19:55+01:00")));
    }
}