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

#include "chrome/browser/ui/ash/shelf/shelf_spinner_controller.h"

#include <algorithm>
#include <vector>

#include "ash/public/cpp/shelf_model.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "chrome/browser/ash/guest_os/guest_os_shelf_utils.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/ash/shelf/chrome_shelf_controller.h"
#include "chrome/browser/ui/ash/shelf/shelf_spinner_item_controller.h"
#include "components/user_manager/user_manager.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/image/canvas_image_source.h"
#include "ui/gfx/image/image_skia_operations.h"
#include "ui/gfx/paint_throbber.h"

namespace {

constexpr int kUpdateIconIntervalMs = 40;  // 40ms for 25 frames per second.

// Controls the spinner animation. See crbug.com/922977 for details.
constexpr base::TimeDelta kFadeInDuration = base::Milliseconds(200);
constexpr base::TimeDelta kFadeOutDuration = base::Milliseconds(200);
constexpr base::TimeDelta kMinimumShowDuration = base::Milliseconds(200);

constexpr int kSpinningGapPercent = 25;
constexpr color_utils::HSL kInactiveHslShift = {-1, 0, 0.25};
constexpr double kInactiveTransparency = 0.5;

// Returns the proportion of the duration |d| from |t1| to |t2|, where 0 means
// |t2| is before or at |t1| and 1 means it is |d| or further ahead.
double TimeProportionSince(const base::Time& t1,
                           const base::Time& t2,
                           const base::TimeDelta& d) {
  return std::clamp((t2 - t1) / d, 0.0, 1.0);
}

}  // namespace

class ShelfSpinnerController::ShelfSpinnerData {
 public:
  explicit ShelfSpinnerData(ShelfSpinnerItemController* controller)
      : controller_(controller),
        creation_time_(controller->start_time()),
        removal_time_() {}

  ~ShelfSpinnerData() = default;

  // Returns true if we are currently fading the spinner in. This will also
  // return true when the spinner is animating but has finished fading in.
  bool IsFadingIn() const {
    return !IsKilled() || (base::Time::Now() < removal_time_);
  }

  // Returns true if we have completed the fade-out animation.
  bool IsFinished() const {
    return IsKilled() && base::Time::Now() >= removal_time_ + kFadeOutDuration;
  }

  // Returns true if this spinner has been killed (no matter what stage of the
  // animation it is up to).
  bool IsKilled() const { return controller_ == nullptr; }

  // Marks the spinner as completed, which begins the fade out animation
  // either now, or at a point in the future when the minimum show duration
  // has been met.
  void Kill() {
    removal_time_ =
        std::max(base::Time::Now(), creation_time_ + kMinimumShowDuration);
    controller_ = nullptr;
  }

  ShelfSpinnerItemController* controller() const { return controller_; }

  // Get a timestamp for when the spinner was started.
  base::Time creation_time() const { return creation_time_; }

  // Get a timestamp for when the spinner's fade-out animation begins. This
  // will be in the future if the spiiner was Kill()ed before the minimum show
  // duration was reached.
  base::Time removal_time() const { return removal_time_; }

 private:
  raw_ptr<ShelfSpinnerItemController, DanglingUntriaged> controller_;
  base::Time creation_time_;
  base::Time removal_time_;
};

namespace {

class SpinningEffectSource : public gfx::CanvasImageSource {
 public:
  SpinningEffectSource(ShelfSpinnerController::ShelfSpinnerData data,
                       const gfx::ImageSkia& image,
                       bool is_pinned)
      : gfx::CanvasImageSource(image.size()),
        data_(std::move(data)),
        active_image_(
            (is_pinned || !data_.IsFadingIn())
                ? image
                : gfx::ImageSkiaOperations::CreateTransparentImage(image, 0)),
        inactive_image_(gfx::ImageSkiaOperations::CreateTransparentImage(
            gfx::ImageSkiaOperations::CreateHSLShiftedImage(image,
                                                            kInactiveHslShift),
            kInactiveTransparency)) {}

  SpinningEffectSource(const SpinningEffectSource&) = delete;
  SpinningEffectSource& operator=(const SpinningEffectSource&) = delete;

  ~SpinningEffectSource() override {}

