// Copyright 2022 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_model.h"

#include <stdlib.h>

#include <cstddef>
#include <memory>

#include "ash/calendar/calendar_client.h"
#include "ash/calendar/calendar_controller.h"
#include "ash/constants/ash_features.h"
#include "ash/shell.h"
#include "ash/system/model/system_tray_model.h"
#include "ash/system/time/calendar_event_fetch.h"
#include "ash/system/time/calendar_list_model.h"
#include "ash/system/time/calendar_metrics.h"
#include "ash/system/time/calendar_utils.h"
#include "base/check.h"
#include "base/containers/contains.h"
#include "base/containers/fixed_flat_set.h"
#include "base/functional/bind.h"
#include "base/metrics/histogram_functions.h"
#include "base/time/time.h"
#include "google_apis/calendar/calendar_api_requests.h"
#include "google_apis/calendar/calendar_api_response_types.h"
#include "google_apis/common/api_error_codes.h"

#undef ENABLED_VLOG_LEVEL
#define ENABLED_VLOG_LEVEL 1

namespace {

using ::google_apis::calendar::CalendarEvent;

struct CmpEvent {
  bool operator()(const CalendarEvent& event1,
                  const CalendarEvent& event2) const {
    return event1.start_time().date_time() < event2.start_time().date_time();
  }
};

constexpr auto kAllowedEventStatuses =
    base::MakeFixedFlatSet<CalendarEvent::EventStatus>(
        {CalendarEvent::EventStatus::kConfirmed,
         CalendarEvent::EventStatus::kTentative});

constexpr auto kAllowedResponseStatuses =
    base::MakeFixedFlatSet<CalendarEvent::ResponseStatus>(
        {CalendarEvent::ResponseStatus::kAccepted,
         CalendarEvent::ResponseStatus::kNeedsAction,
         CalendarEvent::ResponseStatus::kTentative});

[[maybe_unused]] size_t GetEventMapSize(
    const ash::CalendarModel::SingleMonthEventMap& event_map) {
  size_t total_bytes = 0;
  for (auto& event_list : event_map) {
    total_bytes += sizeof(event_list);
    for (auto& event : event_list.second) {
      total_bytes += event.GetApproximateSizeInBytes();
    }
  }

  return total_bytes;
}

auto SplitEventsIntoMultiDayAndSameDay(const ash::SingleDayEventList& list) {
  std::list<CalendarEvent> multi_day_events;
  std::list<CalendarEvent> same_day_events;

  for (const CalendarEvent& event : list) {
    if (event.all_day_event() || ash::calendar_utils::IsMultiDayEvent(&event)) {
      multi_day_events.push_back(std::move(event));
    } else {
      same_day_events.push_back(std::move(event));
    }
  }

  return std::make_tuple(std::move(multi_day_events),
                         std::move(same_day_events));
}

void SortByDateAscending(
    std::list<google_apis::calendar::CalendarEvent>& events) {
  events.sort([](google_apis::calendar::CalendarEvent& a,
                 google_apis::calendar::CalendarEvent& b) {
    if (a.start_time().date_time() == b.start_time().date_time()) {
      return a.end_time().date_time() < b.end_time().date_time();
    }
    return a.start_time().date_time() < b.start_time().date_time();
  });
}

bool EventStartedLessThanOneHourAgo(const CalendarEvent& event,
                                    const base::Time& now_local) {
  const int start_time_difference_in_mins =
      (ash::calendar_utils::GetStartTimeAdjusted(&event) - now_local)
          .InMinutes();
  const int end_time_difference_in_mins =
      (ash::calendar_utils::GetEndTimeAdjusted(&event) - now_local).InMinutes();

  return (0 <= end_time_difference_in_mins &&
          0 > start_time_difference_in_mins &&
          start_time_difference_in_mins >= -60);
}

// Returns 1)events that start in 10 minutes, and the events that are in
// progress and started less than one hour ago; or 2) returns the first next
// event(s) if there's no events meet condition #1.
auto FilterTheNextEventsOrEventsRecentlyInProgress(
    const ash::SingleDayEventList& list,
    const base::Time& now_local) {
  std::list<CalendarEvent> result;
  for (const CalendarEvent& event : list) {
    if (event.all_day_event()) {
      continue;
    }

    if (EventStartedLessThanOneHourAgo(event, now_local)) {
      result.emplace_back(event);
      continue;
    }

    const int start_time_difference_in_mins =
        (ash::calendar_utils::GetStartTimeAdjusted(&event) - now_local)
            .InMinutes();

    // If the event has already started, don't add it and go to the next event,
    // because this event should have started over an hour ago since we have
    // already added events started less than an hour ago earlier.
    if (start_time_difference_in_mins < 0) {
      continue;
    }

    // If there are already events to return and this event starts in more than
    // 10 mins, then don't show it. And don't consider the rest of the events
    // because they are sorted in chronnological order.
    if (!result.empty() && start_time_difference_in_mins > 10) {
      return result;
    }

    result.emplace_back(event);
  }

  return result;
}

}  // namespace

