use recurring_event::{DailyEvent, MonthlyEvent, Ordinal, Recurrent, Periodicity, MonthlyWeekdayOrdinal, WeeklyEvent, YearlyEvent, error::Error, time::{Month, Weekday, macros::datetime}};

/*
Daily
*/

#[test]
fn daily_current_date_get() {
    let expected = datetime!(2022-08-12 00:00 UTC);
    let event = DailyEvent::new(expected);
    let actual = event.current_date();
    assert_eq!(expected, *actual, "actual: {}", *actual);
}

#[test]
fn daily_frequency_get() {
    let expected = 1;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = DailyEvent::new(date);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

#[test]
fn daily_frequency_update() {
    let expected = 7;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = DailyEvent::new(date);
    event.update_frequency(7);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

#[test]
fn daily_periodicity_get() {
    let expected = Periodicity::Daily;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = DailyEvent::new(date);
    let actual = event.periodicity();
    assert_eq!(expected, *actual, "actual: {:?}", *actual);
}

/*
Weekly
*/

#[test]
fn weekly_current_date_get() {
    let expected = datetime!(2022-08-12 00:00 UTC);
    let event = WeeklyEvent::new(expected);
    let actual = event.current_date();
    assert_eq!(expected, *actual, "actual: {}", *actual);
}

#[test]
fn weekly_frequency_get() {
    let expected = 1;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = WeeklyEvent::new(date);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

#[test]
fn weekly_frequency_update() {
    let expected = 7;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = WeeklyEvent::new(date);
    event.update_frequency(7);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

// Weekly week day

#[test]
fn weekly_weekdays_get() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = WeeklyEvent::new(date);
    let actual = event.weekdays().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn weekly_weekdays_insert() {
    let expected = Some(&Weekday::Tuesday);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = WeeklyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday);
    let actual = event.weekdays().find(|&&weekday| weekday == Weekday::Tuesday);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn weekly_weekdays_insert_twice() {
    let expected = Some(&Weekday::Tuesday);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = WeeklyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday);
    event.insert_weekday(Weekday::Tuesday);
    let actual = event.weekdays().find(|&&weekday| weekday == Weekday::Tuesday);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn weekly_weekdays_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = WeeklyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday);
    event.remove_weekday(&Weekday::Tuesday);
    let actual = event.weekdays().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn weekly_remove_weekdays_remove_without_insert() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = WeeklyEvent::new(date);
    event.remove_weekday(&Weekday::Tuesday);
    let actual = event.weekdays().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

/*
Monthly
*/

#[test]
fn monthly_current_date_get() {
    let expected = datetime!(2022-08-12 00:00 UTC);
    let event = MonthlyEvent::new(expected);
    let actual = event.current_date();
    assert_eq!(expected, *actual, "actual: {}", *actual);
}

#[test]
fn monthly_frequency_get() {
    let expected = 1;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = MonthlyEvent::new(date);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

#[test]
fn monthly_frequency_update() {
    let expected = 7;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.update_frequency(7);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

// Monthly monthly day ordinal

#[test]
fn monthly_monthly_days_ordinals_get() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = MonthlyEvent::new(date);
    let actual = event.monthly_days_ordinals().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_days_ordinals_insert() {
    let expected = Some(&7);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_monthly_day_ordinal(7);
    let actual = event.monthly_days_ordinals().find(|&&monthly_day_ordinal| monthly_day_ordinal == 7);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_days_ordinals_insert_twice() {
    let expected = Some(&7);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_monthly_day_ordinal(7);
    event.insert_monthly_day_ordinal(7);
    let actual = event.monthly_days_ordinals().find(|&&monthly_day_ordinal| monthly_day_ordinal == 7);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_days_ordinals_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_monthly_day_ordinal(7);
    event.remove_monthly_day_ordinal(&7);
    let actual = event.monthly_days_ordinals().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_remove_monthly_days_ordinals_without_insert() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.remove_monthly_day_ordinal(&7);
    let actual = event.monthly_days_ordinals().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

// Monthly monthly week day ordinal

#[test]
fn monthly_monthly_weekdays_ordinals_get() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = MonthlyEvent::new(date);
    let actual = event.monthly_weekdays_ordinals().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_weekdays_ordinals_insert() {
    let value = MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday);
    let expected = Some(&value);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    let actual = event.monthly_weekdays_ordinals().find(|&&monthly_day_ordinal| monthly_day_ordinal == MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_weekdays_ordinals_insert_twice() {
    let value = MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday);
    let expected = Some(&value);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    let actual = event.monthly_weekdays_ordinals().find(|&&monthly_weekday_ordinal| monthly_weekday_ordinal == MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_weekdays_ordinals_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    event.remove_monthly_weekday_ordinal(&MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    let actual = event.monthly_weekdays_ordinals().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_monthly_weekdays_ordinals_remove_without_insert() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.remove_monthly_weekday_ordinal(&MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    let actual = event.monthly_weekdays_ordinals().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_periodicity_get() {
    let expected = Periodicity::Monthly;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = MonthlyEvent::new(date);
    let actual = event.periodicity();
    assert_eq!(expected, *actual, "actual: {:?}", *actual);
}

// Monthly week day

#[test]
fn monthly_weekdays_get() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = MonthlyEvent::new(date);
    let actual = event.weekdays().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_weekdays_insert() {
    let expected = Some(&Weekday::Tuesday);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday);
    let actual = event.weekdays().find(|&&weekday| weekday == Weekday::Tuesday);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_weekdays_insert_twice() {
    let expected = Some(&Weekday::Tuesday);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday);
    event.insert_weekday(Weekday::Tuesday);
    let actual = event.weekdays().find(|&&weekday| weekday == Weekday::Tuesday);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_weekdays_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday);
    event.remove_weekday(&Weekday::Tuesday);
    let actual = event.weekdays().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn monthly_weekdays_remove_without_insert() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = MonthlyEvent::new(date);
    event.remove_weekday(&Weekday::Tuesday);
    let actual = event.weekdays().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

/*
Yearly
*/

#[test]
fn yearly_current_date_get() {
    let expected = datetime!(2022-08-12 00:00 UTC);
    let event = YearlyEvent::new(expected);
    let actual = event.current_date();
    assert_eq!(expected, *actual, "actual: {}", *actual);
}

#[test]
fn yearly_frequency_get() {
    let expected = 1;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = YearlyEvent::new(date);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

#[test]
fn yearly_frequency_update() {
    let expected = 7;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.update_frequency(7);
    let actual = event.frequency();
    assert_eq!(expected, actual, "actual: {}", actual);
}

// Yearly monthly day ordinal

#[test]
fn yearly_monthly_days_ordinals_get_unexistent_month() {
    let expected = Error::NotFound;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = YearlyEvent::new(date);
    let actual = event.monthly_days_ordinals(Month::July).unwrap_err();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_days_ordinals_insert() {
    let expected = Some(&7);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_monthly_day_ordinal(7, Month::July);
    event.insert_monthly_day_ordinal(8, Month::December);
    let actual = event.monthly_days_ordinals(Month::July).unwrap().find(|&&monthly_day_ordinal| monthly_day_ordinal == 7);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_days_ordinals_insert_twice() {
    let expected = Some(&7);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_monthly_day_ordinal(7, Month::July);
    event.insert_monthly_day_ordinal(7, Month::July);
    let actual = event.monthly_days_ordinals(Month::July).unwrap().find(|&&monthly_day_ordinal| monthly_day_ordinal == 7);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_days_ordinals_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_monthly_day_ordinal(7, Month::July);
    event.remove_monthly_day_ordinal(&7, Month::July);
    let actual = event.monthly_days_ordinals(Month::July).unwrap().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_days_ordinals_remove_without_insert() {
    let expected = false;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    let actual = event.remove_monthly_day_ordinal(&7, Month::July);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

// Yearly monthly week day ordinal

#[test]
fn yearly_monthly_weekdays_ordinals_get_unexistent_month() {
    let expected = Error::NotFound;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = YearlyEvent::new(date);
    let actual = event.monthly_weekdays_ordinals(Month::July).unwrap_err();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_weekdays_ordinals_insert() {
    let value = MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday);
    let expected = Some(&value);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday), Month::July);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::First, Weekday::Monday), Month::December);
    let actual = event.monthly_weekdays_ordinals(Month::July).unwrap().find(|&&monthly_weekday_ordinal| monthly_weekday_ordinal == MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_weekdays_ordinals_insert_twice() {
    let value = MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday);
    let expected = Some(&value);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday), Month::July);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday), Month::July);
    let actual = event.monthly_weekdays_ordinals(Month::July).unwrap().find(|&&monthly_weekday_ordinal| monthly_weekday_ordinal == MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday));
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_weekdays_ordinals_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_monthly_weekday_ordinal(MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday), Month::July);
    event.remove_monthly_weekday_ordinal(&MonthlyWeekdayOrdinal::new(Ordinal::Fifth, Weekday::Sunday), Month::July);
    let actual = event.monthly_weekdays_ordinals(Month::July).unwrap().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_monthly_weekdays_ordinals_remove_without_insert() {
    let expected = false;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    let actual = event.remove_monthly_weekday_ordinal(&MonthlyWeekdayOrdinal::new(Ordinal::Fourth, Weekday::Thursday), Month::February);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_periodicity_get() {
    let expected = Periodicity::Yearly;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = YearlyEvent::new(date);
    let actual = event.periodicity();
    assert_eq!(expected, *actual, "actual: {:?}", *actual);
}

// Yearly week days

#[test]
fn yearly_weekdays_get_unexistent_month() {
    let expected = Error::NotFound;
    let date = datetime!(2022-08-12 00:00 UTC);
    let event = YearlyEvent::new(date);
    let actual = event.weekdays(Month::July).unwrap_err();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_weekdays_insert() {
    let expected = Some(&Weekday::Tuesday);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday, Month::July);
    event.insert_weekday(Weekday::Sunday, Month::December);
    let actual = event.weekdays(Month::July).unwrap().find(|&&weekday| weekday == Weekday::Tuesday);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_weekdays_insert_twice() {
    let expected = Some(&Weekday::Tuesday);
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday, Month::July);
    event.insert_weekday(Weekday::Tuesday, Month::July);
    let actual = event.weekdays(Month::July).unwrap().find(|&&weekday| weekday == Weekday::Tuesday);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_weekdays_remove() {
    let expected = 0;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    event.insert_weekday(Weekday::Tuesday, Month::July);
    event.remove_weekday(&Weekday::Tuesday, Month::July);
    let actual = event.weekdays(Month::July).unwrap().count();
    assert_eq!(expected, actual, "actual: {:?}", actual);
}

#[test]
fn yearly_weekdays_remove_without_insert() {
    let expected = false;
    let date = datetime!(2022-08-12 00:00 UTC);
    let mut event = YearlyEvent::new(date);
    let actual = event.remove_weekday(&Weekday::Thursday, Month::July);
    assert_eq!(expected, actual, "actual: {:?}", actual);
}