// 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 "components/enhanced_bookmarks/image_store.h"

#include "base/files/file_path.h"
#include "base/files/scoped_temp_dir.h"
#include "base/strings/string_number_conversions.h"
#include "components/enhanced_bookmarks/image_record.h"
#include "components/enhanced_bookmarks/image_store_util.h"
#include "components/enhanced_bookmarks/persistent_image_store.h"
#include "components/enhanced_bookmarks/test_image_store.h"
#include "sql/statement.h"
#include "testing/platform_test.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkColor.h"
#include "url/gurl.h"

namespace {

scoped_ptr<gfx::Image> CreateImage(
    int width, int height, int a, int r, int g, int b) {
  SkBitmap bitmap;
  bitmap.allocN32Pixels(width, height);
  bitmap.eraseARGB(a, r, g, b);
  scoped_ptr<gfx::Image> image(
      new gfx::Image(gfx::Image::CreateFrom1xBitmap(bitmap)));

#if defined(OS_IOS)
  // Make sure the image has a kImageRepCocoaTouch.
  image->ToUIImage();
#endif  // defined(OS_IOS)

  return image;
}

scoped_ptr<gfx::Image> GenerateWhiteImage() {
  return CreateImage(42, 24, 255, 255, 255, 255);
}

scoped_ptr<gfx::Image> GenerateBlackImage(int width, int height) {
  return CreateImage(width, height, 255, 0, 0, 0);
}

scoped_ptr<gfx::Image> GenerateBlackImage() {
  return GenerateBlackImage(42, 24);
}

// Returns true if the two images are identical.
bool CompareImages(const gfx::Image& image_1, const gfx::Image& image_2) {
  if (image_1.IsEmpty() && image_2.IsEmpty())
    return true;

  if (image_1.IsEmpty() || image_2.IsEmpty())
    return false;

  scoped_refptr<base::RefCountedMemory> image_1_bytes =
      enhanced_bookmarks::BytesForImage(image_1);
  scoped_refptr<base::RefCountedMemory> image_2_bytes =
      enhanced_bookmarks::BytesForImage(image_2);

  if (image_1_bytes->size() != image_2_bytes->size())
    return false;

  return !memcmp(image_1_bytes->front(),
                 image_2_bytes->front(),
                 image_1_bytes->size());
}

bool CreateV1PersistentImageStoreDB(const base::FilePath& path) {
  sql::Connection db;
  if (!db.Open(path))
    return false;

  if (db.DoesTableExist("images_by_url"))
    return false;

  const char kV1TableSql[] =
      "CREATE TABLE IF NOT EXISTS images_by_url ("
      "page_url LONGVARCHAR NOT NULL,"
      "image_url LONGVARCHAR NOT NULL,"
      "image_data BLOB,"
      "width INTEGER,"
      "height INTEGER"
      ")";
  if (!db.Execute(kV1TableSql))
    return false;

  const char kV1IndexSql[] =
      "CREATE INDEX IF NOT EXISTS images_by_url_idx ON images_by_url(page_url)";
  if (!db.Execute(kV1IndexSql))
    return false;

  sql::Statement statement(db.GetUniqueStatement(
      "INSERT INTO images_by_url "
      "(page_url, image_url, image_data, width, height) "
      "VALUES (?, ?, ?, ?, ?)"));
  statement.BindString(0, "foo://bar");
  statement.BindString(1, "http://a.jpg");
  scoped_refptr<base::RefCountedMemory> image_bytes =
      enhanced_bookmarks::BytesForImage(*GenerateWhiteImage());
  statement.BindBlob(2, image_bytes->front(), (int)image_bytes->size());
  statement.BindInt(3, 42);
  statement.BindInt(4, 24);

  return statement.Run();
}

// Factory functions for creating instances of the implementations.
template <class T>
ImageStore* CreateStore(base::ScopedTempDir& folder);

template <>
ImageStore* CreateStore<TestImageStore>(
    base::ScopedTempDir& folder) {
  return new TestImageStore();
}

template <>
ImageStore* CreateStore<PersistentImageStore>(
    base::ScopedTempDir& folder) {
  return new PersistentImageStore(folder.path());
}

// Methods to check if persistence is on or not.
template <class T> bool ShouldPersist();
template <> bool ShouldPersist<TestImageStore>() { return false; }
template <> bool ShouldPersist<PersistentImageStore>() { return true; }

// Test fixture class template for the abstract API.
template <class T>
class ImageStoreUnitTest : public PlatformTest {
 protected:
  ImageStoreUnitTest() {}
  ~ImageStoreUnitTest() override {}