namespace ash {

CalendarModel::CalendarModel() : session_observer_(this) {}

CalendarModel::~CalendarModel() = default;

void CalendarModel::OnSessionStateChanged(session_manager::SessionState state) {
  ClearAllCachedEvents();
}

void CalendarModel::OnActiveUserSessionChanged(const AccountId& account_id) {
  ClearAllCachedEvents();
}

void CalendarModel::AddObserver(Observer* observer) {
  if (observer) {
    observers_.AddObserver(observer);
  }
}

void CalendarModel::RemoveObserver(Observer* observer) {
  if (observer) {
    observers_.RemoveObserver(observer);
  }
}

void CalendarModel::PromoteMonth(base::Time start_of_month) {
  // If this month is non-prunable, nothing to do.
  if (base::Contains(non_prunable_months_, start_of_month)) {
    return;
  }

  // If start_of_month is already most-recently-used, nothing to do.
  if (!mru_months_.empty() && mru_months_.front() == start_of_month) {
    return;
  }

  // Remove start_of_month from the queue if it's present.
  for (auto it = mru_months_.begin(); it != mru_months_.end(); ++it) {
    if (*it == start_of_month) {
      mru_months_.erase(it);
      break;
    }
  }

  // start_of_month is now the most-recently-used.
  mru_months_.push_front(start_of_month);
}

void CalendarModel::AddNonPrunableMonth(const base::Time& month) {
  // Early-return if `month` is present, to avoid the limits-check below.
  if (base::Contains(non_prunable_months_, month)) {
    return;
  }

  if (non_prunable_months_.size() < calendar_utils::kMaxNumNonPrunableMonths) {
    non_prunable_months_.emplace(month);
  }
}

void CalendarModel::AddNonPrunableMonths(const std::set<base::Time>& months) {
  for (auto& month : months) {
    AddNonPrunableMonth(month);
  }
}

void CalendarModel::ClearAllCachedEvents() {
  // Destroy all outstanding fetch requests.
  pending_fetches_.clear();

  // Destroy the fetch error codes.
  fetch_error_codes_.clear();

  // Destroy the fetch completion indicators.
  events_have_fetched_.clear();

  // Destroy the set of months that have been fetched.
  months_fetched_.clear();

  // Destroy all prunable months.
  non_prunable_months_.clear();

  // Destroy the list used to decide who gets pruned.
  mru_months_.clear();

  // Destroy the events themselves.
  event_months_.clear();
}

void CalendarModel::ClearAllPrunableEvents() {
  // Destroy all outstanding fetch requests.
  pending_fetches_.clear();

  // Clear out all cached events that start in a prunable month, and any record
  // of having fetched it.
  for (auto& month : mru_months_) {
    event_months_.erase(month);
    months_fetched_.erase(month);
  }

  // Clear out the list of prunable months.
  mru_months_.clear();
}

bool CalendarModel::MonthHasEvents(const base::Time start_of_month) {
  if (base::Contains(event_months_, start_of_month)) {
    for (auto it = event_months_[start_of_month].begin();
         it != event_months_[start_of_month].end(); it++) {
      if (!it->second.empty()) {
        return true;
      }
    }
  }
  return false;
}

void CalendarModel::UploadLifetimeMetrics() {
  calendar_metrics::RecordTotalEventsCacheSizeInMonths(event_months_.size());
}

void CalendarModel::MaybeFetchEvents(base::Time start_of_month) {
  if (Shell::Get()
          ->system_tray_model()
          ->calendar_list_model()
          ->list_cached_and_no_fetch_in_progress()) {
    FetchEvents(start_of_month);
  }
}

void CalendarModel::FetchEvents(base::Time start_of_month) {
  // Early return if it's not a valid user/user-session.
  if (!calendar_utils::ShouldFetchCalendarData()) {
    return;
  }

  // Bail out early if there is no CalendarClient.  This will be the case in
  // most unit tests.
  CalendarClient* client = Shell::Get()->calendar_controller()->GetClient();
  if (!client) {
    return;
  }

  // Bail out early if this is a prunable month that's already been fetched.
  if (!base::Contains(non_prunable_months_, start_of_month) &&
      base::Contains(months_fetched_, start_of_month)) {
    PromoteMonth(start_of_month);
    return;
  }

  // Reset fetch helpers before the new fetch(es).
  fetch_error_codes_.erase(start_of_month);
  if (base::Contains(non_prunable_months_, start_of_month)) {
    events_have_fetched_.insert_or_assign(start_of_month, false);
  }

  if (calendar_utils::IsMultiCalendarEnabled()) {
    ash::CalendarList calendar_list = Shell::Get()
                                          ->system_tray_model()
                                          ->calendar_list_model()
                                          ->GetCachedCalendarList();

    if (!calendar_list.empty()) {
      fetches_start_time_ = base::TimeTicks::Now();

      // Create event fetch requests for up to `kMultipleCalendarsLimit`
      // calendars. Expects a calendar list trimmed to be within the calendar
      // limit.
      for (const auto& calendar : calendar_list) {
        // Create event fetch request for the calendar and transfer ownership to
        // `pending_fetches_`.
        pending_fetches_[start_of_month][calendar.id()] =
            std::make_unique<CalendarEventFetch>(
                start_of_month,
                /*complete_callback =*/
                base::BindRepeating(&CalendarModel::OnEventsFetched,
                                    base::Unretained(this)),
                /*internal_error_callback_ =*/
                base::BindRepeating(
                    &CalendarModel::OnEventFetchFailedInternalError,
                    base::Unretained(this)),
                /*tick_clock =*/nullptr, calendar.id(), calendar.color_id());
      }
    } else {
      // The user has no selected calendars, so notify observers to remove the
      // loading bar.
      for (auto& observer : observers_) {
        observer.OnEventsFetched(kNever, start_of_month);
      }
    }
  } else {
    FetchPrimaryCalendarEvents(start_of_month);
  }
}

void CalendarModel::FetchPrimaryCalendarEvents(
    const base::Time start_of_month) {
  pending_fetches_[start_of_month][google_apis::calendar::kPrimaryCalendarId] =
      std::make_unique<CalendarEventFetch>(
          start_of_month,
          /*complete_callback=*/
          base::BindRepeating(&CalendarModel::OnEventsFetched,
                              base::Unretained(this)),
          /*internal_error_callback_=*/
          base::BindRepeating(&CalendarModel::OnEventFetchFailedInternalError,
                              base::Unretained(this)),
          /*tick_clock=*/nullptr);
}

void CalendarModel::CancelFetch(const base::Time& start_of_month) {
  if (base::Contains(pending_fetches_, start_of_month)) {
    for (auto it = pending_fetches_[start_of_month].begin();
         it != pending_fetches_[start_of_month].end(); it++) {
      it->second->Cancel();
    }
    // We want to wait until after fetches have been cancelled to erase
    // `pending_fetches` for this month.
    pending_fetches_.erase(start_of_month);
    // This method might be called after some events have been fetched. For
    // prunable months, to prevent event storage from being partially populated
    // and displayed, we delete all stored events for the month.
    if (!base::Contains(non_prunable_months_, start_of_month)) {
      event_months_.erase(start_of_month);
      months_fetched_.erase(start_of_month);
    }
  }
}

int CalendarModel::EventsNumberOfDay(base::Time day,
                                     SingleDayEventList* events) {
  const SingleDayEventList& list = FindEvents(day);

  if (list.empty()) {
    return 0;
  }

  // There are events, and the destination should be empty.
  if (events) {
    DCHECK(events->empty());
    *events = list;
  }

  return list.size();
}

void CalendarModel::NotifyObservers(base::Time start_of_month) {
  // If at least one of the month's fetches succeeded, we emit kSuccess.
  // Otherwise, emit kNever to stop the loading animation.
  if (fetch_error_codes_[start_of_month].count(google_apis::HTTP_SUCCESS)) {
    for (auto& observer : observers_) {
      observer.OnEventsFetched(kSuccess, start_of_month);
    }
  } else {
    for (auto& observer : observers_) {
      observer.OnEventsFetched(kNever, start_of_month);
    }
  }
}

void CalendarModel::OnEventsFetched(
    base::Time start_of_month,
    std::string calendar_id,
    google_apis::ApiErrorCode error,
    const google_apis::calendar::EventList* events) {
  calendar_metrics::RecordEventListFetchErrorCode(error);

  fetch_error_codes_[start_of_month].emplace(error);

  if (calendar_utils::IsMultiCalendarEnabled() &&
      pending_fetches_[start_of_month].empty()) {
    // On the completion of the final calendar event fetch, record the time
    // elapsed from the start of the first fetch.
    calendar_metrics::RecordEventListFetchesTotalDuration(
        base::TimeTicks::Now() - fetches_start_time_);
  }

  if (error == google_apis::CANCELLED) {
    return;
  }

  if (error != google_apis::HTTP_SUCCESS) {
    pending_fetches_[start_of_month].erase(calendar_id);
    if (pending_fetches_[start_of_month].empty()) {
      NotifyObservers(start_of_month);
    }
    return;
  }

  PruneEventCache();

  // If this is the first fetch that has returned for a non-prunable month,
  // clear pre-existing event storage and indicate that some new events have
  // fetched.
  if (base::Contains(non_prunable_months_, start_of_month) &&
      !events_have_fetched_[start_of_month]) {
    event_months_.erase(start_of_month);
    events_have_fetched_[start_of_month] = true;
  }

  // If there are no events for the current calendar and the event map for
  // the month does not yet exist, insert an empty map. Otherwise, we do
  // not want to overwrite events from previously fetched calendars.
  if ((!events || events->items().empty())) {
    if (!base::Contains(event_months_, start_of_month)) {
      SingleMonthEventMap empty_event_map;
      event_months_.emplace(start_of_month, empty_event_map);
    }
    PromoteMonth(start_of_month);
  } else {
    // Store the incoming events.
    for (const auto& event : events->items()) {
      if (calendar_utils::IsMultiDayEvent(event.get())) {
        InsertMultiDayEvent(event.get(), start_of_month);
      } else {
        base::Time start_time_midnight =
            calendar_utils::GetStartTimeMidnightAdjusted(event.get());
        InsertEventInMonth(
            event.get(),
            calendar_utils::GetStartOfMonthUTC(start_time_midnight),
            start_time_midnight);
      }
    }
  }

  // Request is no longer outstanding, so it can be destroyed.
  pending_fetches_[start_of_month].erase(calendar_id);

  if (pending_fetches_[start_of_month].empty()) {
    NotifyObservers(start_of_month);

    months_fetched_.emplace(start_of_month);

    // Record the size of the month, and the total number of months.
    calendar_metrics::RecordSingleMonthSizeInBytes(
        GetEventMapSize(event_months_[start_of_month]));
  }
}

void CalendarModel::OnEventFetchFailedInternalError(
    base::Time start_of_month,
    std::string calendar_id,
    CalendarEventFetchInternalErrorCode error) {
  // Request is no longer outstanding, so it can be destroyed.
  pending_fetches_[start_of_month].erase(calendar_id);
  // TODO(b/40822782): May need to respond further based on the
  // specific error code, retry in some cases, etc.
  if (pending_fetches_[start_of_month].empty()) {
    NotifyObservers(start_of_month);
  }
}

bool CalendarModel::ShouldInsertEvent(const CalendarEvent* event) const {
  if (!event) {
    return false;
  }

  return base::Contains(kAllowedEventStatuses, event->status()) &&
         base::Contains(kAllowedResponseStatuses,
                        event->self_response_status());
}

void CalendarModel::InsertMultiDayEvent(
    const google_apis::calendar::CalendarEvent* event,
    const base::Time start_of_month) {
  DCHECK(event);

  if (event->all_day_event()) {
    auto current_day_utc = calendar_utils::GetMaxTime(
                               start_of_month, event->start_time().date_time())
                               .UTCMidnight();
    base::Time start_of_next_month =
        calendar_utils::GetStartOfNextMonthUTC(current_day_utc);
    // Don't go into the next month.
    auto last_day_utc = calendar_utils::GetMinTime(
                            start_of_next_month, event->end_time().date_time())
                            .UTCMidnight();

    // In the Calendar API, the end `base::Time` of an "all day" event will be
    // the following day at midnight. For example for a single "all day" event
    // on 1st October, the start `base::Time` will be 2022-10-01 00:00:00.000
    // UTC and the end `base::Time` will be 2022-10-02 00:00:00.000 UTC, so we
    // iterate until the day before the `last_day_utc` to ensure we don't show
    // the all day event incorrectly going on to the next day. As we are going
    // to always show these events by day rather than time, we don't care about
    // timezone here.
    while (current_day_utc < last_day_utc) {
      InsertEventInMonth(event, start_of_month, current_day_utc);
      current_day_utc = calendar_utils::GetNextDayMidnight(current_day_utc);
    }
    return;
  }

  base::Time start_time_midnight =
      calendar_utils::GetStartTimeMidnightAdjusted(event);
  base::Time end_time_midnight =
      calendar_utils::GetEndTimeMidnightAdjusted(event);
  base::Time end_time = calendar_utils::GetEndTimeAdjusted(event);

  base::Time current_day_midnight =
      calendar_utils::GetMaxTime(start_of_month, start_time_midnight)
          .UTCMidnight();
  base::Time start_of_next_month =
      calendar_utils::GetStartOfNextMonthUTC(current_day_midnight);
  base::Time last_day_midnight =
      calendar_utils::GetMinTime(start_of_next_month, end_time_midnight)
          .UTCMidnight();

  // If the event ends at midnight we don't add it to that last day.
  if (end_time == end_time_midnight) {
    last_day_midnight =
        (last_day_midnight - calendar_utils::kDurationForGettingPreviousDay)
            .UTCMidnight();
  }

  while (current_day_midnight <= last_day_midnight) {
    InsertEventInMonth(event, start_of_month, current_day_midnight);
    current_day_midnight =
        calendar_utils::GetNextDayMidnight(current_day_midnight);
  }
}

void CalendarModel::InsertEventInMonth(
    const google_apis::calendar::CalendarEvent* event,
    const base::Time start_of_month,
    const base::Time start_time_midnight) {
  DCHECK(event);

  // Check the event is in the month we're trying to insert it into.
  if (start_of_month !=
      calendar_utils::GetStartOfMonthUTC(start_time_midnight)) {
    return;
  }

  // Month is now the most-recently-used.
  PromoteMonth(start_of_month);

  auto it = event_months_.find(start_of_month);
  if (it == event_months_.end()) {
    // No events for this month, so add a map for it and insert.
    SingleMonthEventMap month;
    InsertEventInMonthEventList(month, event, start_time_midnight);
    event_months_.emplace(start_of_month, month);
  } else {
    // Insert in a pre-existing month.
    SingleMonthEventMap& month = it->second;
    InsertEventInMonthEventList(month, event, start_time_midnight);
  }
}

void CalendarModel::InsertEventInMonthEventList(
    SingleMonthEventMap& month,
    const google_apis::calendar::CalendarEvent* event,
    const base::Time start_time_midnight) {
  DCHECK(event);
  if (!ShouldInsertEvent(event)) {
    return;
  }

  auto it = month.find(start_time_midnight);
  if (it == month.end()) {
    // No events stored for this day, so create a new list, add the event to
    // it, and insert the list in the map.
    SingleDayEventList list;
    list.push_back(*event);
    month.emplace(start_time_midnight, list);
  } else {
    // Already have some events for this day.
    SingleDayEventList& list = it->second;
    list.push_back(*event);
  }
}

SingleDayEventList CalendarModel::FindEvents(base::Time day) const {
  SingleDayEventList event_list;

  // Early return if there are no events for this month.
  base::Time start_of_month = calendar_utils::GetStartOfMonthUTC(day);
  auto it = event_months_.find(start_of_month);
  if (it == event_months_.end()) {
    return event_list;
  }

  // Early return if there are no events for this day.
  base::Time midnight = day.UTCMidnight();
  const SingleMonthEventMap& month = it->second;
  auto it2 = month.find(midnight);
  if (it2 == month.end()) {
    return event_list;
  }

  auto events = it2->second;
  SortByDateAscending(events);
  return events;
}

std::tuple<SingleDayEventList, SingleDayEventList>
CalendarModel::FindEventsSplitByMultiDayAndSameDay(base::Time day) const {
  return SplitEventsIntoMultiDayAndSameDay(FindEvents(day));
}

std::list<CalendarEvent> CalendarModel::FindUpcomingEvents(
    base::Time now_local) const {
  auto upcoming_events = FindEvents(now_local);
  return FilterTheNextEventsOrEventsRecentlyInProgress(upcoming_events,
                                                       now_local);
}

CalendarModel::FetchingStatus CalendarModel::FindFetchingStatus(
    base::Time start_time) {
  if (!calendar_utils::ShouldFetchCalendarData()) {
    return kNa;
  }

  if (!pending_fetches_[start_time].empty()) {
    if (months_fetched_.count(start_time)) {
      return kRefetching;
    }

    return kFetching;
  }

  if (months_fetched_.count(start_time)) {
    return kSuccess;
  }

  return kNever;
}

void CalendarModel::RedistributeEvents() {
  // Redistributes all the fetched events to the date map with the
  // time difference.
  std::set<google_apis::calendar::CalendarEvent, CmpEvent>
      to_be_redistributed_events;
  for (auto& month : event_months_) {
    SingleMonthEventMap& event_map = month.second;
    for (auto& it : event_map) {
      for (const google_apis::calendar::CalendarEvent& event : it.second) {
        to_be_redistributed_events.insert(event);
      }
    }
  }

  // Clear out the entire event store, freshly insert the redistributed
  // events.
  event_months_.clear();
  for (const google_apis::calendar::CalendarEvent& event :
       to_be_redistributed_events) {
    if (calendar_utils::IsMultiDayEvent(&event)) {
      // Only redistributes the multi-day events within the non-prunable months
      // scope. 1, This can avoid some coroner cases, e.g. some events that are
      // across several years. 2, we only cache the events for non-prunable
      // months.
      for (base::Time month : non_prunable_months_) {
        InsertMultiDayEvent(&event, month);
      }
    } else {
      base::Time start_time_midnight =
          calendar_utils::GetStartTimeMidnightAdjusted(&event);
      InsertEventInMonth(
          &event, calendar_utils::GetStartOfMonthUTC(start_time_midnight),
          start_time_midnight);
    }
  }
}

void CalendarModel::PruneEventCache() {
  while (!mru_months_.empty() &&
         mru_months_.size() > calendar_utils::kMaxNumPrunableMonths) {
    base::Time lru_month = mru_months_.back();
    pending_fetches_.erase(lru_month);
    event_months_.erase(lru_month);
    months_fetched_.erase(lru_month);
    mru_months_.pop_back();
  }
}

}  // namespace ash