// Copyright 2018 The Fuchsia 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 "garnet/bin/overnet/overnetstack/fuchsia_port.h"
#include "garnet/bin/overnet/overnetstack/mdns.h"
#include "garnet/bin/overnet/overnetstack/overnet_app.h"
#include "garnet/bin/overnet/overnetstack/service.h"
#include "garnet/bin/overnet/overnetstack/udp_nub.h"

namespace overnetstack {

class FuchsiaTimer final : public overnet::Timer {
 public:
  overnet::TimeStamp Now() override {
    return ToTimeStamp(async::Now(dispatcher_));
  }

 private:
  async_dispatcher_t* dispatcher_ = async_get_default_dispatcher();

  struct Task : public async_task_t {
    overnet::Timeout* timeout;
  };

  static void TaskHandler(async_dispatcher_t* async, async_task_t* task,
                          zx_status_t status) {
    FireTimeout(static_cast<Task*>(task)->timeout,
                overnet::Status::FromZx(status));
  }

  void InitTimeout(overnet::Timeout* timeout,
                   overnet::TimeStamp when) override {
    auto* async_timeout = TimeoutStorage<Task>(timeout);
    async_timeout->state = {ASYNC_STATE_INIT};
    async_timeout->handler = TaskHandler;
    async_timeout->deadline = FromTimeStamp(when).get();
    async_timeout->timeout = timeout;
    if (async_post_task(dispatcher_, async_timeout) != ZX_OK) {
      FireTimeout(timeout, overnet::Status::Cancelled());
    }
  }
  void CancelTimeout(overnet::Timeout* timeout,
                     overnet::Status status) override {
    if (async_cancel_task(dispatcher_, TimeoutStorage<Task>(timeout)) ==
        ZX_OK) {
      FireTimeout(timeout, overnet::Status::Cancelled());
    }
  }
};

class FuchsiaLog final : public overnet::TraceRenderer {
 public:
  void Render(overnet::TraceOutput output) override {
    auto severity = [sev = output.severity] {
      switch (sev) {
        case overnet::Severity::DEBUG:
          return fxl::LOG_INFO;
        case overnet::Severity::INFO:
          return fxl::LOG_INFO;
        case overnet::Severity::WARNING:
          return fxl::LOG_WARNING;
        case overnet::Severity::ERROR:
          return fxl::LOG_ERROR;
      }
    }();
    fxl::LogMessage(severity, output.file, output.line, nullptr).stream()
        << output.message;
  }
  void NoteParentChild(overnet::Op, overnet::Op) override {}
};

}  // namespace overnetstack

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToThread);
  overnetstack::FuchsiaLog fuchsia_log;
  overnet::ScopedRenderer scoped_renderer(&fuchsia_log);
  overnetstack::FuchsiaTimer fuchsia_timer;
  overnetstack::OvernetApp app(&fuchsia_timer);
  app.InstantiateActor<overnetstack::Service>();
  auto* udp_nub = app.InstantiateActor<overnetstack::UdpNub>();
  app.InstantiateActor<overnetstack::MdnsIntroducer>(udp_nub);
  app.InstantiateActor<overnetstack::MdnsAdvertisement>(udp_nub);
  auto status = app.Start().Then([&]() {
    loop.Run();
    return overnet::Status::Ok();
  });
  if (status.is_ok()) {
    return 0;
  } else {
    std::cerr << "Failed to start overnetstack: " << status << "\n";
    return static_cast<int>(status.code());
  }
}