// 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 "chrome/browser/android/explore_sites/get_images_task.h"

#include <memory>

#include "base/logging.h"
#include "base/test/bind_test_util.h"
#include "base/test/mock_callback.h"
#include "chrome/browser/android/explore_sites/explore_sites_schema.h"
#include "components/offline_pages/task/task.h"
#include "components/offline_pages/task/task_test_base.h"
#include "sql/database.h"
#include "sql/meta_table.h"
#include "sql/statement.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using offline_pages::TaskTestBase;

namespace explore_sites {

class ExploreSitesGetImagesTaskTest : public TaskTestBase {
 public:
  ExploreSitesGetImagesTaskTest() = default;
  ~ExploreSitesGetImagesTaskTest() override = default;

  void SetUp() override {
    store_ = std::make_unique<ExploreSitesStore>(task_runner());
  }

  ExploreSitesStore* store() { return store_.get(); }

  void ExecuteSync(base::RepeatingCallback<bool(sql::Database*)> query) {
    store()->Execute(base::OnceCallback<bool(sql::Database*)>(query),
                     base::BindOnce([](bool result) { ASSERT_TRUE(result); }),
                     false);
    RunUntilIdle();
  }

  void PopulateTestingCatalog();

  void ExpectEmptyImageList(EncodedImageList images) {
    EXPECT_EQ(0U, images.size());
  }

  EncodedImageListCallback StoreResult() {
    return base::BindLambdaForTesting(
        [&](EncodedImageList result) { last_result = std::move(result); });
  }

  EncodedImageList last_result;

 private:
  std::unique_ptr<ExploreSitesStore> store_;

  DISALLOW_COPY_AND_ASSIGN(ExploreSitesGetImagesTaskTest);
};

void ExploreSitesGetImagesTaskTest::PopulateTestingCatalog() {
  ExecuteSync(base::BindLambdaForTesting([](sql::Database* db) {
    sql::MetaTable meta_table;
    ExploreSitesSchema::InitMetaTable(db, &meta_table);
    meta_table.SetValue("current_catalog", 5678);
    meta_table.DeleteKey("downloading_catalog");
    sql::Statement insert(db->GetUniqueStatement(R"(
INSERT INTO categories
(category_id, version, type, label)
VALUES
(3, 5678, 1, "label_1"),
(4, 5678, 2, "label_2");)"));
    if (!insert.Run())
      return false;

    sql::Statement insert_sites(db->GetUniqueStatement(R"(
INSERT INTO sites
(site_id, url, category_id, title, favicon)
VALUES
(1, "https://www.example.com/1", 3, "example_1", "bytes1"),
(2, "https://www.example.com/2", 4, "example_2", "bytes2"),
(3, "https://www.example.com/3", 3, "example_3", "bytes3"),
(4, "https://www.example.com/4", 4, "example_4", "bytes4");
    )"));
    return insert_sites.Run();
  }));
}

TEST_F(ExploreSitesGetImagesTaskTest, StoreFailure) {
  store()->SetInitializationStatusForTest(InitializationStatus::FAILURE);

  GetImagesTask task(store(), 1, StoreResult());
  RunTask(&task);
  EXPECT_EQ(0U, last_result.size());
}

TEST_F(ExploreSitesGetImagesTaskTest, SiteDoesNotExist) {
  GetImagesTask task(store(), 43, StoreResult());
  RunTask(&task);
  EXPECT_EQ(0U, last_result.size());
}

TEST_F(ExploreSitesGetImagesTaskTest, CategoryDoesNotExist) {
  GetImagesTask task(store(), 43 /* invalid id */, 4, StoreResult());
  RunTask(&task);
  EXPECT_EQ(0U, last_result.size());
}

TEST_F(ExploreSitesGetImagesTaskTest, SiteExistsAndHasFavicon) {
  PopulateTestingCatalog();
  GetImagesTask task(store(), 1, StoreResult());
  RunTask(&task);

  EXPECT_EQ(1U, last_result.size());
  std::vector<uint8_t>& result = *last_result[0];
  EXPECT_EQ("bytes1", std::string(result.begin(), result.end()));
  last_result.clear();

  GetImagesTask task2(store(), 3, StoreResult());
  RunTask(&task2);

  EXPECT_EQ(1U, last_result.size());
  std::vector<uint8_t>& result3 = *last_result[0];
  EXPECT_EQ("bytes3", std::string(result3.begin(), result3.end()));
}

TEST_F(ExploreSitesGetImagesTaskTest, SitesExistAndNotBlacklisted) {
  PopulateTestingCatalog();
  GetImagesTask task(store(), 3, 4, StoreResult());
  RunTask(&task);

  EXPECT_EQ(2U, last_result.size());
  std::vector<uint8_t>& result = *last_result[0];
  EXPECT_EQ("bytes1", std::string(result.begin(), result.end()));
  std::vector<uint8_t>& result2 = *last_result[1];
  EXPECT_EQ("bytes3", std::string(result2.begin(), result2.end()));
}

TEST_F(ExploreSitesGetImagesTaskTest, SitesExistAndBlacklisted) {
  PopulateTestingCatalog();
  ExecuteSync(base::BindLambdaForTesting([&](sql::Database* db) {
    sql::Statement insert(db->GetUniqueStatement(R"(
INSERT INTO site_blacklist
(url, date_removed)
VALUES
("https://www.example.com/1", 123);)"));
    return insert.Run();
  }));
  GetImagesTask task(store(), 3, 4, StoreResult());
  RunTask(&task);

  EXPECT_EQ(1U, last_result.size());
  std::vector<uint8_t>& result = *last_result[0];
  EXPECT_EQ("bytes3", std::string(result.begin(), result.end()));
  last_result.clear();
}

TEST_F(ExploreSitesGetImagesTaskTest, TooManySitesToReturn) {
  PopulateTestingCatalog();
  // Add 3 more sites to the interesting category, but limit the site max to 4.
  ExecuteSync(base::BindLambdaForTesting([&](sql::Database* db) {
    sql::Statement insert(db->GetUniqueStatement(R"(
INSERT INTO sites
(site_id, url, category_id, title, favicon)
VALUES
(5, "https://www.example.com/5", 3, "example_5", "bytes5"),
(6, "https://www.example.com/6", 3, "example_6", "bytes6"),
(7, "https://www.example.com/7", 3, "example_7", "bytes7");)"));
    return insert.Run();
  }));
  GetImagesTask task(store(), 3, 4, StoreResult());
  RunTask(&task);

  EXPECT_EQ(4U, last_result.size());
}

}  // namespace explore_sites