  void SetUp() override {
    bool success = tempDir_.CreateUniqueTempDir();
    ASSERT_TRUE(success);
    store_.reset(CreateStore<T>(tempDir_));
  }

  void TearDown() override {
    if (store_ && use_persistent_store())
      store_->ClearAll();
  }

  bool use_persistent_store() const { return ShouldPersist<T>(); }
  void ResetStore() { store_.reset(CreateStore<T>(tempDir_)); }

  // The directory the database is saved into.
  base::ScopedTempDir tempDir_;
  // The object the fixture is testing, via its base interface.
  scoped_ptr<ImageStore> store_;

 private:
  DISALLOW_COPY_AND_ASSIGN(ImageStoreUnitTest);
};

// The list of implementations of the abstract API that are going to be tested.
typedef testing::Types<TestImageStore,
                       PersistentImageStore> Implementations;

TYPED_TEST_CASE(ImageStoreUnitTest, Implementations);

// All those tests are run on all the implementations.
TYPED_TEST(ImageStoreUnitTest, StartsEmpty) {
  std::set<GURL> all_urls;
  this->store_->GetAllPageUrls(&all_urls);
  EXPECT_EQ(0u, all_urls.size());
}

TYPED_TEST(ImageStoreUnitTest, StoreOne) {
  scoped_refptr<enhanced_bookmarks::ImageRecord> image(
      new enhanced_bookmarks::ImageRecord(
          GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK));
  this->store_->Insert(GURL("foo://bar"), image);

  std::set<GURL> all_urls;
  this->store_->GetAllPageUrls(&all_urls);
  EXPECT_EQ(1u, all_urls.size());
  EXPECT_EQ(GURL("foo://bar"), *all_urls.begin());
  EXPECT_TRUE(this->store_->HasKey(GURL("foo://bar")));
}

TYPED_TEST(ImageStoreUnitTest, Retrieve) {
  const GURL url("foo://bar");
  scoped_refptr<enhanced_bookmarks::ImageRecord> image_in(
      new enhanced_bookmarks::ImageRecord(
          CreateImage(42, 24, 1, 0, 0, 1), GURL("http://a.jpg"), SK_ColorBLUE));
  this->store_->Insert(url, image_in);

  scoped_refptr<enhanced_bookmarks::ImageRecord> image_out =
      this->store_->Get(url);
  const gfx::Size size = this->store_->GetSize(url);

  EXPECT_EQ(42, size.width());
  EXPECT_EQ(24, size.height());
  EXPECT_EQ(image_in->url, image_out->url);
  EXPECT_TRUE(CompareImages(*image_in->image, *image_out->image));
  EXPECT_EQ(SK_ColorBLUE, image_out->dominant_color);
}

TYPED_TEST(ImageStoreUnitTest, Erase) {
  const GURL url("foo://bar");
  scoped_refptr<enhanced_bookmarks::ImageRecord> image(
      new enhanced_bookmarks::ImageRecord(
          GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK));
  this->store_->Insert(url, image);
  this->store_->Erase(url);

  EXPECT_FALSE(this->store_->HasKey(url));
  std::set<GURL> all_urls;
  this->store_->GetAllPageUrls(&all_urls);
  EXPECT_EQ(0u, all_urls.size());
}

TYPED_TEST(ImageStoreUnitTest, ClearAll) {
  const GURL url_foo("http://foo");
  scoped_refptr<enhanced_bookmarks::ImageRecord> black_image(
      new enhanced_bookmarks::ImageRecord(
          GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK));
  this->store_->Insert(url_foo, black_image);
  const GURL url_bar("http://bar");
  scoped_refptr<enhanced_bookmarks::ImageRecord> white_image(
      new enhanced_bookmarks::ImageRecord(
          GenerateWhiteImage(), GURL("http://a.jpg"), SK_ColorWHITE));
  this->store_->Insert(url_bar, white_image);

  this->store_->ClearAll();

  EXPECT_FALSE(this->store_->HasKey(url_foo));
  EXPECT_FALSE(this->store_->HasKey(url_bar));
  std::set<GURL> all_urls;
  this->store_->GetAllPageUrls(&all_urls);
  EXPECT_EQ(0u, all_urls.size());
}

TYPED_TEST(ImageStoreUnitTest, Update) {
  const GURL url("foo://bar");

  scoped_refptr<enhanced_bookmarks::ImageRecord> image1(
      new enhanced_bookmarks::ImageRecord(
          GenerateWhiteImage(), GURL("1.jpg"), SK_ColorWHITE));
  this->store_->Insert(url, image1);

  scoped_refptr<enhanced_bookmarks::ImageRecord> image2(
      new enhanced_bookmarks::ImageRecord(
          GenerateBlackImage(), GURL("2.jpg"), SK_ColorBLACK));
  this->store_->Insert(url, image2);

  scoped_refptr<enhanced_bookmarks::ImageRecord> image_out =
      this->store_->Get(url);

  EXPECT_TRUE(this->store_->HasKey(url));
  std::set<GURL> all_urls;
  this->store_->GetAllPageUrls(&all_urls);
  EXPECT_EQ(1u, all_urls.size());
  EXPECT_EQ(image2->url, image_out->url);
  EXPECT_TRUE(CompareImages(*image2->image, *image_out->image));
  EXPECT_EQ(SK_ColorBLACK, image_out->dominant_color);
}

TYPED_TEST(ImageStoreUnitTest, Persistence) {
  const GURL url("foo://bar");
  scoped_refptr<enhanced_bookmarks::ImageRecord> image_in(
      new enhanced_bookmarks::ImageRecord(
          GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK));
  this->store_->Insert(url, image_in);

  this->ResetStore();
  if (this->use_persistent_store()) {
    std::set<GURL> all_urls;
    this->store_->GetAllPageUrls(&all_urls);
    EXPECT_EQ(1u, all_urls.size());
    EXPECT_EQ(url, *all_urls.begin());
    EXPECT_TRUE(this->store_->HasKey(url));
    scoped_refptr<enhanced_bookmarks::ImageRecord> image_out =
        this->store_->Get(url);

    EXPECT_EQ(image_in->url, image_out->url);
    EXPECT_TRUE(CompareImages(*image_in->image, *image_out->image));
    EXPECT_EQ(image_in->dominant_color, image_out->dominant_color);
  } else {
    std::set<GURL> all_urls;
    this->store_->GetAllPageUrls(&all_urls);
    EXPECT_EQ(0u, all_urls.size());
    EXPECT_FALSE(this->store_->HasKey(url));
  }
}

TYPED_TEST(ImageStoreUnitTest, MigrationToV2) {
  // Migration is available only with persistent stores.
  if (!this->use_persistent_store())
    return;

  // Set up v1 DB.
  EXPECT_TRUE(CreateV1PersistentImageStoreDB(this->tempDir_.path().Append(
      base::FilePath::FromUTF8Unsafe("BookmarkImageAndUrlStore.db"))));

  scoped_refptr<enhanced_bookmarks::ImageRecord> image_out =
      this->store_->Get(GURL("foo://bar"));
  EXPECT_EQ(SK_ColorWHITE, image_out->dominant_color);
}

TYPED_TEST(ImageStoreUnitTest, GetSize) {
  const GURL url("foo://bar");
  scoped_refptr<enhanced_bookmarks::ImageRecord> image_in(
      new enhanced_bookmarks::ImageRecord(
          GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK));

  int64 size = 0;
  if (this->use_persistent_store()) {
    // File shouldn't exist before we actually start using it since we do lazy
    // initialization.
    EXPECT_EQ(this->store_->GetStoreSizeInBytes(), -1);
  } else {
    EXPECT_LE(this->store_->GetStoreSizeInBytes(), 1024);
  }
  for (int i = 0; i < 100; ++i) {
    this->store_->Insert(GURL(url.spec() + '/' + base::IntToString(i)),
                         image_in);
    EXPECT_GE(this->store_->GetStoreSizeInBytes(), size);
    size = this->store_->GetStoreSizeInBytes();
  }

  if (this->use_persistent_store()) {
    EXPECT_GE(this->store_->GetStoreSizeInBytes(),  80 * 1024); //  80kb
    EXPECT_LE(this->store_->GetStoreSizeInBytes(), 200 * 1024); // 200kb
  } else {
    EXPECT_GE(this->store_->GetStoreSizeInBytes(), 400 * 1024); // 400kb
    EXPECT_LE(this->store_->GetStoreSizeInBytes(), 500 * 1024); // 500kb
  }
}

}  // namespace