path: root/src/time.rs

use super::IcalDuration;
use super::IcalTimeZone;
use super::TZ_MUTEX;
use crate::ical;
use crate::utils::dateutil;
use chrono::{Date, DateTime, Local, TimeZone, Utc};
use std::ffi::{CStr, CString};
use std::fmt::{Display, Error, Formatter};
use std::ops::{Add, Deref};
use std::str::FromStr;

/// Time type
///
/// A type representing "time"
#[derive(Clone, Debug)]
pub struct IcalTime {
    time: ical::icaltimetype,
}

impl IcalTime {

    /// Get an IcalTime object that represents UTC now
    pub fn utc() -> Self {
        dateutil::now().into()
    }

    /// Get an IcalTime object that represents the current time in the local timezone.
    pub fn local() -> Self {
        dateutil::now().with_timezone(&Local).into()
    }

    /// Get an IcalTime object that represents a specific day.
    pub fn floating_ymd(year: i32, month: i32, day: i32) -> Self {
        let time = ical::icaltimetype {
            year,
            month,
            day,
            hour: 0,
            minute: 0,
            second: 0,
            is_date: 1,
            is_daylight: 0,
            zone: ::std::ptr::null(),
        };
        let time = unsafe { ical::icaltime_normalize(time) };
        IcalTime { time }
    }

    /// Get an IcalTime object that is the same as the object this function is called on, but with
    /// hour, minute and second set
    pub fn and_hms(&self, hour: i32, minute: i32, second: i32) -> Self {
        let mut time = self.time;
        time.hour = hour;
        time.minute = minute;
        time.second = second;
        time.is_date = 0;

        let time = unsafe { ical::icaltime_normalize(time) };

        IcalTime { time }
    }

    /// Get an IcalTime object based on a timestamp
    pub fn from_timestamp(timestamp: i64) -> Self {
        let _lock = TZ_MUTEX.lock();
        let utc = IcalTimeZone::utc();
        let is_date = 0;
        let time = unsafe { ical::icaltime_from_timet_with_zone(timestamp, is_date, *utc) };
        IcalTime { time }
    }

    /// Get the timestamp representation of the IcalTime object
    pub fn timestamp(&self) -> i64 {
        let _lock = TZ_MUTEX.lock();
        unsafe { ical::icaltime_as_timet_with_zone(self.time, self.time.zone) }
    }

    /// Get whether the IcalTime object is a date object
    pub fn is_date(&self) -> bool {
        self.time.is_date != 0
    }

    /// Get the IcalTime object as a date object
    pub fn as_date(&self) -> IcalTime {
        let mut time = self.time;
        time.is_date = 1;
        IcalTime { time }
    }

    /// Get the timezone for the IcalTime object
    pub fn get_timezone(&self) -> Option<IcalTimeZone> {
        if self.time.zone.is_null() {
            return None;
        }
        let tz_ptr = unsafe { ical::icaltime_get_timezone(self.time) };
        Some(IcalTimeZone::from_ptr_copy(tz_ptr))
    }

    /// Get a new IcalTime object with a different timezone
    pub fn with_timezone(&self, timezone: &IcalTimeZone) -> IcalTime {
        let _lock = TZ_MUTEX.lock();
        let mut time = unsafe { ical::icaltime_convert_to_zone(self.time, **timezone) };
        //icaltime_convert_to_zone does nothing if is_date == 1
        time.zone = **timezone;
        IcalTime { time }
    }

    /// Get a new IcalTime object with the day before the day of the current object
    pub fn pred(&self) -> IcalTime {
        let mut time = self.time;
        time.day -= 1;
        let time = unsafe { ical::icaltime_normalize(time) };
        IcalTime { time }
    }

    /// Get a new IcalTime object with the day after the day of the current object
    pub fn succ(&self) -> IcalTime {
        let mut time = self.time;
        time.day += 1;
        let time = unsafe { ical::icaltime_normalize(time) };
        IcalTime { time }
    }
}

impl Deref for IcalTime {
    type Target = ical::icaltimetype;

    fn deref(&self) -> &ical::icaltimetype {
        &self.time
    }
}

impl Display for IcalTime {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        let cstr = unsafe { CStr::from_ptr(ical::icaltime_as_ical_string(self.time)) };
        let string = cstr.to_string_lossy();
        write!(f, "{}", string)
    }
}

impl FromStr for IcalTime {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        unsafe {
            let c_str = CString::new(s).unwrap();
            let time = ical::icaltime_from_string(c_str.as_ptr());
            if ical::icaltime_is_null_time(time) == 0 {
                Ok(IcalTime { time })
            } else {
                Err(format!("Could not parse time {}", s))
            }
        }
    }
}

impl PartialEq<IcalTime> for IcalTime {
    fn eq(&self, rhs: &IcalTime) -> bool {
        let _lock = TZ_MUTEX.lock();
        let cmp = unsafe { ical::icaltime_compare(self.time, rhs.time) };
        cmp == 0
    }
}

impl Eq for IcalTime {}

impl From<ical::icaltimetype> for IcalTime {
    fn from(time: ical::icaltimetype) -> IcalTime {
        IcalTime { time }
    }
}

impl Add<IcalDuration> for IcalTime {
    type Output = IcalTime;

    fn add(self, other: IcalDuration) -> IcalTime {
        let time = unsafe { ical::icaltime_add(self.time, *other) };
        IcalTime { time }
    }
}

impl From<DateTime<Local>> for IcalTime {
    fn from(time: DateTime<Local>) -> IcalTime {
        let timestamp = time.timestamp();
        let local = IcalTimeZone::local();
        IcalTime::from_timestamp(timestamp).with_timezone(&local)
    }
}

impl From<DateTime<Utc>> for IcalTime {
    fn from(time: DateTime<Utc>) -> IcalTime {
        let timestamp = time.timestamp();
        IcalTime::from_timestamp(timestamp)
    }
}

impl From<Date<Local>> for IcalTime {
    fn from(date: Date<Local>) -> IcalTime {
        let timestamp = date.with_timezone(&Utc).and_hms(0, 0, 0).timestamp();
        let timezone = IcalTimeZone::local();
        IcalTime::from_timestamp(timestamp)
            .with_timezone(&timezone)
            .as_date()
    }
}

impl From<Date<Utc>> for IcalTime {
    fn from(date: Date<Utc>) -> IcalTime {
        let timestamp = date.and_hms(0, 0, 0).timestamp();
        IcalTime::from_timestamp(timestamp).as_date()
    }
}

impl From<IcalTime> for Date<Local> {
    fn from(time: IcalTime) -> Date<Local> {
        Local.timestamp(time.timestamp(), 0).date()
    }
}

impl From<IcalTime> for DateTime<Local> {
    fn from(time: IcalTime) -> DateTime<Local> {
        Local.timestamp(time.timestamp(), 0)
    }
}

impl From<IcalTime> for Date<Utc> {
    fn from(time: IcalTime) -> Date<Utc> {
        Utc.timestamp(time.timestamp(), 0).date()
    }
}

impl From<IcalTime> for DateTime<Utc> {
    fn from