// Copyright 2021 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/ash/printing/cups_print_job_manager_utils.h"

#include <memory>
#include <ostream>
#include <utility>
#include <vector>

#include "base/test/scoped_mock_clock_override.h"
#include "chrome/browser/ash/printing/cups_print_job.h"
#include "chrome/browser/ash/printing/history/print_job_info.pb.h"
#include "chrome/browser/printing/printer_query.h"
#include "chromeos/crosapi/mojom/local_printer.mojom.h"
#include "content/public/browser/global_routing_id.h"
#include "content/public/test/browser_task_environment.h"
#include "printing/backend/cups_jobs.h"
#include "printing/print_settings.h"
#include "printing/printed_document.h"
#include "printing/printer_status.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash {

namespace {

using State = CupsPrintJob::State;
using ::printing::CupsJob;
using PrinterReason = ::printing::PrinterStatus::PrinterReason;
using ::chromeos::PrinterErrorCode;

constexpr int kTotalPages = 2;

// Timeout value defined in cups_print_job_manager_utils.cc
constexpr int kTimeout = 30;

struct Params {
  Params(State state,
         int pages,
         CupsJob::JobState job_state,
         std::vector<CupsJob::JobStateReason> job_state_reasons,
         int job_pages,
         State expected_state,
         int expected_pages)
      : state(state),
        pages(pages),
        job_state(job_state),
        job_state_reasons(std::move(job_state_reasons)),
        job_pages(job_pages),
        expected_state(expected_state),
        expected_pages(expected_pages) {}

  // Test state transition that does not affect the page count.
  // `job_pages` is set to `kTotalPages` so that terminal events such as
  // `JobState::COMPLETED` work properly.
  Params(State state,
         CupsJob::JobState job_state,
         std::vector<CupsJob::JobStateReason> job_state_reasons,
         State expected_state)
      : Params(state,
               0,
               job_state,
               std::move(job_state_reasons),
               kTotalPages,
               expected_state,
               0) {}

