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

#include "components/paint_preview/browser/paint_preview_base_service.h"

#include <memory>
#include <utility>

#include "base/files/scoped_temp_dir.h"
#include "base/strings/strcat.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/bind.h"
#include "base/test/test_future.h"
#include "base/threading/thread_restrictions.h"
#include "build/build_config.h"
#include "components/paint_preview/browser/paint_preview_base_service_test_factory.h"
#include "components/paint_preview/browser/paint_preview_file_mixin.h"
#include "components/paint_preview/common/mock_paint_preview_recorder.h"
#include "components/paint_preview/common/mojom/paint_preview_recorder.mojom.h"
#include "components/paint_preview/common/mojom/paint_preview_types.mojom.h"
#include "components/paint_preview/common/serialized_recording.h"
#include "components/paint_preview/common/test_utils.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/test/navigation_simulator.h"
#include "content/public/test/test_browser_context.h"
#include "content/public/test/test_renderer_host.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"

namespace paint_preview {

using testing::Optional;
using testing::Property;

namespace {

const char kTestFeatureDir[] = "test_feature";

class RejectionPaintPreviewPolicy : public PaintPreviewPolicy {
 public:
  RejectionPaintPreviewPolicy() = default;
  ~RejectionPaintPreviewPolicy() override = default;

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

  bool SupportedForContents(content::WebContents* web_contents) override {
    return false;
  }
};

// Builds a PaintPreviewBaseService associated with |key| which will never
// permit paint previews.
std::unique_ptr<KeyedService> BuildServiceWithRejectionPolicy(
    SimpleFactoryKey* key) {
  return std::make_unique<PaintPreviewBaseService>(
      std::make_unique<PaintPreviewFileMixin>(key->GetPath(), kTestFeatureDir),
      std::make_unique<RejectionPaintPreviewPolicy>(), key->IsOffTheRecord());
}

base::FilePath CreateDir(scoped_refptr<FileManager> manager,
                         const DirectoryKey& key) {
  base::test::TestFuture<std::optional<base::FilePath>> future;
  manager->GetTaskRunner()->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&FileManager::CreateOrGetDirectory, manager, key, false),
      future.GetCallback());
  EXPECT_THAT(future.Get(), Optional(Property(&base::FilePath::empty, false)));
  return future.Take().value();
}

}  // namespace

class NoGuidMockPaintPreviewRecorder : public MockPaintPreviewRecorder {
 public:
  NoGuidMockPaintPreviewRecorder() = default;
  ~NoGuidMockPaintPreviewRecorder() override = default;

 protected:
  void CheckParams(
      const mojom::PaintPreviewCaptureParamsPtr& input_params) override {
    // Ignore GUID and File as this is internal information not known by the
    // Keyed Service API.
    EXPECT_EQ(input_params->geometry_metadata_params->clip_rect,
              expected_params_->geometry_metadata_params->clip_rect);
    if (input_params->is_main_frame) {
      EXPECT_EQ(
          input_params->geometry_metadata_params->clip_x_coord_override,
          expected_params_->geometry_metadata_params->clip_x_coord_override);
      EXPECT_EQ(
          input_params->geometry_metadata_params->clip_y_coord_override,
          expected_params_->geometry_metadata_params->clip_y_coord_override);
    } else {
      EXPECT_EQ(input_params->geometry_metadata_params->clip_x_coord_override,
                mojom::ClipCoordOverride::kNone);
      EXPECT_EQ(input_params->geometry_metadata_params->clip_y_coord_override,
                mojom::ClipCoordOverride::kNone);
    }
    EXPECT_EQ(input_params->is_main_frame, expected_params_->is_main_frame);
  }
};

