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

#include "ash/system/time/calendar_utils.h"

#include <optional>
#include <string>

#include "ash/calendar/calendar_client.h"
#include "ash/calendar/calendar_controller.h"
#include "ash/constants/ash_features.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/style/ash_color_provider.h"
#include "ash/style/color_util.h"
#include "ash/system/time/date_helper.h"
#include "base/i18n/time_formatting.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "components/user_manager/user_type.h"
#include "ui/views/layout/table_layout.h"

namespace ash::calendar_utils {

bool IsMultiCalendarEnabled() {
  return features::IsMultiCalendarSupportEnabled();
}

bool IsToday(const base::Time selected_date) {
  return IsTheSameDay(selected_date, base::Time::Now());
}

bool IsTheSameDay(std::optional<base::Time> date_a,
                  std::optional<base::Time> date_b) {
  if (!date_a.has_value() || !date_b.has_value()) {
    return false;
  }

  return calendar_utils::GetMonthDayYear(date_a.value()) ==
         calendar_utils::GetMonthDayYear(date_b.value());
}

ASH_EXPORT std::set<base::Time> GetSurroundingMonthsUTC(
    const base::Time& selected_date,
    int num_months_out) {
  std::set<base::Time> months;

  // First month is the one that contains |selected_date|.
  base::Time selected_date_start =
      calendar_utils::GetStartOfMonthUTC(selected_date);
  months.emplace(selected_date_start);

  // Add |num_months_out| before and after.
  base::Time current_forward = selected_date_start;
  base::Time current_backward = selected_date_start;
  for (int i = 0; i < num_months_out; ++i) {
    current_forward = calendar_utils::GetStartOfNextMonthUTC(current_forward);
    months.emplace(current_forward);
    current_backward =
        calendar_utils::GetStartOfPreviousMonthUTC(current_backward);
    months.emplace(current_backward);
  }

  return months;
}

base::Time::Exploded GetExplodedUTC(const base::Time& date) {
  base::Time::Exploded exploded;
  date.UTCExplode(&exploded);
  return exploded;
}

std::u16string FormatDate(const icu::SimpleDateFormat& formatter,
                          const base::Time date) {
  return DateHelper::GetInstance()->GetFormattedTime(&formatter, date);
}

std::u16string FormatInterval(const icu::DateIntervalFormat* formatter,
                              const base::Time& start_time,
                              const base::Time& end_time) {
  return DateHelper::GetInstance()->GetFormattedInterval(formatter, start_time,
                                                         end_time);
}

std::u16string GetMonthDayYear(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->month_day_year_formatter(), date);
}

std::u16string GetMonthDayYearWeek(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->month_day_year_week_formatter(), date);
}

std::u16string GetMonthName(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->month_name_formatter(), date);
}

std::u16string GetDayOfMonth(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->day_of_month_formatter(), date);
}

std::u16string GetDayIntOfMonth(const base::Time local_date) {
  return base::UTF8ToUTF16(base::NumberToString(
      calendar_utils::GetExplodedUTC(local_date).day_of_month));
}

std::u16string GetMonthNameAndDayOfMonth(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->month_day_formatter(), date);
}

std::u16string GetTwelveHourClockTime(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->twelve_hour_clock_formatter(), date);
}

std::u16string GetTwentyFourHourClockTime(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->twenty_four_hour_clock_formatter(), date);
}

std::u16string GetTimeZone(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->time_zone_formatter(), date);
}

std::u16string GetDayOfWeek(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->day_of_week_formatter(), date);
}

std::u16string GetYear(const base::Time date) {
  return calendar_utils::FormatDate(DateHelper::GetInstance()->year_formatter(),
                                    date);
}

std::u16string GetMonthNameAndYear(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->month_name_year_formatter(), date);
}

std::u16string GetTwelveHourClockHours(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->twelve_hour_clock_hours_formatter(), date);
}

std::u16string GetTwentyFourHourClockHours(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->twenty_four_hour_clock_hours_formatter(),
      date);
}

std::u16string GetMinutes(const base::Time date) {
  return calendar_utils::FormatDate(
      DateHelper::GetInstance()->minutes_formatter(), date);
}

std::u16string FormatTwelveHourClockTimeInterval(const base::Time& start_time,
                                                 const base::Time& end_time) {
  return calendar_utils::FormatInterval(
      DateHelper::GetInstance()->twelve_hour_clock_interval_formatter(),
      start_time, end_time);
}

