/*
 *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
#ifndef TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_
#define TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_

#include <memory>
#include <string>
#include <vector>

#include "absl/memory/memory.h"
#include "api/async_resolver_factory.h"
#include "api/call/call_factory_interface.h"
#include "api/fec_controller.h"
#include "api/media_transport_interface.h"
#include "api/peer_connection_interface.h"
#include "api/test/simulated_network.h"
#include "api/transport/network_control.h"
#include "api/units/time_delta.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
#include "rtc_base/network.h"
#include "rtc_base/rtc_certificate_generator.h"
#include "rtc_base/ssl_certificate.h"
#include "rtc_base/thread.h"
#include "test/pc/e2e/api/audio_quality_analyzer_interface.h"
#include "test/pc/e2e/api/video_quality_analyzer_interface.h"

namespace webrtc {
namespace test {

// TODO(titovartem) move to API when it will be stabilized.
class PeerConnectionE2EQualityTestFixture {
 public:
  // Contains most part from PeerConnectionFactoryDependencies. Also all fields
  // are optional and defaults will be provided by fixture implementation if
  // any will be omitted.
  //
  // Separate class was introduced to clarify which components can be
  // overridden. For example worker and signaling threads will be provided by
  // fixture implementation. The same is applicable to the media engine. So user
  // can override only some parts of media engine like video encoder/decoder
  // factories.
  struct PeerConnectionFactoryComponents {
    std::unique_ptr<CallFactoryInterface> call_factory;
    std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory;
    std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;
    std::unique_ptr<NetworkControllerFactoryInterface>
        network_controller_factory;
    std::unique_ptr<MediaTransportFactory> media_transport_factory;

    // Will be passed to MediaEngineInterface, that will be used in
    // PeerConnectionFactory.
    std::unique_ptr<VideoEncoderFactory> video_encoder_factory;
    std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
  };

  // Contains most parts from PeerConnectionDependencies. Also all fields are
  // optional and defaults will be provided by fixture implementation if any
  // will be omitted.
  //
  // Separate class was introduced to clarify which components can be
  // overridden. For example observer, which is required to
  // PeerConnectionDependencies, will be provided by fixture implementation,
  // so client can't inject its own. Also only network manager can be overridden
  // inside port allocator.
  struct PeerConnectionComponents {
    PeerConnectionComponents(rtc::NetworkManager* network_manager)
        : network_manager(network_manager) {
      RTC_CHECK(network_manager);
    }

    rtc::NetworkManager* const network_manager;
    std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory;
    std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator;
    std::unique_ptr<rtc::SSLCertificateVerifier> tls_cert_verifier;
  };

  // Contains all components, that can be overridden in peer connection. Also
  // has a network thread, that will be used to communicate with another peers.
  struct InjectableComponents {
    explicit InjectableComponents(rtc::Thread* network_thread,
                                  rtc::NetworkManager* network_manager)
        : network_thread(network_thread),
          pcf_dependencies(
              absl::make_unique<PeerConnectionFactoryComponents>()),
          pc_dependencies(
              absl::make_unique<PeerConnectionComponents>(network_manager)) {
      RTC_CHECK(network_thread);
    }

    rtc::Thread* const network_thread;

    std::unique_ptr<PeerConnectionFactoryComponents> pcf_dependencies;
    std::unique_ptr<PeerConnectionComponents> pc_dependencies;
  };

  // Contains screen share video stream properties.
  struct ScreenShareConfig {
    // If true, slides will be generated programmatically.
    bool generate_slides;
    // Shows how long one slide should be presented on the screen during
    // slide generation.
    TimeDelta slide_change_interval;
    // If equal to 0, no scrolling will be applied.
    TimeDelta scroll_duration;
    // If empty, default set of slides will be used.
    std::vector<std::string> slides_yuv_file_names;
  };

  enum VideoGeneratorType { kDefault, kI420A, kI010 };

  // Contains properties of single video stream.
  struct VideoConfig {
    VideoConfig(size_t width, size_t height, int32_t fps)
        : width(width), height(height), fps(fps) {}

    const size_t width;
    const size_t height;
    const int32_t fps;
    // Have to be unique among all specified configs for all peers in the call.
    // Will be auto generated if omitted.
    absl::optional<std::string> stream_label;
    // Only 1 from |generator|, |input_file_name| and |screen_share_config| can
    // be specified. If none of them are specified, then |generator| will be set
    // to VideoGeneratorType::kDefault.
    // If specified generator of this type will be used to produce input video.
    absl::optional<VideoGeneratorType> generator;
    // If specified this file will be used as input. Input video will be played
    // in a circle.
    absl::optional<std::string> input_file_name;
    // If specified screen share video stream will be created as input.
    absl::optional<ScreenShareConfig> screen_share_config;
    // Specifies spatial index of the video stream to analyze.
    // There are 3 cases:
    // 1. |target_spatial_index| omitted: in such case it will be assumed that
    //    video stream has not spatial layers and simulcast streams.
    // 2. |target_spatial_index| presented and simulcast encoder is used:
    //    in such case |target_spatial_index| will specify the index of
    //    simulcast stream, that should be analyzed. Other streams will be
    //    dropped.
    // 3. |target_spatial_index| presented and SVP encoder is used:
    //    in such case |target_spatial_index| will specify the top interesting
    //    spatial layer and all layers bellow, including target one will be
    //    processed. All layers above target one will be dropped.
    absl::optional<int> target_spatial_index;
    // If specified the input stream will be also copied to specified file.
    // It is actually one of the test's output file, which contains copy of what
    // was captured during the test for this video stream on sender side.
    // It is useful when generator is used as input.
    absl::optional<std::string> input_dump_file_name;
    // If specified this file will be used as output on the receiver side for
    // this stream. If multiple streams will be produced by input stream,
    // output files will be appended with indexes. The produced files contains
    // what was rendered for this video stream on receiver side.
    absl::optional<std::string> output_dump_file_name;
  };

  // Contains properties for audio in the call.
  struct AudioConfig {
    enum Mode {
      kGenerated,
      kFile,
    };
    // Have to be unique among all specified configs for all peers in the call.
    // Will be auto generated if omitted.
    absl::optional<std::string> stream_label;
    Mode mode = kGenerated;
    // Have to be specified only if mode = kFile
    absl::optional<std::string> input_file_name;
    // If specified the input stream will be also copied to specified file.
    absl::optional<std::string> input_dump_file_name;
    // If specified the output stream will be copied to specified file.
    absl::optional<std::string> output_dump_file_name;
    // Audio options to use.
    cricket::AudioOptions audio_options;
  };

  // Contains information about call media streams (up to 1 audio stream and
  // unlimited amount of video streams) and rtc configuration, that will be used
  // to set up peer connection.
  struct Params {
    // If |video_configs| is empty - no video should be added to the test call.
    std::vector<VideoConfig> video_configs;
    // If |audio_config| is set audio stream will be configured
    absl::optional<AudioConfig> audio_config;
    // If |rtc_event_log_path| is set, an RTCEventLog will be saved in that
    // location and it will be available for further analysis.
    absl::optional<std::string> rtc_event_log_path;

    PeerConnectionInterface::RTCConfiguration rtc_configuration;
  };

  // Contains parameters, that describe how long framework should run quality
  // test.
  struct RunParams {
    // Specifies how long the test should be run. This time shows how long
    // the media should flow after connection was established and before
    // it will be shut downed.
    TimeDelta run_duration;
  };

  // Add activity that will be executed on the best effort at least after
  // |target_time_since_start| after call will be set up (after offer/answer
  // exchange, ICE gathering will be done and ICE candidates will passed to
  // remote side). |func| param is amount of time spent from the call set up.
  virtual void ExecuteAt(TimeDelta target_time_since_start,
                         std::function<void(TimeDelta)> func) = 0;
  // Add activity that will be executed every |interval| with first execution
  // on the best effort at least after |initial_delay_since_start| after call
  // will be set up (after all participants will be connected). |func| param is
  // amount of time spent from the call set up.
  virtual void ExecuteEvery(TimeDelta initial_delay_since_start,
                            TimeDelta interval,
                            std::function<void(TimeDelta)> func) = 0;

  virtual void Run(std::unique_ptr<InjectableComponents> alice_components,
                   std::unique_ptr<Params> alice_params,
                   std::unique_ptr<InjectableComponents> bob_components,
                   std::unique_ptr<Params> bob_params,
                   RunParams run_params) = 0;
  virtual ~PeerConnectionE2EQualityTestFixture() = default;
};

}  // namespace test
}  // namespace webrtc

#endif  // TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_