class PaintPreviewBaseServiceTest
    : public content::RenderViewHostTestHarness,
      public testing::WithParamInterface<RecordingPersistence> {
 public:
  PaintPreviewBaseServiceTest() = default;
  ~PaintPreviewBaseServiceTest() override = default;

  PaintPreviewBaseServiceTest(const PaintPreviewBaseService&) = delete;
  PaintPreviewBaseServiceTest& operator=(const PaintPreviewBaseService&) =
      delete;

 protected:
  void SetUp() override {
    content::RenderViewHostTestHarness::SetUp();
    key_ = std::make_unique<SimpleFactoryKey>(
        browser_context()->GetPath(), browser_context()->IsOffTheRecord());
    PaintPreviewBaseServiceTestFactory::GetInstance()->SetTestingFactory(
        key_.get(),
        base::BindRepeating(&PaintPreviewBaseServiceTestFactory::Build));

    rejection_policy_key_ = std::make_unique<SimpleFactoryKey>(
        browser_context()->GetPath(), browser_context()->IsOffTheRecord());
    PaintPreviewBaseServiceTestFactory::GetInstance()->SetTestingFactory(
        rejection_policy_key_.get(),
        base::BindRepeating(&BuildServiceWithRejectionPolicy));
    content::NavigationSimulator::NavigateAndCommitFromBrowser(
        web_contents(), GURL("https://www.chromium.org"));
  }

  void OverrideInterface(NoGuidMockPaintPreviewRecorder* service) {
    blink::AssociatedInterfaceProvider* remote_interfaces =
        main_rfh()->GetRemoteAssociatedInterfaces();
    remote_interfaces->OverrideBinderForTesting(
        mojom::PaintPreviewRecorder::Name_,
        base::BindRepeating(&NoGuidMockPaintPreviewRecorder::BindRequest,
                            base::Unretained(service)));
  }

  PaintPreviewBaseService* GetService() {
    return PaintPreviewBaseServiceTestFactory::GetForKey(key_.get());
  }

  PaintPreviewBaseService* GetServiceWithRejectionPolicy() {
    return PaintPreviewBaseServiceTestFactory::GetForKey(
        rejection_policy_key_.get());
  }

  PaintPreviewBaseService::CaptureParams CreateCaptureParams(
      content::WebContents* web_contents,
      base::FilePath* root_dir,
      RecordingPersistence persistence,
      gfx::Rect clip_rect,
      mojom::ClipCoordOverride clip_x_coord_override,
      mojom::ClipCoordOverride clip_y_coord_override,
      bool capture_links,
      size_t max_per_capture_size,
      uint64_t max_decoded_image_size_bytes) {
    PaintPreviewBaseService::CaptureParams capture_params;
    capture_params.web_contents = web_contents;
    capture_params.root_dir = root_dir;
    capture_params.persistence = persistence;
    capture_params.clip_rect = clip_rect;
    capture_params.clip_x_coord_override = clip_x_coord_override;
    capture_params.clip_y_coord_override = clip_y_coord_override;
    capture_params.capture_links = capture_links;
    capture_params.max_per_capture_size = max_per_capture_size;
    capture_params.max_decoded_image_size_bytes = max_decoded_image_size_bytes;
    return capture_params;
  }

 private:
  std::unique_ptr<SimpleFactoryKey> key_;
  std::unique_ptr<SimpleFactoryKey> rejection_policy_key_;
};

TEST_P(PaintPreviewBaseServiceTest, CaptureMainFrame) {
  NoGuidMockPaintPreviewRecorder recorder;
  auto params = mojom::PaintPreviewCaptureParams::New();
  params->geometry_metadata_params = mojom::GeometryMetadataParams::New();
  params->geometry_metadata_params->clip_rect = gfx::Rect(0, 0, 0, 0);
  params->geometry_metadata_params->clip_x_coord_override =
      mojom::ClipCoordOverride::kCenterOnScrollOffset;
  params->geometry_metadata_params->clip_y_coord_override =
      mojom::ClipCoordOverride::kScrollOffset;
  params->is_main_frame = true;
  params->max_capture_size = 50;
  params->max_decoded_image_size_bytes = 1000;
  recorder.SetExpectedParams(std::move(params));
  auto response = mojom::PaintPreviewCaptureResponse::New();
  response->geometry_metadata = mojom::GeometryMetadataResponse::New();
  response->embedding_token = std::nullopt;
  if (GetParam() == RecordingPersistence::kMemoryBuffer) {
    response->skp.emplace(mojo_base::BigBuffer());
  }
  recorder.SetResponse(std::move(response));
  OverrideInterface(&recorder);

  auto* service = GetService();
  EXPECT_FALSE(service->IsOffTheRecord());
  auto manager = service->GetFileMixin()->GetFileManager();
  base::FilePath path = CreateDir(
      manager, manager->CreateKey(web_contents()->GetLastCommittedURL()));

  base::RunLoop loop;
  service->CapturePaintPreview(
      CreateCaptureParams(
          web_contents(), &path, GetParam(), gfx::Rect(0, 0, 0, 0),
          mojom::ClipCoordOverride::kCenterOnScrollOffset,
          mojom::ClipCoordOverride::kScrollOffset, true, 50, 1000),
      base::BindLambdaForTesting(
          [&](PaintPreviewBaseService::CaptureStatus status,
              std::unique_ptr<CaptureResult> result) {
            EXPECT_EQ(status, PaintPreviewBaseService::CaptureStatus::kOk);
            EXPECT_TRUE(result->proto.has_root_frame());
            EXPECT_EQ(result->proto.subframes_size(), 0);
            EXPECT_TRUE(result->proto.root_frame().is_main_frame());
            auto token = base::UnguessableToken::Deserialize(
                             result->proto.root_frame().embedding_token_high(),
                             result->proto.root_frame().embedding_token_low())
                             .value();
            switch (GetParam()) {
              case RecordingPersistence::kFileSystem: {
#if BUILDFLAG(IS_WIN)
                base::FilePath received_path = base::FilePath(
                    base::UTF8ToWide(result->proto.root_frame().file_path()));
                base::FilePath name(
                    base::UTF8ToWide(base::StrCat({token.ToString(), ".skp"})));
#else
                base::FilePath received_path =
                    base::FilePath(result->proto.root_frame().file_path());
                base::FilePath name(base::StrCat({token.ToString(), ".skp"}));
#endif
                EXPECT_EQ(received_path.DirName(), path);
                EXPECT_EQ(received_path.BaseName(), name);
              } break;

              case RecordingPersistence::kMemoryBuffer: {
                EXPECT_EQ(result->serialized_skps.size(), 1u);
                EXPECT_TRUE(result->serialized_skps.contains(token));
              } break;

              default:
                NOTREACHED();
            }
            loop.Quit();
          }));
  loop.Run();
}

