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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "ash/quick_insert/search/quick_insert_date_search.h"

#include <map>
#include <optional>
#include <string>
#include <vector>

#include "ash/quick_insert/quick_insert_search_result.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/strings/grit/ash_strings.h"
#include "base/containers/fixed_flat_map.h"
#include "base/containers/to_vector.h"
#include "base/i18n/case_conversion.h"
#include "base/i18n/time_formatting.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "third_party/re2/src/re2/re2.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/styles/cros_tokens_color_mappings.h"

namespace ash {
namespace {

constexpr int kDaysPerWeek = 7;
constexpr LazyRE2 kDaysOrWeeksAwayRegex = {
    "(\\d{1,6}|one|two|three|four|five|six|seven|eight|nine|ten) "
    "(days?|weeks?) (from now|ago)"};
constexpr LazyRE2 kDayOfWeekRegex = {
    "(this |next |last |)"
    "(sunday|monday|tuesday|wednesday|thursday|friday|saturday)"};
constexpr auto kTextToDays = base::MakeFixedFlatMap<std::string_view, int>({
    {"yesterday", -1},
    {"today", 0},
    {"tomorrow", 1},
});
constexpr auto kWordToNumber = base::MakeFixedFlatMap<std::string_view, int>({
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4},
    {"five", 5},
    {"six", 6},
    {"seven", 7},
    {"eight", 8},
    {"nine", 9},
    {"ten", 10},
});
constexpr auto kDayOfWeekToNumber =
    base::MakeFixedFlatMap<std::string_view, int>({
        {"sunday", 0},
        {"monday", 1},
        {"tuesday", 2},
        {"wednesday", 3},
        {"thursday", 4},
        {"friday", 5},
        {"saturday", 6},
    });

constexpr std::u16string_view kSuggestedDates[] = {
    {u"Today"},
    {u"Tomorrow"},
    {u"2 weeks from now"},
};

std::u16string GetLocalizedDayOfWeek(const base::Time& time) {
  return base::LocalizedTimeFormatWithPattern(time, "EEEE");
}

// The result of parsing a date expression query.
struct ResolvedDate {
  base::Time time;

