// Copyright 2015 The Chromium 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 <math.h>
#include <memory>

#include "mojo/public/c/system/main.h"
#include "mojo/public/cpp/application/application_delegate.h"
#include "mojo/public/cpp/application/application_impl.h"
#include "mojo/public/cpp/application/application_runner.h"
#include "mojo/public/cpp/application/connect.h"
#include "mojo/public/cpp/utility/run_loop.h"
#include "mojo/services/media/audio/interfaces/audio_server.mojom.h"
#include "mojo/services/media/audio/interfaces/audio_track.mojom.h"
#include "mojo/services/media/common/cpp/circular_buffer_media_pipe_adapter.h"
#include "mojo/services/media/common/cpp/linear_transform.h"
#include "mojo/services/media/common/cpp/local_time.h"
#include "mojo/services/media/common/interfaces/rate_control.mojom.h"

namespace mojo {
namespace media {
namespace audio {
namespace examples {

static constexpr uint32_t SAMP_FREQ = 48000;
static constexpr uint32_t CHUNK_USEC = 10000;
static constexpr uint32_t BUF_LO_WATER_USEC = 500000;
static constexpr uint32_t BUF_HI_WATER_USEC = BUF_LO_WATER_USEC
                                            + (4 * CHUNK_USEC);
static constexpr uint32_t BUF_DEPTH_USEC    = BUF_HI_WATER_USEC
                                            + (4 * CHUNK_USEC);
static constexpr uint32_t FRAME_BYTES = sizeof(int16_t);

static inline constexpr uint32_t USecToBytes(uint64_t usec) {
  return ((usec * SAMP_FREQ) / 1000000) * FRAME_BYTES;
}

class PlayToneApp : public ApplicationDelegate {
 public:
  ~PlayToneApp() override { Quit(); }

  // ApplicationDelegate
  void Initialize(ApplicationImpl* app) override;
  void Quit() override;

 private:
  void GenerateToneCbk(MediaResult res);
  void PlayTone(double freq_hz, double amplitude, double duration_sec);
  void PostShutdown();
  void Shutdown();
  void OnConnectionError(const std::string& connection_name);

  AudioServerPtr audio_server_;
  AudioTrackPtr  audio_track_;
  RateControlPtr rate_control_;
  std::unique_ptr<CircularBufferMediaPipeAdapter> audio_pipe_;

