// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/ash/components/report/utils/time_utils.h"

#include "base/test/simple_test_clock.h"
#include "base/time/time.h"
#include "chromeos/ash/components/system/fake_statistics_provider.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/icu/source/i18n/unicode/timezone.h"

namespace ash::report::utils {

TEST(TimeUtilsTest, ConvertGmtToPt) {
  // Test case for converting to PT.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 1, 0, 28, 0, 0, 0}, &ts));

  // Set test clock to fake ts.
  base::SimpleTestClock test_clock;
  test_clock.SetNow(ts);

  base::Time pt_ts = ConvertGmtToPt(&test_clock);

  // Validate that the converted time is 8 hours behind GMT time.
  base::TimeDelta expected_diff = base::Hours(-8);
  EXPECT_EQ(pt_ts - ts, expected_diff);
}

TEST(TimeUtilsTest, ConvertGmtToPtDaylightSavings) {
  // Test case for converting to PT during daylight savings.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 3, 0, 13, 0, 0, 0}, &ts));

  // Set test clock to fake ts.
  base::SimpleTestClock test_clock;
  test_clock.SetNow(ts);

  base::Time pt_ts = ConvertGmtToPt(&test_clock);

  // Validate that the converted time is 7 hours behind GMT time.
  base::TimeDelta expected_diff = base::Hours(-7);
  EXPECT_EQ(pt_ts - ts, expected_diff);
}

TEST(TimeUtilsTest, ConvertGmtToPtUnknownTimeZone) {
  // Test case for converting to PT when the time zone is unknown.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 1, 0, 28, 0, 0, 0}, &ts));

  // Set test clock to fake ts.
  base::SimpleTestClock test_clock;
  test_clock.SetNow(ts);

  // Mock TimeZone::createTimeZone() to return unknown time zone
  icu::TimeZone::adoptDefault(
      icu::TimeZone::createTimeZone(icu::UnicodeString("UnknownTimeZone")));

  base::Time pt_ts = ConvertGmtToPt(&test_clock);

  // Validate that the converted time is 8 hours behind GMT time.
  base::TimeDelta expected_diff = base::Hours(-8);
  EXPECT_EQ(pt_ts - ts, expected_diff);
}

TEST(TimeUtilsTest, GetPreviousMonth) {
  // Test case for getting the previous month.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 5, 0, 28, 0, 0, 0}, &ts));
  base::Time previous_month_ts = GetPreviousMonth(ts).value();

  // Validate that the previous month is April 2023
  base::Time expected_previous_month_ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 4, 0, 1, 0, 0, 0},
                                          &expected_previous_month_ts));
  EXPECT_EQ(previous_month_ts, expected_previous_month_ts);
}

TEST(TimeUtilsTest, GetNextMonth) {
  // Test case for getting the next month.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 5, 0, 28, 0, 0, 0}, &ts));
  base::Time next_month_ts = GetNextMonth(ts).value();

  // Validate that the next month is June 2023
  base::Time expected_next_month_ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 6, 0, 1, 0, 0, 0},
                                          &expected_next_month_ts));
  EXPECT_EQ(next_month_ts, expected_next_month_ts);
}

TEST(TimeUtilsTest, GetPreviousYear) {
  // Test case for getting the previous year.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 5, 0, 28, 0, 0, 0}, &ts));
  base::Time previous_year_ts = GetPreviousYear(ts).value();

  // Validate that the previous year is 2022
  base::Time expected_previous_year_ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2022, 5, 0, 1, 0, 0, 0},
                                          &expected_previous_year_ts));
  EXPECT_EQ(previous_year_ts, expected_previous_year_ts);
}

TEST(TimeUtilsTest, GetPreviousMonthJanuary) {
  // Test case for getting the previous month when the current month is January.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 1, 0, 28, 0, 0, 0}, &ts));
  base::Time previous_month_ts = GetPreviousMonth(ts).value();

  // Validate that the previous month is December 2022
  base::Time expected_previous_month_ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2022, 12, 0, 1, 0, 0, 0},
                                          &expected_previous_month_ts));
  EXPECT_EQ(previous_month_ts, expected_previous_month_ts);
}

