// Copyright 2014 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 "nacl_io/devfs/jspipe_event_emitter.h"

#include <assert.h>
#include <errno.h>
#include <string.h>

#include <algorithm>

#define TRACE(format, ...) \
  LOG_TRACE("jspipe[%s]: " format, name_.c_str(), ##__VA_ARGS__)
#define ERROR(format, ...) \
  LOG_ERROR("jspipe[%s]: " format, name_.c_str(), ##__VA_ARGS__)

#include "nacl_io/log.h"
#include "nacl_io/osinttypes.h"
#include "nacl_io/pepper_interface.h"

namespace {
const size_t kMaxPostMessageSize = 64 * 1024;
const char* kDictKeyPipe = "pipe";
const char* kDictKeyOperation = "operation";
const char* kDictKeyPayload = "payload";
const char* kOperationNameAck = "ack";
const char* kOperationNameWrite = "write";
}

namespace nacl_io {

JSPipeEventEmitter::JSPipeEventEmitter(PepperInterface* ppapi, size_t size)
    : input_fifo_(size),
      post_message_buffer_size_(size),
      bytes_sent_(0),
      bytes_acked_(0),
      bytes_read_(0),
      ppapi_(ppapi),
      messaging_iface_(NULL),
      var_iface_(NULL),
      array_iface_(NULL),
      buffer_iface_(NULL),
      dict_iface_(NULL),
      pipe_name_var_(PP_MakeUndefined()),
      pipe_key_(PP_MakeUndefined()),
      operation_key_(PP_MakeUndefined()),
      payload_key_(PP_MakeUndefined()),
      write_var_(PP_MakeUndefined()),
      ack_var_(PP_MakeUndefined()) {
  UpdateStatus_Locked();
  if (ppapi == NULL) {
    TRACE("missing PPAPI provider");
    return;
  }
  messaging_iface_ = ppapi->GetMessagingInterface();
  var_iface_ = ppapi->GetVarInterface();
  array_iface_ = ppapi->GetVarArrayInterface();
  buffer_iface_ = ppapi->GetVarArrayBufferInterface();
  dict_iface_ = ppapi->GetVarDictionaryInterface();

  if (var_iface_ == NULL)
    return;

  pipe_key_ = VarFromCStr(kDictKeyPipe);
  operation_key_ = VarFromCStr(kDictKeyOperation);
  payload_key_ = VarFromCStr(kDictKeyPayload);
  write_var_ = VarFromCStr(kOperationNameWrite);
  ack_var_ = VarFromCStr(kOperationNameAck);
}

void JSPipeEventEmitter::Destroy() {
  if (var_iface_ == NULL)
    return;
  var_iface_->Release(pipe_name_var_);
  var_iface_->Release(pipe_key_);
  var_iface_->Release(operation_key_);
  var_iface_->Release(payload_key_);
  var_iface_->Release(write_var_);
  var_iface_->Release(ack_var_);
}

PP_Var JSPipeEventEmitter::VarFromCStr(const char* string) {
  assert(var_iface_);
  return var_iface_->VarFromUtf8(string, strlen(string));
}

void JSPipeEventEmitter::UpdateStatus_Locked() {
  uint32_t status = 0;
  if (!input_fifo_.IsEmpty())
    status |= POLLIN;

  if (GetOSpace() > 0)
    status |= POLLOUT;

  ClearEvents_Locked(~status);
  RaiseEvents_Locked(status);
}

Error JSPipeEventEmitter::Read_Locked(char* data, size_t len, int* out_bytes) {
  *out_bytes = input_fifo_.Read(data, len);
  if (*out_bytes > 0) {
    bytes_read_ += *out_bytes;
    Error err = SendAckMessage(bytes_read_);
    if (err != 0)
      ERROR("Sending ACK failed: %d\n", err.error);
  }

  UpdateStatus_Locked();
  return 0;
}

Error JSPipeEventEmitter::SendWriteMessage(const void* buf, size_t count) {
  TRACE("SendWriteMessage [%" PRIuS "] total=%" PRIuS, count, bytes_sent_);
  if (!var_iface_ || !buffer_iface_) {
    ERROR("Got NULL interface(s): %s%s",
          var_iface_ ? "" : "Var ",
          buffer_iface_ ? "" : "ArrayBuffer");
    return EIO;
  }

  // Copy payload data in a new ArrayBuffer
  PP_Var buffer = buffer_iface_->Create(count);
  memcpy(buffer_iface_->Map(buffer), buf, count);
  buffer_iface_->Unmap(buffer);

  Error rtn = SendMessageToJS(write_var_, buffer);
  var_iface_->Release(buffer);
  return rtn;
}

Error JSPipeEventEmitter::SetName(const char* name) {
  if (var_iface_ == NULL) {
    // No error here: many of the tests trigger this message.
    LOG_TRACE("Got NULL interface: Var");
    return EIO;
  }

  // name can only be set once
  if (!name_.empty()) {
    LOG_ERROR("Attempting to set name more than once.");
    return EIO;
  }

  // new name must not be empty
  if (!name || strlen(name) == 0) {
    LOG_ERROR("Empty name is invalid.");
    return EIO;
  }

  TRACE("set name: %s", name);
  name_ = name;
  pipe_name_var_ = VarFromCStr(name);
  return 0;
}

Error JSPipeEventEmitter::SendMessageToJS(PP_Var operation, PP_Var payload) {
  if (!ppapi_) {
    LOG_ERROR("ppapi_ is NULL.");
    return EIO;
  }

  if (!messaging_iface_ || !var_iface_ || !dict_iface_) {
    LOG_ERROR("Got NULL interface(s): %s%s%s",
              messaging_iface_ ? "" : "Messaging ",
              dict_iface_ ? "" : "Dictionary ",
              var_iface_ ? "" : "Var");
    return EIO;
  }

  // Create dict object which will be sent to JavaScript.
  PP_Var dict = dict_iface_->Create();

  // Set three keys in the dictionary: 'pipe', 'operation', and 'payload'
  dict_iface_->Set(dict, pipe_key_, pipe_name_var_);
  dict_iface_->Set(dict, operation_key_, operation);
  dict_iface_->Set(dict, payload_key_, payload);

  // Send the dict via PostMessage
  messaging_iface_->PostMessage(ppapi_->GetInstance(), dict);

  // Release the dict
  var_iface_->Release(dict);
  return 0;
}

Error JSPipeEventEmitter::SendAckMessage(size_t byte_count) {
  TRACE("SendAckMessage %" PRIuS, byte_count);
  PP_Var payload;
  payload.type = PP_VARTYPE_INT32;
  payload.value.as_int = (int32_t)byte_count;

  return SendMessageToJS(ack_var_, payload);
}

size_t JSPipeEventEmitter::HandleJSWrite(const char* data, size_t len) {
  size_t out_len = input_fifo_.Write(data, len);
  UpdateStatus_Locked();
  return out_len;
}

void JSPipeEventEmitter::HandleJSAck(size_t byte_count) {
  if (byte_count > bytes_sent_) {
    ERROR("Unexpected byte count: %" PRIuS, byte_count);
    return;
  }

  bytes_acked_ = byte_count;
  TRACE("HandleAck: %" SCNuS "/%" PRIuS, bytes_acked_, bytes_sent_);
  UpdateStatus_Locked();
}

Error JSPipeEventEmitter::HandleJSWrite(struct PP_Var message) {
  TRACE("HandleJSWrite");
  if (message.type != PP_VARTYPE_ARRAY_BUFFER) {
    ERROR("Expected ArrayBuffer but got %d.", message.type);
    return EINVAL;
  }
  uint32_t length;
  if (buffer_iface_->ByteLength(message, &length) != PP_TRUE) {
    ERROR("ArrayBuffer.ByteLength returned PP_FALSE");
    return EINVAL;
  }

  char* buffer = (char*)buffer_iface_->Map(message);

  // Write data to the input fifo
  size_t wrote = HandleJSWrite(buffer, length);
  buffer_iface_->Unmap(message);
  if (wrote != length) {
    ERROR("Only wrote %d of %d bytes to pipe", (int)wrote, (int)length);
    return EIO;
  }
  TRACE("done HandleWrite: %d", length);
  return 0;
}

Error JSPipeEventEmitter::HandleJSAck(PP_Var message) {
  if (message.type != PP_VARTYPE_INT32) {
    ERROR("Integer object expected but got %d.", message.type);
    return EINVAL;
  }
  HandleJSAck(message.value.as_int);
  return 0;
}

int JSPipeEventEmitter::VarStrcmp(PP_Var a, PP_Var b) {
  uint32_t length_a = 0;
  uint32_t length_b = 0;
  const char* cstring_a = var_iface_->VarToUtf8(a, &length_a);
  const char* cstring_b = var_iface_->VarToUtf8(a, &length_b);
  std::string string_a(cstring_a, length_a);
  std::string string_b(cstring_b, length_a);
  return strcmp(string_a.c_str(), string_b.c_str());
}

Error JSPipeEventEmitter::HandleJSMessage(struct PP_Var message) {
  Error err = 0;
  if (!messaging_iface_ || !var_iface_ || !dict_iface_ || !buffer_iface_) {
    ERROR("Got NULL interface(s): %s%s%s%s",
          messaging_iface_ ? "" : "Messaging ",
          var_iface_ ? "" : "Var ",
          dict_iface_ ? "" : "Dictionary ",
          buffer_iface_ ? "" : "ArrayBuffer");
    return ENOSYS;
  }

  // Verify that we have an array with size two.
  if (message.type != PP_VARTYPE_DICTIONARY) {
    ERROR("Expected Dictionary but got %d.", message.type);
    return EINVAL;
  }

#ifndef NDEBUG
  PP_Var pipe_name_var = dict_iface_->Get(message, pipe_key_);
  if (VarStrcmp(pipe_name_var, pipe_name_var_)) {
    ERROR("Wrong pipe name.");
    return EINVAL;
  }
  var_iface_->Release(pipe_name_var);
#endif

  PP_Var operation_var = dict_iface_->Get(message, operation_key_);
  if (operation_var.type != PP_VARTYPE_STRING) {
    ERROR("Expected String but got %d.", operation_var.type);
    err = EINVAL;
  } else {
    uint32_t length;
    const char* operation_string;
    operation_string = var_iface_->VarToUtf8(operation_var, &length);
    std::string message_type(operation_string, length);

    TRACE("HandleJSMessage %s", message_type.c_str());
    PP_Var payload = dict_iface_->Get(message, payload_key_);
    if (message_type == kOperationNameWrite) {
      err = HandleJSWrite(payload);
    } else if (message_type == kOperationNameAck) {
      err = HandleJSAck(payload);
    } else {
      ERROR("Unknown message type: %s", message_type.c_str());
      err = EINVAL;
    }
    var_iface_->Release(payload);
  }

  var_iface_->Release(operation_var);
  return err;
}

Error JSPipeEventEmitter::Write_Locked(const char* data,
                                       size_t len,
                                       int* out_bytes) {
  if (GetOSpace() == 0) {
    *out_bytes = 0;
    return 0;
  }

  if (len > GetOSpace())
    len = GetOSpace();

  // Limit the size of the data we send with PostMessage to kMaxPostMessageSize
  if (len > kMaxPostMessageSize)
    len = kMaxPostMessageSize;

  Error err = SendWriteMessage(data, len);
  if (err != 0)
    return err;
  *out_bytes = len;
  bytes_sent_ += len;

  UpdateStatus_Locked();
  return 0;
}

}  // namespace nacl_io