#![allow(deprecated)]
use crate::timezone;
use anyhow::{anyhow, Result};
use chrono::prelude::*;
use lazy_static::lazy_static;
use regex::Regex;

/// Parse struct has methods implemented parsers for accepted formats.
pub struct Parse<'z, Tz2> {
    tz: &'z Tz2,
    default_time: Option<NaiveTime>,
}

impl<'z, Tz2> Parse<'z, Tz2>
where
    Tz2: TimeZone,
{
    /// Create a new instrance of [`Parse`] with a custom parsing timezone that handles the
    /// datetime string without time offset.
    pub fn new(tz: &'z Tz2, default_time: Option<NaiveTime>) -> Self {
        Self { tz, default_time }
    }

    /// This method tries to parse the input datetime string with a list of accepted formats. See
    /// more exmaples from [`Parse`], [`crate::parse()`] and [`crate::parse_with_timezone()`].
    pub fn parse(&self, input: &str) -> Result<DateTime<Utc>> {
        self.unix_timestamp(input)
            .or_else(|| self.rfc2822(input))
            .or_else(|| self.ymd_family(input))
            .or_else(|| self.hms_family(input))
            .or_else(|| self.month_ymd(input))
            .or_else(|| self.month_mdy_family(input))
            .or_else(|| self.month_dmy_family(input))
            .or_else(|| self.slash_mdy_family(input))
            .or_else(|| self.slash_ymd_family(input))
            .or_else(|| self.dot_mdy_or_ymd(input))
            .or_else(|| self.mysql_log_timestamp(input))
            .or_else(|| self.chinese_ymd_family(input))
            .unwrap_or_else(|| Err(anyhow!("{} did not match any formats.", input)))
    }

    fn ymd_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}-[0-9]{2}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.rfc3339(input)
            .or_else(|| self.postgres_timestamp(input))
            .or_else(|| self.ymd_hms(input))
            .or_else(|| self.ymd_hms_z(input))
            .or_else(|| self.ymd(input))
            .or_else(|| self.ymd_z(input))
    }

    fn hms_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{1,2}:[0-9]{2}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.hms(input).or_else(|| self.hms_z(input))
    }

    fn month_mdy_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[a-zA-Z]{3,9}\.?\s+[0-9]{1,2}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.month_md_hms(input)
            .or_else(|| self.month_mdy_hms(input))
            .or_else(|| self.month_mdy_hms_z(input))
            .or_else(|| self.month_mdy(input))
    }

    fn month_dmy_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{1,2}\s+[a-zA-Z]{3,9}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.month_dmy_hms(input).or_else(|| self.month_dmy(input))
    }

    fn slash_mdy_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{1,2}/[0-9]{1,2}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.slash_mdy_hms(input).or_else(|| self.slash_mdy(input))
    }

    fn slash_ymd_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}/[0-9]{1,2}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.slash_ymd_hms(input).or_else(|| self.slash_ymd(input))
    }

    fn chinese_ymd_family(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}年[0-9]{2}月").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }
        self.chinese_ymd_hms(input)
            .or_else(|| self.chinese_ymd(input))
    }

    // unix timestamp
    // - 1511648546
    // - 1620021848429
    // - 1620024872717915000
    fn unix_timestamp(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{10,19}$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        input
            .parse::<i64>()
            .ok()
            .and_then(|timestamp| {
                match input.len() {
                    10 => Some(Utc.timestamp(timestamp, 0)),
                    13 => Some(Utc.timestamp_millis(timestamp)),
                    19 => Some(Utc.timestamp_nanos(timestamp)),
                    _ => None,
                }
                .map(|datetime| datetime.with_timezone(&Utc))
            })
            .map(Ok)
    }

    // rfc3339
    // - 2021-05-01T01:17:02.604456Z
    // - 2017-11-25T22:34:50Z
    fn rfc3339(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        DateTime::parse_from_rfc3339(input)
            .ok()
            .map(|parsed| parsed.with_timezone(&Utc))
            .map(Ok)
    }

    // rfc2822
    // - Wed, 02 Jun 2021 06:31:39 GMT
    fn rfc2822(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        DateTime::parse_from_rfc2822(input)
            .ok()
            .map(|parsed| parsed.with_timezone(&Utc))
            .map(Ok)
    }

    // postgres timestamp yyyy-mm-dd hh:mm:ss z
    // - 2019-11-29 08:08-08
    // - 2019-11-29 08:08:05-08
    // - 2021-05-02 23:31:36.0741-07
    // - 2021-05-02 23:31:39.12689-07
    // - 2019-11-29 08:15:47.624504-08
    // - 2017-07-19 03:21:51+00:00
    fn postgres_timestamp(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]{2}:[0-9]{2}(:[0-9]{2})?(\.[0-9]{1,9})?[+-:0-9]{3,6}$",
            )
            .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        DateTime::parse_from_str(input, "%Y-%m-%d %H:%M:%S%#z")
            .or_else(|_| DateTime::parse_from_str(input, "%Y-%m-%d %H:%M:%S%.f%#z"))
            .or_else(|_| DateTime::parse_from_str(input, "%Y-%m-%d %H:%M%#z"))
            .ok()
            .map(|parsed| parsed.with_timezone(&Utc))
            .map(Ok)
    }

    // yyyy-mm-dd hh:mm:ss
    // - 2014-04-26 05:24:37 PM
    // - 2021-04-30 21:14
    // - 2021-04-30 21:14:10
    // - 2021-04-30 21:14:10.052282
    // - 2014-04-26 17:24:37.123
    // - 2014-04-26 17:24:37.3186369
    // - 2012-08-03 18:31:59.257000000
    fn ymd_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]{2}:[0-9]{2}(:[0-9]{2})?(\.[0-9]{1,9})?\s*(am|pm|AM|PM)?$",
            )
            .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        self.tz
            .datetime_from_str(input, "%Y-%m-%d %H:%M:%S")
            .or_else(|_| self.tz.datetime_from_str(input, "%Y-%m-%d %H:%M"))
            .or_else(|_| self.tz.datetime_from_str(input, "%Y-%m-%d %H:%M:%S%.f"))
            .or_else(|_| self.tz.datetime_from_str(input, "%Y-%m-%d %I:%M:%S %P"))
            .or_else(|_| self.tz.datetime_from_str(input, "%Y-%m-%d %I:%M %P"))
            .ok()
            .map(|parsed| parsed.with_timezone(&Utc))
            .map(Ok)
    }

    // yyyy-mm-dd hh:mm:ss z
    // - 2017-11-25 13:31:15 PST
    // - 2017-11-25 13:31 PST
    // - 2014-12-16 06:20:00 UTC
    // - 2014-12-16 06:20:00 GMT
    // - 2014-04-26 13:13:43 +0800
    // - 2014-04-26 13:13:44 +09:00
    // - 2012-08-03 18:31:59.257000000 +0000
    // - 2015-09-30 18:48:56.35272715 UTC
    fn ymd_hms_z(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]{2}:[0-9]{2}(:[0-9]{2})?(\.[0-9]{1,9})?(?P<tz>\s*[+-:a-zA-Z0-9]{3,6})$",
            ).unwrap();
        }

        if !RE.is_match(input) {
            return None;
        }
        if let Some(caps) = RE.captures(input) {
            if let Some(matched_tz) = caps.name("tz") {
                let parse_from_str = NaiveDateTime::parse_from_str;
                return match timezone::parse(matched_tz.as_str().trim()) {
                    Ok(offset) => parse_from_str(input, "%Y-%m-%d %H:%M:%S %Z")
                        .or_else(|_| parse_from_str(input, "%Y-%m-%d %H:%M %Z"))
                        .or_else(|_| parse_from_str(input, "%Y-%m-%d %H:%M:%S%.f %Z"))
                        .ok()
                        .and_then(|parsed| offset.from_local_datetime(&parsed).single())
                        .map(|datetime| datetime.with_timezone(&Utc))
                        .map(Ok),
                    Err(err) => Some(Err(err)),
                };
            }
        }
        None
    }

    // yyyy-mm-dd
    // - 2021-02-21
    fn ymd(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$").unwrap();
        }

        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%Y-%m-%d")
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // yyyy-mm-dd z
    // - 2021-02-21 PST
    // - 2021-02-21 UTC
    // - 2020-07-20+08:00 (yyyy-mm-dd-07:00)
    fn ymd_z(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex =
                Regex::new(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}(?P<tz>\s*[+-:a-zA-Z0-9]{3,6})$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        if let Some(caps) = RE.captures(input) {
            if let Some(matched_tz) = caps.name("tz") {
                return match timezone::parse(matched_tz.as_str().trim()) {
                    Ok(offset) => {
                        // set time to use
                        let time = match self.default_time {
                            Some(v) => v,
                            None => Utc::now().with_timezone(&offset).time(),
                        };
                        NaiveDate::parse_from_str(input, "%Y-%m-%d %Z")
                            .ok()
                            .map(|parsed| parsed.and_time(time))
                            .and_then(|datetime| offset.from_local_datetime(&datetime).single())
                            .map(|at_tz| at_tz.with_timezone(&Utc))
                            .map(Ok)
                    }
                    Err(err) => Some(Err(err)),
                };
            }
        }
        None
    }

    // hh:mm:ss
    // - 01:06:06
    // - 4:00pm
    // - 6:00 AM
    fn hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex =
                Regex::new(r"^[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?\s*(am|pm|AM|PM)?$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        let now = Utc::now().with_timezone(self.tz);
        NaiveTime::parse_from_str(input, "%H:%M:%S")
            .or_else(|_| NaiveTime::parse_from_str(input, "%H:%M"))
            .or_else(|_| NaiveTime::parse_from_str(input, "%I:%M:%S %P"))
            .or_else(|_| NaiveTime::parse_from_str(input, "%I:%M %P"))
            .ok()
            .and_then(|parsed| now.date().and_time(parsed))
            .map(|datetime| datetime.with_timezone(&Utc))
            .map(Ok)
    }

    // hh:mm:ss z
    // - 01:06:06 PST
    // - 4:00pm PST
    // - 6:00 AM PST
    // - 6:00pm UTC
    fn hms_z(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?\s*(am|pm|AM|PM)?(?P<tz>\s+[+-:a-zA-Z0-9]{3,6})$",
            )
            .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        if let Some(caps) = RE.captures(input) {
            if let Some(matched_tz) = caps.name("tz") {
                return match timezone::parse(matched_tz.as_str().trim()) {
                    Ok(offset) => {
                        let now = Utc::now().with_timezone(&offset);
                        NaiveTime::parse_from_str(input, "%H:%M:%S %Z")
                            .or_else(|_| NaiveTime::parse_from_str(input, "%H:%M %Z"))
                            .or_else(|_| NaiveTime::parse_from_str(input, "%I:%M:%S %P %Z"))
                            .or_else(|_| NaiveTime::parse_from_str(input, "%I:%M %P %Z"))
                            .ok()
                            .map(|parsed| now.date().naive_local().and_time(parsed))
                            .and_then(|datetime| offset.from_local_datetime(&datetime).single())
                            .map(|at_tz| at_tz.with_timezone(&Utc))
                            .map(Ok)
                    }
                    Err(err) => Some(Err(err)),
                };
            }
        }
        None
    }

    // yyyy-mon-dd
    // - 2021-Feb-21
    fn month_ymd(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}-[a-zA-Z]{3,9}-[0-9]{2}$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%Y-%m-%d")
            .or_else(|_| NaiveDate::parse_from_str(input, "%Y-%b-%d"))
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // Mon dd hh:mm:ss
    // - May 6 at 9:24 PM
    // - May 27 02:45:27
    fn month_md_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[a-zA-Z]{3}\s+[0-9]{1,2}\s*(at)?\s+[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?\s*(am|pm|AM|PM)?$",
            )
            .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        let now = Utc::now().with_timezone(self.tz);
        let with_year = format!("{} {}", now.year(), input);
        self.tz
            .datetime_from_str(&with_year, "%Y %b %d at %I:%M %P")
            .or_else(|_| self.tz.datetime_from_str(&with_year, "%Y %b %d %H:%M:%S"))
            .ok()
            .map(|parsed| parsed.with_timezone(&Utc))
            .map(Ok)
    }

    // Mon dd, yyyy, hh:mm:ss
    // - May 8, 2009 5:57:51 PM
    // - September 17, 2012 10:09am
    // - September 17, 2012, 10:10:09
    fn month_mdy_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[a-zA-Z]{3,9}\.?\s+[0-9]{1,2},\s+[0-9]{2,4},?\s+[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?\s*(am|pm|AM|PM)?$",
            ).unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        let dt = input.replace(", ", " ").replace(". ", " ");
        self.tz
            .datetime_from_str(&dt, "%B %d %Y %H:%M:%S")
            .or_else(|_| self.tz.datetime_from_str(&dt, "%B %d %Y %H:%M"))
            .or_else(|_| self.tz.datetime_from_str(&dt, "%B %d %Y %I:%M:%S %P"))
            .or_else(|_| self.tz.datetime_from_str(&dt, "%B %d %Y %I:%M %P"))
            .ok()
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // Mon dd, yyyy hh:mm:ss z
    // - May 02, 2021 15:51:31 UTC
    // - May 02, 2021 15:51 UTC
    // - May 26, 2021, 12:49 AM PDT
    // - September 17, 2012 at 10:09am PST
    fn month_mdy_hms_z(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[a-zA-Z]{3,9}\s+[0-9]{1,2},?\s+[0-9]{4}\s*,?(at)?\s+[0-9]{2}:[0-9]{2}(:[0-9]{2})?\s*(am|pm|AM|PM)?(?P<tz>\s+[+-:a-zA-Z0-9]{3,6})$",
            ).unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        if let Some(caps) = RE.captures(input) {
            if let Some(matched_tz) = caps.name("tz") {
                let parse_from_str = NaiveDateTime::parse_from_str;
                return match timezone::parse(matched_tz.as_str().trim()) {
                    Ok(offset) => {
                        let dt = input.replace(',', "").replace("at", "");
                        parse_from_str(&dt, "%B %d %Y %H:%M:%S %Z")
                            .or_else(|_| parse_from_str(&dt, "%B %d %Y %H:%M %Z"))
                            .or_else(|_| parse_from_str(&dt, "%B %d %Y %I:%M:%S %P %Z"))
                            .or_else(|_| parse_from_str(&dt, "%B %d %Y %I:%M %P %Z"))
                            .ok()
                            .and_then(|parsed| offset.from_local_datetime(&parsed).single())
                            .map(|datetime| datetime.with_timezone(&Utc))
                            .map(Ok)
                    }
                    Err(err) => Some(Err(err)),
                };
            }
        }
        None
    }

    // Mon dd, yyyy
    // - May 25, 2021
    // - oct 7, 1970
    // - oct 7, 70
    // - oct. 7, 1970
    // - oct. 7, 70
    // - October 7, 1970
    fn month_mdy(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex =
                Regex::new(r"^[a-zA-Z]{3,9}\.?\s+[0-9]{1,2},\s+[0-9]{2,4}$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        let dt = input.replace(", ", " ").replace(". ", " ");
        NaiveDate::parse_from_str(&dt, "%B %d %y")
            .or_else(|_| NaiveDate::parse_from_str(&dt, "%B %d %Y"))
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // dd Mon yyyy hh:mm:ss
    // - 12 Feb 2006, 19:17
    // - 12 Feb 2006 19:17
    // - 14 May 2019 19:11:40.164
    fn month_dmy_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{1,2}\s+[a-zA-Z]{3,9}\s+[0-9]{2,4},?\s+[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?(\.[0-9]{1,9})?$",
            ).unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        let dt = input.replace(", ", " ");
        self.tz
            .datetime_from_str(&dt, "%d %B %Y %H:%M:%S")
            .or_else(|_| self.tz.datetime_from_str(&dt, "%d %B %Y %H:%M"))
            .or_else(|_| self.tz.datetime_from_str(&dt, "%d %B %Y %H:%M:%S%.f"))
            .or_else(|_| self.tz.datetime_from_str(&dt, "%d %B %Y %I:%M:%S %P"))
            .or_else(|_| self.tz.datetime_from_str(&dt, "%d %B %Y %I:%M %P"))
            .ok()
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // dd Mon yyyy
    // - 7 oct 70
    // - 7 oct 1970
    // - 03 February 2013
    // - 1 July 2013
    fn month_dmy(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex =
                Regex::new(r"^[0-9]{1,2}\s+[a-zA-Z]{3,9}\s+[0-9]{2,4}$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%d %B %y")
            .or_else(|_| NaiveDate::parse_from_str(input, "%d %B %Y"))
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // mm/dd/yyyy hh:mm:ss
    // - 4/8/2014 22:05
    // - 04/08/2014 22:05
    // - 4/8/14 22:05
    // - 04/2/2014 03:00:51
    // - 8/8/1965 12:00:00 AM
    // - 8/8/1965 01:00:01 PM
    // - 8/8/1965 01:00 PM
    // - 8/8/1965 1:00 PM
    // - 8/8/1965 12:00 AM
    // - 4/02/2014 03:00:51
    // - 03/19/2012 10:11:59
    // - 03/19/2012 10:11:59.3186369
    fn slash_mdy_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{1,2}/[0-9]{1,2}/[0-9]{2,4}\s+[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?(\.[0-9]{1,9})?\s*(am|pm|AM|PM)?$"
            )
            .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        self.tz
            .datetime_from_str(input, "%m/%d/%y %H:%M:%S")
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%y %H:%M"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%y %H:%M:%S%.f"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%y %I:%M:%S %P"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%y %I:%M %P"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%Y %H:%M:%S"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%Y %H:%M"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%Y %H:%M:%S%.f"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%Y %I:%M:%S %P"))
            .or_else(|_| self.tz.datetime_from_str(input, "%m/%d/%Y %I:%M %P"))
            .ok()
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // mm/dd/yyyy
    // - 3/31/2014
    // - 03/31/2014
    // - 08/21/71
    // - 8/1/71
    fn slash_mdy(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{1,2}/[0-9]{1,2}/[0-9]{2,4}$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%m/%d/%y")
            .or_else(|_| NaiveDate::parse_from_str(input, "%m/%d/%Y"))
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // yyyy/mm/dd hh:mm:ss
    // - 2014/4/8 22:05
    // - 2014/04/08 22:05
    // - 2014/04/2 03:00:51
    // - 2014/4/02 03:00:51
    // - 2012/03/19 10:11:59
    // - 2012/03/19 10:11:59.3186369
    fn slash_ymd_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(
                r"^[0-9]{4}/[0-9]{1,2}/[0-9]{1,2}\s+[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?(\.[0-9]{1,9})?\s*(am|pm|AM|PM)?$"
            )
            .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        self.tz
            .datetime_from_str(input, "%Y/%m/%d %H:%M:%S")
            .or_else(|_| self.tz.datetime_from_str(input, "%Y/%m/%d %H:%M"))
            .or_else(|_| self.tz.datetime_from_str(input, "%Y/%m/%d %H:%M:%S%.f"))
            .or_else(|_| self.tz.datetime_from_str(input, "%Y/%m/%d %I:%M:%S %P"))
            .or_else(|_| self.tz.datetime_from_str(input, "%Y/%m/%d %I:%M %P"))
            .ok()
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // yyyy/mm/dd
    // - 2014/3/31
    // - 2014/03/31
    fn slash_ymd(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}/[0-9]{1,2}/[0-9]{1,2}$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%Y/%m/%d")
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // mm.dd.yyyy
    // - 3.31.2014
    // - 03.31.2014
    // - 08.21.71
    // yyyy.mm.dd
    // - 2014.03.30
    // - 2014.03
    fn dot_mdy_or_ymd(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"[0-9]{1,4}.[0-9]{1,4}[0-9]{1,4}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%m.%d.%y")
            .or_else(|_| NaiveDate::parse_from_str(input, "%m.%d.%Y"))
            .or_else(|_| NaiveDate::parse_from_str(input, "%Y.%m.%d"))
            .or_else(|_| {
                NaiveDate::parse_from_str(&format!("{}.{}", input, Utc::now().day()), "%Y.%m.%d")
            })
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // yymmdd hh:mm:ss mysql log
    // - 171113 14:14:20
    fn mysql_log_timestamp(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"[0-9]{6}\s+[0-9]{2}:[0-9]{2}:[0-9]{2}").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        self.tz
            .datetime_from_str(input, "%y%m%d %H:%M:%S")
            .ok()
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // chinese yyyy mm dd hh mm ss
    // - 2014年04月08日11时25分18秒
    fn chinese_ymd_hms(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex =
                Regex::new(r"^[0-9]{4}年[0-9]{2}月[0-9]{2}日[0-9]{2}时[0-9]{2}分[0-9]{2}秒$")
                    .unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        self.tz
            .datetime_from_str(input, "%Y年%m月%d日%H时%M分%S秒")
            .ok()
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }

    // chinese yyyy mm dd
    // - 2014年04月08日
    fn chinese_ymd(&self, input: &str) -> Option<Result<DateTime<Utc>>> {
        lazy_static! {
            static ref RE: Regex = Regex::new(r"^[0-9]{4}年[0-9]{2}月[0-9]{2}日$").unwrap();
        }
        if !RE.is_match(input) {
            return None;
        }

        // set time to use
        let time = match self.default_time {
            Some(v) => v,
            None => Utc::now().with_timezone(self.tz).time(),
        };

        NaiveDate::parse_from_str(input, "%Y年%m月%d日")
            .ok()
            .map(|parsed| parsed.and_time(time))
            .and_then(|datetime| self.tz.from_local_datetime(&datetime).single())
            .map(|at_tz| at_tz.with_timezone(&Utc))
            .map(Ok)
    }
}

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

    #[test]
    fn unix_timestamp() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            ("0000000000", Utc.ymd(1970, 1, 1).and_hms(0, 0, 0)),
            ("0000000000000", Utc.ymd(1970, 1, 1).and_hms(0, 0, 0)),
            ("0000000000000000000", Utc.ymd(1970, 1, 1).and_hms(0, 0, 0)),
            ("1511648546", Utc.ymd(2017, 11, 25).and_hms(22, 22, 26)),
            (
                "1620021848429",
                Utc.ymd(2021, 5, 3).and_hms_milli(6, 4, 8, 429),
            ),
            (
                "1620024872717915000",
                Utc.ymd(2021, 5, 3).and_hms_nano(6, 54, 32, 717915000),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.unix_timestamp(input).unwrap().unwrap(),
                want,
                "unix_timestamp/{}",
                input
            )
        }
        assert!(parse.unix_timestamp("15116").is_none());
        assert!(parse
            .unix_timestamp("16200248727179150001620024872717915000")
            .is_none());
        assert!(parse.unix_timestamp("not-a-ts").is_none());
    }

    #[test]
    fn rfc3339() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "2021-05-01T01:17:02.604456Z",
                Utc.ymd(2021, 5, 1).and_hms_nano(1, 17, 2, 604456000),
            ),
            (
                "2017-11-25T22:34:50Z",
                Utc.ymd(2017, 11, 25).and_hms(22, 34, 50),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.rfc3339(input).unwrap().unwrap(),
                want,
                "rfc3339/{}",
                input
            )
        }
        assert!(parse.rfc3339("2017-11-25 22:34:50").is_none());
        assert!(parse.rfc3339("not-date-time").is_none());
    }

    #[test]
    fn rfc2822() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "Wed, 02 Jun 2021 06:31:39 GMT",
                Utc.ymd(2021, 6, 2).and_hms(6, 31, 39),
            ),
            (
                "Wed, 02 Jun 2021 06:31:39 PDT",
                Utc.ymd(2021, 6, 2).and_hms(13, 31, 39),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.rfc2822(input).unwrap().unwrap(),
                want,
                "rfc2822/{}",
                input
            )
        }
        assert!(parse.rfc2822("02 Jun 2021 06:31:39").is_none());
        assert!(parse.rfc2822("not-date-time").is_none());
    }

    #[test]
    fn postgres_timestamp() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "2019-11-29 08:08-08",
                Utc.ymd(2019, 11, 29).and_hms(16, 8, 0),
            ),
            (
                "2019-11-29 08:08:05-08",
                Utc.ymd(2019, 11, 29).and_hms(16, 8, 5),
            ),
            (
                "2021-05-02 23:31:36.0741-07",
                Utc.ymd(2021, 5, 3).and_hms_micro(6, 31, 36, 74100),
            ),
            (
                "2021-05-02 23:31:39.12689-07",
                Utc.ymd(2021, 5, 3).and_hms_micro(6, 31, 39, 126890),
            ),
            (
                "2019-11-29 08:15:47.624504-08",
                Utc.ymd(2019, 11, 29).and_hms_micro(16, 15, 47, 624504),
            ),
            (
                "2017-07-19 03:21:51+00:00",
                Utc.ymd(2017, 7, 19).and_hms(3, 21, 51),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.postgres_timestamp(input).unwrap().unwrap(),
                want,
                "postgres_timestamp/{}",
                input
            )
        }
        assert!(parse.postgres_timestamp("not-date-time").is_none());
    }

    #[test]
    fn ymd_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = vec![
            ("2021-04-30 21:14", Utc.ymd(2021, 4, 30).and_hms(21, 14, 0)),
            (
                "2021-04-30 21:14:10",
                Utc.ymd(2021, 4, 30).and_hms(21, 14, 10),
            ),
            (
                "2021-04-30 21:14:10.052282",
                Utc.ymd(2021, 4, 30).and_hms_micro(21, 14, 10, 52282),
            ),
            (
                "2014-04-26 05:24:37 PM",
                Utc.ymd(2014, 4, 26).and_hms(17, 24, 37),
            ),
            (
                "2014-04-26 17:24:37.123",
                Utc.ymd(2014, 4, 26).and_hms_milli(17, 24, 37, 123),
            ),
            (
                "2014-04-26 17:24:37.3186369",
                Utc.ymd(2014, 4, 26).and_hms_nano(17, 24, 37, 318636900),
            ),
            (
                "2012-08-03 18:31:59.257000000",
                Utc.ymd(2012, 8, 3).and_hms_nano(18, 31, 59, 257000000),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.ymd_hms(input).unwrap().unwrap(),
                want,
                "ymd_hms/{}",
                input
            )
        }
        assert!(parse.ymd_hms("not-date-time").is_none());
    }

    #[test]
    fn ymd_hms_z() {
        let parse = Parse::new(&Utc, None);

        let test_cases = vec![
            (
                "2017-11-25 13:31:15 PST",
                Utc.ymd(2017, 11, 25).and_hms(21, 31, 15),
            ),
            (
                "2017-11-25 13:31 PST",
                Utc.ymd(2017, 11, 25).and_hms(21, 31, 0),
            ),
            (
                "2014-12-16 06:20:00 UTC",
                Utc.ymd(2014, 12, 16).and_hms(6, 20, 0),
            ),
            (
                "2014-12-16 06:20:00 GMT",
                Utc.ymd(2014, 12, 16).and_hms(6, 20, 0),
            ),
            (
                "2014-04-26 13:13:43 +0800",
                Utc.ymd(2014, 4, 26).and_hms(5, 13, 43),
            ),
            (
                "2014-04-26 13:13:44 +09:00",
                Utc.ymd(2014, 4, 26).and_hms(4, 13, 44),
            ),
            (
                "2012-08-03 18:31:59.257000000 +0000",
                Utc.ymd(2012, 8, 3).and_hms_nano(18, 31, 59, 257000000),
            ),
            (
                "2015-09-30 18:48:56.35272715 UTC",
                Utc.ymd(2015, 9, 30).and_hms_nano(18, 48, 56, 352727150),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.ymd_hms_z(input).unwrap().unwrap(),
                want,
                "ymd_hms_z/{}",
                input
            )
        }
        assert!(parse.ymd_hms_z("not-date-time").is_none());
    }

    #[test]
    fn ymd() {
        let parse = Parse::new(&Utc, Some(Utc::now().time()));

        let test_cases = [(
            "2021-02-21",
            Utc.ymd(2021, 2, 21).and_time(Utc::now().time()),
        )];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .ymd(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "ymd/{}",
                input
            )
        }
        assert!(parse.ymd("not-date-time").is_none());
    }

    #[test]
    fn ymd_z() {
        let parse = Parse::new(&Utc, None);
        let now_at_pst = Utc::now().with_timezone(&FixedOffset::west(8 * 3600));
        let now_at_cst = Utc::now().with_timezone(&FixedOffset::east(8 * 3600));

        let test_cases = [
            (
                "2021-02-21 PST",
                FixedOffset::west(8 * 3600)
                    .ymd(2021, 2, 21)
                    .and_time(now_at_pst.time())
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
            (
                "2021-02-21 UTC",
                FixedOffset::west(0)
                    .ymd(2021, 2, 21)
                    .and_time(Utc::now().time())
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
            (
                "2020-07-20+08:00",
                FixedOffset::east(8 * 3600)
                    .ymd(2020, 7, 20)
                    .and_time(now_at_cst.time())
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .ymd_z(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "ymd_z/{}",
                input
            )
        }
        assert!(parse.ymd_z("not-date-time").is_none());
    }

    #[test]
    fn hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "01:06:06",
                Utc::now().date().and_time(NaiveTime::from_hms(1, 6, 6)),
            ),
            (
                "4:00pm",
                Utc::now().date().and_time(NaiveTime::from_hms(16, 0, 0)),
            ),
            (
                "6:00 AM",
                Utc::now().date().and_time(NaiveTime::from_hms(6, 0, 0)),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.hms(input).unwrap().unwrap(),
                want.unwrap(),
                "hms/{}",
                input
            )
        }
        assert!(parse.hms("not-date-time").is_none());
    }

    #[test]
    fn hms_z() {
        let parse = Parse::new(&Utc, None);
        let now_at_pst = Utc::now().with_timezone(&FixedOffset::west(8 * 3600));

        let test_cases = [
            (
                "01:06:06 PST",
                FixedOffset::west(8 * 3600)
                    .from_local_date(&now_at_pst.date().naive_local())
                    .and_time(NaiveTime::from_hms(1, 6, 6))
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
            (
                "4:00pm PST",
                FixedOffset::west(8 * 3600)
                    .from_local_date(&now_at_pst.date().naive_local())
                    .and_time(NaiveTime::from_hms(16, 0, 0))
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
            (
                "6:00 AM PST",
                FixedOffset::west(8 * 3600)
                    .from_local_date(&now_at_pst.date().naive_local())
                    .and_time(NaiveTime::from_hms(6, 0, 0))
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
            (
                "6:00pm UTC",
                FixedOffset::west(0)
                    .from_local_date(&Utc::now().date().naive_local())
                    .and_time(NaiveTime::from_hms(18, 0, 0))
                    .map(|dt| dt.with_timezone(&Utc)),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.hms_z(input).unwrap().unwrap(),
                want.unwrap(),
                "hms_z/{}",
                input
            )
        }
        assert!(parse.hms_z("not-date-time").is_none());
    }

    #[test]
    fn month_ymd() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [(
            "2021-Feb-21",
            Utc.ymd(2021, 2, 21).and_time(Utc::now().time()),
        )];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .month_ymd(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "month_ymd/{}",
                input
            )
        }
        assert!(parse.month_ymd("not-date-time").is_none());
    }

    #[test]
    fn month_md_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "May 6 at 9:24 PM",
                Utc.ymd(Utc::now().year(), 5, 6).and_hms(21, 24, 0),
            ),
            (
                "May 27 02:45:27",
                Utc.ymd(Utc::now().year(), 5, 27).and_hms(2, 45, 27),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.month_md_hms(input).unwrap().unwrap(),
                want,
                "month_md_hms/{}",
                input
            )
        }
        assert!(parse.month_md_hms("not-date-time").is_none());
    }

    #[test]
    fn month_mdy_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "May 8, 2009 5:57:51 PM",
                Utc.ymd(2009, 5, 8).and_hms(17, 57, 51),
            ),
            (
                "September 17, 2012 10:09am",
                Utc.ymd(2012, 9, 17).and_hms(10, 9, 0),
            ),
            (
                "September 17, 2012, 10:10:09",
                Utc.ymd(2012, 9, 17).and_hms(10, 10, 9),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.month_mdy_hms(input).unwrap().unwrap(),
                want,
                "month_mdy_hms/{}",
                input
            )
        }
        assert!(parse.month_mdy_hms("not-date-time").is_none());
    }

    #[test]
    fn month_mdy_hms_z() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "May 02, 2021 15:51:31 UTC",
                Utc.ymd(2021, 5, 2).and_hms(15, 51, 31),
            ),
            (
                "May 02, 2021 15:51 UTC",
                Utc.ymd(2021, 5, 2).and_hms(15, 51, 0),
            ),
            (
                "May 26, 2021, 12:49 AM PDT",
                Utc.ymd(2021, 5, 26).and_hms(7, 49, 0),
            ),
            (
                "September 17, 2012 at 10:09am PST",
                Utc.ymd(2012, 9, 17).and_hms(18, 9, 0),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.month_mdy_hms_z(input).unwrap().unwrap(),
                want,
                "month_mdy_hms_z/{}",
                input
            )
        }
        assert!(parse.month_mdy_hms_z("not-date-time").is_none());
    }

    #[test]
    fn month_mdy() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "May 25, 2021",
                Utc.ymd(2021, 5, 25).and_time(Utc::now().time()),
            ),
            (
                "oct 7, 1970",
                Utc.ymd(1970, 10, 7).and_time(Utc::now().time()),
            ),
            (
                "oct 7, 70",
                Utc.ymd(1970, 10, 7).and_time(Utc::now().time()),
            ),
            (
                "oct. 7, 1970",
                Utc.ymd(1970, 10, 7).and_time(Utc::now().time()),
            ),
            (
                "oct. 7, 70",
                Utc.ymd(1970, 10, 7).and_time(Utc::now().time()),
            ),
            (
                "October 7, 1970",
                Utc.ymd(1970, 10, 7).and_time(Utc::now().time()),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .month_mdy(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "month_mdy/{}",
                input
            )
        }
        assert!(parse.month_mdy("not-date-time").is_none());
    }

    #[test]
    fn month_dmy_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "12 Feb 2006, 19:17",
                Utc.ymd(2006, 2, 12).and_hms(19, 17, 0),
            ),
            ("12 Feb 2006 19:17", Utc.ymd(2006, 2, 12).and_hms(19, 17, 0)),
            (
                "14 May 2019 19:11:40.164",
                Utc.ymd(2019, 5, 14).and_hms_milli(19, 11, 40, 164),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.month_dmy_hms(input).unwrap().unwrap(),
                want,
                "month_dmy_hms/{}",
                input
            )
        }
        assert!(parse.month_dmy_hms("not-date-time").is_none());
    }

    #[test]
    fn month_dmy() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            ("7 oct 70", Utc.ymd(1970, 10, 7).and_time(Utc::now().time())),
            (
                "7 oct 1970",
                Utc.ymd(1970, 10, 7).and_time(Utc::now().time()),
            ),
            (
                "03 February 2013",
                Utc.ymd(2013, 2, 3).and_time(Utc::now().time()),
            ),
            (
                "1 July 2013",
                Utc.ymd(2013, 7, 1).and_time(Utc::now().time()),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .month_dmy(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "month_dmy/{}",
                input
            )
        }
        assert!(parse.month_dmy("not-date-time").is_none());
    }

    #[test]
    fn slash_mdy_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = vec![
            ("4/8/2014 22:05", Utc.ymd(2014, 4, 8).and_hms(22, 5, 0)),
            ("04/08/2014 22:05", Utc.ymd(2014, 4, 8).and_hms(22, 5, 0)),
            ("4/8/14 22:05", Utc.ymd(2014, 4, 8).and_hms(22, 5, 0)),
            ("04/2/2014 03:00:51", Utc.ymd(2014, 4, 2).and_hms(3, 0, 51)),
            ("8/8/1965 12:00:00 AM", Utc.ymd(1965, 8, 8).and_hms(0, 0, 0)),
            (
                "8/8/1965 01:00:01 PM",
                Utc.ymd(1965, 8, 8).and_hms(13, 0, 1),
            ),
            ("8/8/1965 01:00 PM", Utc.ymd(1965, 8, 8).and_hms(13, 0, 0)),
            ("8/8/1965 1:00 PM", Utc.ymd(1965, 8, 8).and_hms(13, 0, 0)),
            ("8/8/1965 12:00 AM", Utc.ymd(1965, 8, 8).and_hms(0, 0, 0)),
            ("4/02/2014 03:00:51", Utc.ymd(2014, 4, 2).and_hms(3, 0, 51)),
            (
                "03/19/2012 10:11:59",
                Utc.ymd(2012, 3, 19).and_hms(10, 11, 59),
            ),
            (
                "03/19/2012 10:11:59.3186369",
                Utc.ymd(2012, 3, 19).and_hms_nano(10, 11, 59, 318636900),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.slash_mdy_hms(input).unwrap().unwrap(),
                want,
                "slash_mdy_hms/{}",
                input
            )
        }
        assert!(parse.slash_mdy_hms("not-date-time").is_none());
    }

    #[test]
    fn slash_mdy() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            (
                "3/31/2014",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()),
            ),
            (
                "03/31/2014",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()),
            ),
            ("08/21/71", Utc.ymd(1971, 8, 21).and_time(Utc::now().time())),
            ("8/1/71", Utc.ymd(1971, 8, 1).and_time(Utc::now().time())),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .slash_mdy(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "slash_mdy/{}",
                input
            )
        }
        assert!(parse.slash_mdy("not-date-time").is_none());
    }

    #[test]
    fn slash_ymd_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            ("2014/4/8 22:05", Utc.ymd(2014, 4, 8).and_hms(22, 5, 0)),
            ("2014/04/08 22:05", Utc.ymd(2014, 4, 8).and_hms(22, 5, 0)),
            ("2014/04/2 03:00:51", Utc.ymd(2014, 4, 2).and_hms(3, 0, 51)),
            ("2014/4/02 03:00:51", Utc.ymd(2014, 4, 2).and_hms(3, 0, 51)),
            (
                "2012/03/19 10:11:59",
                Utc.ymd(2012, 3, 19).and_hms(10, 11, 59),
            ),
            (
                "2012/03/19 10:11:59.3186369",
                Utc.ymd(2012, 3, 19).and_hms_nano(10, 11, 59, 318636900),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.slash_ymd_hms(input).unwrap().unwrap(),
                want,
                "slash_ymd_hms/{}",
                input
            )
        }
        assert!(parse.slash_ymd_hms("not-date-time").is_none());
    }

    #[test]
    fn slash_ymd() {
        let parse = Parse::new(&Utc, Some(Utc::now().time()));

        let test_cases = [
            (
                "2014/3/31",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()),
            ),
            (
                "2014/03/31",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .slash_ymd(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "slash_ymd/{}",
                input
            )
        }
        assert!(parse.slash_ymd("not-date-time").is_none());
    }

    #[test]
    fn dot_mdy_or_ymd() {
        let parse = Parse::new(&Utc, Some(Utc::now().time()));

        let test_cases = [
            // mm.dd.yyyy
            (
                "3.31.2014",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()),
            ),
            (
                "03.31.2014",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()),
            ),
            ("08.21.71", Utc.ymd(1971, 8, 21).and_time(Utc::now().time())),
            // yyyy.mm.dd
            (
                "2014.03.30",
                Utc.ymd(2014, 3, 30).and_time(Utc::now().time()),
            ),
            (
                "2014.03",
                Utc.ymd(2014, 3, Utc::now().day())
                    .and_time(Utc::now().time()),
            ),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .dot_mdy_or_ymd(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "dot_mdy_or_ymd/{}",
                input
            )
        }
        assert!(parse.dot_mdy_or_ymd("not-date-time").is_none());
    }

    #[test]
    fn mysql_log_timestamp() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [
            // yymmdd hh:mm:ss mysql log
            ("171113 14:14:20", Utc.ymd(2017, 11, 13).and_hms(14, 14, 20)),
        ];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.mysql_log_timestamp(input).unwrap().unwrap(),
                want,
                "mysql_log_timestamp/{}",
                input
            )
        }
        assert!(parse.mysql_log_timestamp("not-date-time").is_none());
    }

    #[test]
    fn chinese_ymd_hms() {
        let parse = Parse::new(&Utc, None);

        let test_cases = [(
            "2014年04月08日11时25分18秒",
            Utc.ymd(2014, 4, 8).and_hms(11, 25, 18),
        )];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse.chinese_ymd_hms(input).unwrap().unwrap(),
                want,
                "chinese_ymd_hms/{}",
                input
            )
        }
        assert!(parse.chinese_ymd_hms("not-date-time").is_none());
    }

    #[test]
    fn chinese_ymd() {
        let parse = Parse::new(&Utc, Some(Utc::now().time()));

        let test_cases = [(
            "2014年04月08日",
            Utc.ymd(2014, 4, 8).and_time(Utc::now().time()),
        )];

        for &(input, want) in test_cases.iter() {
            assert_eq!(
                parse
                    .chinese_ymd(input)
                    .unwrap()
                    .unwrap()
                    .trunc_subsecs(0)
                    .with_second(0)
                    .unwrap(),
                want.unwrap().trunc_subsecs(0).with_second(0).unwrap(),
                "chinese_ymd/{}",
                input
            )
        }
        assert!(parse.chinese_ymd("not-date-time").is_none());
    }
}