// 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/media/webrtc/fake_desktop_media_picker_factory.h"

#include <utility>

#include "base/compiler_specific.h"
#include "base/functional/bind.h"
#include "base/memory/weak_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "chrome/browser/media/webrtc/fake_desktop_media_list.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/base/mojom/ui_base_types.mojom-shared.h"

FakeDesktopMediaPicker::FakeDesktopMediaPicker(
    FakeDesktopMediaPickerFactory::TestFlags* expectation)
    : expectation_(expectation),
      picker_params_(Params::RequestSource::kUnknown) {
  expectation_->picker_created = true;
}
FakeDesktopMediaPicker::~FakeDesktopMediaPicker() {
  expectation_->picker_deleted = true;
}

// DesktopMediaPicker interface.
void FakeDesktopMediaPicker::Show(
    const DesktopMediaPicker::Params& params,
    std::vector<std::unique_ptr<DesktopMediaList>> source_lists,
    DoneCallback done_callback) {
  expectation_->picker_shown = true;
  picker_params_ = params;

#if !BUILDFLAG(IS_ANDROID)
  // Android does not use DesktopMediaList. See
  // DesktopMediaPickerFactoryImpl::CreateMediaList.
  bool show_screens = false;
  bool show_windows = false;
  bool show_tabs = false;
  bool show_current_tab = false;
  for (auto& source_list : source_lists) {
    switch (source_list->GetMediaListType()) {
      case DesktopMediaList::Type::kNone:
        break;
      case DesktopMediaList::Type::kScreen:
        show_screens = true;
        break;
      case DesktopMediaList::Type::kWindow:
        show_windows = true;
        break;
      case DesktopMediaList::Type::kWebContents:
        show_tabs = true;
        break;
      case DesktopMediaList::Type::kCurrentTab:
        show_current_tab = true;
        break;
    }
  }
  EXPECT_EQ(expectation_->expect_screens, show_screens);
  EXPECT_EQ(expectation_->expect_windows, show_windows);
  EXPECT_EQ(expectation_->expect_tabs, show_tabs);
  EXPECT_EQ(expectation_->expect_current_tab, show_current_tab);
#endif  // !BUILDFLAG(IS_ANDROID)

  EXPECT_EQ(expectation_->expect_audio, params.request_audio);
  EXPECT_TRUE(params.modality == ui::mojom::ModalType::kChild ||
              params.modality == ui::mojom::ModalType::kWindow);

  if (!expectation_->cancelled) {
    // Post a task to call the callback asynchronously.
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE,
        base::BindOnce(&FakeDesktopMediaPicker::CallCallback,
                       weak_factory_.GetWeakPtr(), std::move(done_callback)));
  } else {
    // If we expect the dialog to be cancelled then store the callback to
    // retain reference to the callback handler.
    done_callback_ = std::move(done_callback);
  }
}

DesktopMediaPicker::Params FakeDesktopMediaPicker::GetParams() {
  return picker_params_;
}

base::WeakPtr<FakeDesktopMediaPicker> FakeDesktopMediaPicker::GetWeakPtr() {
  return weak_factory_.GetWeakPtr();
}

void FakeDesktopMediaPicker::CallCallback(DoneCallback done_callback) {
  CHECK(expectation_->picker_result.has_value());
  std::move(done_callback).Run(expectation_->picker_result.value());
}

FakeDesktopMediaPickerFactory::FakeDesktopMediaPickerFactory() = default;

FakeDesktopMediaPickerFactory::~FakeDesktopMediaPickerFactory() = default;

void FakeDesktopMediaPickerFactory::SetTestFlags(
    base::span<TestFlags> test_flags) {
  test_flags_ = test_flags;
  current_test_ = 0;
}

std::unique_ptr<DesktopMediaPicker> FakeDesktopMediaPickerFactory::CreatePicker(
    const content::MediaStreamRequest* request) {
  EXPECT_LT(current_test_, test_flags_.size());
  if (current_test_ >= test_flags_.size()) {
    return nullptr;
  }
  auto picker =
      std::make_unique<FakeDesktopMediaPicker>(&test_flags_[current_test_]);
  current_test_++;
  picker_ = picker->GetWeakPtr();
  return picker;
}

std::vector<std::unique_ptr<DesktopMediaList>>
FakeDesktopMediaPickerFactory::CreateMediaList(
    const std::vector<DesktopMediaList::Type>& types,
    content::WebContents* web_contents,
    DesktopMediaList::WebContentsFilter includable_web_contents_filter) {
  EXPECT_LE(current_test_, test_flags_.size());
  is_web_contents_excluded_ = !includable_web_contents_filter.Run(web_contents);
  std::vector<std::unique_ptr<DesktopMediaList>> media_lists;
  for (auto source_type : types) {
    media_lists.emplace_back(new FakeDesktopMediaList(source_type));
  }
  return media_lists;
}