// 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/jsfs/js_fs.h"

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

#include "nacl_io/ioctl.h"
#include "nacl_io/jsfs/js_fs_node.h"
#include "nacl_io/kernel_handle.h"
#include "nacl_io/log.h"
#include "nacl_io/osdirent.h"
#include "nacl_io/pepper_interface.h"
#include "sdk_util/macros.h"

namespace nacl_io {

JsFs::JsFs()
    : messaging_iface_(NULL),
      array_iface_(NULL),
      buffer_iface_(NULL),
      dict_iface_(NULL),
      var_iface_(NULL),
      request_id_(0) {
}

Error JsFs::Init(const FsInitArgs& args) {
  Error error = Filesystem::Init(args);
  if (error)
    return error;

  pthread_cond_init(&response_cond_, NULL);

  messaging_iface_ = ppapi_->GetMessagingInterface();
  array_iface_ = ppapi_->GetVarArrayInterface();
  buffer_iface_ = ppapi_->GetVarArrayBufferInterface();
  dict_iface_ = ppapi_->GetVarDictionaryInterface();
  var_iface_ = ppapi_->GetVarInterface();

  if (!messaging_iface_ || !array_iface_ || !buffer_iface_ || !dict_iface_ ||
      !var_iface_) {
    LOG_ERROR("Got 1+ NULL interface(s): %s%s%s%s%s",
              messaging_iface_ ? "" : "Messaging ",
              array_iface_ ? "" : "VarArray ",
              buffer_iface_ ? "" : "VarArrayBuffer ",
              dict_iface_ ? "" : "VarDictionary ",
              var_iface_ ? "" : "Var ");
    return ENOSYS;
  }

  return 0;
}

void JsFs::Destroy() {
  pthread_cond_destroy(&response_cond_);
}

bool JsFs::SetDictVar(PP_Var dict, const char* key, PP_Var value) {
  PP_Var key_var = var_iface_->VarFromUtf8(key, strlen(key));
  ScopedVar scoped_key(ppapi_, key_var);
  if (key_var.type != PP_VARTYPE_STRING) {
    LOG_ERROR("Unable to create string key \"%s\".", key);
    return false;
  }

  PP_Bool success = dict_iface_->Set(dict, key_var, value);
  if (!success) {
    LOG_ERROR("Unable to set \"%s\" key of dictionary.", key);
    return false;
  }

  return true;
}

PP_Var JsFs::GetDictVar(PP_Var dict, const char* key) {
  PP_Var key_var = var_iface_->VarFromUtf8(key, strlen(key));
  ScopedVar scoped_key(ppapi_, key_var);
  if (key_var.type != PP_VARTYPE_STRING) {
    LOG_ERROR("Unable to create string key \"%s\".", key);
    return PP_MakeUndefined();
  }

  return dict_iface_->Get(dict, key_var);
}

bool JsFs::GetVarInt32(PP_Var var, int32_t* out_value) {
  switch (var.type) {
    case PP_VARTYPE_INT32:
      *out_value = var.value.as_int;
      return true;

    case PP_VARTYPE_DOUBLE:
      *out_value = static_cast<int32_t>(var.value.as_double);
      return true;

    default:
      return false;
  }
}

bool JsFs::GetVarUint32(PP_Var var, uint32_t* out_value) {
  switch (var.type) {
    case PP_VARTYPE_INT32:
      *out_value = static_cast<uint32_t>(var.value.as_int);
      return true;

    case PP_VARTYPE_DOUBLE:
      *out_value = static_cast<uint32_t>(var.value.as_double);
      return true;

    default:
      return false;
  }
}

bool JsFs::GetVarInt64(PP_Var var, int64_t* out_value) {
  switch (var.type) {
    case PP_VARTYPE_INT32:
      *out_value = var.value.as_int;
      return true;

    case PP_VARTYPE_DOUBLE:
      *out_value = static_cast<int64_t>(var.value.as_double);
      return true;

    case PP_VARTYPE_ARRAY: {
      uint32_t len = array_iface_->GetLength(var);
      if (len != 2) {
        LOG_ERROR("Expected int64 array type to have 2 elements, not %d", len);
        return false;
      }

      PP_Var high_int_var = array_iface_->Get(var, 0);
      ScopedVar scoped_high_int_var(ppapi_, high_int_var);
      uint32_t high_int;
      if (!GetVarUint32(high_int_var, &high_int))
        return false;

      PP_Var low_int_var = array_iface_->Get(var, 1);
      ScopedVar scoped_low_int_var(ppapi_, low_int_var);
      uint32_t low_int;
      if (!GetVarUint32(low_int_var, &low_int))
        return false;

      *out_value = static_cast<int64_t>(
          (static_cast<uint64_t>(high_int) << 32) | low_int);
      return true;
    }

    default:
      return false;
  }
}

PP_Var JsFs::VMakeRequest(RequestId request_id,
                          const char* format,
                          va_list args) {
  PP_Var dict = dict_iface_->Create();
  ScopedVar scoped_dict(ppapi_, dict);

  if (!SetDictVar(dict, "id", PP_MakeInt32(request_id)))
    return PP_MakeNull();

  const char* p = format;
  while (*p) {
    assert(*p == '%');
    ++p;

    const char* key = va_arg(args, const char*);
    PP_Var value_var = PP_MakeUndefined();

    switch(*p) {
      case 'd':
        value_var = PP_MakeInt32(va_arg(args, int32_t));
        break;
      case 'u':
        value_var = PP_MakeInt32(va_arg(args, uint32_t));
        break;
      case 's': {
        const char* value = va_arg(args, const char*);
        value_var = var_iface_->VarFromUtf8(value, strlen(value));
        if (value_var.type != PP_VARTYPE_STRING) {
          LOG_ERROR("Unable to create \"%s\" string var.", value);
          return PP_MakeNull();
        }
        break;
      }
      case 'p':
        value_var = *va_arg(args, const PP_Var*);
        var_iface_->AddRef(value_var);
        break;
      case 'l': {
        // Only '%lld' is supported.
        ++p;
        assert(*p == 'l');
        ++p;
        assert(*p == 'd');

        int64_t value = va_arg(args, int64_t);
        if (value >= INT_MIN && value <= INT_MAX) {
          // Send as an int.
          value_var = PP_MakeInt32(static_cast<int32_t>(value));
        } else {
          // Send as an array of two ints: [high int32, low int32].
          value_var = array_iface_->Create();
          if (!array_iface_->SetLength(value_var, 2)) {
            LOG_ERROR("Unable to set length of s64 array.");
            return PP_MakeNull();
          }

          if (!array_iface_->Set(value_var, 0, PP_MakeInt32(value >> 32))) {
            LOG_ERROR("Unable to set of high int32 of s64 array.");
            return PP_MakeNull();
          }

          if (!array_iface_->Set(
                  value_var, 1, PP_MakeInt32(value & 0xffffffff))) {
            LOG_ERROR("Unable to set of low int32 of s64 array.");
            return PP_MakeNull();
          }
        }

        break;
      }
      default:
        LOG_ERROR("Unknown format specifier %%\"%s\"", p);
        assert(0);
        return PP_MakeNull();
    }

    ++p;

    if (!SetDictVar(dict, key, value_var))
      return PP_MakeNull();

    // Unconditionally release the value var. It is legal to do this even for
    // non-refcounted types.
    var_iface_->Release(value_var);
  }

  return scoped_dict.Release();
}

JsFs::RequestId JsFs::VSendRequest(const char* format, va_list args) {
  AUTO_LOCK(lock_);
  RequestId id = ++request_id_;
  // Skip 0 (the invalid request id) in the very unlikely case that the request
  // id wraps.
  if (id == 0)
    id = ++request_id_;

  PP_Var dict_var = VMakeRequest(id, format, args);
  ScopedVar scoped_dict_var(ppapi_, dict_var);
  if (dict_var.type != PP_VARTYPE_DICTIONARY)
    return 0;

  messaging_iface_->PostMessage(ppapi_->GetInstance(), dict_var);
  return id;
}

bool JsFs::VSendRequestAndWait(ScopedVar* out_response,
                               const char* format,
                               va_list args) {
  RequestId id = VSendRequest(format, args);
  if (id == 0)
    return false;

  out_response->Reset(WaitForResponse(id));
  return true;
}

bool JsFs::SendRequestAndWait(ScopedVar* out_response,
                              const char* format,
                              ...) {
  va_list args;
  va_start(args, format);
  bool result = VSendRequestAndWait(out_response, format, args);
  va_end(args);
  return result;
}

Error JsFs::ErrorFromResponse(const ScopedVar& response) {
  int32_t error;
  if (ScanVar(response.pp_var(), "%d", "error", &error) != 1) {
    LOG_ERROR("Expected \"error\" field in response.");
    return EINVAL;
  }

  return error;
}

int JsFs::ScanVar(PP_Var var, const char* format, ...) {
  va_list args;
  va_start(args, format);
  int result = VScanVar(var, format, args);
  va_end(args);
  return result;
}

int JsFs::VScanVar(PP_Var dict_var, const char* format, va_list args) {
  if (dict_var.type != PP_VARTYPE_DICTIONARY) {
    LOG_ERROR("Expected var of type dictionary, not %d.", dict_var.type);
    return 0;
  }

  int num_values = 0;

  const char* p = format;
  while (*p) {
    assert(*p == '%');
    ++p;

    const char* key = va_arg(args, const char*);
    PP_Var value_var = GetDictVar(dict_var, key);
    ScopedVar scoped_value_var(ppapi_, value_var);

    if (value_var.type == PP_VARTYPE_UNDEFINED)
      break;

    bool ok = true;

    switch (*p) {
      case 'd': {
        int32_t* value = va_arg(args, int32_t*);
        if (!GetVarInt32(value_var, value)) {
          LOG_ERROR("Expected int32_t value for key \"%s\"", key);
          ok = false;
        }
        break;
      }
      case 'u': {
        uint32_t* value = va_arg(args, uint32_t*);
        if (!GetVarUint32(value_var, value)) {
          LOG_ERROR("Expected uint32_t value for key \"%s\"", key);
          ok = false;
        }
        break;
      }
      case 'l': {
        // Only '%lld' is supported.
        ++p;
        assert(*p == 'l');
        ++p;
        assert(*p == 'd');

        int64_t* value = va_arg(args, int64_t*);
        if (!GetVarInt64(value_var, value)) {
          LOG_ERROR("Expected int64_t value for key \"%s\"", key);
          ok = false;
        }
        break;
      }
      case 'p': {
        PP_Var* value = va_arg(args, PP_Var*);
        *value = scoped_value_var.Release();
        break;
      }
      default:
        LOG_ERROR("Unknown format specifier %%\"%s\"", p);
        assert(0);
        ok = false;
        break;
    }

    if (!ok)
      break;

    p++;
    num_values++;
  }

  return num_values;
}

PP_Var JsFs::WaitForResponse(RequestId request_id) {
  AUTO_LOCK(lock_);
  while (1) {
    ResponseMap_t::iterator iter = responses_.find(request_id);
    if (iter != responses_.end()) {
      PP_Var response = iter->second;
      responses_.erase(iter);
      return response;
    }

    pthread_cond_wait(&response_cond_, lock_.mutex());
  }
}

Error JsFs::Access(const Path& path, int a_mode) {
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(&response, "%s%s%d",
                          "cmd", "access",
                          "path", path.Join().c_str(),
                          "amode", a_mode)) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  return ErrorFromResponse(response);
}