  State state;
  int pages;
  CupsJob::JobState job_state;
  std::vector<CupsJob::JobStateReason> job_state_reasons;
  // Current printed page count.
  // The total print job page count for the tests is `kTotalPages`.
  int job_pages;
  State expected_state;
  int expected_pages;
};

std::ostream& operator<<(std::ostream& out, const Params& params) {
  out << "state: " << static_cast<int>(params.state) << ", ";
  out << "pages: " << params.pages << ", ";
  out << "job_state: " << params.job_state << ", ";
  for (const auto& job_state_reason : params.job_state_reasons) {
    out << "job_state_reason: "
        << ::printing::ToJobStateReasonString(job_state_reason) << ", ";
  }
  out << "job_pages: " << params.job_pages << ", ";
  out << "expected_state: " << static_cast<int>(params.expected_state) << ", ";
  out << "expected_pages: " << params.expected_pages << std::endl;
  return out;
}

std::vector<Params> GenerateParams(CupsJob::JobState job_state,
                                   State terminal_state) {
  std::vector<Params> params;
  for (State state :
       {State::STATE_WAITING, State::STATE_STARTED, State::STATE_PAGE_DONE}) {
    params.emplace_back(state, job_state,
                        std::vector<CupsJob::JobStateReason>(), terminal_state);
  }
  return params;
}

// Transition from 'STATE_WAITING' to `STATE_STARTED` before
// `STATE_PAGE_DONE`, even if a page has finished printing.
std::vector<Params> WaitingToStarted() {
  std::vector<Params> params;

  for (int i = 0; i <= kTotalPages; i++) {
    params.emplace_back(State::STATE_WAITING, 0, CupsJob::PROCESSING,
                        std::vector<CupsJob::JobStateReason>(), i,
                        State::STATE_STARTED, i);
  }

  return params;
}

// Transition from `STATE_STARTED` to `STATE_PAGE_DOWN`.
std::vector<Params> StartedToPageDone() {
  std::vector<Params> params;

  for (int i = 1; i <= kTotalPages; i++) {
    params.emplace_back(State::STATE_STARTED, 1, CupsJob::PROCESSING,
                        std::vector<CupsJob::JobStateReason>(), i,
                        State::STATE_PAGE_DONE, i);
  }

  return params;
}

// Process the second page and subsequent pages in `STATE_PAGE_DONE`.
std::vector<Params> PageDoneToPageDone() {
  std::vector<Params> params;

  for (int i = 1; i <= kTotalPages; i++) {
    for (int j = i; j <= kTotalPages; j++) {
      params.emplace_back(State::STATE_PAGE_DONE, i, CupsJob::PROCESSING,
                          std::vector<CupsJob::JobStateReason>(), j,
                          State::STATE_PAGE_DONE, j);
    }
  }

  return params;
}

using CupsPrintJobManagerUtilsTest = testing::TestWithParam<Params>;

INSTANTIATE_TEST_SUITE_P(
    Completed,
    CupsPrintJobManagerUtilsTest,
    testing::ValuesIn(GenerateParams(CupsJob::COMPLETED,
                                     State::STATE_DOCUMENT_DONE)));

INSTANTIATE_TEST_SUITE_P(
    CompletedCancelledAtDevice,
    CupsPrintJobManagerUtilsTest,
    testing::Values(Params(State::STATE_STARTED,
                           /*pages=*/1,
                           CupsJob::COMPLETED,
                           std::vector<CupsJob::JobStateReason>(),
                           /*job_pages=*/1,
                           State::STATE_CANCELLED,
                           /*expected_pages=*/1)));

INSTANTIATE_TEST_SUITE_P(
    Cancelled,
    CupsPrintJobManagerUtilsTest,
    testing::ValuesIn(GenerateParams(CupsJob::CANCELED,
                                     State::STATE_CANCELLED)));
INSTANTIATE_TEST_SUITE_P(
    Failed,
    CupsPrintJobManagerUtilsTest,
    testing::ValuesIn(GenerateParams(CupsJob::ABORTED, State::STATE_FAILED)));

INSTANTIATE_TEST_SUITE_P(
    ClientUnauthorizedToStateFailed,
    CupsPrintJobManagerUtilsTest,
    testing::Values(
        Params(State::STATE_SUSPENDED,
               CupsJob::HELD,
               std::vector<CupsJob::JobStateReason>{
                   CupsJob::JobStateReason::kCupsHeldForAuthentication},
               State::STATE_FAILED)));

INSTANTIATE_TEST_SUITE_P(
    FilterFailedtoStateFailed,
    CupsPrintJobManagerUtilsTest,
    testing::Values(
        Params(State::STATE_SUSPENDED,
               CupsJob::STOPPED,
               std::vector<CupsJob::JobStateReason>{
                   CupsJob::JobStateReason::kJobCompletedWithErrors},
               State::STATE_FAILED)));

INSTANTIATE_TEST_SUITE_P(
    Pending,
    CupsPrintJobManagerUtilsTest,
    testing::Values(Params(State::STATE_WAITING,
                           CupsJob::PENDING,
                           std::vector<CupsJob::JobStateReason>(),
                           State::STATE_WAITING)));

INSTANTIATE_TEST_SUITE_P(ProcessingWaitingToStarted,
                         CupsPrintJobManagerUtilsTest,
                         testing::ValuesIn(WaitingToStarted()));

INSTANTIATE_TEST_SUITE_P(
    ProcessingWaitingToStartedUnknownState,
    CupsPrintJobManagerUtilsTest,
    testing::Values(Params(State::STATE_WAITING,
                           0,
                           CupsJob::PROCESSING,
                           std::vector<CupsJob::JobStateReason>(),
                           -1,
                           State::STATE_STARTED,
                           0)));

INSTANTIATE_TEST_SUITE_P(
    ProcessingStartedToStarted,
    CupsPrintJobManagerUtilsTest,
    testing::Values(Params(State::STATE_STARTED,
                           0,
                           CupsJob::PROCESSING,
                           std::vector<CupsJob::JobStateReason>(),
                           0,
                           State::STATE_STARTED,
                           0)));

INSTANTIATE_TEST_SUITE_P(
    ProcessingStartedToStartedUnknownState,
    CupsPrintJobManagerUtilsTest,
    testing::Values(Params(State::STATE_STARTED,
                           0,
                           CupsJob::PROCESSING,
                           std::vector<CupsJob::JobStateReason>(),
                           -1,
                           State::STATE_STARTED,
                           0)));

INSTANTIATE_TEST_SUITE_P(ProcessingStartedToPageDone,
                         CupsPrintJobManagerUtilsTest,
                         testing::ValuesIn(StartedToPageDone()));

INSTANTIATE_TEST_SUITE_P(ProcessingPageDoneToPageDone,
                         CupsPrintJobManagerUtilsTest,
                         testing::ValuesIn(PageDoneToPageDone()));

TEST_P(CupsPrintJobManagerUtilsTest, UpdatePrintJob) {
  const Params& params = GetParam();
  CupsJob job;
  job.id = 0;
  job.state = params.job_state;
  job.current_pages = params.job_pages;
  for (const auto& job_state_reason : params.job_state_reasons) {
    job.state_reasons.push_back(
        ::printing::ToJobStateReasonString(job_state_reason).data());
  }
  CupsPrintJob print_job(chromeos::Printer(), 0, std::string(), kTotalPages,
                         crosapi::mojom::PrintJob::Source::kUnknown,
                         std::string(), printing::proto::PrintSettings());
  print_job.set_state(params.state);
  print_job.set_printed_page_number(params.pages);
  bool expected_print_job_updated = params.state != params.expected_state ||
                                    params.pages != params.expected_pages;
  EXPECT_EQ(expected_print_job_updated,
            UpdatePrintJob(::printing::PrinterStatus(), job, &print_job));
  EXPECT_EQ(params.expected_state, print_job.state());
  EXPECT_EQ(params.expected_pages, print_job.printed_page_number());
}

// Testing the behavior that CUPS is allowed to have a few seconds to reset a
// connection ot the printer.
TEST(CupsPrintJobManagerUtilsTest, UpdatePrintJobTimeout) {
  base::ScopedMockClockOverride mock_clock;

  CupsJob job;
  job.id = 0;
  job.state = CupsJob::PROCESSING;

  CupsPrintJob print_job(chromeos::Printer(), 0, std::string(), kTotalPages,
                         crosapi::mojom::PrintJob::Source::kUnknown,
                         std::string(), printing::proto::PrintSettings());
  print_job.set_state(State::STATE_STARTED);

  PrinterReason printer_reason;
  printer_reason.severity = PrinterReason::Severity::kError;
  printer_reason.reason = PrinterReason::Reason::kTimedOut;

  ::printing::PrinterStatus printer_status;
  printer_status.reasons.push_back(printer_reason);

  // Idle time is less than CUPS timeout limit. No error should be found.
  mock_clock.Advance(base::Seconds(kTimeout - 1));

  UpdatePrintJob(printer_status, job, &print_job);

  EXPECT_EQ(print_job.error_code(), PrinterErrorCode::NO_ERROR);
  EXPECT_EQ(print_job.state(), State::STATE_STARTED);

  // Idle time is more than CUPS timeout limit. Error should be returned.
  mock_clock.Advance(base::Seconds(kTimeout + 1));

  UpdatePrintJob(printer_status, job, &print_job);

  EXPECT_EQ(print_job.error_code(), PrinterErrorCode::PRINTER_UNREACHABLE);
  EXPECT_EQ(print_job.state(), CupsPrintJob::State::STATE_FAILED);
}

// Parameters required for CalculatePrintJobPageTotalTest.
struct PrintJobPageTotalParams {
  // Pages in document.
  int pages = 0;
  // Copies requested in settings.
  int copies = 0;
  // Expected total pages to be returned.
  int expected_total = 0;
};

// Test configuration required for setting up fake PrintedDocument.
class CalculatePrintJobPageTotalTest
    : public testing::TestWithParam<PrintJobPageTotalParams> {
 public:
  CalculatePrintJobPageTotalTest()
      : task_environment_(std::make_unique<content::BrowserTaskEnvironment>()) {
  }
  ~CalculatePrintJobPageTotalTest() override = default;

 private:
  // We need to create a MessageLoop, otherwise a bunch of things fails.
  std::unique_ptr<content::BrowserTaskEnvironment> task_environment_;
};

INSTANTIATE_TEST_SUITE_P(NoCopies,
                         CalculatePrintJobPageTotalTest,
                         testing::Values(PrintJobPageTotalParams{
                             .pages = 1,
                             .copies = 0,
                             .expected_total = 1}));

INSTANTIATE_TEST_SUITE_P(WithCopies,
                         CalculatePrintJobPageTotalTest,
                         testing::Values(PrintJobPageTotalParams{
                             .pages = 2,
                             .copies = 5,
                             .expected_total = 10}));

// Verify correct total number of pages generated based on incoming
// `::printing::PrintedDocument`.
TEST_P(CalculatePrintJobPageTotalTest, CalculatesPrintJobPageTotal) {
  const PrintJobPageTotalParams& param = GetParam();
  auto query =
      ::printing::PrinterQuery::Create(content::GlobalRenderFrameHostId());
  auto settings = std::make_unique<::printing::PrintSettings>();
  settings->set_copies(param.copies);
  auto new_doc = base::MakeRefCounted<::printing::PrintedDocument>(
      std::move(settings), u"fake.pdf", query->cookie());
  new_doc->set_page_count(param.pages);

  // Get total pages for document.
  int total_pages = CalculatePrintJobTotalPages(new_doc.get());

  // Verify totals match.
  ASSERT_EQ(param.expected_total, total_pages);
}

}  // namespace
}  // namespace ash