std::u16string FormatTwentyFourHourClockTimeInterval(
    const base::Time& start_time,
    const base::Time& end_time) {
  return calendar_utils::FormatInterval(
      DateHelper::GetInstance()->twenty_four_hour_clock_interval_formatter(),
      start_time, end_time);
}

void SetUpWeekColumns(views::TableLayout* layout) {
  for (int i = 0; i < calendar_utils::kDateInOneWeek; ++i) {
    layout->AddColumn(views::LayoutAlignment::kStretch,
                      views::LayoutAlignment::kStretch, 1.0f,
                      views::TableLayout::ColumnSize::kFixed, 0, 0);
  }
}

int GetMonthsBetween(const base::Time& start_date, const base::Time& end_date) {
  base::Time::Exploded start_exp = calendar_utils::GetExplodedUTC(start_date);
  base::Time::Exploded end_exp = calendar_utils::GetExplodedUTC(end_date);
  return (end_exp.year - start_exp.year) * 12 +
         (end_exp.month - start_exp.month) % 12;
}

base::Time GetMaxTime(const base::Time d1, const base::Time d2) {
  return (d1 > d2) ? d1 : d2;
}

base::Time GetMinTime(const base::Time d1, const base::Time d2) {
  return (d1 < d2) ? d1 : d2;
}

SkColor GetPrimaryTextColor() {
  const ash::AshColorProvider* color_provider = ash::AshColorProvider::Get();
  return color_provider->GetContentLayerColor(
      AshColorProvider::ContentLayerType::kTextColorPrimary);
}

SkColor GetSecondaryTextColor() {
  const ash::AshColorProvider* color_provider = ash::AshColorProvider::Get();
  return color_provider->GetContentLayerColor(
      AshColorProvider::ContentLayerType::kTextColorSecondary);
}

SkColor GetDisabledTextColor() {
  const ash::AshColorProvider* color_provider = ash::AshColorProvider::Get();
  const SkColor primary_color = color_provider->GetContentLayerColor(
      AshColorProvider::ContentLayerType::kTextColorPrimary);
  return ColorUtil::GetDisabledColor(primary_color);
}

base::Time GetFirstDayOfMonth(const base::Time& date) {
  return date -
         base::Days(calendar_utils::GetExplodedUTC(date).day_of_month - 1);
}

base::Time GetStartOfPreviousMonthLocal(base::Time date) {
  return GetFirstDayOfMonth(GetFirstDayOfMonth(date) - base::Days(1));
}

base::Time GetStartOfNextMonthLocal(base::Time date) {
  // Adds over 31 days to make sure it goes to the next month.
  return GetFirstDayOfMonth(GetFirstDayOfMonth(date) + base::Days(33));
}

ASH_EXPORT base::Time GetStartOfMonthUTC(const base::Time& date) {
  return (date -
          base::Days(calendar_utils::GetExplodedUTC(date).day_of_month - 1))
      .UTCMidnight();
}

base::Time GetNextDayMidnight(base::Time date) {
  return (date.UTCMidnight() + base::Days(1) + kDurationForAdjustingDST)
      .UTCMidnight();
}

ASH_EXPORT base::Time GetStartOfPreviousMonthUTC(base::Time date) {
  return GetStartOfMonthUTC(GetStartOfMonthUTC(date) - base::Days(1));
}

ASH_EXPORT base::Time GetStartOfNextMonthUTC(base::Time date) {
  // Adds over 31 days to make sure it goes to the next month.
  return GetStartOfMonthUTC(GetStartOfMonthUTC(date) + base::Days(33));
}

ASH_EXPORT bool ShouldFetchCalendarData() {
  return IsActiveUser() && !IsDisabledByAdmin();
}

ASH_EXPORT bool IsActiveUser() {
  std::optional<user_manager::UserType> user_type =
      Shell::Get()->session_controller()->GetUserType();
  return (user_type && (*user_type == user_manager::UserType::kRegular ||
                        *user_type == user_manager::UserType::kChild)) &&
         !Shell::Get()->session_controller()->IsUserSessionBlocked();
}

ASH_EXPORT bool IsDisabledByAdmin() {
  const auto* const client = Shell::Get()->calendar_controller()->GetClient();
  return !client || client->IsDisabledByAdmin();
}

base::TimeDelta GetTimeDifference(base::Time date) {
  return DateHelper::GetInstance()->GetTimeDifference(date);
}

