// 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 <deque>
#include <iomanip>
#include <iostream>

#include "base/bind.h"
#include "examples/media_test/keystroke.h"
#include "examples/media_test/media_test.h"
#include "mojo/application/application_runner_chromium.h"
#include "mojo/public/c/system/main.h"
#include "mojo/public/cpp/application/application_delegate.h"
#include "mojo/public/cpp/application/application_impl.h"

namespace mojo {
namespace media {
namespace examples {

class MediaTestApp : public mojo::ApplicationDelegate {
 public:
  MediaTestApp() {}

  ~MediaTestApp() override {}

  // ApplicationDelegate implementation.
  void Initialize(mojo::ApplicationImpl* app) override {
    app_ = app;
    ProcessArgs(app->args());

    std::cout << std::endl << "MEDIA TEST" << std::endl << std::endl;

    if (input_file_names_.empty()) {
      std::cout << "Please provide the names of the files you want to play;"
                << " for example:" << std::endl
                << "mojo/devtools/common/mojo_run \\" << std::endl
                << "    \"https://core.mojoapps.io/media_test.mojo \\"
                << std::endl
                << "    http:/localhost/superstition.ogg \\" << std::endl
                << "    http:/localhost/higherground.ogg\"" << std::endl
                << std::endl;
      base::MessageLoop::current()->Quit();
      return;
    }

    std::cout << "    <enter>         play/pause" << std::endl
              << "    n<enter>        next file" << std::endl
              << "    p<enter>        previous file" << std::endl
              << "    <digit><enter>  seek (0% - 90%)" << std::endl
              << "    q<enter>        quit" << std::endl
              << std::endl;

    if (paint_) {
      std::cout << "    duration   <none>" << std::endl
                << "    title      <none>" << std::endl
                << "    artist     <none>" << std::endl
                << "    album      <none>" << std::endl
                << "    publisher  <none>" << std::endl
                << "    genre      <none>" << std::endl
                << "    composer   <none>" << std::endl
                << std::endl
                << std::endl
                << std::endl
                << kUp << std::flush;
    }

    CreateNewMediaTest();
    Poll();
  }

 private:
  static const char* kHome;
  static const char* kClearLine;
  static const char* kUp;
  static constexpr double ns_per_second = 1000000000.0;

  // Processes arguments.
  void ProcessArgs(const std::vector<std::string>& args) {
    for (size_t i = 1; i < args.size(); ++i) {
      const std::string& arg = args[i];
      if (arg == "--paint") {
        paint_ = true;
      } else if (arg == "--no-paint") {
        paint_ = false;
      } else {
        input_file_names_.push_back(arg);
      }
    }

    input_file_names_iter_ = input_file_names_.begin();
  }

  // Creates a new MediaTest object to play the file referenced by
  // input_file_names_iter_.
  void CreateNewMediaTest() {
    MOJO_DCHECK(input_file_names_iter_ != input_file_names_.end());
    media_test_ = MediaTest::Create(app_, *input_file_names_iter_);

    metadata_shown_ = false;
    media_test_->RegisterUpdateCallback(
        [this]() { HandleMediaTestUpdateCallback(); });

    media_test_->Play();
  }

  void HandleMediaTestUpdateCallback() {
    if (media_test_->state() == MediaState::ENDED &&
        media_test_->previous_state() != MediaState::ENDED) {
      // MediaTest doesn't appreciate being deleted in this callback.
      // Next time Poll runs, we move on to the next file.
      base::MessageLoop::current()->PostTask(
          FROM_HERE,
          base::Bind(&MediaTestApp::PlayNext, base::Unretained(this)));
    }

    const MediaMetadataPtr& metadata = media_test_->metadata();

    if (metadata) {
      duration_ns_ = metadata->duration;
    }

    if (paint_) {
      // Move the cursor up the terminal so we paint over the old metadata
      // (7 lines) a blank line and the state line (total of 9 lines).
      std::cout << kHome << kUp << kUp << kUp << kUp << kUp << kUp << kUp << kUp
                << kUp;
    }

    if (!paint_ && metadata_shown_) {
      // Do nothing.
    } else if (metadata) {
      metadata_shown_ = true;
      std::cout << "    duration   " << std::fixed << std::setprecision(1)
                << double(metadata->duration) / ns_per_second << " seconds"
                << clear_line() << std::endl
                << "    title      "
                << (metadata->title ? metadata->title : "<none>")
                << clear_line() << std::endl
                << "    artist     "
                << (metadata->artist ? metadata->artist : "<none>")
                << clear_line() << std::endl
                << "    album      "
                << (metadata->album ? metadata->album : "<none>")
                << clear_line() << std::endl
                << "    publisher  "
                << (metadata->publisher ? metadata->publisher : "<none>")
                << clear_line() << std::endl
                << "    genre      "
                << (metadata->genre ? metadata->genre : "<none>")
                << clear_line() << std::endl
                << "    composer   "
                << (metadata->composer ? metadata->composer : "<none>")
                << clear_line() << std::endl
                << std::endl;
    } else if (paint_) {
      std::cout << "    duration   <none>" << kClearLine << std::endl
                << "    title      <none>" << kClearLine << std::endl
                << "    artist     <none>" << kClearLine << std::endl
                << "    album      <none>" << kClearLine << std::endl
                << "    publisher  <none>" << kClearLine << std::endl
                << "    genre      <none>" << kClearLine << std::endl
                << "    composer   <none>" << kClearLine << std::endl
                << std::endl;
    }
    std::cout << "    " << state_string() << clear_line() << std::endl;
  }

