// Copyright 2014 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 "content/browser/android/system_ui_resource_manager_impl.h"

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/debug/trace_event.h"
#include "base/location.h"
#include "base/observer_list.h"
#include "base/threading/worker_pool.h"
#include "cc/resources/ui_resource_bitmap.h"
#include "content/public/browser/android/ui_resource_client_android.h"
#include "content/public/browser/android/ui_resource_provider.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkPaint.h"
#include "third_party/skia/include/effects/SkPorterDuff.h"
#include "ui/gfx/android/java_bitmap.h"
#include "ui/gfx/screen.h"

namespace content {
namespace {

SkBitmap CreateOverscrollGlowLBitmap(const gfx::Size& screen_size) {
  const float kSin = 0.5f;    // sin(PI / 6)
  const float kCos = 0.866f;  // cos(PI / 6);

  SkPaint paint;
  paint.setAntiAlias(true);
  paint.setAlpha(0x33);
  paint.setStyle(SkPaint::kFill_Style);

  const float arc_width =
      std::min(screen_size.width(), screen_size.height()) * 0.5f / kSin;
  const float y = kCos * arc_width;
  const float height = arc_width - y;
  gfx::Size bounds(arc_width, height);
  SkRect arc_rect = SkRect::MakeXYWH(
      -arc_width / 2.f, -arc_width - y, arc_width * 2.f, arc_width * 2.f);
  SkBitmap glow_bitmap;
  if (!glow_bitmap.allocPixels(
          SkImageInfo::MakeA8(bounds.width(), bounds.height()))) {
    LOG(FATAL) << " Failed to allocate bitmap of size " << bounds.width() << "x"
               << bounds.height();
  }
  glow_bitmap.eraseColor(SK_ColorTRANSPARENT);

  SkCanvas canvas(glow_bitmap);
  canvas.clipRect(SkRect::MakeXYWH(0, 0, bounds.width(), bounds.height()));
  canvas.drawArc(arc_rect, 45, 90, true, paint);
  return glow_bitmap;
}

void LoadBitmap(ui::SystemUIResourceManager::ResourceType type,
                SkBitmap* bitmap_holder,
                const gfx::Size& screen_size) {
  TRACE_EVENT1(
      "browser", "SystemUIResourceManagerImpl::LoadBitmap", "type", type);
  SkBitmap bitmap;
  switch (type) {
    case ui::SystemUIResourceManager::OVERSCROLL_EDGE:
      bitmap = gfx::CreateSkBitmapFromAndroidResource(
          "android:drawable/overscroll_edge", gfx::Size(128, 12));
      break;
    case ui::SystemUIResourceManager::OVERSCROLL_GLOW:
      bitmap = gfx::CreateSkBitmapFromAndroidResource(
          "android:drawable/overscroll_glow", gfx::Size(128, 64));
      break;
    case ui::SystemUIResourceManager::OVERSCROLL_GLOW_L:
      bitmap = CreateOverscrollGlowLBitmap(screen_size);
      break;
  }
  bitmap.setImmutable();
  *bitmap_holder = bitmap;
}

}  // namespace

class SystemUIResourceManagerImpl::Entry
    : public content::UIResourceClientAndroid {
 public:
  explicit Entry(UIResourceProvider* provider) : id_(0), provider_(provider) {
    DCHECK(provider);
  }

  virtual ~Entry() {
    if (id_)
      provider_->DeleteUIResource(id_);
    id_ = 0;
  }

  void SetBitmap(const SkBitmap& bitmap) {
    DCHECK(!bitmap.empty());
    DCHECK(bitmap_.empty());
    DCHECK(!id_);
    bitmap_ = bitmap;
  }

  cc::UIResourceId GetUIResourceId() {
    if (bitmap_.empty())
      return 0;
    if (!id_)
      id_ = provider_->CreateUIResource(this);
    return id_;
  }

  // content::UIResourceClient implementation.
  virtual cc::UIResourceBitmap GetBitmap(cc::UIResourceId uid,
                                         bool resource_lost) OVERRIDE {
    DCHECK(!bitmap_.empty());
    return cc::UIResourceBitmap(bitmap_);
  }

  // content::UIResourceClientAndroid implementation.
  virtual void UIResourceIsInvalid() OVERRIDE { id_ = 0; }

  const SkBitmap& bitmap() const { return bitmap_; }

 private:
  SkBitmap bitmap_;
  cc::UIResourceId id_;
  UIResourceProvider* provider_;

  DISALLOW_COPY_AND_ASSIGN(Entry);
};

SystemUIResourceManagerImpl::SystemUIResourceManagerImpl(
    UIResourceProvider* ui_resource_provider)
    : ui_resource_provider_(ui_resource_provider), weak_factory_(this) {
}

SystemUIResourceManagerImpl::~SystemUIResourceManagerImpl() {
}

void SystemUIResourceManagerImpl::PreloadResource(ResourceType type) {
  GetEntry(type);
}

cc::UIResourceId SystemUIResourceManagerImpl::GetUIResourceId(
    ResourceType type) {
  return GetEntry(type)->GetUIResourceId();
}

SystemUIResourceManagerImpl::Entry* SystemUIResourceManagerImpl::GetEntry(
    ResourceType type) {
  DCHECK_GE(type, RESOURCE_TYPE_FIRST);
  DCHECK_LE(type, RESOURCE_TYPE_LAST);
  if (!resource_map_[type]) {
    resource_map_[type].reset(new Entry(ui_resource_provider_));
    // Lazily build the resource.
    BuildResource(type);
  }
  return resource_map_[type].get();
}

void SystemUIResourceManagerImpl::BuildResource(ResourceType type) {
  DCHECK(GetEntry(type)->bitmap().empty());

  // Instead of blocking the main thread, we post a task to load the bitmap.
  SkBitmap* bitmap = new SkBitmap();
  gfx::Size screen_size =
      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().GetSizeInPixel();
  base::Closure load_bitmap =
      base::Bind(&LoadBitmap, type, bitmap, screen_size);
  base::Closure finished_load =
      base::Bind(&SystemUIResourceManagerImpl::OnFinishedLoadBitmap,
                 weak_factory_.GetWeakPtr(),
                 type,
                 base::Owned(bitmap));
  base::WorkerPool::PostTaskAndReply(
      FROM_HERE, load_bitmap, finished_load, true);
}

void SystemUIResourceManagerImpl::OnFinishedLoadBitmap(
    ResourceType type,
    SkBitmap* bitmap_holder) {
  DCHECK(bitmap_holder);
  GetEntry(type)->SetBitmap(*bitmap_holder);
}

}  // namespace content