// Copyright 2022 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "starboard/shared/uwp/audio_renderer_passthrough.h"

#include <algorithm>
#include <string>

#include "starboard/common/log.h"
#include "starboard/common/string.h"

namespace starboard {
namespace shared {
namespace uwp {

namespace {

int CodecToIecSampleRate(SbMediaAudioCodec codec) {
  switch (codec) {
    case kSbMediaAudioCodecAc3:
      return 48000;
    case kSbMediaAudioCodecEac3:
      return 192000;
    default:
      SB_NOTREACHED();
      return 0;
  }
}

}  // namespace

AudioRendererPassthrough::AudioRendererPassthrough(
    scoped_ptr<AudioDecoder> audio_decoder,
    const AudioStreamInfo& audio_stream_info)
    : channels_(audio_stream_info.number_of_channels),
      codec_(audio_stream_info.codec),
      iec_sample_rate_(CodecToIecSampleRate(audio_stream_info.codec)),
      decoder_(audio_decoder.Pass()),
      sink_(new WASAPIAudioSink),
      process_audio_buffers_job_(
          std::bind(&AudioRendererPassthrough::ProcessAudioBuffers, this)) {
  SB_DCHECK(codec_ == kSbMediaAudioCodecAc3 ||
            codec_ == kSbMediaAudioCodecEac3);
  SB_DCHECK(decoder_);
  QueryPerformanceFrequency(&performance_frequency_);
  SB_DCHECK(performance_frequency_.QuadPart > 0);
  SB_LOG(INFO) << "Creating AudioRendererPassthrough with " << channels_
               << " channels.";
}

AudioRendererPassthrough::~AudioRendererPassthrough() {
  SB_DCHECK(BelongsToCurrentThread());
  SB_LOG(INFO) << "Destroying AudioRendererPassthrough with " << channels_
               << " channels.";
}

void AudioRendererPassthrough::Initialize(const ErrorCB& error_cb,
                                          const PrerolledCB& prerolled_cb,
                                          const EndedCB& ended_cb) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(error_cb);
  SB_DCHECK(prerolled_cb);
  SB_DCHECK(ended_cb);
  SB_DCHECK(!error_cb_);
  SB_DCHECK(!prerolled_cb_);
  SB_DCHECK(!ended_cb_);

  error_cb_ = error_cb;
  prerolled_cb_ = prerolled_cb;
  ended_cb_ = ended_cb;

  decoder_->Initialize(
      std::bind(&AudioRendererPassthrough::OnDecoderOutput, this), error_cb);

  if (!sink_->Initialize(channels_, iec_sample_rate_, codec_)) {
    error_cb_(kSbPlayerErrorDecode, "failed to start audio sink");
  }
}

void AudioRendererPassthrough::WriteSamples(const InputBuffers& input_buffers) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(input_buffers.size() == 1);
  SB_DCHECK(input_buffers[0]);
  SB_DCHECK(can_accept_more_data_.load());

  if (end_of_stream_written_.load()) {
    SB_LOG(ERROR) << "Appending audio sample at "
                  << input_buffers[0]->timestamp() << " after EOS reached.";
    return;
  }