TEST(TimeUtilsTest, GetNextMonthDecember) {
  // Test case for getting the next month when the current month is December.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 12, 0, 28, 0, 0, 0}, &ts));
  base::Time next_month_ts = GetNextMonth(ts).value();

  // Validate that the next month is January 2024
  base::Time expected_next_month_ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2024, 1, 0, 1, 0, 0, 0},
                                          &expected_next_month_ts));
  EXPECT_EQ(next_month_ts, expected_next_month_ts);
}

TEST(TimeUtilsTest, GetPreviousYearJanuary) {
  // Test case for getting the previous year when the current year is January.
  base::Time ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 1, 0, 28, 0, 0, 0}, &ts));
  base::Time previous_year_ts = GetPreviousYear(ts).value();

  // Validate that the previous year is 2022
  base::Time expected_previous_year_ts;
  EXPECT_TRUE(base::Time::FromUTCExploded({2022, 1, 0, 1, 0, 0, 0},
                                          &expected_previous_year_ts));
  EXPECT_EQ(previous_year_ts, expected_previous_year_ts);
}

TEST(TimeUtilsTest, IsSameYearAndMonth) {
  // Test case for checking if two timestamps have the same year and month.
  base::Time ts1;
  base::Time ts2;
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 5, 0, 25, 0, 0, 0}, &ts1));
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 5, 0, 10, 0, 0, 0}, &ts2));

  // Validate that ts1 and ts2 have the same year and month
  EXPECT_TRUE(IsSameYearAndMonth(ts1, ts2));

  // Modify ts2 to have a different month
  EXPECT_TRUE(base::Time::FromUTCExploded({2023, 6, 0, 10, 0, 0, 0}, &ts2));
  EXPECT_FALSE(IsSameYearAndMonth(ts1, ts2));

  // Modify ts2 to have a different year
  EXPECT_TRUE(base::Time::FromUTCExploded({2024, 5, 0, 25, 0, 0, 0}, &ts2));
  EXPECT_FALSE(IsSameYearAndMonth(ts1, ts2));
}

TEST(TimeUtilsTest, FormatTimestampToMidnightGMTString) {
  // Test case for formatting a timestamp to midnight GMT string.
  base::Time ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2023, 5, 0, 25, 23, 59, 59, 999}, &ts));
  std::string formatted_ts = FormatTimestampToMidnightGMTString(ts);

  // Validate the formatted string
  std::string expected_formatted_ts = "2023-05-25 00:00:00.000 GMT";
  EXPECT_EQ(formatted_ts, expected_formatted_ts);
}

TEST(TimeUtilsTest, TimeToYYYYMMDDString) {
  // Test case for converting a time to YYYYMMDD string.
  base::Time ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2023, 5, 0, 25, 23, 59, 59, 999}, &ts));
  std::string formatted_ts = TimeToYYYYMMDDString(ts);

  // Validate the formatted string
  std::string expected_formatted_ts = "20230525";
  EXPECT_EQ(formatted_ts, expected_formatted_ts);
}

TEST(TimeUtilsTest, TimeToYYYYMMString) {
  // Test case for converting a time to YYYYMM string.
  base::Time ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2023, 5, 0, 25, 23, 59, 59, 999}, &ts));
  std::string formatted_ts = TimeToYYYYMMString(ts);

  // Validate the formatted string
  std::string expected_formatted_ts = "202305";
  EXPECT_EQ(formatted_ts, expected_formatted_ts);
}

