// Copyright (c) 2017 Intel Corporation. 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 "shadow_node.h"

#include <memory>
#include <vector>

#include "executor.h"
#include "handle_manager.h"
#include "rcl_handle.h"

namespace rclnodejs {

Napi::FunctionReference ShadowNode::constructor;

ShadowNode::ShadowNode(const Napi::CallbackInfo& info)
    : Napi::ObjectWrap<ShadowNode>(info),
      handle_manager_(std::make_unique<HandleManager>()) {
  executor_ =
      std::make_unique<Executor>(info.Env(), handle_manager_.get(), this);
}

ShadowNode::~ShadowNode() { StopRunning(); }

void ShadowNode::Init(Napi::Env env, Napi::Object exports) {
  Napi::HandleScope scope(env);

  Napi::Function func =
      DefineClass(env, "ShadowNode",
                  {
                      InstanceMethod("start", &ShadowNode::Start),
                      InstanceMethod("stop", &ShadowNode::Stop),
                      InstanceMethod("syncHandles", &ShadowNode::SyncHandles),
                      InstanceMethod("spinOnce", &ShadowNode::SpinOnce),
                  });

  constructor = Napi::Persistent(func);
  constructor.SuppressDestruct();
  exports.Set("ShadowNode", func);
}

void ShadowNode::StopRunning() {
  executor_->Stop();
  handle_manager_->ClearHandles();
}

void ShadowNode::StartRunning(rcl_context_t* context, int32_t timeout) {
  handle_manager_->SynchronizeHandles(this->Value());
  executor_->Start(context, timeout);
}

void ShadowNode::RunOnce(rcl_context_t* context, int32_t timeout) {
  handle_manager_->SynchronizeHandles(this->Value());
  executor_->SpinOnce(context, timeout);
}

Napi::Value ShadowNode::Start(const Napi::CallbackInfo& info) {
  Napi::Object context_handle = info[0].As<Napi::Object>();
  RclHandle* handle = RclHandle::Unwrap(context_handle);
  int32_t timeout = info[1].As<Napi::Number>().Int32Value();

  rcl_context_t* context = reinterpret_cast<rcl_context_t*>(handle->ptr());
  StartRunning(context, timeout);

  return info.Env().Undefined();
}

Napi::Value ShadowNode::Stop(const Napi::CallbackInfo& info) {
  StopRunning();
  return info.Env().Undefined();
}

Napi::Value ShadowNode::SpinOnce(const Napi::CallbackInfo& info) {
  Napi::Object context_handle = info[0].As<Napi::Object>();
  RclHandle* handle = RclHandle::Unwrap(context_handle);
  int32_t timeout = info[1].As<Napi::Number>().Int32Value();

  rcl_context_t* context = reinterpret_cast<rcl_context_t*>(handle->ptr());
  RunOnce(context, timeout);

  return info.Env().Undefined();
}

Napi::Value ShadowNode::SyncHandles(const Napi::CallbackInfo& info) {
  handle_manager()->SynchronizeHandles(this->Value());
  return info.Env().Undefined();
}

void ShadowNode::Execute(const std::vector<rclnodejs::RclHandle*>& handles) {
  Napi::Env env = Env();
  Napi::HandleScope scope(env);

  Napi::Array results = Napi::Array::New(env, handles.size());
  for (size_t i = 0; i < handles.size(); ++i) {
    handles[i]->SyncProperties();
    results[i] = handles[i]->Value();
  }

  Napi::Function execute =
      Value().As<Napi::Object>().Get("execute").As<Napi::Function>();
  execute.Call(Value(), {results});
}

void ShadowNode::CatchException(std::exception_ptr e_ptr) {
  try {
    std::rethrow_exception(e_ptr);
  } catch (const std::exception& e) {
    Napi::Error::New(Env(), e.what()).ThrowAsJavaScriptException();
  }
}

}  // namespace rclnodejs