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

#include "components/optimization_guide/hint_cache.h"

#include <algorithm>

#include "base/bind.h"
#include "components/optimization_guide/hint_update_data.h"
#include "components/optimization_guide/hints_processing_util.h"
#include "components/optimization_guide/optimization_guide_features.h"
#include "url/gurl.h"

namespace optimization_guide {

namespace {

// The default number of hints retained within the memory cache. When the limit
// is exceeded, the least recently used hint is purged from the cache.
const size_t kDefaultMaxMemoryCacheHints = 20;

}  // namespace

HintCache::HintCache(
    std::unique_ptr<HintCacheStore> hint_store,
    base::Optional<int> max_memory_cache_hints /*= base::Optional<int>()*/)
    : hint_store_(std::move(hint_store)),
      memory_cache_(
          std::max(max_memory_cache_hints.value_or(kDefaultMaxMemoryCacheHints),
                   1)) {
  DCHECK(hint_store_);
}

HintCache::~HintCache() = default;

void HintCache::Initialize(bool purge_existing_data,
                           base::OnceClosure callback) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  hint_store_->Initialize(
      purge_existing_data,
      base::BindOnce(&HintCache::OnStoreInitialized, base::Unretained(this),
                     std::move(callback)));
}

std::unique_ptr<HintUpdateData>
HintCache::MaybeCreateUpdateDataForComponentHints(
    const base::Version& version) const {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  return hint_store_->MaybeCreateUpdateDataForComponentHints(version);
}

std::unique_ptr<HintUpdateData> HintCache::CreateUpdateDataForFetchedHints(
    base::Time update_time,
    base::Time expiry_time) const {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  return hint_store_->CreateUpdateDataForFetchedHints(update_time, expiry_time);
}

void HintCache::UpdateComponentHints(
    std::unique_ptr<HintUpdateData> component_data,
    base::OnceClosure callback) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  DCHECK(component_data);

  // Clear the memory cache prior to updating the store with the new component
  // data.
  memory_cache_.Clear();

  hint_store_->UpdateComponentHints(std::move(component_data),
                                    std::move(callback));
}

void HintCache::UpdateFetchedHints(
    std::unique_ptr<proto::GetHintsResponse> get_hints_response,
    base::Time update_time,
    base::OnceClosure callback) {
  base::Time expiry_time = update_time;
  if (get_hints_response->has_max_cache_duration()) {
    expiry_time += base::TimeDelta().FromSeconds(
        get_hints_response->max_cache_duration().seconds());
  } else {
    expiry_time += features::StoredFetchedHintsFreshnessDuration();
  }
  std::unique_ptr<HintUpdateData> fetched_hints_update_data =
      CreateUpdateDataForFetchedHints(update_time, expiry_time);
  ProcessHints(get_hints_response.get()->mutable_hints(),
               fetched_hints_update_data.get());
  hint_store_->UpdateFetchedHints(std::move(fetched_hints_update_data),
                                  std::move(callback));
}

void HintCache::ClearFetchedHints() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  DCHECK(hint_store_);
  // TODO(mcrouse): Update to remove only fetched hints from |memory_cache_|.
  memory_cache_.Clear();
  hint_store_->ClearFetchedHintsFromDatabase();
}

bool HintCache::HasHint(const std::string& host) const {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  HintCacheStore::EntryKey hint_entry_key;
  return hint_store_->FindHintEntryKey(host, &hint_entry_key);
}

void HintCache::LoadHint(const std::string& host, HintLoadedCallback callback) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  HintCacheStore::EntryKey hint_entry_key;
  if (!hint_store_->FindHintEntryKey(host, &hint_entry_key)) {
    std::move(callback).Run(nullptr);
    return;
  }

  // Search for the entry key in the memory cache; if it is not already there,
  // then asynchronously load it from the store and return.
  auto hint_it = memory_cache_.Get(hint_entry_key);
  if (hint_it == memory_cache_.end()) {
    hint_store_->LoadHint(
        hint_entry_key,
        base::BindOnce(&HintCache::OnLoadStoreHint, base::Unretained(this),
                       std::move(callback)));
    return;
  }

  // Run the callback with the hint from the memory cache.
  std::move(callback).Run(hint_it->second.get());
}

const proto::Hint* HintCache::GetHintIfLoaded(const std::string& host) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  // Try to retrieve the hint entry key for the host. If no hint exists for the
  // host, then simply return.
  HintCacheStore::EntryKey hint_entry_key;
  if (!hint_store_->FindHintEntryKey(host, &hint_entry_key)) {
    return nullptr;
  }

  // Find the hint within the memory cache. It will only be available here if
  // it has been loaded recently enough to be retained within the MRU cache.
  auto hint_it = memory_cache_.Get(hint_entry_key);
  if (hint_it != memory_cache_.end()) {
    return hint_it->second.get();
  }

  return nullptr;
}

base::Time HintCache::FetchedHintsUpdateTime() const {
  if (!hint_store_) {
    return base::Time();
  }
  return hint_store_->FetchedHintsUpdateTime();
}

void HintCache::OnStoreInitialized(base::OnceClosure callback) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  std::move(callback).Run();
}

void HintCache::OnLoadStoreHint(HintLoadedCallback callback,
                                const HintCacheStore::EntryKey& hint_entry_key,
                                std::unique_ptr<proto::Hint> hint) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  if (!hint) {
    std::move(callback).Run(nullptr);
    return;
  }

  // Check if the hint was cached in memory after the load was requested from
  // the store. This can occur if multiple loads for the same entry key occur
  // consecutively prior to any returning.
  auto hint_it = memory_cache_.Get(hint_entry_key);
  if (hint_it == memory_cache_.end()) {
    hint_it = memory_cache_.Put(hint_entry_key, std::move(hint));
  }

  std::move(callback).Run(hint_it->second.get());
}

}  // namespace optimization_guide