TEST(TimeUtilsTest, GetFirstActiveWeek) {
  system::FakeStatisticsProvider statistics_provider;
  system::StatisticsProvider::SetTestProvider(&statistics_provider);

  // Mocking the StatisticsProvider for testing.
  statistics_provider.SetMachineStatistic(system::kActivateDateKey, "2023-18");

  // Call the method under test
  auto result = GetFirstActiveWeek();
  EXPECT_TRUE(result.has_value());

  // Calculate the expected result for comparison.
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2023, 5, 0, 1, 0, 0, 0, 0}, &expected_ts));

  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, FirstMondayOfISONewYear2000) {
  // Call the method under test.
  std::optional<base::Time> result = FirstMondayOfISONewYear(2000);

  // Calculate the expected result for comparison.
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2000, 1, 0, 3, 0, 0, 0, 0}, &expected_ts));

  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, FirstMondayOfISONewYear2001) {
  // Call the method under test.
  std::optional<base::Time> result = FirstMondayOfISONewYear(2001);

  // Calculate the expected result for comparison.
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2001, 1, 0, 1, 0, 0, 0, 0}, &expected_ts));

  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, FirstMondayOfISONewYear2020) {
  // Call the method under test.
  std::optional<base::Time> result = FirstMondayOfISONewYear(2020);

  // Calculate the expected result for comparison.
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2019, 12, 1, 30, 0, 0, 0, 0}, &expected_ts));

  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, FirstMondayOfISONewYear2025) {
  // Call the method under test.
  std::optional<base::Time> result = FirstMondayOfISONewYear(2025);

  // Calculate the expected result for comparison.
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2024, 12, 1, 30, 0, 0, 0, 0}, &expected_ts));

  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, Iso8601DateWeekAsTime_2023_W18) {
  // Call method under test and calculate the expected result for comparison.
  auto result = Iso8601DateWeekAsTime(2023, 18);
  EXPECT_TRUE(result.has_value());
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2023, 5, 0, 1, 0, 0, 0, 0}, &expected_ts));
  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, Iso8601DateWeekAsTime_2026_W01) {
  // Call method under test and calculate the expected result for comparison.
  auto result = Iso8601DateWeekAsTime(2026, 1);
  EXPECT_TRUE(result.has_value());
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2025, 12, 1, 29, 0, 0, 0, 0}, &expected_ts));
  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, Iso8601DateWeekAsTime_2026_W53) {
  // Call method under test and calculate the expected result for comparison.
  auto result = Iso8601DateWeekAsTime(2026, 53);
  EXPECT_TRUE(result.has_value());
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2026, 12, 1, 28, 0, 0, 0, 0}, &expected_ts));
  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, InvalidIso8601DateWeekAsTime) {
  // Call the method under test
  auto result = Iso8601DateWeekAsTime(0, 0);
  EXPECT_FALSE(result.has_value());

  result = Iso8601DateWeekAsTime(-1, 0);
  EXPECT_FALSE(result.has_value());

  // Week of year is greater than 53.
  result = Iso8601DateWeekAsTime(2023, 54);
  EXPECT_FALSE(result.has_value());
}

TEST(TimeUtilsTest, Iso8601DateWeekAsTimeWeek53) {
  // Call the method under test
  // I.e Year 2020 has 53 weeks instead of 52.
  auto result = Iso8601DateWeekAsTime(2020, 53);
  EXPECT_TRUE(result.has_value());

  // Calculate the expected result for comparison.
  base::Time expected_ts;
  EXPECT_TRUE(
      base::Time::FromUTCExploded({2020, 12, 0, 28, 0, 0, 0, 0}, &expected_ts));

  EXPECT_EQ(result.value(), expected_ts);
}