  // gfx::CanvasImageSource override.
  void Draw(gfx::Canvas* canvas) override {
    base::Time now = base::Time::Now();
    double animation_lirp = GetAnimationStage(now);

    canvas->DrawImageInt(gfx::ImageSkiaOperations::CreateBlendedImage(
                             inactive_image_, active_image_, animation_lirp),
                         0, 0);

    const int gap = kSpinningGapPercent * inactive_image_.width() / 100;
    constexpr SkColor kThrobberColor = SK_ColorWHITE;
    gfx::PaintThrobberSpinning(
        canvas,
        gfx::Rect(gap, gap, inactive_image_.width() - 2 * gap,
                  inactive_image_.height() - 2 * gap),
        SkColorSetA(kThrobberColor, SkColorGetA(kThrobberColor) *
                                        (1.0 - std::abs(animation_lirp))),
        now - data_.creation_time());
  }

 private:
  // Returns a number in the range [0, 1] where:
  //  - 0   -> spinner image is completely shown.
  //  - 0.5 -> spinner image is half-way gone.
  //  - 1   -> normal image is shown.
  double GetAnimationStage(const base::Time& now) {
    if (data_.IsFadingIn()) {
      return 1.0 -
             TimeProportionSince(data_.creation_time(), now, kFadeInDuration);
    }

    return TimeProportionSince(data_.removal_time(), now, kFadeOutDuration);
  }

  ShelfSpinnerController::ShelfSpinnerData data_;
  const gfx::ImageSkia active_image_;
  const gfx::ImageSkia inactive_image_;
};

}  // namespace

ShelfSpinnerController::ShelfSpinnerController(ChromeShelfController* owner)
    : owner_(owner) {
  owner->shelf_model()->AddObserver(this);
  if (user_manager::UserManager::IsInitialized()) {
    if (auto* active_user = user_manager::UserManager::Get()->GetActiveUser()) {
      current_account_id_ = active_user->GetAccountId();
    } else {
      LOG(ERROR) << "Failed to get active user, UserManager returned null";
    }
  } else {
    LOG(ERROR) << "Failed to get active user, UserManager is not initialized";
  }
}

ShelfSpinnerController::~ShelfSpinnerController() {
  owner_->shelf_model()->RemoveObserver(this);
}

void ShelfSpinnerController::MaybeApplySpinningEffect(const std::string& app_id,
                                                      gfx::ImageSkia* image) {
  DCHECK(image);
  auto it = app_controller_map_.find(app_id);
  if (it == app_controller_map_.end()) {
    return;
  }

  *image = gfx::ImageSkia(std::make_unique<SpinningEffectSource>(
                              it->second, *image, owner_->IsAppPinned(app_id)),
                          image->size());
}

void ShelfSpinnerController::HideSpinner(const std::string& app_id) {
  if (!RemoveSpinnerFromControllerMap(app_id)) {
    return;
  }

  const ash::ShelfID shelf_id(app_id);

  // If the app whose spinner is being hidden is pinned, we don't want to un-pin
  // it when we remove it from the shelf, so disable pin syncing while we update
  // things.
  auto pin_disabler = owner_->GetScopedPinSyncDisabler();
  // The static_cast here is safe, because if the delegate were not a
  // ShelfSpinnerItemController then ShelfItemDelegateChanged would have been
  // called and we would not have reached this place.
  auto delegate =
      owner_->shelf_model()->RemoveItemAndTakeShelfItemDelegate(shelf_id);
  std::unique_ptr<ShelfSpinnerItemController> cast_delegate(
      static_cast<ShelfSpinnerItemController*>(delegate.release()));

  hidden_app_controller_map_.emplace(
      current_account_id_, std::make_pair(app_id, std::move(cast_delegate)));
}

void ShelfSpinnerController::CloseSpinner(const std::string& app_id) {
  if (!RemoveSpinnerFromControllerMap(app_id)) {
    return;
  }

  owner_->ReplaceWithAppShortcutOrRemove(ash::ShelfID(app_id));
  UpdateShelfItemIcon(app_id);
}

bool ShelfSpinnerController::RemoveSpinnerFromControllerMap(
    const std::string& app_id) {
  AppControllerMap::const_iterator it = app_controller_map_.find(app_id);
  if (it == app_controller_map_.end()) {
    return false;
  }

  const ash::ShelfID shelf_id(app_id);
  DCHECK_EQ(it->second.controller(),
            it->second.IsKilled()
                ? nullptr
                : owner_->shelf_model()->GetShelfItemDelegate(shelf_id));
  app_controller_map_.erase(it);

  return true;
}