  bool     clock_started_ = false;
  uint64_t media_time_    = 0;
  double   freq_hz_       = 440.0;
  double   amplitude_     = 1.0;
  bool     shutting_down_ = false;
};

void PlayToneApp::Quit() {
  rate_control_.reset();
  audio_pipe_.reset();
  audio_track_.reset();
  audio_server_.reset();
}

void PlayToneApp::Initialize(ApplicationImpl* app) {
  mojo::ConnectToService(app->shell(), "mojo:audio_server",
                         GetProxy(&audio_server_));
  audio_server_.set_connection_error_handler([this]() {
    OnConnectionError("audio_server");
  });

  audio_server_->CreateTrack(GetProxy(&audio_track_));
  audio_track_.set_connection_error_handler([this]() {
    OnConnectionError("audio_track");
  });

  // Query the sink's format capabilities.
  AudioTrackDescriptorPtr sink_desc;
  auto desc_cbk = [&sink_desc](AudioTrackDescriptorPtr desc) {
    sink_desc = desc.Pass();
  };
  audio_track_->Describe(AudioTrack::DescribeCallback(desc_cbk));

  // TODO(johngro): this pattern is awkward.  We really don't want to be
  // calling WaitForIncomingResponse, even if we were able supply a timeout.
  // The best practice would be to defer to a handler for the message we are
  // expecting to eventually come back.
  //
  // But... what if the message never comes back?  Perhaps the service is not
  // implemented properly, or perhaps the service is malicious.  We could
  // queue a delayed message on our run loop which indicates a timeout, but
  // then what happens when when the response to Describe comes back (as
  // expected).  We don't really have a good way to cancel the "timeout"
  // message once we have queued it.  Maintaining all of the bookkeeping
  // required to nerf the callback when it happens and is discovered to be
  // useless is going to get very old, very fast.
  //
  // For now, we just do the evil thing and block during init, but I sure do
  // wish there was something nicer we could do.
  if (!audio_track_.WaitForIncomingResponse()) {
    MOJO_LOG(ERROR)
      << "Failed to fetch sync capabilities; no response received.";
    Shutdown();
    return;
  }

  // TODO(johngro): do something useful with our capabilities description.
  sink_desc.reset();

  // Grab the rate control interface for our audio renderer.
  audio_track_->GetRateControl(GetProxy(&rate_control_));
  rate_control_.set_connection_error_handler([this]() {
    OnConnectionError("rate_control");
  });

  // Configure our sink for 16-bit 48KHz mono.
  AudioTrackConfigurationPtr cfg = AudioTrackConfiguration::New();

  AudioMediaTypeDetailsPtr pcm_cfg = AudioMediaTypeDetails::New();
  pcm_cfg->sample_format     = AudioSampleFormat::SIGNED_16;
  pcm_cfg->channels          = 1;
  pcm_cfg->frames_per_second = SAMP_FREQ;

  cfg->media_type = MediaType::New();
  cfg->media_type->medium = MediaTypeMedium::AUDIO;
  cfg->media_type->details = MediaTypeDetails::New();
  cfg->media_type->details->set_audio(pcm_cfg.Pass());
  cfg->media_type->encoding = MediaType::kAudioEncodingLpcm;

  MediaConsumerPtr pipe;
  audio_track_->Configure(cfg.Pass(), GetProxy(&pipe));

  // Now that the configuration request is in-flight and we our media pipe
  // proxy, pass its interface to our circular buffer helper, set up our
  // high/low water marks, register our callback, and start to buffer our audio.
  audio_pipe_.reset(new CircularBufferMediaPipeAdapter(pipe.Pass()));
  audio_pipe_->Init(USecToBytes(BUF_DEPTH_USEC));
  audio_pipe_->SetSignalCallback(
  [this](MediaResult res) -> void {
    GenerateToneCbk(res);
  });
  audio_pipe_->SetWatermarks(USecToBytes(BUF_HI_WATER_USEC),
                             USecToBytes(BUF_LO_WATER_USEC));
}

void PlayToneApp::GenerateToneCbk(MediaResult res) {
  using MappedPacket = CircularBufferMediaPipeAdapter::MappedPacket;
  MappedPacket mapped_pkt;

  MOJO_DCHECK(freq_hz_ > 0.0);
  MOJO_DCHECK(amplitude_ >= 0.0);
  MOJO_DCHECK(amplitude_ <= 1.0);

  if (res != MediaResult::OK) {
    MOJO_LOG(ERROR) << "Fatal error in media pipe (" << res << ").";
    PostShutdown();
    return;
  }

  while (!audio_pipe_->AboveHiWater()) {
    res = audio_pipe_->CreateMediaPacket(USecToBytes(CHUNK_USEC),
                                         false,
                                         &mapped_pkt);
    if (res != MediaResult::OK) {
      MOJO_LOG(ERROR) << "Unexpected error when creating media packet ("
                 << res << ").";
      PostShutdown();
      return;
    }

    mapped_pkt.packet()->pts = media_time_;

    for (uint32_t i = 0; i < MappedPacket::kMaxRegions; ++i) {
      int16_t* data = reinterpret_cast<int16_t*>(mapped_pkt.data(i));
      uint64_t len;

      if (!data) continue;
      len = mapped_pkt.length(i);

      MOJO_DCHECK(len && !(len % FRAME_BYTES));
      len /= FRAME_BYTES;
      for (uint64_t i = 0; i < len; ++i, ++media_time_) {
        double tmp = ((M_PI * 2.0) / SAMP_FREQ) * freq_hz_ * media_time_;
        data[i] = std::numeric_limits<int16_t>::max() * amplitude_ * sin(tmp);
      }
    }

    res = audio_pipe_->SendMediaPacket(&mapped_pkt);
    if (res != MediaResult::OK) {
      MOJO_LOG(ERROR) << "Unexpected error when sending media packet ("
                 << res << ").";
      audio_pipe_->CancelMediaPacket(&mapped_pkt);
      PostShutdown();
      return;
    }
  }

  if (!clock_started_) {
    // In theory, this could be done at compile time using std::ratio, but
    // std::ratio is prohibited.
    LinearTransform::Ratio audio_rate(SAMP_FREQ, 1);
    LinearTransform::Ratio local_time_rate(LocalDuration::period::num,
                                           LocalDuration::period::den);
    LinearTransform::Ratio rate;
    bool success = LinearTransform::Ratio::Compose(local_time_rate,
                                                   audio_rate,
                                                   &rate);
    MOJO_DCHECK(success);  // assert that there was no loss of precision.

    MOJO_LOG(INFO) << "Setting rate " << rate;

    rate_control_->SetRate(rate.numerator, rate.denominator);
    clock_started_ = true;
  }
}

void PlayToneApp::OnConnectionError(const std::string& connection_name) {
  if (!shutting_down_) {
    MOJO_LOG(ERROR) << connection_name << " connection closed unexpectedly!";
    Shutdown();
  }
}

void PlayToneApp::PostShutdown() {
  if (audio_pipe_) {
    audio_pipe_->ResetSignalCallback();
  }
  audio_pipe_ = nullptr;

  mojo::RunLoop::current()->PostDelayedTask([this]() -> void {
    Shutdown();
  }, 0);
}

void PlayToneApp::Shutdown() {
  Quit();
  RunLoop::current()->Quit();
}

}  // namespace examples
}  // namespace audio
}  // namespace media
}  // namespace mojo

MojoResult MojoMain(MojoHandle app_request) {
  mojo::ApplicationRunner runner(
      std::unique_ptr<mojo::media::audio::examples::PlayToneApp>(
          new mojo::media::audio::examples::PlayToneApp()));
  return runner.Run(app_request);
}