  // Some optional text to disambiguate the date when the original query is
  // ambiguous.
  std::optional<std::u16string> disambiguation_text;
};

QuickInsertSearchResult MakeResult(const ResolvedDate& date) {
  return QuickInsertTextResult(
      base::LocalizedTimeFormatWithPattern(date.time, "LLLd"),
      date.disambiguation_text.value_or(u""),
      ui::ImageModel::FromVectorIcon(kQuickInsertCalendarIcon,
                                     cros_tokens::kCrosSysOnSurface),
      QuickInsertTextResult::Source::kDate);
}

QuickInsertSearchResult MakeSuggestedResult(std::u16string_view query_text,
                                            const ResolvedDate& date) {
  CHECK(!date.disambiguation_text.has_value());
  return QuickInsertSearchRequestResult(
      query_text, base::LocalizedTimeFormatWithPattern(date.time, "LLLd"),
      ui::ImageModel::FromVectorIcon(kQuickInsertCalendarIcon,
                                     cros_tokens::kCrosSysOnSurface));
}

void HandleSpecificDayQueries(const base::Time& now,
                              std::string_view query,
                              std::vector<ResolvedDate>& resolved_dates) {
  const auto day_lookup = kTextToDays.find(query);
  if (day_lookup == kTextToDays.end()) {
    return;
  }
  resolved_dates.push_back({.time = now + base::Days(day_lookup->second)});
}

void HandleDaysOrWeeksAwayQueries(const base::Time& now,
                                  std::string_view query,
                                  std::vector<ResolvedDate>& resolved_dates) {
  std::string number, unit, suffix;
  if (!RE2::FullMatch(query, *kDaysOrWeeksAwayRegex, &number, &unit, &suffix)) {
    return;
  }
  const auto word_lookup = kWordToNumber.find(number);
  int x = 0;
  if (word_lookup != kWordToNumber.end()) {
    x = word_lookup->second;
  } else {
    base::StringToInt(number, &x);
  }
  if (x <= 0) {
    return;
  }
  if (unit.starts_with("week")) {
    x *= kDaysPerWeek;
  }
  if (suffix == "ago") {
    x = -x;
  }
  resolved_dates.push_back({.time = now + base::Days(x)});
}

void HandleDayOfWeekQueries(const base::Time& now,
                            std::string_view query,
                            std::vector<ResolvedDate>& resolved_dates) {
  std::string prefix, target_day_of_week_str;
  if (!RE2::FullMatch(query, *kDayOfWeekRegex, &prefix,
                      &target_day_of_week_str)) {
    return;
  }
  const auto day_lookup = kDayOfWeekToNumber.find(target_day_of_week_str);
  CHECK(day_lookup != kDayOfWeekToNumber.end());
  int target_day_of_week = day_lookup->second;
  base::Time::Exploded exploded;
  now.LocalExplode(&exploded);
  int current_day_of_week = exploded.day_of_week;
  int day_diff = target_day_of_week - current_day_of_week;
  if (prefix.empty() || prefix == "this ") {
    if (target_day_of_week < current_day_of_week) {
      std::u16string localized_day_of_week =
          GetLocalizedDayOfWeek(now + base::Days(day_diff));
      resolved_dates.push_back({
          .time = now + base::Days(day_diff + kDaysPerWeek),
          .disambiguation_text = l10n_util::GetStringFUTF16(
              IDS_PICKER_DATE_DISAMBIGUATION_THIS_COMING_DAY,
              localized_day_of_week),
      });
      resolved_dates.push_back({
          .time = now + base::Days(day_diff),
          .disambiguation_text = l10n_util::GetStringFUTF16(
              IDS_PICKER_DATE_DISAMBIGUATION_THIS_PAST_DAY,
              std::move(localized_day_of_week)),
      });
    } else {
      resolved_dates.push_back({.time = now + base::Days(day_diff)});
    }
  } else if (prefix == "next ") {
    if (target_day_of_week > current_day_of_week) {
      std::u16string localized_day_of_week =
          GetLocalizedDayOfWeek(now + base::Days(day_diff));
      resolved_dates.push_back({
          .time = now + base::Days(day_diff + kDaysPerWeek),
          .disambiguation_text = l10n_util::GetStringFUTF16(
              IDS_PICKER_DATE_DISAMBIGUATION_NEXT_WEEK, localized_day_of_week),
      });
      resolved_dates.push_back({
          .time = now + base::Days(day_diff),
          .disambiguation_text = l10n_util::GetStringFUTF16(
              IDS_PICKER_DATE_DISAMBIGUATION_THIS_COMING_DAY,
              std::move(localized_day_of_week)),
      });
    } else {
      resolved_dates.push_back(
          {.time = now + base::Days(day_diff + kDaysPerWeek)});
    }
  } else if (prefix == "last ") {
    if (target_day_of_week < current_day_of_week) {
      std::u16string localized_day_of_week =
          GetLocalizedDayOfWeek(now + base::Days(day_diff));
      resolved_dates.push_back({
          .time = now + base::Days(day_diff - kDaysPerWeek),
          .disambiguation_text = l10n_util::GetStringFUTF16(
              IDS_PICKER_DATE_DISAMBIGUATION_LAST_WEEK, localized_day_of_week),
      });
      resolved_dates.push_back({
          .time = now + base::Days(day_diff),
          .disambiguation_text = l10n_util::GetStringFUTF16(
              IDS_PICKER_DATE_DISAMBIGUATION_THIS_PAST_DAY,
              std::move(localized_day_of_week)),
      });
    } else {
      resolved_dates.push_back(
          {.time = now + base::Days(day_diff - kDaysPerWeek)});
    }
  }
}

std::vector<ResolvedDate> ResolveQuery(const base::Time& now,
                                       std::u16string_view query) {
  std::vector<ResolvedDate> resolved_dates;
  std::string clean_query = base::UTF16ToUTF8(base::TrimWhitespace(
      base::i18n::ToLower(query), base::TrimPositions::TRIM_ALL));
  HandleSpecificDayQueries(now, clean_query, resolved_dates);
  HandleDaysOrWeeksAwayQueries(now, clean_query, resolved_dates);
  HandleDayOfWeekQueries(now, clean_query, resolved_dates);
  return resolved_dates;
}

}  // namespace

std::vector<QuickInsertSearchResult> QuickInsertDateSearch(
    const base::Time& now,
    std::u16string_view query) {
  return base::ToVector(ResolveQuery(now, query), MakeResult);
}

std::vector<QuickInsertSearchResult> QuickInsertSuggestedDateResults() {
  std::vector<QuickInsertSearchResult> results;

  for (const std::u16string_view query : kSuggestedDates) {
    std::vector<ResolvedDate> resolved_dates =
        ResolveQuery(base::Time::Now(), query);
    CHECK_EQ(resolved_dates.size(), 1u);
    results.push_back(MakeSuggestedResult(query, resolved_dates[0]));
  }

  return results;
}

}  // namespace ash