// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

//! Timezone for timestamp arrays

use arrow_schema::ArrowError;

use chrono::FixedOffset;

pub use private::{Tz, TzOffset};

/// Parses a fixed offset of the form "+09:00", "-09" or "+0930"

fn parse_fixed_offset(tz: &str) -> Option<FixedOffset> {

    let bytes = tz.as_bytes();

    let mut values = match bytes.len() {

        // [+-]XX:XX

        6 if bytes[3] == b':' => [bytes[1], bytes[2], bytes[4], bytes[5]],

        // [+-]XXXX

        5 => [bytes[1], bytes[2], bytes[3], bytes[4]],

        // [+-]XX

        3 => [bytes[1], bytes[2], b'0', b'0'],

        _ => return None,

    };

    values.iter_mut().for_each(|x| *x = x.wrapping_sub(b'0'));

    if values.iter().any(|x| *x > 9) {

        return None;

    }

    let secs =

        (values[0] * 10 + values[1]) as i32 * 60 * 60 + (values[2] * 10 + values[3]) as i32 * 60;

    match bytes[0] {

        b'+' => FixedOffset::east_opt(secs),

        b'-' => FixedOffset::west_opt(secs),

        _ => None,

    }

}

#[cfg(feature = "chrono-tz")]

mod private {

    use super::*;

    use chrono::offset::TimeZone;

    use chrono::{LocalResult, NaiveDate, NaiveDateTime, Offset};

    use std::fmt::Display;

    use std::str::FromStr;

    /// An [`Offset`] for [`Tz`]

    #[derive(Debug, Copy, Clone)]

    pub struct TzOffset {

        tz: Tz,

        offset: FixedOffset,

    }

    impl std::fmt::Display for TzOffset {

        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

            self.offset.fmt(f)

        }

    }

    impl Offset for TzOffset {

        fn fix(&self) -> FixedOffset {

            self.offset

        }

    }

    /// An Arrow [`TimeZone`]

    #[derive(Debug, Copy, Clone)]

    pub struct Tz(TzInner);

    #[derive(Debug, Copy, Clone)]

    enum TzInner {

        Timezone(chrono_tz::Tz),

        Offset(FixedOffset),

    }

    impl FromStr for Tz {

        type Err = ArrowError;

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

            match parse_fixed_offset(tz) {

                Some(offset) => Ok(Self(TzInner::Offset(offset))),

                None => Ok(Self(TzInner::Timezone(tz.parse().map_err(|e| {

                    ArrowError::ParseError(format!("Invalid timezone \"{tz}\": {e}"))

                })?))),

            }

        }

    }

    impl Display for Tz {

        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

            match self.0 {

                TzInner::Timezone(tz) => tz.fmt(f),

                TzInner::Offset(offset) => offset.fmt(f),

            }

        }

    }

    macro_rules! tz {

        ($s:ident, $tz:ident, $b:block) => {

            match $s.0 {

                TzInner::Timezone($tz) => $b,

                TzInner::Offset($tz) => $b,

            }

        };

    }

    impl TimeZone for Tz {

        type Offset = TzOffset;

        fn from_offset(offset: &Self::Offset) -> Self {

            offset.tz

        }

        fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<Self::Offset> {

            tz!(self, tz, {

                tz.offset_from_local_date(local).map(|x| TzOffset {

                    tz: *self,

                    offset: x.fix(),

                })

            })

        }

        fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult<Self::Offset> {

            tz!(self, tz, {

                tz.offset_from_local_datetime(local).map(|x| TzOffset {

                    tz: *self,

                    offset: x.fix(),

                })

            })

        }

        fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset {

            tz!(self, tz, {

                TzOffset {

                    tz: *self,

                    offset: tz.offset_from_utc_date(utc).fix(),

                }

            })

        }

        fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset {

            tz!(self, tz, {

                TzOffset {

                    tz: *self,

                    offset: tz.offset_from_utc_datetime(utc).fix(),

                }

            })

        }

    }

    #[cfg(test)]

    mod tests {

        use super::*;

        use chrono::{Timelike, Utc};

        #[test]

        fn test_with_timezone() {

            let vals = [

                Utc.timestamp_millis_opt(37800000).unwrap(),

                Utc.timestamp_millis_opt(86339000).unwrap(),

            ];

            assert_eq!(10, vals[0].hour());

            assert_eq!(23, vals[1].hour());

            let tz: Tz = "America/Los_Angeles".parse().unwrap();

            assert_eq!(2, vals[0].with_timezone(&tz).hour());

            assert_eq!(15, vals[1].with_timezone(&tz).hour());

        }

        #[test]

        fn test_using_chrono_tz_and_utc_naive_date_time() {

            let sydney_tz = "Australia/Sydney".to_string();

            let tz: Tz = sydney_tz.parse().unwrap();

            let sydney_offset_without_dst = FixedOffset::east_opt(10 * 60 * 60).unwrap();

            let sydney_offset_with_dst = FixedOffset::east_opt(11 * 60 * 60).unwrap();

            // Daylight savings ends

            // When local daylight time was about to reach

            // Sunday, 4 April 2021, 3:00:00 am clocks were turned backward 1 hour to

            // Sunday, 4 April 2021, 2:00:00 am local standard time instead.

            // Daylight savings starts

            // When local standard time was about to reach

            // Sunday, 3 October 2021, 2:00:00 am clocks were turned forward 1 hour to

            // Sunday, 3 October 2021, 3:00:00 am local daylight time instead.

            // Sydney 2021-04-04T02:30:00+11:00 is 2021-04-03T15:30:00Z

            let utc_just_before_sydney_dst_ends = NaiveDate::from_ymd_opt(2021, 4, 3)

                .unwrap()

                .and_hms_nano_opt(15, 30, 0, 0)

                .unwrap();

            assert_eq!(

                tz.offset_from_utc_datetime(&utc_just_before_sydney_dst_ends)

                    .fix(),

                sydney_offset_with_dst

            );

            // Sydney 2021-04-04T02:30:00+10:00 is 2021-04-03T16:30:00Z

            let utc_just_after_sydney_dst_ends = NaiveDate::from_ymd_opt(2021, 4, 3)

                .unwrap()

                .and_hms_nano_opt(16, 30, 0, 0)

                .unwrap();

            assert_eq!(

                tz.offset_from_utc_datetime(&utc_just_after_sydney_dst_ends)

                    .fix(),

                sydney_offset_without_dst

            );

            // Sydney 2021-10-03T01:30:00+10:00 is 2021-10-02T15:30:00Z

            let utc_just_before_sydney_dst_starts = NaiveDate::from_ymd_opt(2021, 10, 2)

                .unwrap()

                .and_hms_nano_opt(15, 30, 0, 0)

                .unwrap();

            assert_eq!(

                tz.offset_from_utc_datetime(&utc_just_before_sydney_dst_starts)

                    .fix(),

                sydney_offset_without_dst

            );

            // Sydney 2021-04-04T03:30:00+11:00 is 2021-10-02T16:30:00Z

            let utc_just_after_sydney_dst_starts = NaiveDate::from_ymd_opt(2022, 10, 2)

                .unwrap()

                .and_hms_nano_opt(16, 30, 0, 0)

                .unwrap();

            assert_eq!(

                tz.offset_from_utc_datetime(&utc_just_after_sydney_dst_starts)

                    .fix(),

                sydney_offset_with_dst

            );

        }

        #[test]

        fn test_timezone_display() {

            let test_cases = ["UTC", "America/Los_Angeles", "-08:00", "+05:30"];

            for &case in &test_cases {

                let tz: Tz = case.parse().unwrap();

                assert_eq!(tz.to_string(), case);

            }

        }

    }

}

