// 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 <memory>
#include <string_view>

#include "base/i18n/time_formatting.h"
#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_number_conversions.h"
#include "base/time/clock.h"
#include "base/time/time.h"
#include "chromeos/ash/components/policy/weekly_time/time_utils.h"
#include "chromeos/ash/components/system/statistics_provider.h"
#include "third_party/icu/source/i18n/unicode/timezone.h"

namespace ash::report::utils {

namespace {

// Record histogram for whether ActivateDate is read and parsed correctly.
void RecordIsActivateDateSet(bool is_set) {
  base::UmaHistogramBoolean("Ash.Report.IsActivateDateSet", is_set);
}

}  // namespace

base::Time ConvertGmtToPt(base::Clock* clock) {
  base::Time gmt_ts = clock->Now();
  DCHECK(gmt_ts != base::Time::UnixEpoch() && gmt_ts != base::Time())
      << "Invalid timestamp ts  = " << gmt_ts;

  int pt_offset;
  bool offset_success = policy::weekly_time_utils::GetOffsetFromTimezoneToGmt(
      "America/Los_Angeles", clock, &pt_offset);

  if (!offset_success) {
    LOG(ERROR) << "Failed to get offset for Pacific Time. "
               << "Returning UTC-8 timezone as default.";
    return gmt_ts - base::Hours(8);
  }

  return gmt_ts - base::Milliseconds(pt_offset);
}

std::optional<base::Time> GetPreviousMonth(base::Time ts) {
  if (ts == base::Time()) {
    LOG(ERROR) << "Timestamp not set = " << ts;
    return std::nullopt;
  }

  base::Time::Exploded exploded;
  ts.UTCExplode(&exploded);

  // Set new time to the first midnight of the previous month.
  // "+ 11) % 12) + 1" wraps the month around if it goes outside 1..12.
  exploded.month = (((exploded.month - 1) + 11) % 12) + 1;
  exploded.year -= (exploded.month == 12);
  exploded.day_of_month = 1;
  exploded.hour = exploded.minute = exploded.second = exploded.millisecond = 0;

  base::Time new_month_ts;
  bool success = base::Time::FromUTCExploded(exploded, &new_month_ts);

  if (!success) {
    LOG(ERROR) << "Failed to get previous month of ts = " << ts;
    return std::nullopt;
  }

  return new_month_ts;
}

std::optional<base::Time> GetNextMonth(base::Time ts) {
  if (ts == base::Time()) {
    LOG(ERROR) << "Timestamp not set = " << ts;
    return std::nullopt;
  }

  base::Time::Exploded exploded;
  ts.UTCExplode(&exploded);

  // Set new time to the first midnight of the next month.
  // "+ 11) % 12) + 1" wraps the month around if it goes outside 1..12.
  exploded.month = (((exploded.month + 1) + 11) % 12) + 1;
  exploded.year += (exploded.month == 1);
  exploded.day_of_month = 1;
  exploded.hour = exploded.minute = exploded.second = exploded.millisecond = 0;

  base::Time new_month_ts;
  bool success = base::Time::FromUTCExploded(exploded, &new_month_ts);

  if (!success) {
    LOG(ERROR) << "Failed to get next month of ts = " << ts;
    return std::nullopt;
  }

  return new_month_ts;
}

std::optional<base::Time> GetPreviousYear(base::Time ts) {
  if (ts == base::Time()) {
    LOG(ERROR) << "Timestamp not set = " << ts;
    return std::nullopt;
  }

  base::Time::Exploded exploded;
  ts.UTCExplode(&exploded);

  // Set new time to the first midnight of the previous year.
  exploded.year -= 1;
  exploded.day_of_month = 1;
  exploded.hour = 0;
  exploded.minute = 0;
  exploded.second = 0;
  exploded.millisecond = 0;

  base::Time new_year_ts;
  bool success = base::Time::FromUTCExploded(exploded, &new_year_ts);

  if (!success) {
    LOG(ERROR) << "Failed to get previous year of ts = " << ts;
    return std::nullopt;
  }

  return new_year_ts;
}

bool IsSameYearAndMonth(base::Time ts1, base::Time ts2) {
  base::Time::Exploded ts1_exploded;
  ts1.UTCExplode(&ts1_exploded);
  base::Time::Exploded ts2_exploded;
  ts2.UTCExplode(&ts2_exploded);
  return (ts1_exploded.year == ts2_exploded.year) &&
         (ts1_exploded.month == ts2_exploded.month);
}

bool IsFirstActiveUnderNDaysAgo(base::Time active_ts,
                                base::Time first_active_week,
                                int num_days) {
  // Checks for the starting point which is num of days before active_ts.
  base::Time starting_point = active_ts - base::Days(num_days);

  // Check if first_active_week is after the starting point
  return first_active_week >= starting_point;
}

std::string FormatTimestampToMidnightGMTString(base::Time ts) {
  return base::UnlocalizedTimeFormatWithPattern(ts, "yyyy-MM-dd 00:00:00.000 z",
                                                icu::TimeZone::getGMT());
}

std::string TimeToYYYYMMDDString(base::Time ts) {
  return base::UnlocalizedTimeFormatWithPattern(ts, "yyyyMMdd",
                                                icu::TimeZone::getGMT());
}

std::string TimeToYYYYMMString(base::Time ts) {
  return base::UnlocalizedTimeFormatWithPattern(ts, "yyyyMM",
                                                icu::TimeZone::getGMT());
}

std::optional<base::Time> GetFirstActiveWeek() {
  std::optional<std::string_view> first_active_week_val =
      system::StatisticsProvider::GetInstance()->GetMachineStatistic(
          system::kActivateDateKey);
  std::string first_active_week_str =
      std::string(first_active_week_val.value_or(kActivateDateKeyNotFound));

  if (first_active_week_str == kActivateDateKeyNotFound) {
    LOG(ERROR)
        << "Failed to retrieve ActivateDate VPD field from machine statistics. "
        << "Leaving |first_active_week_| unset.";
    RecordIsActivateDateSet(false);
    return std::nullopt;
  }

  // Activate date is formatted: "YYYY-WW"
  int delimiter_index = first_active_week_str.find('-');

  const int expected_first_active_week_size = 7;
  const int expected_delimiter_index = 4;
  if (first_active_week_str.size() != expected_first_active_week_size ||
      delimiter_index != expected_delimiter_index) {
    LOG(ERROR) << "ActivateDate was retrieved but is not formatted as YYYY-WW. "
               << "Received string : " << first_active_week_str;
    RecordIsActivateDateSet(false);
    return std::nullopt;
  }

  const int expected_year_size = 4;
  const int expected_weeks_size = 2;

  std::string parsed_year = first_active_week_str.substr(0, expected_year_size);
  std::string parsed_weeks = first_active_week_str.substr(
      expected_delimiter_index + 1, expected_weeks_size);

  if (parsed_year.empty() || parsed_weeks.empty()) {
    LOG(ERROR) << "Failed to parse and convert the first active weeks string "
               << "year and weeks.";
    RecordIsActivateDateSet(false);
    return std::nullopt;
  }

  // Convert parsed year and weeks to int.
  int activate_year, activate_week_of_year;
  bool success_year = base::StringToInt(parsed_year, &activate_year);
  bool success_week = base::StringToInt(parsed_weeks, &activate_week_of_year);

  if (!success_year || !success_week) {
    LOG(ERROR) << "Failed to convert parsed_year or parsed_weeks: "
               << parsed_year << " and " << parsed_weeks;
    RecordIsActivateDateSet(false);
    return std::nullopt;
  }

  auto iso8601_ts =
      utils::Iso8601DateWeekAsTime(activate_year, activate_week_of_year);
  if (!iso8601_ts.has_value()) {
    LOG(ERROR) << "Failed to ISO8601 year and week of year as a timestamp.";
    RecordIsActivateDateSet(false);
    return std::nullopt;
  }

  RecordIsActivateDateSet(true);
  return iso8601_ts.value();
}

std::optional<base::Time> FirstMondayOfISONewYear(int iso_year) {
  // 1. Get week of first Thursday in iso_year.
  // 2. Subtract days to get the first Monday.
  // ISO calendar new year may start 1-3 days before the
  // Gregorian new year or 1-3 days later.

  // Get week of the first Thursday in ISO year.
  base::Time first_thursday_ts;
  base::Time::Exploded first_thursday_exploded = {iso_year, 1, 0, 1,
                                                  0,        0, 0, 0};
  bool success =
      base::Time::FromUTCExploded(first_thursday_exploded, &first_thursday_ts);

  if (!success) {
    LOG(ERROR) << "Failed to explode first day of iso Year = " << iso_year;
    return std::nullopt;
  }

  // Re-create exploded object from first thursday timestamp.
  // This allows us to get an accurate day of week, so that we can
  // determine the first Thursday in iso_year.
  first_thursday_ts.UTCExplode(&first_thursday_exploded);

  // Adjust number of days to get to the first Thursday of year.
  while (first_thursday_exploded.day_of_week != kThursdayDayOfWeekIndex) {
    first_thursday_ts += base::Days(1);

    // Recalculate exploded object.
    first_thursday_ts.UTCExplode(&first_thursday_exploded);
  }

  base::Time first_monday_ts =
      first_thursday_ts -
      base::Days(kThursdayDayOfWeekIndex - kMondayDayOfWeekIndex);

  return first_monday_ts;
}

// The ActivateDate is formatted: YYYY-WW and is generated based on UTC date.
// Returns the first day of the ISO8601 week.
std::optional<base::Time> Iso8601DateWeekAsTime(int activate_year,
                                                int activate_week_of_year) {
  if (activate_year < 0 || activate_week_of_year <= 0 ||
      activate_week_of_year > 53) {
    LOG(ERROR) << "Invalid year or week of year"
               << ". Variable activate_year = " << activate_year
               << ". Variable activate_week_of_year = "
               << activate_week_of_year;
    return std::nullopt;
  }

  std::optional<base::Time> first_monday_iso_year =
      FirstMondayOfISONewYear(activate_year);

  if (!first_monday_iso_year.has_value()) {
    return std::nullopt;
  }

  // Get the number of days to the start of a ISO 8601 week standard period
  // for that year from the years first monday. This is equal to
  // (activate_week_of_year-1) * 7 days.
  int days_in_iso_period = 0;
  days_in_iso_period = (activate_week_of_year - 1) * 7;

  // Add the above two steps to get the start of a ISO 8601 week time.
  return first_monday_iso_year.value() + base::Days(days_in_iso_period);
}

std::string ConvertTimeToISO8601String(base::Time ts) {
  if (ts.is_null()) {
    LOG(ERROR) << "Timestamp ts is not defined correctly. ts = " << ts;
    return std::string();
  }

  // Calculate the year of the given time
  base::Time::Exploded exploded;
  ts.UTCExplode(&exploded);
  int activate_year = exploded.year;

  std::optional<base::Time> first_monday_iso_year =
      FirstMondayOfISONewYear(activate_year);

  if (!first_monday_iso_year.has_value()) {
    return std::string();
  }

  // Assign to the last ISO week of previous year. We use W52 for simplicity.
  // Some years have 53 weeks, but we simply use 52 to avoid complexity here.
  // This captures ts for up to the 3 days after the new year that are apart of
  // the previous year last ISO week.
  if (ts < first_monday_iso_year.value()) {
    return base::NumberToString(activate_year - 1) + "-52";
  }

  std::optional<base::Time> first_monday_iso_year_next =
      FirstMondayOfISONewYear(activate_year + 1);

  if (!first_monday_iso_year_next.has_value()) {
    return std::string();
  }

  // Assign to first ISO week of next year.
  // This captures ts for up to the 3 days before the new year that are apart of
  // the current year first ISO week.
  if (ts >= first_monday_iso_year_next.value()) {
    return base::NumberToString(activate_year + 1) + "-01";
  }

  // Calculate the number of days between the given time and the first
  // Monday of the year
  base::TimeDelta delta = ts - first_monday_iso_year.value();
  int days_difference = delta.InDays();

  // Calculate the ISO 8601 week number
  int activate_week_of_year = days_difference / 7 + 1;

  return base::NumberToString(activate_year) + "-" +
         (activate_week_of_year < 10 ? "0" : "") +
         base::NumberToString(activate_week_of_year);
}

}  // namespace ash::report::utils