  can_accept_more_data_.store(false);
  decoder_->Decode(
      input_buffers,
      std::bind(&AudioRendererPassthrough::OnDecoderConsumed, this));
}

void AudioRendererPassthrough::WriteEndOfStream() {
  SB_DCHECK(BelongsToCurrentThread());

  if (end_of_stream_written_.load()) {
    SB_LOG(ERROR) << "Try to write EOS after EOS is reached";
    return;
  }

  end_of_stream_written_.store(true);
  decoder_->WriteEndOfStream();
}

void AudioRendererPassthrough::SetVolume(double volume) {
  SB_DCHECK(BelongsToCurrentThread());
  sink_->SetVolume(volume);
}

bool AudioRendererPassthrough::IsEndOfStreamWritten() const {
  SB_DCHECK(BelongsToCurrentThread());

  return end_of_stream_written_.load();
}

bool AudioRendererPassthrough::IsEndOfStreamPlayed() const {
  SB_DCHECK(BelongsToCurrentThread());

  return end_of_stream_played_.load();
}

bool AudioRendererPassthrough::CanAcceptMoreData() const {
  SB_DCHECK(BelongsToCurrentThread());

  return !end_of_stream_written_.load() &&
         pending_inputs_.size() < kMaxDecodedAudios &&
         can_accept_more_data_.load();
}

void AudioRendererPassthrough::Play() {
  SB_DCHECK(BelongsToCurrentThread());
  ScopedLock lock(mutex_);
  paused_ = false;
  sink_->Play();
}

void AudioRendererPassthrough::Pause() {
  SB_DCHECK(BelongsToCurrentThread());
  ScopedLock lock(mutex_);
  paused_ = true;
  sink_->Pause();
}

void AudioRendererPassthrough::SetPlaybackRate(double playback_rate) {
  SB_DCHECK(BelongsToCurrentThread());

  if (playback_rate > 0.0 && playback_rate != 1.0) {
    std::string error_message = ::starboard::FormatString(
        "Playback rate %f is not supported", playback_rate);
    error_cb_(kSbPlayerErrorDecode, error_message);
    return;
  }

  ScopedLock lock(mutex_);
  playback_rate_ = playback_rate;
  sink_->SetPlaybackRate(playback_rate);
}

void AudioRendererPassthrough::Seek(SbTime seek_to_time) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(seek_to_time >= 0);
  {
    ScopedLock lock(mutex_);
    seeking_to_time_ = std::max<SbTime>(seek_to_time, 0);
    seeking_ = true;
  }

  total_frames_sent_to_sink_ = 0;
  can_accept_more_data_.store(true);
  process_audio_buffers_job_token_.ResetToInvalid();
  total_buffers_sent_to_sink_ = 0;
  end_of_stream_written_.store(false);
  end_of_stream_played_.store(false);
  pending_inputs_ = std::queue<scoped_refptr<DecodedAudio>>();
  sink_->Reset();
  decoder_->Reset();

  CancelPendingJobs();
}

SbTime AudioRendererPassthrough::GetCurrentMediaTime(bool* is_playing,
                                                     bool* is_eos_played,
                                                     bool* is_underflow,
                                                     double* playback_rate) {
  SB_DCHECK(is_playing);
  SB_DCHECK(is_eos_played);
  SB_DCHECK(is_underflow);
  SB_DCHECK(playback_rate);

  ScopedLock lock(mutex_);
  *is_playing = !paused_ && !seeking_;
  *is_eos_played = end_of_stream_played_.load();
  *is_underflow = false;  // TODO: Support underflow
  *playback_rate = playback_rate_;

  if (seeking_) {
    return seeking_to_time_;
  }

  uint64_t sink_playback_time_updated_at;
  SbTime sink_playback_time = static_cast<SbTime>(
      sink_->GetCurrentPlaybackTime(&sink_playback_time_updated_at));
  if (sink_playback_time <= 0) {
    if (sink_playback_time < 0) {
      error_cb_(kSbPlayerErrorDecode,
                "Error obtaining playback time from WASAPI sink");
    }
    return seeking_to_time_;
  }

  SbTime media_time = seeking_to_time_ + sink_playback_time;
  if (!sink_->playing()) {
    return media_time;
  }

  return media_time +
         CalculateElapsedPlaybackTime(sink_playback_time_updated_at);
}

void AudioRendererPassthrough::OnDecoderConsumed() {
  SB_DCHECK(BelongsToCurrentThread());
  can_accept_more_data_.store(true);
}

void AudioRendererPassthrough::OnDecoderOutput() {
  SB_DCHECK(BelongsToCurrentThread());
  int samples_per_second = 0;
  scoped_refptr<DecodedAudio> decoded_audio =
      decoder_->Read(&samples_per_second);
  SB_DCHECK(decoded_audio);
  pending_inputs_.push(decoded_audio);

  if (process_audio_buffers_job_token_.is_valid()) {
    RemoveJobByToken(process_audio_buffers_job_token_);
    process_audio_buffers_job_token_.ResetToInvalid();
  }
  ProcessAudioBuffers();
}