TEST_P(PaintPreviewBaseServiceTest, CaptureFailed) {
  NoGuidMockPaintPreviewRecorder recorder;
  auto params = mojom::PaintPreviewCaptureParams::New();
  params->geometry_metadata_params = mojom::GeometryMetadataParams::New();
  params->geometry_metadata_params->clip_rect = gfx::Rect(0, 0, 0, 0);
  params->geometry_metadata_params->clip_x_coord_override =
      mojom::ClipCoordOverride::kCenterOnScrollOffset;
  params->geometry_metadata_params->clip_y_coord_override =
      mojom::ClipCoordOverride::kScrollOffset;
  params->is_main_frame = true;
  params->max_capture_size = 0;
  recorder.SetExpectedParams(std::move(params));
  recorder.SetResponse(base::unexpected(mojom::PaintPreviewStatus::kFailed));
  OverrideInterface(&recorder);

  auto* service = GetService();
  EXPECT_FALSE(service->IsOffTheRecord());
  auto manager = service->GetFileMixin()->GetFileManager();
  base::FilePath path = CreateDir(
      manager, manager->CreateKey(web_contents()->GetLastCommittedURL()));

  base::RunLoop loop;
  service->CapturePaintPreview(
      CreateCaptureParams(web_contents(), &path, GetParam(),
                          gfx::Rect(0, 0, 0, 0),
                          mojom::ClipCoordOverride::kCenterOnScrollOffset,
                          mojom::ClipCoordOverride::kScrollOffset, true, 0,
                          std::numeric_limits<uint64_t>::max()),
      base::BindLambdaForTesting(
          [&](PaintPreviewBaseService::CaptureStatus status,
              std::unique_ptr<CaptureResult> result) {
            EXPECT_EQ(status,
                      PaintPreviewBaseService::CaptureStatus::kCaptureFailed);
            EXPECT_EQ(result, nullptr);
            loop.Quit();
          }));
  loop.Run();
}

TEST_P(PaintPreviewBaseServiceTest, CaptureDisallowed) {
  NoGuidMockPaintPreviewRecorder recorder;
  auto params = mojom::PaintPreviewCaptureParams::New();
  params->geometry_metadata_params = mojom::GeometryMetadataParams::New();
  params->geometry_metadata_params->clip_rect = gfx::Rect(0, 0, 0, 0);
  params->geometry_metadata_params->clip_x_coord_override =
      mojom::ClipCoordOverride::kCenterOnScrollOffset;
  params->geometry_metadata_params->clip_y_coord_override =
      mojom::ClipCoordOverride::kScrollOffset;
  params->is_main_frame = true;
  params->max_capture_size = 0;
  recorder.SetExpectedParams(std::move(params));
  OverrideInterface(&recorder);

  auto* service = GetServiceWithRejectionPolicy();
  EXPECT_FALSE(service->IsOffTheRecord());
  auto manager = service->GetFileMixin()->GetFileManager();
  base::FilePath path = CreateDir(
      manager, manager->CreateKey(web_contents()->GetLastCommittedURL()));

  base::RunLoop loop;
  service->CapturePaintPreview(
      CreateCaptureParams(web_contents(), &path, GetParam(),
                          gfx::Rect(0, 0, 0, 0),
                          mojom::ClipCoordOverride::kCenterOnScrollOffset,
                          mojom::ClipCoordOverride::kScrollOffset, true, 0,
                          std::numeric_limits<uint64_t>::max()),
      base::BindLambdaForTesting(
          [&](PaintPreviewBaseService::CaptureStatus status,
              std::unique_ptr<CaptureResult> result) {
            EXPECT_EQ(
                status,
                PaintPreviewBaseService::CaptureStatus::kContentUnsupported);
            EXPECT_EQ(result, nullptr);
            loop.Quit();
          }));
  loop.Run();
}

INSTANTIATE_TEST_SUITE_P(
    All,
    PaintPreviewBaseServiceTest,
    testing::Values(RecordingPersistence::kFileSystem,
                    RecordingPersistence::kMemoryBuffer),
    [](const testing::TestParamInfo<RecordingPersistence>& info) {
      return std::string(PersistenceToString(info.param));
    });

}  // namespace paint_preview