// 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 "media_perception/media_perception_impl.h"

#include <utility>
#include <vector>

#include "base/callback_helpers.h"
#include "base/logging.h"
#include "media_perception/media_perception_mojom.pb.h"
#include "media_perception/perception_interface.pb.h"
#include "media_perception/proto_mojom_conversion.h"
#include "media_perception/serialized_proto.h"

namespace mri {

MediaPerceptionImpl::MediaPerceptionImpl(
    chromeos::media_perception::mojom::MediaPerceptionRequest request,
    std::shared_ptr<VideoCaptureServiceClient> vidcap_client,
    std::shared_ptr<ChromeAudioServiceClient> cras_client,
    std::shared_ptr<Rtanalytics> rtanalytics)
    : binding_(this, std::move(request)),
      vidcap_client_(vidcap_client),
      cras_client_(cras_client),
      rtanalytics_(rtanalytics) {
  if (!vidcap_client_->IsConnected()) {
    vidcap_client_->Connect();
  }

  if (!cras_client_->IsConnected()) {
    cras_client_->Connect();
  }

  CHECK(rtanalytics_.get())
      << "Rtanalytics is a nullptr: " << rtanalytics_.get();
}

void MediaPerceptionImpl::set_connection_error_handler(
    base::Closure connection_error_handler) {
  binding_.set_connection_error_handler(std::move(connection_error_handler));
}

void MediaPerceptionImpl::SetupConfiguration(
    const std::string& configuration_name,
    SetupConfigurationCallback callback) {
  SerializedSuccessStatus serialized_status;
  SerializedPerceptionInterfaces serialized_perception_interfaces =
      rtanalytics_->SetupConfiguration(configuration_name, &serialized_status);
  PerceptionInterfaces perception_interfaces =
      Serialized<PerceptionInterfaces>(serialized_perception_interfaces)
          .Deserialize();

  SuccessStatus status =
      Serialized<SuccessStatus>(serialized_status).Deserialize();
  chromeos::media_perception::mojom::PerceptionInterfacesPtr interfaces_ptr =
      chromeos::media_perception::mojom::PerceptionInterfaces::New();

  // Sets up perception interfaces and assigns output handlers.
  configuration_name_to_output_manager_map_[configuration_name] =
      std::make_unique<OutputManager>(configuration_name, rtanalytics_,
                                      perception_interfaces, &interfaces_ptr);
  std::move(callback).Run(chromeos::media_perception::mojom::ToMojom(status),
                          std::move(interfaces_ptr));
}

void MediaPerceptionImpl::SetTemplateArguments(
    const std::string& configuration_name,
    const std::vector<uint8_t>& serialized_arguments_proto,
    SetTemplateArgumentsCallback callback) {
  SerializedSuccessStatus serialized_status =
      rtanalytics_->SetTemplateArguments(configuration_name,
                                         serialized_arguments_proto);
  std::move(callback).Run(chromeos::media_perception::mojom::ToMojom(
      Serialized<SuccessStatus>(serialized_status).Deserialize()));
}

void MediaPerceptionImpl::GetVideoDevices(GetVideoDevicesCallback callback) {
  // Get the list of video devices from the VideoCaptureServiceClient and
  // convert them to mojom objects.
  auto repeating_callback =
      base::AdaptCallbackForRepeating(std::move(callback));
  vidcap_client_->GetDevices([repeating_callback](
                                 std::vector<SerializedVideoDevice> devices) {
    std::vector<chromeos::media_perception::mojom::VideoDevicePtr>
        mojom_devices;
    for (const SerializedVideoDevice& device : devices) {
      VideoDevice video_device = Serialized<VideoDevice>(device).Deserialize();
      mojom_devices.push_back(
          chromeos::media_perception::mojom::ToMojom(video_device));
    }
    repeating_callback.Run(std::move(mojom_devices));
  });
}

void MediaPerceptionImpl::GetAudioDevices(GetAudioDevicesCallback callback) {
  // Get the list of audio devices from the ChromeAudioServiceClient and convert
  // them to mojom objects.
  std::vector<SerializedAudioDevice> devices = cras_client_->GetInputDevices();
  std::vector<chromeos::media_perception::mojom::AudioDevicePtr> mojom_devices;
  for (const SerializedAudioDevice& device : devices) {
    AudioDevice audio_device = Serialized<AudioDevice>(device).Deserialize();
    mojom_devices.push_back(
        chromeos::media_perception::mojom::ToMojom(audio_device));
  }
  std::move(callback).Run(std::move(mojom_devices));
}

void MediaPerceptionImpl::GetTemplateDevices(
    const std::string& configuration_name,
    GetTemplateDevicesCallback callback) {
  std::vector<SerializedDeviceTemplate> device_templates =
      rtanalytics_->GetTemplateDevices(configuration_name);
  std::vector<chromeos::media_perception::mojom::DeviceTemplatePtr>
      template_ptrs;
  for (const auto& serialized_device_template : device_templates) {
    DeviceTemplate device_template =
        Serialized<DeviceTemplate>(serialized_device_template).Deserialize();
    template_ptrs.push_back(
        chromeos::media_perception::mojom::ToMojom(device_template));
  }
  std::move(callback).Run(std::move(template_ptrs));
}

void MediaPerceptionImpl::SetVideoDeviceForTemplateName(
    const std::string& configuration_name,
    const std::string& template_name,
    chromeos::media_perception::mojom::VideoDevicePtr device,
    SetVideoDeviceForTemplateNameCallback callback) {
  SerializedVideoDevice serialized_video_device =
      Serialized<VideoDevice>(ToProto(device)).GetBytes();
  SerializedSuccessStatus status = rtanalytics_->SetVideoDeviceForTemplateName(
      configuration_name, template_name, serialized_video_device);

  SuccessStatus success_status =
      Serialized<SuccessStatus>(status).Deserialize();
  std::move(callback).Run(
      chromeos::media_perception::mojom::ToMojom(success_status));
}

void MediaPerceptionImpl::SetAudioDeviceForTemplateName(
    const std::string& configuration_name,
    const std::string& template_name,
    chromeos::media_perception::mojom::AudioDevicePtr device,
    SetAudioDeviceForTemplateNameCallback callback) {
  SerializedAudioDevice serialized_audio_device =
      Serialized<AudioDevice>(ToProto(device)).GetBytes();
  SerializedSuccessStatus status = rtanalytics_->SetAudioDeviceForTemplateName(
      configuration_name, template_name, serialized_audio_device);

  SuccessStatus success_status =
      Serialized<SuccessStatus>(status).Deserialize();
  std::move(callback).Run(
      chromeos::media_perception::mojom::ToMojom(success_status));
}

void MediaPerceptionImpl::SetVirtualVideoDeviceForTemplateName(
    const std::string& configuration_name,
    const std::string& template_name,
    chromeos::media_perception::mojom::VirtualVideoDevicePtr device,
    SetVirtualVideoDeviceForTemplateNameCallback callback) {
  SerializedVirtualVideoDevice serialized_virtual_video_device =
      Serialized<VirtualVideoDevice>(ToProto(device)).GetBytes();
  SerializedSuccessStatus status =
      rtanalytics_->SetVirtualVideoDeviceForTemplateName(
          configuration_name, template_name, serialized_virtual_video_device);

  SuccessStatus success_status =
      Serialized<SuccessStatus>(status).Deserialize();
  std::move(callback).Run(
      chromeos::media_perception::mojom::ToMojom(success_status));
}

void MediaPerceptionImpl::GetPipelineState(
    const std::string& configuration_name, GetPipelineStateCallback callback) {
  SerializedPipelineState serialized_pipeline_state =
      rtanalytics_->GetPipelineState(configuration_name);

  PipelineState pipeline_state =
      Serialized<PipelineState>(serialized_pipeline_state).Deserialize();
  std::move(callback).Run(
      chromeos::media_perception::mojom::ToMojom(pipeline_state));
}

void MediaPerceptionImpl::SetPipelineState(
    const std::string& configuration_name,
    chromeos::media_perception::mojom::PipelineStatePtr desired_state,
    SetPipelineStateCallback callback) {
  SerializedPipelineState serialized_desired_state =
      Serialized<PipelineState>(ToProto(desired_state)).GetBytes();
  SerializedPipelineState serialized_pipeline_state =
      rtanalytics_->SetPipelineState(configuration_name,
                                     serialized_desired_state);

  PipelineState pipeline_state =
      Serialized<PipelineState>(serialized_pipeline_state).Deserialize();
  std::move(callback).Run(
      chromeos::media_perception::mojom::ToMojom(pipeline_state));
}

void MediaPerceptionImpl::GetGlobalPipelineState(
    GetGlobalPipelineStateCallback callback) {
  SerializedGlobalPipelineState serialized_state =
      rtanalytics_->GetGlobalPipelineState();

  GlobalPipelineState state =
      Serialized<GlobalPipelineState>(serialized_state).Deserialize();
  std::move(callback).Run(chromeos::media_perception::mojom::ToMojom(state));
}

}  // namespace mri