TEST(TimeUtilsTest, ConvertTimeToISO8601String) {
  // Call the method under test.
  // Cross validated against calculator: https://planetcalc.com/8540/
  struct {
    base::Time::Exploded exploded;
    std::string_view expected_yyyy_mm;
  } kTestCases[] = {
      {{2025, 1, 0, 1, 12, 30, 0, 0}, "2025-01"},
      {{2020, 1, 0, 1, 12, 30, 0, 0}, "2020-01"},
      {{2023, 1, 0, 1, 12, 30, 0, 0}, "2022-52"},
      {{2023, 12, 0, 30, 12, 30, 0, 0}, "2023-52"},
      {{2019, 12, 0, 30, 12, 30, 0, 0}, "2020-01"},
      {{2019, 8, 0, 25, 12, 30, 0, 0}, "2019-34"},
      {{2020, 8, 0, 25, 12, 30, 0, 0}, "2020-35"},
      {{2021, 8, 0, 25, 12, 30, 0, 0}, "2021-34"},
      {{2023, 11, 0, 25, 12, 30, 0, 0}, "2023-47"},
      {{2020, 12, 0, 27, 12, 30, 0, 0}, "2020-52"},
      {{2020, 12, 0, 28, 12, 30, 0, 0}, "2020-53"},
      {{2021, 1, 0, 4, 12, 30, 0, 0}, "2021-01"},
      // Edge Case: Returns 52 weeks, even though previous year has 53 weeks.
      // ISO calendar date to Gregorian calendar calculator outputs 2020-53.
      {{2021, 1, 0, 3, 12, 30, 0, 0}, "2020-52"},
  };

  for (const auto& test_case : kTestCases) {
    SCOPED_TRACE(testing::Message() << "Case: " << test_case.expected_yyyy_mm);
    base::Time test_ts;
    EXPECT_TRUE(base::Time::FromUTCExploded(test_case.exploded, &test_ts));
    EXPECT_EQ(ConvertTimeToISO8601String(test_ts), test_case.expected_yyyy_mm);
  }
}

TEST(TimeUtilsTest, IsFirstActiveUnderFourMonthsAgo) {
  struct {
    base::Time::Exploded active_exploded;
    base::Time::Exploded first_active_exploded;
    bool expected_result;
  } kTestCases[] = {
      // Check when active and first active represent the same time.
      {{2021, 1, 0, 3, 12, 30, 0, 0}, {2021, 1, 0, 3, 12, 30, 0, 0}, true},
      // Check boundary case if first active under four months ago.
      {{2021, 1, 0, 31, 12, 30, 0, 0}, {2020, 10, 0, 1, 12, 30, 0, 0}, true},
      // Check outside four month boundary is false.
      {{2021, 1, 0, 31, 12, 30, 0, 0}, {2020, 9, 0, 1, 12, 30, 0, 0}, false},
  };

  for (const auto& test_case : kTestCases) {
    base::Time active_ts;
    base::Time first_active_ts;
    EXPECT_TRUE(
        base::Time::FromUTCExploded(test_case.active_exploded, &active_ts));
    EXPECT_TRUE(base::Time::FromUTCExploded(test_case.first_active_exploded,
                                            &first_active_ts));

    // 4 Months ago assuming max 31 days per month.
    int max_days_in_4_months = 31 * 4;
    EXPECT_EQ(IsFirstActiveUnderNDaysAgo(active_ts, first_active_ts,
                                         max_days_in_4_months),
              test_case.expected_result);
  }
}

TEST(TimeUtilsTest, IsFirstActiveUnderFiveWeeksAgo) {
  struct {
    base::Time::Exploded active_exploded;
    base::Time::Exploded first_active_exploded;
    bool expected_result;
  } kTestCases[] = {
      // Check when active and first active represent the same time.
      {{2021, 1, 0, 3, 12, 30, 0, 0}, {2021, 1, 0, 3, 12, 30, 0, 0}, true},
      // Check boundary case if first active under 5 weeks ago.
      {{2021, 2, 0, 4, 12, 30, 0, 0}, {2020, 12, 0, 31, 12, 30, 0, 0}, true},
      // Check outside four month boundary is false.
      {{2021, 1, 0, 31, 12, 30, 0, 0}, {2020, 9, 0, 1, 12, 30, 0, 0}, false},
  };

  for (const auto& test_case : kTestCases) {
    base::Time active_ts;
    base::Time first_active_ts;
    EXPECT_TRUE(
        base::Time::FromUTCExploded(test_case.active_exploded, &active_ts));
    EXPECT_TRUE(base::Time::FromUTCExploded(test_case.first_active_exploded,
                                            &first_active_ts));

    int max_days_in_5_weeks = 7 * 5;
    EXPECT_EQ(IsFirstActiveUnderNDaysAgo(active_ts, first_active_ts,
                                         max_days_in_5_weeks),
              test_case.expected_result);
  }
}

}  // namespace ash::report::utils