/*
 *  Copyright (c) 2019 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.
 */
#include "test/pc/e2e/network_quality_metrics_reporter.h"

#include <utility>

#include "api/stats/rtc_stats.h"
#include "api/stats/rtcstats_objects.h"
#include "api/test/metrics/metric.h"
#include "rtc_base/event.h"
#include "system_wrappers/include/field_trial.h"
#include "test/testsupport/perf_test.h"

namespace webrtc {
namespace webrtc_pc_e2e {
namespace {

using ::webrtc::test::ImprovementDirection;
using ::webrtc::test::Unit;

constexpr TimeDelta kStatsWaitTimeout = TimeDelta::Seconds(1);

// Field trial which controls whether to report standard-compliant bytes
// sent/received per stream.  If enabled, padding and headers are not included
// in bytes sent or received.
constexpr char kUseStandardBytesStats[] = "WebRTC-UseStandardBytesStats";
}

void NetworkQualityMetricsReporter::Start(
    absl::string_view test_case_name,
    const TrackIdStreamInfoMap* /*reporter_helper*/) {
  test_case_name_ = std::string(test_case_name);
  // Check that network stats are clean before test execution.
  std::unique_ptr<EmulatedNetworkStats> alice_stats =
      PopulateStats(alice_network_);
  RTC_CHECK_EQ(alice_stats->PacketsSent(), 0);
  RTC_CHECK_EQ(alice_stats->PacketsReceived(), 0);
  std::unique_ptr<EmulatedNetworkStats> bob_stats = PopulateStats(bob_network_);
  RTC_CHECK_EQ(bob_stats->PacketsSent(), 0);
  RTC_CHECK_EQ(bob_stats->PacketsReceived(), 0);
}

void NetworkQualityMetricsReporter::OnStatsReports(
    absl::string_view pc_label,
    const rtc::scoped_refptr<const RTCStatsReport>& report) {
  DataSize payload_received = DataSize::Zero();
  DataSize payload_sent = DataSize::Zero();

  auto inbound_stats = report->GetStatsOfType<RTCInboundRTPStreamStats>();
  for (const auto& stat : inbound_stats) {
    payload_received +=
        DataSize::Bytes(stat->bytes_received.ValueOrDefault(0ul) +
                        stat->header_bytes_received.ValueOrDefault(0ul));
  }

  auto outbound_stats = report->GetStatsOfType<RTCOutboundRTPStreamStats>();
  for (const auto& stat : outbound_stats) {
    payload_sent +=
        DataSize::Bytes(stat->bytes_sent.ValueOrDefault(0ul) +
                        stat->header_bytes_sent.ValueOrDefault(0ul));
  }

  MutexLock lock(&lock_);
  PCStats& stats = pc_stats_[std::string(pc_label)];
  stats.payload_received = payload_received;
  stats.payload_sent = payload_sent;
}

void NetworkQualityMetricsReporter::StopAndReportResults() {
  std::unique_ptr<EmulatedNetworkStats> alice_stats =
      PopulateStats(alice_network_);
  std::unique_ptr<EmulatedNetworkStats> bob_stats = PopulateStats(bob_network_);
  int64_t alice_packets_loss =
      alice_stats->PacketsSent() - bob_stats->PacketsReceived();
  int64_t bob_packets_loss =
      bob_stats->PacketsSent() - alice_stats->PacketsReceived();
  ReportStats("alice", std::move(alice_stats), alice_packets_loss);
  ReportStats("bob", std::move(bob_stats), bob_packets_loss);

  if (!webrtc::field_trial::IsEnabled(kUseStandardBytesStats)) {
    RTC_LOG(LS_ERROR)
        << "Non-standard GetStats; \"payload\" counts include RTP headers";
  }

  MutexLock lock(&lock_);
  for (const auto& pair : pc_stats_) {
    ReportPCStats(pair.first, pair.second);
  }
}

std::unique_ptr<EmulatedNetworkStats>
NetworkQualityMetricsReporter::PopulateStats(
    EmulatedNetworkManagerInterface* network) {
  rtc::Event wait;
  std::unique_ptr<EmulatedNetworkStats> stats;
  network->GetStats([&](std::unique_ptr<EmulatedNetworkStats> s) {
    stats = std::move(s);
    wait.Set();
  });
  bool stats_received = wait.Wait(kStatsWaitTimeout);
  RTC_CHECK(stats_received);
  return stats;
}

void NetworkQualityMetricsReporter::ReportStats(
    const std::string& network_label,
    std::unique_ptr<EmulatedNetworkStats> stats,
    int64_t packet_loss) {
  if (metrics_logger_ == nullptr) {
    ReportResult("bytes_sent", network_label, stats->BytesSent().bytes(),
                 "sizeInBytes");
    ReportResult("packets_sent", network_label, stats->PacketsSent(),
                 "unitless");
    ReportResult("average_send_rate", network_label,
                 stats->PacketsSent() >= 2
                     ? stats->AverageSendRate().bytes_per_sec()
                     : 0,
                 "bytesPerSecond");
    ReportResult("bytes_discarded_no_receiver", network_label,
                 stats->BytesDropped().bytes(), "sizeInBytes");
    ReportResult("packets_discarded_no_receiver", network_label,
                 stats->PacketsDropped(), "unitless");
    ReportResult("bytes_received", network_label,
                 stats->BytesReceived().bytes(), "sizeInBytes");
    ReportResult("packets_received", network_label, stats->PacketsReceived(),
                 "unitless");
    ReportResult("average_receive_rate", network_label,
                 stats->PacketsReceived() >= 2
                     ? stats->AverageReceiveRate().bytes_per_sec()
                     : 0,
                 "bytesPerSecond");
    ReportResult("sent_packets_loss", network_label, packet_loss, "unitless");
  } else {
    metrics_logger_->LogSingleValueMetric(
        "bytes_sent", GetTestCaseName(network_label),
        stats->BytesSent().bytes(), Unit::kBytes,
        ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "packets_sent", GetTestCaseName(network_label), stats->PacketsSent(),
        Unit::kUnitless, ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "average_send_rate", GetTestCaseName(network_label),
        stats->PacketsSent() >= 2 ? stats->AverageSendRate().kbps() : 0,
        Unit::kKilobitsPerSecond, ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "bytes_discarded_no_receiver", GetTestCaseName(network_label),
        stats->BytesDropped().bytes(), Unit::kBytes,
        ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "packets_discarded_no_receiver", GetTestCaseName(network_label),
        stats->PacketsDropped(), Unit::kUnitless,
        ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "bytes_received", GetTestCaseName(network_label),
        stats->BytesReceived().bytes(), Unit::kBytes,
        ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "packets_received", GetTestCaseName(network_label),
        stats->PacketsReceived(), Unit::kUnitless,
        ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "average_receive_rate", GetTestCaseName(network_label),
        stats->PacketsReceived() >= 2 ? stats->AverageReceiveRate().kbps() : 0,
        Unit::kKilobitsPerSecond, ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "sent_packets_loss", GetTestCaseName(network_label), packet_loss,
        Unit::kUnitless, ImprovementDirection::kNeitherIsBetter);
  }
}

void NetworkQualityMetricsReporter::ReportPCStats(const std::string& pc_label,
                                                  const PCStats& stats) {
  if (metrics_logger_ == nullptr) {
    ReportResult("payload_bytes_received", pc_label,
                 stats.payload_received.bytes(), "sizeInBytes");
    ReportResult("payload_bytes_sent", pc_label, stats.payload_sent.bytes(),
                 "sizeInBytes");
  } else {
    metrics_logger_->LogSingleValueMetric(
        "payload_bytes_received", pc_label, stats.payload_received.bytes(),
        Unit::kBytes, ImprovementDirection::kNeitherIsBetter);
    metrics_logger_->LogSingleValueMetric(
        "payload_bytes_sent", pc_label, stats.payload_sent.bytes(),
        Unit::kBytes, ImprovementDirection::kNeitherIsBetter);
  }
}

void NetworkQualityMetricsReporter::ReportResult(
    const std::string& metric_name,
    const std::string& network_label,
    const double value,
    const std::string& unit) const {
  test::PrintResult(metric_name, /*modifier=*/"",
                    GetTestCaseName(network_label), value, unit,
                    /*important=*/false);
}

std::string NetworkQualityMetricsReporter::GetTestCaseName(
    const std::string& network_label) const {
  return test_case_name_ + "/" + network_label;
}

}  // namespace webrtc_pc_e2e
}  // namespace webrtc