// Copyright 2020 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/ash/scanning/scanning_type_converters.h"

#include "ash/webui/scanning/mojom/scanning.mojom.h"
#include "chromeos/dbus/lorgnette/lorgnette_service.pb.h"
#include "mojo/public/cpp/bindings/enum_traits.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash {

namespace {

using ::testing::ElementsAreArray;

namespace mojo_ipc = scanning::mojom;

// POD struct for ScannerCapabilitiesTest.
struct ScannerCapabilitiesTestParams {
  lorgnette::SourceType lorgnette_source_type;
  lorgnette::ColorMode lorgnette_color_mode;
  mojo_ipc::SourceType mojom_source_type;
  mojo_ipc::ColorMode mojom_color_mode;
};

// POD struct for ScanSettingsTest.
struct ScanSettingsTestParams {
  mojo_ipc::ColorMode mojom_color_mode;
  lorgnette::ColorMode lorgnette_color_mode;
  mojo_ipc::FileType mojom_file_type;
  lorgnette::ImageFormat lorgnete_image_format;
  mojo_ipc::PageSize mojom_page_size;
  double bottom_right_x;
  double bottom_right_y;
};

// Document source name used for tests.
constexpr char kDocumentSourceName[] = "Test Name";

// Scannable area dimensions used for tests. These are large enough to ensure
// every page size is supported by the scanner.
constexpr int kScanAreaWidthMm = 500;
constexpr int kScanAreaHeightMm = 750;

// Resolutions used for tests.
constexpr uint32_t kFirstResolution = 75;
constexpr uint32_t kSecondResolution = 300;

// Returns a DocumentSource object with the given |source_type|.
lorgnette::DocumentSource CreateLorgnetteDocumentSource(
    lorgnette::SourceType source_type) {
  lorgnette::DocumentSource source;
  source.set_type(source_type);
  source.set_name(kDocumentSourceName);
  source.mutable_area()->set_width(kScanAreaWidthMm);
  source.mutable_area()->set_height(kScanAreaHeightMm);
  return source;
}

// Returns a ScannerCapabilities object with the given |source_type| and
// |color_mode|.
lorgnette::ScannerCapabilities CreateLorgnetteScannerCapabilities(
    lorgnette::SourceType source_type,
    lorgnette::ColorMode color_mode) {
  lorgnette::ScannerCapabilities caps;
  *caps.add_sources() = CreateLorgnetteDocumentSource(source_type);
  caps.add_color_modes(color_mode);
  caps.add_resolutions(kFirstResolution);
  caps.add_resolutions(kSecondResolution);
  return caps;
}

// Returns a ScanSettingsPtr with the given |color_mode|, |page_size| and
// |file_type|.
mojo_ipc::ScanSettingsPtr CreateMojomScanSettings(
    mojo_ipc::ColorMode color_mode,
    mojo_ipc::PageSize page_size,
    mojo_ipc::FileType file_type) {
  mojo_ipc::ScanSettings settings;
  settings.source_name = kDocumentSourceName;
  settings.color_mode = color_mode;
  settings.file_type = file_type;
  settings.page_size = page_size;
  settings.resolution_dpi = kFirstResolution;
  return settings.Clone();
}

}  // namespace

// Tests that each possible lorgnette::ScannerCapabilities proto can be
// correctly converted into a mojo_ipc::ScannerCapabilitiesPtr.
//
// This is a parameterized test with the following parameters (accessed through
// ScannerCapabilitiesTestParams):
// * |lorgnette_source_type| - the lorgnette::SourceType to convert.
// * |lorgnette_color_mode| - the lorgnette::ColorMode to convert.
// * |mojom_source_type| - the expected mojo_ipc::SourceType.
// * |mojom_color_mode| - the expected mojo_ipc::ColorMode.
class ScannerCapabilitiesTest
    : public testing::Test,
      public testing::WithParamInterface<ScannerCapabilitiesTestParams> {
 protected:
  // Accessors to the test parameters returned by gtest's GetParam():
  ScannerCapabilitiesTestParams params() const { return GetParam(); }
};

