/*
 *  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/analyzer/audio/default_audio_quality_analyzer.h"

#include <cmath>
#include <cstdint>
#include <map>
#include <string>
#include <utility>

#include "absl/flags/flag.h"
#include "absl/strings/string_view.h"
#include "api/scoped_refptr.h"
#include "api/stats/rtc_stats_report.h"
#include "api/stats/rtcstats_objects.h"
#include "api/test/metrics/metric.h"
#include "api/test/metrics/metrics_logger.h"
#include "api/test/track_id_stream_info_map.h"
#include "api/units/time_delta.h"
#include "rtc_base/checks.h"
#include "rtc_base/synchronization/mutex.h"
#include "test/pc/e2e/metric_metadata_keys.h"
#include "test/test_flags.h"

namespace webrtc {
namespace webrtc_pc_e2e {

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

DefaultAudioQualityAnalyzer::DefaultAudioQualityAnalyzer(
    test::MetricsLogger* const metrics_logger)
    : metrics_logger_(metrics_logger) {
  RTC_CHECK(metrics_logger_);
}

void DefaultAudioQualityAnalyzer::Start(std::string test_case_name,
                                        TrackIdStreamInfoMap* analyzer_helper) {
  test_case_name_ = std::move(test_case_name);
  analyzer_helper_ = analyzer_helper;
}

void DefaultAudioQualityAnalyzer::OnStatsReports(
    absl::string_view pc_label,
    const scoped_refptr<const RTCStatsReport>& report) {
  auto stats = report->GetStatsOfType<RTCInboundRtpStreamStats>();

  for (auto& stat : stats) {
    if (!stat->kind.has_value() || !(*stat->kind == "audio")) {
      continue;
    }

    StatsSample sample;
    sample.total_samples_received = stat->total_samples_received.value_or(0ul);
    sample.concealed_samples = stat->concealed_samples.value_or(0ul);
    sample.removed_samples_for_acceleration =
        stat->removed_samples_for_acceleration.value_or(0ul);
    sample.inserted_samples_for_deceleration =
        stat->inserted_samples_for_deceleration.value_or(0ul);
    sample.silent_concealed_samples =
        stat->silent_concealed_samples.value_or(0ul);
    sample.jitter_buffer_delay =
        TimeDelta::Seconds(stat->jitter_buffer_delay.value_or(0.));
    sample.jitter_buffer_target_delay =
        TimeDelta::Seconds(stat->jitter_buffer_target_delay.value_or(0.));
    sample.jitter_buffer_emitted_count =
        stat->jitter_buffer_emitted_count.value_or(0ul);
    sample.total_samples_duration = stat->total_samples_duration.value_or(0.);
    sample.total_audio_energy = stat->total_audio_energy.value_or(0.);

    TrackIdStreamInfoMap::StreamInfo stream_info =
        analyzer_helper_->GetStreamInfoFromTrackId(*stat->track_identifier);

    MutexLock lock(&lock_);
    stream_info_.emplace(stream_info.stream_label, stream_info);
    StatsSample prev_sample = last_stats_sample_[stream_info.stream_label];
    RTC_CHECK_GE(sample.total_samples_received,
                 prev_sample.total_samples_received);
    double total_samples_diff = static_cast<double>(
        sample.total_samples_received - prev_sample.total_samples_received);
    if (total_samples_diff == 0) {
      return;
    }

    AudioStreamStats& audio_stream_stats =
        streams_stats_[stream_info.stream_label];
    audio_stream_stats.expand_rate.AddSample(
        {.value = (sample.concealed_samples - prev_sample.concealed_samples) /
                  total_samples_diff,
         .time = report->timestamp()});
    audio_stream_stats.accelerate_rate.AddSample(
        {.value = (sample.removed_samples_for_acceleration -
                   prev_sample.removed_samples_for_acceleration) /
                  total_samples_diff,
         .time = report->timestamp()});
    audio_stream_stats.preemptive_rate.AddSample(
        {.value = (sample.inserted_samples_for_deceleration -
                   prev_sample.inserted_samples_for_deceleration) /
                  total_samples_diff,
         .time = report->timestamp()});

    int64_t speech_concealed_samples =
        sample.concealed_samples - sample.silent_concealed_samples;
    int64_t prev_speech_concealed_samples =
        prev_sample.concealed_samples - prev_sample.silent_concealed_samples;
    audio_stream_stats.speech_expand_rate.AddSample(
        {.value = (speech_concealed_samples - prev_speech_concealed_samples) /
                  total_samples_diff,
         .time = report->timestamp()});

    int64_t jitter_buffer_emitted_count_diff =
        sample.jitter_buffer_emitted_count -
        prev_sample.jitter_buffer_emitted_count;
    if (jitter_buffer_emitted_count_diff > 0) {
      TimeDelta jitter_buffer_delay_diff =
          sample.jitter_buffer_delay - prev_sample.jitter_buffer_delay;
      TimeDelta jitter_buffer_target_delay_diff =
          sample.jitter_buffer_target_delay -
          prev_sample.jitter_buffer_target_delay;
      audio_stream_stats.average_jitter_buffer_delay_ms.AddSample(
          {.value = jitter_buffer_delay_diff.ms<double>() /
                    jitter_buffer_emitted_count_diff,
           .time = report->timestamp()});
      audio_stream_stats.preferred_buffer_size_ms.AddSample(
          {.value = jitter_buffer_target_delay_diff.ms<double>() /
                    jitter_buffer_emitted_count_diff,
           .time = report->timestamp()});
    }
    audio_stream_stats.energy.AddSample(
        {.value =
             sqrt((sample.total_audio_energy - prev_sample.total_audio_energy) /
                  (sample.total_samples_duration -
                   prev_sample.total_samples_duration)),
         .time = report->timestamp()});

    last_stats_sample_[stream_info.stream_label] = sample;
  }
}

std::string DefaultAudioQualityAnalyzer::GetTestCaseName(
    const std::string& stream_label) const {
  if (!absl::GetFlag(FLAGS_isolated_script_test_perf_output).empty()) {
    return test_case_name_ + "/" + stream_label;
  }
  return test_case_name_;
}

void DefaultAudioQualityAnalyzer::Stop() {
  MutexLock lock(&lock_);
  for (auto& item : streams_stats_) {
    std::string test_case_name = GetTestCaseName(item.first);
    const TrackIdStreamInfoMap::StreamInfo& stream_info =
        stream_info_[item.first];
    std::map<std::string, std::string> metric_metadata{
        {MetricMetadataKey::kAudioStreamMetadataKey, item.first},
        {MetricMetadataKey::kPeerMetadataKey, stream_info.receiver_peer},
        {MetricMetadataKey::kReceiverMetadataKey, stream_info.receiver_peer}};

    metrics_logger_->LogMetric(
        "expand_rate", test_case_name, item.second.expand_rate, Unit::kUnitless,
        ImprovementDirection::kSmallerIsBetter, metric_metadata);
    metrics_logger_->LogMetric("accelerate_rate", test_case_name,
                               item.second.accelerate_rate, Unit::kUnitless,
                               ImprovementDirection::kSmallerIsBetter,
                               metric_metadata);
    metrics_logger_->LogMetric("preemptive_rate", test_case_name,
                               item.second.preemptive_rate, Unit::kUnitless,
                               ImprovementDirection::kSmallerIsBetter,
                               metric_metadata);
    metrics_logger_->LogMetric("speech_expand_rate", test_case_name,
                               item.second.speech_expand_rate, Unit::kUnitless,
                               ImprovementDirection::kSmallerIsBetter,
                               metric_metadata);
    metrics_logger_->LogMetric(
        "average_jitter_buffer_delay_ms", test_case_name,
        item.second.average_jitter_buffer_delay_ms, Unit::kMilliseconds,
        ImprovementDirection::kNeitherIsBetter, metric_metadata);
    metrics_logger_->LogMetric(
        "preferred_buffer_size_ms", test_case_name,
        item.second.preferred_buffer_size_ms, Unit::kMilliseconds,
        ImprovementDirection::kNeitherIsBetter, metric_metadata);
    metrics_logger_->LogMetric(
        "energy", test_case_name, item.second.energy, Unit::kUnitless,
        ImprovementDirection::kNeitherIsBetter, metric_metadata);
  }
}

std::map<std::string, AudioStreamStats>
DefaultAudioQualityAnalyzer::GetAudioStreamsStats() const {
  MutexLock lock(&lock_);
  return streams_stats_;
}

}  // namespace webrtc_pc_e2e
}  // namespace webrtc