/**
 * @license
 * Copyright 2018 Google LLC. 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.
 * =============================================================================
 */

#ifndef TF_NODEJS_UTILS_H_
#define TF_NODEJS_UTILS_H_

#include <node_api.h>
#include <stdarg.h>
#include <stdio.h>
#include <cstdlib>
#include <cstring>
#include <vector>
#include "tensorflow/c/c_api.h"
#include "tf_auto_status.h"

#define MAX_TENSOR_SHAPE 4

#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))

#ifndef DEBUG
#define DEBUG 0
#endif

#define DEBUG_LOG(message, file, line_number)                             \
  do {                                                                    \
    if (DEBUG)                                                            \
      fprintf(stderr, "** -%s:%zu\n-- %s\n", file, line_number, message); \
  } while (0)

namespace tfnodejs {

#define NAPI_THROW_ERROR(env, message, ...) \
  NapiThrowError(env, __FILE__, __LINE__, message, ##__VA_ARGS__);

inline void NapiThrowError(napi_env env, const char *file,
                           const size_t line_number, const char *message, ...) {
  char buffer[500];
  va_list args;
  va_start(args, message);
  std::vsnprintf(buffer, 500, message, args);
  va_end(args);
  DEBUG_LOG(buffer, file, line_number);
  napi_throw_error(env, nullptr, buffer);
}

#define ENSURE_NAPI_OK(env, status) \
  if (!EnsureNapiOK(env, status, __FILE__, __LINE__)) return;
#define ENSURE_NAPI_OK_RETVAL(env, status, retval) \
  if (!EnsureNapiOK(env, status, __FILE__, __LINE__)) return retval;

inline bool EnsureNapiOK(napi_env env, napi_status status, const char *file,
                         const size_t line_number) {
  if (status != napi_ok) {
    const napi_extended_error_info *error_info = 0;
    napi_get_last_error_info(env, &error_info);
    NapiThrowError(
        env, file, line_number, "Invalid napi_status: %s\n",
        error_info->error_message ? error_info->error_message : "unknown");
  }
  return status == napi_ok;
}

#define ENSURE_TF_OK(env, status) \
  if (!EnsureTFOK(env, status, __FILE__, __LINE__)) return;
#define ENSURE_TF_OK_RETVAL(env, status, retval) \
  if (!EnsureTFOK(env, status, __FILE__, __LINE__)) return retval;

inline bool EnsureTFOK(napi_env env, TF_AutoStatus &status, const char *file,
                       const size_t line_number) {
  TF_Code tf_code = TF_GetCode(status.status);
  if (tf_code != TF_OK) {
    NapiThrowError(env, file, line_number, "Invalid TF_Status: %u\nMessage: %s",
                   TF_GetCode(status.status), TF_Message(status.status));
  }
  return tf_code == TF_OK;
}

#define ENSURE_CONSTRUCTOR_CALL(env, info) \
  if (!EnsureConstructorCall(env, info, __FILE__, __LINE__)) return;
#define ENSURE_CONSTRUCTOR_CALL_RETVAL(env, info, retval) \
  if (!EnsureConstructorCall(env, info, __FILE__, __LINE__)) return retval;

inline bool EnsureConstructorCall(napi_env env, napi_callback_info info,
                                  const char *file, const size_t line_number) {
  napi_value js_target;
  napi_status nstatus = napi_get_new_target(env, info, &js_target);
  ENSURE_NAPI_OK_RETVAL(env, nstatus, false);
  bool is_target = js_target != nullptr;
  if (!is_target) {
    NapiThrowError(env, file, line_number,
                   "Function not used as a constructor!");
  }
  return is_target;
}

#define ENSURE_VALUE_IS_OBJECT(env, value) \
  if (!EnsureValueIsObject(env, value, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_OBJECT_RETVAL(env, value, retval) \
  if (!EnsureValueIsObject(env, value, __FILE__, __LINE__)) return retval;

inline bool EnsureValueIsObject(napi_env env, napi_value value,
                                const char *file, const size_t line_number) {
  napi_valuetype type;
  ENSURE_NAPI_OK_RETVAL(env, napi_typeof(env, value, &type), false);
  bool is_object = type == napi_object;
  if (!is_object) {
    NapiThrowError(env, file, line_number, "Argument is not an object!");
  }
  return is_object;
}

#define ENSURE_VALUE_IS_STRING(env, value) \
  if (!EnsureValueIsString(env, value, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_STRING_RETVAL(env, value, retval) \
  if (!EnsureValueIsString(env, value, __FILE__, __LINE__)) return retval;

inline bool EnsureValueIsString(napi_env env, napi_value value,
                                const char *file, const size_t line_number) {
  napi_valuetype type;
  ENSURE_NAPI_OK_RETVAL(env, napi_typeof(env, value, &type), false);
  bool is_string = type == napi_string;
  if (!is_string) {
    NapiThrowError(env, file, line_number, "Argument is not a string!");
  }
  return is_string;
}

#define ENSURE_VALUE_IS_NUMBER(env, value) \
  if (!EnsureValueIsNumber(env, value, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_NUMBER_RETVAL(env, value, retval) \
  if (!EnsureValueIsNumber(env, value, __FILE__, __LINE__)) return retval;

inline bool EnsureValueIsNumber(napi_env env, napi_value value,
                                const char *file, const size_t line_number) {
  napi_valuetype type;
  ENSURE_NAPI_OK_RETVAL(env, napi_typeof(env, value, &type), false);
  bool is_number = type == napi_number;
  if (!is_number) {
    NapiThrowError(env, file, line_number, "Argument is not a number!");
  }
  return is_number;
}

#define ENSURE_VALUE_IS_ARRAY(env, value) \
  if (!EnsureValueIsArray(env, value, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_ARRAY_RETVAL(env, value, retval) \
  if (!EnsureValueIsArray(env, value, __FILE__, __LINE__)) return retval;

inline bool EnsureValueIsArray(napi_env env, napi_value value, const char *file,
                               const size_t line_number) {
  bool is_array;
  ENSURE_NAPI_OK_RETVAL(env, napi_is_array(env, value, &is_array), false);
  if (!is_array) {
    NapiThrowError(env, file, line_number, "Argument is not an array!");
  }
  return is_array;
}

#define ENSURE_VALUE_IS_TYPED_ARRAY(env, value) \
  if (!EnsureValueIsTypedArray(env, value, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_TYPED_ARRAY_RETVAL(env, value, retval) \
  if (!EnsureValueIsTypedArray(env, value, __FILE__, __LINE__)) return retval;

inline bool EnsureValueIsTypedArray(napi_env env, napi_value value,
                                    const char *file,
                                    const size_t line_number) {
  bool is_array;
  ENSURE_NAPI_OK_RETVAL(env, napi_is_typedarray(env, value, &is_array), false);
  if (!is_array) {
    NapiThrowError(env, file, line_number, "Argument is not a typed-array!");
  }
  return is_array;
}

#define ENSURE_VALUE_IS_LESS_THAN(env, value, max) \
  if (!EnsureValueIsLessThan(env, value, max, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_LESS_THAN_RETVAL(env, value, max, retval)  \
  if (!EnsureValueIsLessThan(env, value, max, __FILE__, __LINE__)) \
    return retval;

inline bool EnsureValueIsLessThan(napi_env env, uint32_t value, uint32_t max,
                                  const char *file, const size_t line_number) {
  if (value > max) {
    NapiThrowError(env, file, line_number,
                   "Argument is greater than max: %u > %u", value, max);
    return false;
  } else {
    return true;
  }
}

#define REPORT_UNKNOWN_TF_DATA_TYPE(env, type) \
  ReportUnknownTFDataType(env, type, __FILE__, __LINE__)

inline void ReportUnknownTFDataType(napi_env env, TF_DataType type,
                                    const char *file,
                                    const size_t line_number) {
  NapiThrowError(env, file, line_number, "Unhandled TF_DataType: %u\n", type);
}

#define REPORT_UNKNOWN_TF_ATTR_TYPE(env, type) \
  ReportUnknownTFAttrType(env, type, __FILE__, __LINE__)

inline void ReportUnknownTFAttrType(napi_env env, TF_AttrType type,
                                    const char *file,
                                    const size_t line_number) {
  NapiThrowError(env, file, line_number, "Unhandled TF_AttrType: %u\n", type);
}

#define REPORT_UNKNOWN_TYPED_ARRAY_TYPE(env, type) \
  ReportUnknownTypedArrayType(env, type, __FILE__, __LINE__)

inline void ReportUnknownTypedArrayType(napi_env env, napi_typedarray_type type,
                                        const char *file,
                                        const size_t line_number) {
  NapiThrowError(env, file, line_number, "Unhandled napi typed_array_type: %u",
                 type);
}

// Returns a vector with the shape values of an array.
inline void ExtractArrayShape(napi_env env, napi_value array_value,
                              std::vector<int64_t> *result) {
  napi_status nstatus;

  uint32_t array_length;
  nstatus = napi_get_array_length(env, array_value, &array_length);
  ENSURE_NAPI_OK(env, nstatus);

  for (uint32_t i = 0; i < array_length; i++) {
    napi_value dimension_value;
    nstatus = napi_get_element(env, array_value, i, &dimension_value);
    ENSURE_NAPI_OK(env, nstatus);

    int64_t dimension;
    nstatus = napi_get_value_int64(env, dimension_value, &dimension);
    ENSURE_NAPI_OK(env, nstatus);

    result->push_back(dimension);
  }
}

inline bool IsExceptionPending(napi_env env) {
  bool has_exception = false;
  ENSURE_NAPI_OK_RETVAL(env, napi_is_exception_pending(env, &has_exception),
                        has_exception);
  return has_exception;
}

#define ENSURE_VALUE_IS_NOT_NULL(env, value) \
  if (!EnsureValueIsNotNull(env, value, __FILE__, __LINE__)) return;
#define ENSURE_VALUE_IS_NOT_NULL_RETVAL(env, value, retval) \
  if (!EnsureValueIsNotNull(env, value, __FILE__, __LINE__)) return retval;

inline bool EnsureValueIsNotNull(napi_env env, void *value, const char *file,
                                 const size_t line_number) {
  bool is_null = value == nullptr;
  if (is_null) {
    NapiThrowError(env, file, line_number, "Argument is null!");
  }
  return !is_null;
}

inline napi_status GetStringParam(napi_env env, napi_value string_value,
                                  std::string &string) {
  ENSURE_VALUE_IS_STRING_RETVAL(env, string_value, napi_invalid_arg);

  napi_status nstatus;

  size_t str_length;
  nstatus =
      napi_get_value_string_utf8(env, string_value, nullptr, 0, &str_length);
  ENSURE_NAPI_OK_RETVAL(env, nstatus, nstatus);

  char *buffer = (char *)(malloc(sizeof(char) * (str_length + 1)));
  ENSURE_VALUE_IS_NOT_NULL_RETVAL(env, buffer, napi_generic_failure);

  nstatus = napi_get_value_string_utf8(env, string_value, buffer,
                                       str_length + 1, &str_length);
  ENSURE_NAPI_OK_RETVAL(env, nstatus, nstatus);

  string.assign(buffer, str_length);
  free(buffer);
  return napi_ok;
}

// Returns the number of elements in a Tensor.
inline size_t GetTensorNumElements(TF_Tensor *tensor) {
  size_t ret = 1;
  for (int i = 0; i < TF_NumDims(tensor); ++i) {
    ret *= TF_Dim(tensor, i);
  }
  return ret;
}

// Split a string into an array of characters array with `,` as delimiter.
inline std::vector<const char *> splitStringByComma(const std::string &str) {
  std::vector<const char *> tokens;
  size_t prev = 0, pos = 0;
  do {
    pos = str.find(',', prev);
    if (pos == std::string::npos) pos = str.length();
    std::string token = str.substr(prev, pos - prev);
    if (!token.empty()) {
      char *cstr = new char[str.length() + 1];
      std::strcpy(cstr, token.c_str());
      tokens.push_back(cstr);
    }
    prev = pos + 1;
  } while (pos < str.length() && prev < str.length());
  return tokens;
}

}  // namespace tfnodejs

#endif  // TF_NODEJS_UTILS_H_