// 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_month_view.h"

#include "ash/public/cpp/ash_typography.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/style/ash_color_provider.h"
#include "ash/style/typography.h"
#include "ash/system/model/system_tray_model.h"
#include "ash/system/time/calendar_metrics.h"
#include "ash/system/time/calendar_model.h"
#include "ash/system/time/calendar_utils.h"
#include "ash/system/time/calendar_view_controller.h"
#include "ash/system/time/date_helper.h"
#include "base/check.h"
#include "base/debug/crash_logging.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "chromeos/ash/components/settings/timezone_settings.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/chromeos/styles/cros_tokens_color_mappings.h"
#include "ui/color/color_provider.h"
#include "ui/compositor/layer.h"
#include "ui/events/event.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/insets_f.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/layout/table_layout.h"

namespace ash {

namespace {

// The thickness of the border.
constexpr int kBorderLineThickness = 2;

// The radius used to draw the border.
constexpr float kBorderRadius = 21.f;
constexpr float kBorderRadiusGlanceables = 19.f;

// The radius used to draw "today's" date cell view border and background.
constexpr float kTodayBorderRadius = 100.f;

// The insets used to draw "today's" date cell view.
constexpr float kTodayRoundedBackgroundHorizontalInset = 8.f;
constexpr float kTodayRoundedBackgroundVerticalInset = 0.f;
constexpr float kTodayRoundedBackgroundHorizontalFocusedInset =
    kTodayRoundedBackgroundHorizontalInset + kBorderLineThickness + 2.f;
constexpr float kTodayRoundedBackgroundVerticalFocusedInset =
    kTodayRoundedBackgroundVerticalInset + kBorderLineThickness + 2.f;

// For Glanceables: The horizontal inset used to draw "today's" date cell view.
constexpr float kTodayRoundedBackgroundHorizontalInsetGlanceables = 9.f;

// Radius of the small dot displayed on a CalendarDateCellView if events are
// present for that day.
constexpr float kEventsPresentRoundedRadius = 1.f;

// The gap padding between the date and the indicator.
constexpr int kGapBetweenDateAndIndicator = 1;

// The insets within the date cell.
constexpr int kDateCellVerticalPaddingGlanceables = 10;
constexpr auto kDateCellInsetsGlanceables =
    gfx::Insets::VH(kDateCellVerticalPaddingGlanceables, 16);

// Move to the next day. Both the column and the current date are moved to the
// next one.
void MoveToNextDay(int& column,
                   base::Time& current_date,
                   base::Time& local_current_date,
                   base::Time::Exploded& current_date_exploded) {
  // Using 30 hours to make sure the date is moved to the next day, since there
  // are daylight saving days which have more than 24 hours in a day.
  // `base::Days(1)` cannot be used, because it is 24 hours.
  //
  // Also using the `current_date_exploded` hours to calculate the local
  // midnight.
  int hours = current_date_exploded.hour;
  current_date += base::Hours(30 - hours);
  local_current_date += base::Hours(30 - hours);
  local_current_date.UTCExplode(&current_date_exploded);
  column = (column + 1) % calendar_utils::kDateInOneWeek;
}

}  // namespace

CalendarDateCellView::CalendarDateCellView(
    CalendarViewController* calendar_view_controller,
    base::Time date,
    base::TimeDelta time_difference,
    bool is_grayed_out_date,
    bool should_fetch_calendar_data,
    int row_index,
    bool is_fetched)
    : views::LabelButton(
          views::Button::PressedCallback(
              base::BindRepeating(&CalendarDateCellView::OnDateCellActivated,
                                  base::Unretained(this))),
          calendar_utils::GetDayIntOfMonth(date + time_difference),
          CONTEXT_CALENDAR_DATE),
      date_(date),
      grayed_out_(is_grayed_out_date),
      should_fetch_calendar_data_(should_fetch_calendar_data),
      row_index_(row_index),
      is_fetched_(is_fetched),
      is_today_(calendar_utils::IsToday(date)),
      time_difference_(time_difference),
      calendar_view_controller_(calendar_view_controller) {
  SetHorizontalAlignment(gfx::ALIGN_CENTER);
  SetBorder(views::CreateEmptyBorder(
      features::AreAnyGlanceablesTimeManagementViewsEnabled()
          ? kDateCellInsetsGlanceables
          : calendar_utils::kDateCellInsets));
  label()->SetElideBehavior(gfx::NO_ELIDE);
  label()->SetSubpixelRenderingEnabled(false);
  if (is_today_) {
    TypographyProvider::Get()->StyleLabel(TypographyToken::kCrosButton1,
                                          *label());
  } else {
    TypographyProvider::Get()->StyleLabel(TypographyToken::kCrosBody1,
                                          *label());
  }
  views::FocusRing::Remove(this);

  DisableFocus();
  if (!grayed_out_) {
    if (should_fetch_calendar_data_ && is_fetched_) {
      UpdateFetchStatus(true);
    }

    SetTooltipAndAccessibleName();
    is_selected_ = calendar_view_controller->selected_date_cell_view() == this;
  }
  scoped_calendar_view_controller_observer_.Observe(
      calendar_view_controller_.get());
}

CalendarDateCellView::~CalendarDateCellView() = default;

void CalendarDateCellView::OnThemeChanged() {
  views::View::OnThemeChanged();

  // Gray-out the date that is not in the current month.
  SetEnabledTextColors(grayed_out_ ? cros_tokens::kCrosSysOnSurfaceVariant
                                   : cros_tokens::kCrosSysOnSurface);
}

// Draws the background for this date. Note that this includes not only the
// circular fill (if any), but also the border (if focused) and text color. If
// this is a grayed out date, which is shown in its previous/next month, this
// background won't be drawn.
void CalendarDateCellView::OnPaintBackground(gfx::Canvas* canvas) {
  if (grayed_out_) {
    return;
  }

  const gfx::Rect content = GetContentsBounds();
  const gfx::SizeF local_bounds = gfx::SizeF(GetLocalBounds().size());

  const SkColor border_color =
      GetColorProvider()->GetColor(cros_tokens::kCrosSysFocusRing);
  cc::PaintFlags highlight_border;
  highlight_border.setColor(border_color);
  highlight_border.setAntiAlias(true);
  highlight_border.setStyle(cc::PaintFlags::kStroke_Style);
  highlight_border.setStrokeWidth(kBorderLineThickness);

  const bool is_for_glanceables =
      features::AreAnyGlanceablesTimeManagementViewsEnabled();
  if (is_today_) {
    gfx::RectF background_rect(local_bounds);

    const SkColor bg_color = GetColorProvider()->GetColor(
        cros_tokens::kCrosSysSystemPrimaryContainer);
    cc::PaintFlags highlight_background;
    highlight_background.setColor(bg_color);
    highlight_background.setStyle(cc::PaintFlags::kFill_Style);
    highlight_background.setAntiAlias(true);

    // If the today view is focused, we draw a border around the background
    // and inset the background a couple of pixels to leave 2dp of space
    // between.
    // Else we just draw the background full size with no border.
    if (views::View::HasFocus()) {
      gfx::RectF border_rect(local_bounds);
      const int half_stroke_thickness = kBorderLineThickness / 2;
      border_rect.Inset(gfx::InsetsF::VH(
          half_stroke_thickness,
          is_for_glanceables ? kTodayRoundedBackgroundHorizontalInsetGlanceables
                             : kTodayRoundedBackgroundHorizontalInset));
      canvas->DrawRoundRect(border_rect, kTodayBorderRadius, highlight_border);

      background_rect.Inset(
          gfx::InsetsF::VH(kTodayRoundedBackgroundVerticalFocusedInset,
                           kTodayRoundedBackgroundHorizontalFocusedInset));
      canvas->DrawRoundRect(background_rect, kTodayBorderRadius,
                            highlight_background);

      return;
    }

    background_rect.Inset(
        gfx::InsetsF::VH(kTodayRoundedBackgroundVerticalInset,
                         kTodayRoundedBackgroundHorizontalInset));
    canvas->DrawRoundRect(background_rect, kTodayBorderRadius,
                          highlight_background);

    return;
  }

  // If !today and view is focused or selected, draw a circle around the view.
  if (views::View::HasFocus() || is_selected_) {
    const gfx::Point center(
        (content.width() + calendar_utils::kDateHorizontalPadding * 2) / 2,
        (content.height() + (is_for_glanceables
                                 ? kDateCellVerticalPaddingGlanceables
                                 : calendar_utils::kDateVerticalPadding) *
                                2) /
            2);
    canvas->DrawCircle(
        center, is_for_glanceables ? kBorderRadiusGlanceables : kBorderRadius,
        highlight_border);
  }
}

void CalendarDateCellView::OnSelectedDateUpdated() {
  const bool is_selected =
      calendar_view_controller_->selected_date_cell_view() == this;
  // If the selected day changes, repaint the background.
  if (is_selected_ != is_selected) {
    is_selected_ = is_selected;
    SchedulePaint();
    if (!is_selected_) {
      GetViewAccessibility().SetName(tool_tip_);
      return;
    }
    // Sets accessible label. E.g. Calendar, week of July 16th 2021, [selected
    // date] is currently selected.
    base::Time local_date = date_ + time_difference_;
    base::Time::Exploded date_exploded =
        calendar_utils::GetExplodedUTC(local_date);
    base::Time first_day_of_week =
        date_ - base::Days(date_exploded.day_of_week);

    GetViewAccessibility().SetName(l10n_util::GetStringFUTF16(
        IDS_ASH_CALENDAR_SELECTED_DATE_CELL_ACCESSIBLE_DESCRIPTION,
        calendar_utils::GetMonthDayYear(first_day_of_week),
        calendar_utils::GetDayOfMonth(date_)));
  }
}

void CalendarDateCellView::CloseEventList() {
  if (!is_selected_) {
    return;
  }

  // If this date is selected, repaint the background.
  is_selected_ = false;
  SchedulePaint();
}

void CalendarDateCellView::EnableFocus() {
  if (grayed_out_) {
    return;
  }
  SetFocusBehavior(FocusBehavior::ALWAYS);
}

void CalendarDateCellView::DisableFocus() {
  SetFocusBehavior(FocusBehavior::NEVER);
}

void CalendarDateCellView::SetTooltipAndAccessibleName() {
  std::u16string formatted_date = calendar_utils::GetMonthDayYearWeek(date_);
  if (!should_fetch_calendar_data_) {
    tool_tip_ = formatted_date;
  } else {
    if (is_fetched_) {
      const int tooltip_id =
          event_number_ == 1 ? IDS_ASH_CALENDAR_DATE_CELL_TOOLTIP
                             : IDS_ASH_CALENDAR_DATE_CELL_PLURAL_EVENTS_TOOLTIP;
      tool_tip_ = l10n_util::GetStringFUTF16(
          tooltip_id, formatted_date,
          base::UTF8ToUTF16(base::NumberToString(event_number_)));
    } else {
      const int tooltip_id = IDS_ASH_CALENDAR_DATE_CELL_LOADING_TOOLTIP;
      tool_tip_ = l10n_util::GetStringFUTF16(tooltip_id, formatted_date);
    }
  }
  SetTooltipText(tool_tip_);
  GetViewAccessibility().SetName(tool_tip_);
}

void CalendarDateCellView::UpdateFetchStatus(bool is_fetched) {
  // No need to re-paint the grayed out cells, since here should be no change
  // for them.
  if (grayed_out_) {
    return;
  }

  if (!should_fetch_calendar_data_) {
    SetTooltipAndAccessibleName();
    return;
  }

  // If the fetching status remains unfetched, no need to schedule repaint.
  if (!is_fetched_ && !is_fetched) {
    return;
  }

  // If the events are fetched, gets the event number and checks if the event
  // number has been changed. If the event number hasn't been changed and the
  // events have been fetched before (i.e. a re-fetch with no event number
  // change), no need to repaint. In all other cases, schedules a repaint.
  if (is_fetched) {
    const int event_number = calendar_view_controller_->GetEventNumber(date_);
    if (event_number_ == event_number && is_fetched_) {
      return;
    }

    event_number_ = event_number;
    if (is_today_) {
      calendar_view_controller_->OnTodaysEventFetchComplete();
    }
  }

  is_fetched_ = is_fetched;
  SetTooltipAndAccessibleName();
  SchedulePaint();
}

void CalendarDateCellView::SetFirstOnFocusedAccessibilityLabel() {
  GetViewAccessibility().SetName(l10n_util::GetStringFUTF16(
      IDS_ASH_CALENDAR_DATE_CELL_ON_FOCUS_ACCESSIBLE_DESCRIPTION, tool_tip_));
}

void CalendarDateCellView::PaintButtonContents(gfx::Canvas* canvas) {
  views::LabelButton::PaintButtonContents(canvas);
  if (grayed_out_) {
    return;
  }

  SetEnabledTextColors(is_today_ ? cros_tokens::kCrosSysSystemOnPrimaryContainer
                                 : cros_tokens::kCrosSysOnSurface);
  MaybeDrawEventsIndicator(canvas);
}

void CalendarDateCellView::OnDateCellActivated(const ui::Event& event) {
  if (grayed_out_ || !should_fetch_calendar_data_ ||
      !calendar_view_controller_->is_date_cell_clickable()) {
    return;
  }

  // Explicitly request focus after being activated to ensure focus moves away
  // from any CalendarDateCellView which was focused prior.
  RequestFocus();
  calendar_metrics::RecordCalendarDateCellActivated(event);
  calendar_view_controller_->ShowEventListView(/*selected_date_cell_view=*/this,
                                               date_, row_index_);
}

gfx::Point CalendarDateCellView::GetEventsPresentIndicatorCenterPosition() {
  const gfx::Rect content = GetContentsBounds();
  const int horizontal_padding = calendar_utils::kDateHorizontalPadding;
  const int vertical_padding =
      features::AreAnyGlanceablesTimeManagementViewsEnabled()
          ? kDateCellVerticalPaddingGlanceables
          : calendar_utils::kDateVerticalPadding;
  return gfx::Point(
      (content.width() + horizontal_padding * 2) / 2,
      content.height() + vertical_padding + kGapBetweenDateAndIndicator);
}

void CalendarDateCellView::MaybeDrawEventsIndicator(gfx::Canvas* canvas) {
  // Not drawing the event dot if it's a grayed out cell or the user is not in
  // an active session (without a vilid user account id).
  if (grayed_out_ || !should_fetch_calendar_data_) {
    return;
  }

  if (event_number_ == 0) {
    return;
  }

  const auto* color_provider = GetColorProvider();
  const SkColor indicator_color = color_provider->GetColor(
      is_today_ ? cros_tokens::kCrosSysSystemOnPrimaryContainer
                : cros_tokens::kCrosSysOnSurface);

  const float indicator_radius = is_selected_ ? kEventsPresentRoundedRadius * 2
                                              : kEventsPresentRoundedRadius;

  cc::PaintFlags indicator_paint_flags;
  indicator_paint_flags.setColor(indicator_color);
  indicator_paint_flags.setStyle(cc::PaintFlags::kFill_Style);
  indicator_paint_flags.setAntiAlias(true);
  canvas->DrawCircle(GetEventsPresentIndicatorCenterPosition(),
                     indicator_radius, indicator_paint_flags);
  is_events_indicator_drawn = true;
}

CalendarMonthView::CalendarMonthView(
    const base::Time first_day_of_month,
    CalendarViewController* calendar_view_controller)
    : calendar_view_controller_(calendar_view_controller),
      calendar_list_model_(
          Shell::Get()->system_tray_model()->calendar_list_model()),
      calendar_model_(Shell::Get()->system_tray_model()->calendar_model()) {
  views::TableLayout* layout =
      SetLayoutManager(std::make_unique<views::TableLayout>());
  // This layer is required for animations.
  SetPaintToLayer();
  layer()->SetFillsBoundsOpaquely(false);
  calendar_utils::SetUpWeekColumns(layout);
  base::TimeDelta const time_difference =
      calendar_utils::GetTimeDifference(first_day_of_month);

  // Using the time difference to get the local `base::Time`, which is used to
  // generate the exploded.
  base::Time first_day_of_month_local = first_day_of_month + time_difference;
  base::Time::Exploded first_day_of_month_exploded =
      calendar_utils::GetExplodedUTC(first_day_of_month_local);
  // Find the first day of the week. Use 8:00 in the morning to avoid any issues
  // caused by DTS, since some timezones' DST start at midnight, some start at
  // 1:00AM etc, but no one starts at 8:00 in the morning.
  base::Time current_date =
      calendar_utils::GetFirstDayOfWeekLocalMidnight(first_day_of_month) +
      base::Hours(8);
  base::Time current_date_local = current_date + time_difference;
  base::Time::Exploded current_date_exploded =
      calendar_utils::GetExplodedUTC(current_date_local);

  fetch_month_ = first_day_of_month_local.UTCMidnight();

  if (calendar_utils::IsMultiCalendarEnabled()) {
    // Set up the Calendar List Model observer to trigger an event fetch only
    // after the calendar list fetch is completed.
    scoped_calendar_list_model_observer_.Observe(calendar_list_model_.get());

    // If the month view has been created after a successful calendar list
    // fetch, this will trigger an event list fetch immediately. Otherwise,
    // events will be fetched during `OnCalendarListFetchComplete`.
    calendar_model_->MaybeFetchEvents(fetch_month_);
  } else {
    FetchEvents(fetch_month_);
  }

  bool has_fetched_data =
      calendar_view_controller_->IsSuccessfullyFetched(fetch_month_);
  const bool should_fetch_calendar_data =
      calendar_utils::ShouldFetchCalendarData();

  // TODO(crbug.com/40192677): Extract the following 3 parts (while
  // loops) into a method.
  int column = 0;
  int safe_index = 0;
  // Gray-out dates in the first row, which are from the previous month.
  while (current_date_exploded.month % 12 ==
         (first_day_of_month_exploded.month - 1) % 12) {
    AddDateCellToLayout(current_date, column,
                        /*is_in_current_month=*/false, /*row_index=*/0,
                        /*is_fetched=*/has_fetched_data,
                        should_fetch_calendar_data);
    MoveToNextDay(column, current_date, current_date_local,
                  current_date_exploded);
    ++safe_index;
    if (safe_index == calendar_utils::kDateInOneWeek) {
      DUMP_WILL_BE_NOTREACHED()
          << "Should not render more than 7 days as the grayed out cells.";
      break;
    }
  }

  int row_number = 0;
  safe_index = 0;
  // Builds non-gray-out dates of the current month.
  while (current_date_exploded.month == first_day_of_month_exploded.month) {
    // Count a row when a new row starts.
    if (column == 0 || current_date_exploded.day_of_month == 1) {
      ++row_number;
    }
    auto* cell = AddDateCellToLayout(current_date, column,
                                     /*is_in_current_month=*/true,
                                     /*row_index=*/row_number - 1,
                                     /*is_fetched=*/has_fetched_data,
                                     should_fetch_calendar_data);
    // Add the first non-grayed-out cell of the row to the `focused_cells_`.
    if (column == 0 || current_date_exploded.day_of_month == 1) {
      focused_cells_.push_back(cell);
    }
    // If this row has today, updates today's row number and replaces today to
    // the last element in the `focused_cells_`.
    if (cell->is_today()) {
      calendar_view_controller_->set_row_height(
          cell->GetPreferredSize().height());
      calendar_view_controller_->set_today_row(row_number);
      focused_cells_.back() = cell;
      has_today_ = true;
      DCHECK(calendar_view_controller_->todays_date_cell_view() == nullptr);
      calendar_view_controller_->set_todays_date_cell_view(cell);
    }
    MoveToNextDay(column, current_date, current_date_local,
                  current_date_exploded);

    ++safe_index;
    if (safe_index == 32) {
      NOTREACHED() << "Should not render more than 31 days in a month.";
    }
  }

  last_row_index_ = row_number - 1;

  // To receive the fetched events.
  scoped_calendar_model_observer_.Observe(calendar_model_.get());

  // Gets the fetched status again in case the events are fetched in the middle
  // of rendering date cells.
  bool updated_has_fetched_data =
      calendar_view_controller_->IsSuccessfullyFetched(fetch_month_);

  // If the fetching status changed, schedule repaint.
  if (updated_has_fetched_data != has_fetched_data) {
    UpdateIsFetchedAndRepaint(updated_has_fetched_data);
  }

  // Adds the remaining days from the next month to complete the last row.
  auto gray_out_days = 8 - calendar_utils::GetDayOfWeekInt(current_date);

  // If the last row is already complete (all days are from the next month), no
  // action is needed.
  if (gray_out_days == 7) {
    return;
  }

  // Add the remaining days from the next month as grayed-out cells.
  for (int rendered_days = 0; rendered_days < gray_out_days; rendered_days++) {
    AddDateCellToLayout(current_date, column,
                        /*is_in_current_month=*/false,
                        /*row_index=*/row_number,
                        /*is_fetched=*/has_fetched_data,
                        should_fetch_calendar_data);
    MoveToNextDay(column, current_date, current_date_local,
                  current_date_exploded);
  }
}

CalendarMonthView::~CalendarMonthView() {
  calendar_model_->CancelFetch(fetch_month_);

  auto* todays_date_cell_view =
      calendar_view_controller_->todays_date_cell_view();
  if (todays_date_cell_view && todays_date_cell_view->parent() == this) {
    calendar_view_controller_->set_todays_date_cell_view(nullptr);
  }

  auto* selected_date_cell_view =
      calendar_view_controller_->selected_date_cell_view();
  if (selected_date_cell_view && selected_date_cell_view->parent() == this) {
    calendar_view_controller_->set_selected_date_cell_view(nullptr);
  }
}

void CalendarMonthView::OnCalendarListFetchComplete() {
  // When the Calendar gets opened and the first 5 month views are created,
  // the calendar list is usually not yet ready when FetchEvents gets called in
  // the constructor.
  // Therefore, the first month views call FetchEvents when the calendar list
  // model signals that the fetch is complete. Any month views created after
  // the calendar list is ready will fetch events immediately during the
  // constructor instead.
  if (calendar_utils::IsMultiCalendarEnabled()) {
    calendar_model_->FetchEvents(fetch_month_);
  }
}

void CalendarMonthView::OnEventsFetched(
    const CalendarModel::FetchingStatus status,
    const base::Time start_time) {
  if (status == CalendarModel::kSuccess && start_time == fetch_month_) {
    UpdateIsFetchedAndRepaint(true);
  }

  if (!(calendar_model_->MonthHasEvents(start_time))) {
    return;
  }

  has_events_ = true;

  if (start_time ==
      calendar_view_controller_->GetOnScreenMonthFirstDayUTC().UTCMidnight()) {
    calendar_view_controller_->EventsDisplayedToUser();
  }
}

void CalendarMonthView::EnableFocus() {
  for (views::View* cell : children()) {
    static_cast<CalendarDateCellView*>(cell)->EnableFocus();
  }
}

void CalendarMonthView::DisableFocus() {
  for (views::View* cell : children()) {
    static_cast<CalendarDateCellView*>(cell)->DisableFocus();
  }
}

void CalendarMonthView::UpdateIsFetchedAndRepaint(bool updated_is_fetched) {
  for (views::View* cell : children()) {
    static_cast<CalendarDateCellView*>(cell)->UpdateFetchStatus(
        updated_is_fetched);
  }
}

BEGIN_METADATA(CalendarMonthView)
END_METADATA

CalendarDateCellView* CalendarMonthView::AddDateCellToLayout(
    base::Time current_date,
    int column,
    bool is_in_current_month,
    int row_index,
    bool is_fetched,
    bool should_fetch_calendar_data) {
  auto* layout_manager = static_cast<views::TableLayout*>(GetLayoutManager());
  if (column == 0) {
    layout_manager->AddRows(1, views::TableLayout::kFixedSize);
  }
  return AddChildView(std::make_unique<CalendarDateCellView>(
      calendar_view_controller_, current_date,
      calendar_utils::GetTimeDifference(current_date),
      /*is_grayed_out_date=*/!is_in_current_month, should_fetch_calendar_data,
      /*row_index=*/row_index,
      /*is_fetched=*/is_fetched));
}

void CalendarMonthView::FetchEvents(const base::Time& month) {
  calendar_model_->FetchEvents(month);
}

BEGIN_METADATA(CalendarDateCellView)
END_METADATA

}  // namespace ash