Error JsFs::Open(const Path& path, int open_flags, ScopedNode* out_node) {
  out_node->reset(NULL);
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(&response, "%s%s%d",
                          "cmd", "open",
                          "path", path.Join().c_str(),
                          "oflag", open_flags)) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  int32_t error;
  int32_t fd;
  int result = ScanVar(response.pp_var(), "%d%d", "error", &error, "fd", &fd);
  if (result >= 1 && error)
    return error;

  if (result != 2) {
    LOG_ERROR("Expected \"error\" and \"fd\" fields in response.");
    return EINVAL;
  }

  out_node->reset(new JsFsNode(this, fd));
  return 0;
}

Error JsFs::Unlink(const Path& path) {
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(
          &response, "%s%s", "cmd", "unlink", "path", path.Join().c_str())) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  return ErrorFromResponse(response);
}

Error JsFs::Mkdir(const Path& path, int perm) {
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(&response, "%s%s%d",
                          "cmd", "mkdir",
                          "path", path.Join().c_str(),
                          "mode", perm)) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  return ErrorFromResponse(response);
}

Error JsFs::Rmdir(const Path& path) {
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(
          &response, "%s%s", "cmd", "rmdir", "path", path.Join().c_str())) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  return ErrorFromResponse(response);
}

Error JsFs::Remove(const Path& path) {
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(
          &response, "%s%s", "cmd", "remove", "path", path.Join().c_str())) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  return ErrorFromResponse(response);
}

Error JsFs::Rename(const Path& path, const Path& newpath) {
  ScopedVar response(ppapi_);
  if (!SendRequestAndWait(&response, "%s%s%s",
                          "cmd", "rename",
                          "old", path.Join().c_str(),
                          "new", newpath.Join().c_str())) {
    LOG_ERROR("Failed to send request.");
    return EINVAL;
  }

  return ErrorFromResponse(response);
}

Error JsFs::Filesystem_VIoctl(int request, va_list args) {
  if (request != NACL_IOC_HANDLEMESSAGE) {
    LOG_ERROR("Unknown ioctl: %#x", request);
    return EINVAL;
  }

  PP_Var response = *va_arg(args, PP_Var*);

  AUTO_LOCK(lock_);

  RequestId response_id;
  if (ScanVar(response, "%d", "id", &response_id) != 1) {
    LOG_TRACE("ioctl with no \"id\", ignoring.\n");
    return EINVAL;
  }

  responses_.insert(ResponseMap_t::value_type(response_id, response));
  pthread_cond_broadcast(&response_cond_);
  return 0;
}

}  // namespace nacl_io