void AudioRendererPassthrough::ProcessAudioBuffers() {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(!pending_inputs_.empty());

  process_audio_buffers_job_token_.ResetToInvalid();
  SbTime process_audio_buffers_job_delay = 5 * kSbTimeMillisecond;

  scoped_refptr<DecodedAudio> decoded_audio = pending_inputs_.front();
  SB_DCHECK(decoded_audio);

  if (decoded_audio->is_end_of_stream()) {
    SB_DCHECK(end_of_stream_written_.load());
    ScopedLock lock(mutex_);
    if (seeking_) {
      seeking_ = false;
      Schedule(prerolled_cb_);
    }
    pending_inputs_.pop();
    SB_DCHECK(pending_inputs_.empty());
  } else {
    ScopedLock lock(mutex_);
    while (seeking_ && decoded_audio &&
           CalculateLastOutputTime(decoded_audio) < seeking_to_time_) {
      pending_inputs_.pop();
      decoded_audio = pending_inputs_.empty() ? scoped_refptr<DecodedAudio>()
                                              : pending_inputs_.front();
    }

    if (decoded_audio && TryToWriteAudioBufferToSink(decoded_audio)) {
      pending_inputs_.pop();
      process_audio_buffers_job_delay = 0;
      if (seeking_ && total_buffers_sent_to_sink_ >= kNumPrerollDecodedAudios) {
        seeking_ = false;
        Schedule(prerolled_cb_);
      }
    }
  }

  if (!pending_inputs_.empty()) {
    process_audio_buffers_job_token_ =
        Schedule(process_audio_buffers_job_, process_audio_buffers_job_delay);
    return;
  }

  if (end_of_stream_written_.load() && !end_of_stream_played_.load()) {
    TryToEndStream();
  }
}

bool AudioRendererPassthrough::TryToWriteAudioBufferToSink(
    scoped_refptr<DecodedAudio> decoded_audio) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(decoded_audio);

  bool buffer_written = sink_->WriteBuffer(decoded_audio);
  if (buffer_written && !decoded_audio->is_end_of_stream()) {
    total_frames_sent_to_sink_ += decoded_audio->frames();
    total_buffers_sent_to_sink_++;
  }
  return buffer_written;
}

void AudioRendererPassthrough::TryToEndStream() {
  bool is_playing, is_eos_played, is_underflow;
  double playback_rate;
  int64_t total_frames_played_by_sink =
      GetCurrentMediaTime(&is_playing, &is_eos_played, &is_underflow,
                          &playback_rate) *
      iec_sample_rate_ / kSbTimeSecond;
  // Wait for the audio sink to output the remaining frames before calling
  // Pause().
  if (total_frames_played_by_sink >= total_frames_sent_to_sink_) {
    sink_->Pause();
    end_of_stream_played_.store(true);
    ended_cb_();
    return;
  }
  Schedule(std::bind(&AudioRendererPassthrough::TryToEndStream, this),
           5 * kSbTimeMillisecond);
}

SbTime AudioRendererPassthrough::CalculateElapsedPlaybackTime(
    uint64_t update_time) {
  LARGE_INTEGER current_time;
  QueryPerformanceCounter(&current_time);
  // Convert current performance counter timestamp to units of 100 nanoseconds.
  // https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nf-audioclient-iaudioclock-getposition#remarks
  uint64_t current_time_converted =
      static_cast<double>(current_time.QuadPart) *
      (10000000.0 / static_cast<double>(performance_frequency_.QuadPart));
  SB_DCHECK(current_time_converted >= update_time);

  // Convert elapsed time to SbTime.
  return ((current_time_converted - update_time) * 100) /
         kSbTimeNanosecondsPerMicrosecond;
}

SbTime AudioRendererPassthrough::CalculateLastOutputTime(
    scoped_refptr<DecodedAudio>& decoded_audio) {
  return decoded_audio->timestamp() +
         (decoded_audio->frames() / iec_sample_rate_ * kSbTimeSecond);
}

}  // namespace uwp
}  // namespace shared
}  // namespace starboard