  // Returns a string describing the MediaTest object's state.
  const char* state_string() const {
    switch (media_test_->state()) {
      case MediaState::FAULT:
        return "FAULT";
      case MediaState::UNPREPARED:
        return "unprepared";
      case MediaState::PAUSED:
        return "paused";
      case MediaState::PLAYING:
        return "playing";
      case MediaState::ENDED:
        return "ended";
    }
    return "UNSUPPORTED STATE VALUE";
  }

  // Handles a keystroke.
  void HandleKeystroke(char keystroke) {
    switch (keystroke) {
      case '\n':
        TogglePlayPause();
        break;
      case 'q':
        base::MessageLoop::current()->Quit();
        quit_ = true;
        if (paint_) {
          std::cout << kHome << kUp << "    quitting" << kClearLine << std::endl
                    << kClearLine << std::endl;
        } else {
          std::cout << "    quitting" << std::endl;
        }
        break;
      case 'n':
        if (++input_file_names_iter_ == input_file_names_.end()) {
          input_file_names_iter_ = input_file_names_.begin();
        }
        CreateNewMediaTest();
        break;
      case 'p':
        if (input_file_names_iter_ == input_file_names_.begin()) {
          input_file_names_iter_ = input_file_names_.end();
        }
        input_file_names_iter_--;
        CreateNewMediaTest();
        break;
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9': {
        int64_t position_ns = ((keystroke - '0') / 10.0) * duration_ns_;
        media_test_->Seek(position_ns);
        if (!paint_) {
          std::cout << "    seeking to " << std::fixed << std::setprecision(1)
                    << double(position_ns) / ns_per_second << " seconds  "
                    << std::endl;
        }
        break;
      }
    }
  }

  // Toggles between play and pause (prepared) states.
  void TogglePlayPause() {
    switch (media_test_->state()) {
      case MediaState::PAUSED:
        media_test_->Play();
        break;
      case MediaState::PLAYING:
        media_test_->Pause();
        break;
      case MediaState::ENDED:
        if (input_file_names_.size() == 1) {
          // Replaying the only file. Reuse the same MediaTest instance.
          media_test_->Seek(0);
          media_test_->Play();
        } else {
          // Starting a new file. Create a new MediaTest instance.
          CreateNewMediaTest();
        }
        break;
      default:
        break;
    }
  }

  // Does any needed work and schedules itself to run again soon. Quits when
  // quit_ is true.
  void Poll() {
    MOJO_DCHECK(!quit_);

    char keystroke = Keystroke();
    if (keystroke != 0) {
      HandleKeystroke(keystroke);
    }

    if (quit_) {
      // Eat the any additional keystrokes, which would otherwise make it to the
      // command shell.
      while (Keystroke() != 0) {
        // Do nothing.
      }
      return;
    }

    if (paint_) {
      std::cout << kHome << "    " << std::fixed << std::setprecision(1)
                << double(media_test_->position_ns()) / ns_per_second
                << " seconds  " << kClearLine << std::flush;
    }

    base::MessageLoop::current()->PostDelayedTask(
        FROM_HERE, base::Bind(&MediaTestApp::Poll, base::Unretained(this)),
        base::TimeDelta::FromMilliseconds(100));
  }

  void PlayNext() {
    if (++input_file_names_iter_ == input_file_names_.end()) {
      input_file_names_iter_ = input_file_names_.begin();
    } else {
      CreateNewMediaTest();
    }
  }

  const char* clear_line() const { return paint_ ? kClearLine : ""; }

  mojo::ApplicationImpl* app_;
  std::unique_ptr<MediaTest> media_test_;
  std::deque<std::string> input_file_names_;
  decltype(input_file_names_.begin()) input_file_names_iter_;
  bool quit_ = false;
  bool paint_ = true;
  bool metadata_shown_ = false;
  uint64_t duration_ns_;

  DISALLOW_COPY_AND_ASSIGN(MediaTestApp);
};

const char* MediaTestApp::kHome = "\r";
const char* MediaTestApp::kClearLine = "\033[K";
const char* MediaTestApp::kUp = "\033[A";

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

MojoResult MojoMain(MojoHandle application_request) {
  mojo::ApplicationRunnerChromium runner(
      new mojo::media::examples::MediaTestApp);
  return runner.Run(application_request);
}