// Copyright 2018 The Chromium OS 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 <memory>
#include <utility>

#include <base/run_loop.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <mojo/public/cpp/bindings/binding.h>

#include "media_perception/fake_rtanalytics.h"
#include "media_perception/frame_perception.pb.h"
#include "media_perception/hotword_detection.pb.h"
#include "media_perception/output_manager.h"
#include "media_perception/presence_perception.pb.h"
#include "media_perception/proto_mojom_conversion.h"
#include "media_perception/serialized_proto.h"

namespace mri {
namespace {

class FramePerceptionHandlerImpl
    : public chromeos::media_perception::mojom::FramePerceptionHandler {
 public:
  FramePerceptionHandlerImpl(
      chromeos::media_perception::mojom::FramePerceptionHandlerRequest request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnFramePerception(chromeos::media_perception::mojom::FramePerceptionPtr
                             frame_perception) override {
    frame_perception_ = ToProto(frame_perception);
  }

  FramePerception frame_perception_;

  mojo::Binding<chromeos::media_perception::mojom::FramePerceptionHandler>
      binding_;
};

class HotwordDetectionHandlerImpl
    : public chromeos::media_perception::mojom::HotwordDetectionHandler {
 public:
  HotwordDetectionHandlerImpl(
      chromeos::media_perception::mojom::HotwordDetectionHandlerRequest request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnHotwordDetection(chromeos::media_perception::mojom::HotwordDetectionPtr
                              hotword_detection) override {
    hotword_detection_ = ToProto(hotword_detection);
  }

  HotwordDetection hotword_detection_;

  mojo::Binding<chromeos::media_perception::mojom::HotwordDetectionHandler>
      binding_;
};

class PresencePerceptionHandlerImpl
    : public chromeos::media_perception::mojom::PresencePerceptionHandler {
 public:
  PresencePerceptionHandlerImpl(
      chromeos::media_perception::mojom::PresencePerceptionHandlerRequest
          request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnPresencePerception(
      chromeos::media_perception::mojom::PresencePerceptionPtr
          presence_perception) override {
    presence_perception_ = ToProto(presence_perception);
  }

  PresencePerception presence_perception_;

  mojo::Binding<chromeos::media_perception::mojom::PresencePerceptionHandler>
      binding_;
};

class OccupancyTriggerHandlerImpl
    : public chromeos::media_perception::mojom::OccupancyTriggerHandler {
 public:
  OccupancyTriggerHandlerImpl(
      chromeos::media_perception::mojom::OccupancyTriggerHandlerRequest request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnOccupancyTrigger(chromeos::media_perception::mojom::OccupancyTriggerPtr
                              occupancy_trigger) override {
    occupancy_trigger_ = ToProto(occupancy_trigger);
  }

  OccupancyTrigger occupancy_trigger_;

  mojo::Binding<chromeos::media_perception::mojom::OccupancyTriggerHandler>
      binding_;
};

class AppearancesHandlerImpl
    : public chromeos::media_perception::mojom::AppearancesHandler {
 public:
  AppearancesHandlerImpl(
      chromeos::media_perception::mojom::AppearancesHandlerRequest request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnAppearances(const std::vector<uint8_t>& appearances) override {
    appearances_ = appearances;
  }

  std::vector<uint8_t> appearances_;

  mojo::Binding<chromeos::media_perception::mojom::AppearancesHandler> binding_;
};

class OneTouchAutozoomHandlerImpl
    : public chromeos::media_perception::mojom::OneTouchAutozoomHandler {
 public:
  OneTouchAutozoomHandlerImpl(
      chromeos::media_perception::mojom::OneTouchAutozoomHandlerRequest request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnSmartFraming(const std::vector<uint8_t>& smart_framing) override {
    smart_framing_ = smart_framing;
  }

  std::vector<uint8_t> smart_framing_;

  mojo::Binding<chromeos::media_perception::mojom::OneTouchAutozoomHandler>
      binding_;
};

class SoftwareAutozoomHandlerImpl
    : public chromeos::media_perception::mojom::SoftwareAutozoomHandler {
 public:
  SoftwareAutozoomHandlerImpl(
      chromeos::media_perception::mojom::SoftwareAutozoomHandlerRequest request)
      : binding_(this, std::move(request)) {
    EXPECT_TRUE(binding_.is_bound());
  }

  void OnSmartFraming(const std::vector<uint8_t>& smart_framing) override {
    smart_framing_ = smart_framing;
  }

  std::vector<uint8_t> smart_framing_;

  mojo::Binding<chromeos::media_perception::mojom::SoftwareAutozoomHandler>
      binding_;
};

class OutputManagerTest : public testing::Test {
 protected:
  void SetUp() override {
    fake_rtanalytics_ = new FakeRtanalytics();
    rtanalytics_ = std::shared_ptr<Rtanalytics>(fake_rtanalytics_);
  }

  FakeRtanalytics* fake_rtanalytics_;
  std::shared_ptr<Rtanalytics> rtanalytics_;
};

TEST_F(OutputManagerTest, FramePerceptionOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(
      PerceptionInterfaceType::INTERFACE_FRAME_PERCEPTION);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_FRAME_PERCEPTION);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();
  OutputManager output_manager("fake_frame_perception_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);
  // Verify that the mojo interface was created correctly.
  EXPECT_TRUE(interfaces_ptr->frame_perception_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  FramePerceptionHandlerImpl frame_perception_handler_impl(
      std::move(interfaces_ptr->frame_perception_handler_request));
  base::RunLoop().RunUntilIdle();

  FramePerception frame_perception;
  frame_perception.set_frame_id(1);
  output_manager.HandleFramePerception(
      Serialized<FramePerception>(frame_perception).GetBytes());
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(frame_perception_handler_impl.frame_perception_.frame_id(), 1);
}

TEST_F(OutputManagerTest, HotwordDetectionOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(
      PerceptionInterfaceType::INTERFACE_HOTWORD_DETECTION);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_HOTWORD_DETECTION);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();
  OutputManager output_manager("fake_hotword_detection_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);
  // Verify that the mojo interface was created correctly.
  EXPECT_TRUE(interfaces_ptr->hotword_detection_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  HotwordDetectionHandlerImpl hotword_detection_handler_impl(
      std::move(interfaces_ptr->hotword_detection_handler_request));
  base::RunLoop().RunUntilIdle();

  HotwordDetection hotword_detection;
  hotword_detection.add_hotwords()->set_type(HotwordType::OK_GOOGLE);
  output_manager.HandleHotwordDetection(
      Serialized<HotwordDetection>(hotword_detection).GetBytes());
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(
      hotword_detection_handler_impl.hotword_detection_.hotwords(0).type(),
      HotwordType::OK_GOOGLE);
}

TEST_F(OutputManagerTest, PresencePerceptionOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(
      PerceptionInterfaceType::INTERFACE_PRESENCE_PERCEPTION);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_PRESENCE_PERCEPTION);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();
  OutputManager output_manager("fake_presence_perception_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);
  // Verify that the mojo interface was created correctly.
  EXPECT_TRUE(interfaces_ptr->presence_perception_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  PresencePerceptionHandlerImpl presence_perception_handler_impl(
      std::move(interfaces_ptr->presence_perception_handler_request));
  base::RunLoop().RunUntilIdle();

  PresencePerception presence_perception;
  presence_perception.set_timestamp_us(1);
  output_manager.HandlePresencePerception(
      Serialized<PresencePerception>(presence_perception).GetBytes());
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(
      presence_perception_handler_impl.presence_perception_.timestamp_us(), 1);
}

TEST_F(OutputManagerTest, OccupancyTriggerOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(
      PerceptionInterfaceType::INTERFACE_OCCUPANCY_TRIGGER);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_OCCUPANCY_TRIGGER);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();
  OutputManager output_manager("fake_presence_perception_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);
  // Verify that the mojo interface was created correctly.
  EXPECT_TRUE(interfaces_ptr->occupancy_trigger_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  OccupancyTriggerHandlerImpl occupancy_trigger_handler_impl(
      std::move(interfaces_ptr->occupancy_trigger_handler_request));
  base::RunLoop().RunUntilIdle();

  OccupancyTrigger occupancy_trigger;
  occupancy_trigger.set_trigger(true);
  output_manager.HandleOccupancyTrigger(
      Serialized<OccupancyTrigger>(occupancy_trigger).GetBytes());
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(occupancy_trigger_handler_impl.occupancy_trigger_.trigger(), true);
}

TEST_F(OutputManagerTest, AppearancesOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(PerceptionInterfaceType::INTERFACE_APPEARANCES);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_APPEARANCES);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();

  OutputManager output_manager("fake_presence_perception_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);

  EXPECT_TRUE(interfaces_ptr->appearances_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  AppearancesHandlerImpl appearances_handler_impl(
      std::move(interfaces_ptr->appearances_handler_request));
  base::RunLoop().RunUntilIdle();

  std::vector<uint8_t> bytes{0, 1, 2, 3, 1, 2, 3, 2, 1};

  output_manager.HandleAppearances(bytes);
  base::RunLoop().RunUntilIdle();

  ASSERT_EQ(appearances_handler_impl.appearances_.size(), bytes.size())
      << "Vectors are of unequal length.";

  for (int i = 0; i < bytes.size(); ++i) {
    EXPECT_EQ(appearances_handler_impl.appearances_[i], bytes[i])
        << "Bytes and Output Appearances Vector differ at index " << i;
  }
}

TEST_F(OutputManagerTest, OneTouchAutozoomOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(
      PerceptionInterfaceType::INTERFACE_ONE_TOUCH_AUTOZOOM);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_SMART_FRAMING);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();

  OutputManager output_manager("fake_one_touch_autozoom_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);

  EXPECT_TRUE(interfaces_ptr->one_touch_autozoom_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  OneTouchAutozoomHandlerImpl one_touch_autozoom_handler_impl(
      std::move(interfaces_ptr->one_touch_autozoom_handler_request));
  base::RunLoop().RunUntilIdle();

  std::vector<uint8_t> bytes{0, 1, 2, 3, 1, 2, 3, 2, 1};

  output_manager.HandleSmartFraming(bytes);
  base::RunLoop().RunUntilIdle();

  ASSERT_EQ(one_touch_autozoom_handler_impl.smart_framing_.size(), bytes.size())
      << "Vectors are of unequal length.";

  for (int i = 0; i < bytes.size(); ++i) {
    EXPECT_EQ(one_touch_autozoom_handler_impl.smart_framing_[i], bytes[i])
        << "Bytes and Output Appearances Vector differ at index " << i;
  }
}

TEST_F(OutputManagerTest, SoftwareAutozoomOutputManagerTest) {
  PerceptionInterfaces perception_interfaces;
  PerceptionInterface* interface = perception_interfaces.add_interface();
  interface->set_interface_type(
      PerceptionInterfaceType::INTERFACE_SOFTWARE_AUTOZOOM);
  PipelineOutput* output = interface->add_output();
  output->set_output_type(PipelineOutputType::OUTPUT_SMART_FRAMING);
  output->set_stream_name("fake_stream_name");

  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();

  OutputManager output_manager("fake_software_autozoom_configuration",
                               rtanalytics_, perception_interfaces,
                               &interfaces_ptr);

  EXPECT_TRUE(interfaces_ptr->software_autozoom_handler_request.is_pending());
  EXPECT_EQ(fake_rtanalytics_->GetMostRecentOutputStreamName(),
            "fake_stream_name");

  SoftwareAutozoomHandlerImpl software_autozoom_handler_impl(
      std::move(interfaces_ptr->software_autozoom_handler_request));
  base::RunLoop().RunUntilIdle();

  std::vector<uint8_t> bytes{0, 1, 2, 3, 1, 2, 3, 2, 1};

  output_manager.HandleSmartFraming(bytes);
  base::RunLoop().RunUntilIdle();

  ASSERT_EQ(software_autozoom_handler_impl.smart_framing_.size(), bytes.size())
      << "Vectors are of unequal length.";

  for (int i = 0; i < bytes.size(); ++i) {
    EXPECT_EQ(software_autozoom_handler_impl.smart_framing_[i], bytes[i])
        << "Bytes and Output Appearances Vector differ at index " << i;
  }
}

}  // namespace
}  // namespace mri