// Test that lorgnette::ScannerCapabilities can be converted into a
// mojo_ipc::ScannerCapabilitiesPtr.
TEST_P(ScannerCapabilitiesTest, LorgnetteCapsToMojom) {
  mojo_ipc::ScannerCapabilitiesPtr mojo_caps =
      mojo::StructTraits<ash::scanning::mojom::ScannerCapabilitiesPtr,
                         lorgnette::ScannerCapabilities>::
          ToMojom(CreateLorgnetteScannerCapabilities(
              params().lorgnette_source_type, params().lorgnette_color_mode));
  ASSERT_EQ(mojo_caps->sources.size(), 1u);
  EXPECT_EQ(mojo_caps->sources[0]->type, params().mojom_source_type);
  EXPECT_EQ(mojo_caps->sources[0]->name, kDocumentSourceName);
  EXPECT_THAT(
      mojo_caps->sources[0]->page_sizes,
      ElementsAreArray({mojo_ipc::PageSize::kMax, mojo_ipc::PageSize::kIsoA4,
                        mojo_ipc::PageSize::kNaLetter}));
  ASSERT_EQ(mojo_caps->color_modes.size(), 1u);
  EXPECT_EQ(mojo_caps->color_modes[0], params().mojom_color_mode);
  ASSERT_EQ(mojo_caps->resolutions.size(), 2u);
  EXPECT_EQ(mojo_caps->resolutions[0], kFirstResolution);
  EXPECT_EQ(mojo_caps->resolutions[1], kSecondResolution);
}

INSTANTIATE_TEST_SUITE_P(
    ,
    ScannerCapabilitiesTest,
    testing::Values(
        ScannerCapabilitiesTestParams{lorgnette::SOURCE_PLATEN,
                                      lorgnette::MODE_LINEART,
                                      mojo_ipc::SourceType::kFlatbed,
                                      mojo_ipc::ColorMode::kBlackAndWhite},
        ScannerCapabilitiesTestParams{
            lorgnette::SOURCE_ADF_SIMPLEX, lorgnette::MODE_GRAYSCALE,
            mojo_ipc::SourceType::kAdfSimplex, mojo_ipc::ColorMode::kGrayscale},
        ScannerCapabilitiesTestParams{
            lorgnette::SOURCE_ADF_DUPLEX, lorgnette::MODE_COLOR,
            mojo_ipc::SourceType::kAdfDuplex, mojo_ipc::ColorMode::kColor},
        ScannerCapabilitiesTestParams{
            lorgnette::SOURCE_DEFAULT, lorgnette::MODE_COLOR,
            mojo_ipc::SourceType::kDefault, mojo_ipc::ColorMode::kColor}));

// Tests that each possible mojo_ipc::ScanSettingsPtr can be correctly converted
// into a lorgnette::ScanSettings proto.
//
// This is a parameterized test with the following parameters (accessed through
// ScanSettingsTestParams):
// * |mojom_color_mode| - the mojo_ipc::ColorMode to convert.
// * |lorgnette_color_mode| - the expected lorgnette::ColorMode.
// * |mojom_file_type| - the mojo_ipc::FileType to convert.
// * |lorgnette_image_format| - the expected lorgnette::ImageFormat.
// * |mojom_page_size| - the mojo_ipc::PageSize to convert.
// * |bottom_right_x| - the expected bottom-right x-coordinate.
// * |bottom_right_y| - the expected bottom-right y-coordinate.
class ScanSettingsTest
    : public testing::Test,
      public testing::WithParamInterface<ScanSettingsTestParams> {
 protected:
  // Accessors to the test parameters returned by gtest's GetParam():
  ScanSettingsTestParams params() const { return GetParam(); }
};