base::Time GetFirstDayOfWeekLocalMidnight(base::Time date) {
  int day_of_week = calendar_utils::GetDayOfWeekInt(date);
  base::Time first_day_of_week =
      DateHelper::GetInstance()->GetLocalMidnight(date) -
      base::Days(day_of_week - 1) + kDurationForAdjustingDST;
  return DateHelper::GetInstance()->GetLocalMidnight(first_day_of_week);
}

ASH_EXPORT const std::pair<base::Time, base::Time> GetFetchStartEndTimes(
    base::Time start_of_month_local_midnight) {
  base::Time start = start_of_month_local_midnight -
                     DateHelper::GetInstance()->GetTimeDifference(
                         start_of_month_local_midnight);
  base::Time end =
      GetStartOfMonthUTC(start_of_month_local_midnight + base::Days(33));
  end -= DateHelper::GetInstance()->GetTimeDifference(end);
  return std::make_pair(start, end);
}

int GetDayOfWeekInt(const base::Time date) {
  int day_int;
  if (base::StringToInt(GetDayOfWeek(date), &day_int)) {
    return day_int;
  }

  // For a few special locales the day of week is not in a number. In these
  // cases, use the default day of week from time exploded. For example:
  // 'pa-PK', it returns '۰۳' for the fourth day of week.
  base::Time date_local = date + GetTimeDifference(date);
  base::Time::Exploded local_date_exploded = GetExplodedUTC(date_local);
  // Time exploded uses 0-based day of week (0 = Sunday, etc.)
  return local_date_exploded.day_of_week + 1;
}

bool IsMultiDayEvent(const google_apis::calendar::CalendarEvent* event) {
  DCHECK(event);
  return (GetStartTimeMidnightAdjusted(event) <
          GetEndTimeMidnightAdjusted(event));
}

base::Time GetStartTimeAdjusted(
    const google_apis::calendar::CalendarEvent* event) {
  base::Time start_time = event->start_time().date_time();
  return start_time + GetTimeDifference(start_time);
}

base::Time GetEndTimeAdjusted(
    const google_apis::calendar::CalendarEvent* event) {
  base::Time end_time = event->end_time().date_time();
  return end_time + GetTimeDifference(end_time);
}

ASH_EXPORT base::Time GetStartTimeMidnightAdjusted(
    const google_apis::calendar::CalendarEvent* event) {
  return GetStartTimeAdjusted(event).UTCMidnight();
}

ASH_EXPORT base::Time GetEndTimeMidnightAdjusted(
    const google_apis::calendar::CalendarEvent* event) {
  return GetEndTimeAdjusted(event).UTCMidnight();
}

ASH_EXPORT const std::tuple<base::Time, base::Time> GetStartAndEndTime(
    const google_apis::calendar::CalendarEvent* event,
    const base::Time& selected_date,
    const base::Time& selected_date_midnight,
    const base::Time& selected_date_midnight_utc) {
  const base::Time selected_last_minute =
      calendar_utils::GetNextDayMidnight(selected_date_midnight) -
      base::Minutes(1);
  const base::TimeDelta time_difference =
      calendar_utils::GetTimeDifference(selected_date);
  const base::Time selected_last_minute_utc =
      selected_last_minute - time_difference;

  // If it's an "all day" event, then we want to display 00:00 - 23:59 for the
  // event. The formatter we use will apply timezone changes to the given
  // `base::Time` which are set to UTC midnight in the response, so we need to
  // negate the timezone, so when the formatter formats, it will make the dates
  // midnight in the local timezone.
  if (event->all_day_event()) {
    return std::make_tuple(selected_date_midnight_utc,
                           selected_last_minute_utc);
  }

  base::Time start_time = calendar_utils::GetMaxTime(
      event->start_time().date_time(), selected_date_midnight_utc);
  base::Time end_time = calendar_utils::GetMinTime(
      event->end_time().date_time(), selected_last_minute_utc);

  return std::make_tuple(start_time, end_time);
}

const std::tuple<base::Time, base::Time> GetMidnight(const base::Time time) {
  const auto time_difference = GetTimeDifference(time);
  const auto utc_midnight = (time + time_difference).UTCMidnight();
  const auto local_midnight = utc_midnight - time_difference;

  return std::make_tuple(utc_midnight, local_midnight);
}

}  // namespace ash::calendar_utils