void ShelfSpinnerController::CloseCrostiniSpinners() {
  std::vector<std::string> app_ids_to_close;
  const Profile* profile =
      ash::ProfileHelper::Get()->GetProfileByAccountId(current_account_id_);
  for (const auto& app_id_controller_pair : app_controller_map_) {
    if (guest_os::IsCrostiniShelfAppId(profile, app_id_controller_pair.first)) {
      app_ids_to_close.push_back(app_id_controller_pair.first);
    }
  }
  for (const auto& app_id : app_ids_to_close) {
    CloseSpinner(app_id);
  }
}

bool ShelfSpinnerController::HasApp(const std::string& app_id) const {
  auto it = app_controller_map_.find(app_id);
  return it != app_controller_map_.end() && !it->second.IsKilled();
}

base::TimeDelta ShelfSpinnerController::GetActiveTime(
    const std::string& app_id) const {
  AppControllerMap::const_iterator it = app_controller_map_.find(app_id);
  if (it == app_controller_map_.end()) {
    return base::TimeDelta();
  }

  return base::Time::Now() - it->second.creation_time();
}

Profile* ShelfSpinnerController::OwnerProfile() {
  return owner_->profile();
}

void ShelfSpinnerController::ShelfItemDelegateChanged(
    const ash::ShelfID& id,
    ash::ShelfItemDelegate* old_delegate,
    ash::ShelfItemDelegate* delegate) {
  auto it = app_controller_map_.find(id.app_id);
  if (it != app_controller_map_.end()) {
    it->second.Kill();
  }
}

void ShelfSpinnerController::ActiveUserChanged(const AccountId& account_id) {
  if (account_id == current_account_id_) {
    LOG(WARNING) << "Tried switching to currently active user";
    return;
  }

  std::vector<std::string> to_hide;
  std::vector<
      std::pair<std::string, std::unique_ptr<ShelfSpinnerItemController>>>
      to_show;

  for (const auto& app_id : app_controller_map_) {
    to_hide.push_back(app_id.first);
  }
  for (auto it = hidden_app_controller_map_.lower_bound(account_id);
       it != hidden_app_controller_map_.upper_bound(account_id); it++) {
    to_show.push_back(std::move(it->second));
  }

  hidden_app_controller_map_.erase(
      hidden_app_controller_map_.lower_bound(account_id),
      hidden_app_controller_map_.upper_bound(account_id));

  for (const auto& app_id : to_hide) {
    HideSpinner(app_id);
  }

  for (auto& app_id_delegate_pair : to_show) {
    AddSpinnerToShelf(app_id_delegate_pair.first,
                      std::move(app_id_delegate_pair.second));
  }

  current_account_id_ = account_id;
}

void ShelfSpinnerController::UpdateShelfItemIcon(const std::string& app_id) {
  owner_->UpdateItemImage(app_id);
}

void ShelfSpinnerController::UpdateApps() {
  if (app_controller_map_.empty()) {
    return;
  }

  RegisterNextUpdate();
  std::vector<std::string> app_ids_to_close;
  for (const auto& pair : app_controller_map_) {
    UpdateShelfItemIcon(pair.first);
    if (pair.second.IsFinished()) {
      app_ids_to_close.emplace_back(pair.first);
    }
  }
  for (const auto& app_id : app_ids_to_close) {
    if (RemoveSpinnerFromControllerMap(app_id)) {
      UpdateShelfItemIcon(app_id);
    }
  }
}

void ShelfSpinnerController::RegisterNextUpdate() {
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
      FROM_HERE,
      base::BindOnce(&ShelfSpinnerController::UpdateApps,
                     weak_ptr_factory_.GetWeakPtr()),
      base::Milliseconds(kUpdateIconIntervalMs));
}

void ShelfSpinnerController::AddSpinnerToShelf(
    const std::string& app_id,
    std::unique_ptr<ShelfSpinnerItemController> controller) {
  const ash::ShelfID shelf_id(app_id);

  // We should only apply the spinner controller only over non-active items.
  const ash::ShelfItem* item = owner_->GetItem(shelf_id);
  if (item && item->status != ash::STATUS_CLOSED) {
    return;
  }

  controller->SetHost(weak_ptr_factory_.GetWeakPtr());
  ShelfSpinnerItemController* item_controller = controller.get();
  if (!item) {
    owner_->CreateAppItem(std::move(controller), ash::STATUS_RUNNING,
                          /*pinned=*/false);
  } else {
    owner_->shelf_model()->ReplaceShelfItemDelegate(shelf_id,
                                                    std::move(controller));
    owner_->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
  }

  if (app_controller_map_.empty()) {
    RegisterNextUpdate();
  }

  app_controller_map_.emplace(app_id, ShelfSpinnerData(item_controller));
}