#[cfg(not(feature = "chrono-tz"))]

mod private {

    use super::*;

    use chrono::offset::TimeZone;

    use chrono::{LocalResult, NaiveDate, NaiveDateTime, Offset};

    use std::str::FromStr;

    /// An [`Offset`] for [`Tz`]

    #[derive(Debug, Copy, Clone)]

    pub struct TzOffset(FixedOffset);

    impl std::fmt::Display for TzOffset {

        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

            self.0.fmt(f)

        }

    }

    impl Offset for TzOffset {

        fn fix(&self) -> FixedOffset {

            self.0

        }

    }

    /// An Arrow [`TimeZone`]

    #[derive(Debug, Copy, Clone)]

    pub struct Tz(FixedOffset);

    impl FromStr for Tz {

        type Err = ArrowError;

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

            let offset = parse_fixed_offset(tz).ok_or_else(|| {

                ArrowError::ParseError(format!(

                    "Invalid timezone \"{tz}\": only offset based timezones supported without chrono-tz feature"

                ))

            })?;

            Ok(Self(offset))

        }

    }

    impl TimeZone for Tz {

        type Offset = TzOffset;

        fn from_offset(offset: &Self::Offset) -> Self {

            Self(offset.0)

        }

        fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<Self::Offset> {

            self.0.offset_from_local_date(local).map(TzOffset)

        }

        fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult<Self::Offset> {

            self.0.offset_from_local_datetime(local).map(TzOffset)

        }

        fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset {

            TzOffset(self.0.offset_from_utc_date(utc).fix())

        }

        fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset {

            TzOffset(self.0.offset_from_utc_datetime(utc).fix())

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use chrono::{NaiveDate, Offset, TimeZone};

    #[test]

    fn test_with_offset() {

        let t = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();

        let tz: Tz = "-00:00".parse().unwrap();

        assert_eq!(tz.offset_from_utc_date(&t).fix().local_minus_utc(), 0);

        let tz: Tz = "+00:00".parse().unwrap();

        assert_eq!(tz.offset_from_utc_date(&t).fix().local_minus_utc(), 0);

        let tz: Tz = "-10:00".parse().unwrap();

        assert_eq!(

            tz.offset_from_utc_date(&t).fix().local_minus_utc(),

            -10 * 60 * 60

        );

        let tz: Tz = "+09:00".parse().unwrap();

        assert_eq!(

            tz.offset_from_utc_date(&t).fix().local_minus_utc(),

            9 * 60 * 60

        );

        let tz = "+09".parse::<Tz>().unwrap();

        assert_eq!(

            tz.offset_from_utc_date(&t).fix().local_minus_utc(),

            9 * 60 * 60

        );

        let tz = "+0900".parse::<Tz>().unwrap();

        assert_eq!(

            tz.offset_from_utc_date(&t).fix().local_minus_utc(),

            9 * 60 * 60

        );

        let err = "+9:00".parse::<Tz>().unwrap_err().to_string();

        assert!(err.contains("Invalid timezone"), "{}", err);

    }

}