// Test that mojo_ipc::ScanSettingsPtr can be converted into a
// lorgnette::ScanSettings proto.
TEST_P(ScanSettingsTest, MojomSettingsToLorgnette) {
  lorgnette::ScanSettings lorgnette_settings =
      mojo::StructTraits<lorgnette::ScanSettings, mojo_ipc::ScanSettingsPtr>::
          ToMojom(CreateMojomScanSettings(params().mojom_color_mode,
                                          params().mojom_page_size,
                                          params().mojom_file_type));
  EXPECT_EQ(lorgnette_settings.source_name(), kDocumentSourceName);
  EXPECT_EQ(lorgnette_settings.color_mode(), params().lorgnette_color_mode);
  EXPECT_EQ(lorgnette_settings.image_format(), params().lorgnete_image_format);
  EXPECT_EQ(lorgnette_settings.resolution(), kFirstResolution);

  if (params().mojom_page_size == mojo_ipc::PageSize::kMax) {
    EXPECT_FALSE(lorgnette_settings.has_scan_region());
  } else {
    ASSERT_TRUE(lorgnette_settings.has_scan_region());
    EXPECT_EQ(lorgnette_settings.scan_region().top_left_x(), 0);
    EXPECT_EQ(lorgnette_settings.scan_region().top_left_y(), 0);
    EXPECT_EQ(lorgnette_settings.scan_region().bottom_right_x(),
              params().bottom_right_x);
    EXPECT_EQ(lorgnette_settings.scan_region().bottom_right_y(),
              params().bottom_right_y);
  }
}

INSTANTIATE_TEST_SUITE_P(
    ,
    ScanSettingsTest,
    testing::Values(
        ScanSettingsTestParams{
            mojo_ipc::ColorMode::kBlackAndWhite, lorgnette::MODE_LINEART,
            mojo_ipc::FileType::kPng, lorgnette::IMAGE_FORMAT_PNG,
            mojo_ipc::PageSize::kIsoA4, 210, 297},
        ScanSettingsTestParams{
            mojo_ipc::ColorMode::kGrayscale, lorgnette::MODE_GRAYSCALE,
            mojo_ipc::FileType::kJpg, lorgnette::IMAGE_FORMAT_JPEG,
            mojo_ipc::PageSize::kNaLetter, 215.9, 279.4},
        ScanSettingsTestParams{mojo_ipc::ColorMode::kColor,
                               lorgnette::MODE_COLOR, mojo_ipc::FileType::kPdf,
                               lorgnette::IMAGE_FORMAT_JPEG,
                               mojo_ipc::PageSize::kMax, 0, 0},
        ScanSettingsTestParams{
            mojo_ipc::ColorMode::kColor, lorgnette::MODE_COLOR,
            mojo_ipc::FileType::kSearchablePdf, lorgnette::IMAGE_FORMAT_JPEG,
            mojo_ipc::PageSize::kMax, 0, 0}));

// Test that each lorgnette::ScanFailureMode is converted into the correct
// mojo_ipc::ScanResult.
TEST(ScanResultTest, Convert) {
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_NO_FAILURE)),
            mojo_ipc::ScanResult::kSuccess);
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_UNKNOWN)),
            mojo_ipc::ScanResult::kUnknownError);
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_DEVICE_BUSY)),
            mojo_ipc::ScanResult::kDeviceBusy);
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_ADF_JAMMED)),
            mojo_ipc::ScanResult::kAdfJammed);
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_ADF_EMPTY)),
            mojo_ipc::ScanResult::kAdfEmpty);
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_FLATBED_OPEN)),
            mojo_ipc::ScanResult::kFlatbedOpen);
  EXPECT_EQ((mojo::EnumTraits<ash::scanning::mojom::ScanResult,
                              lorgnette::ScanFailureMode>::
                 ToMojom(lorgnette::SCAN_FAILURE_MODE_IO_ERROR)),
            mojo_ipc::ScanResult::kIoError);
}

}  // namespace ash