// clang-format off
#include "diagnostic_status.h"
#include "../../../macros.h"
#include "../../../resource_types.h"
#include "../../../terms.h"

#include <erl_nif.h>

#include <rosidl_runtime_c/message_type_support_struct.h>
#include <rosidl_runtime_c/primitives_sequence.h>
#include <rosidl_runtime_c/primitives_sequence_functions.h>
#include <rosidl_runtime_c/string.h>
#include <rosidl_runtime_c/string_functions.h>

#include <diagnostic_msgs/msg/detail/key_value__functions.h>
#include <diagnostic_msgs/msg/detail/key_value__struct.h>

#include <diagnostic_msgs/msg/detail/diagnostic_status__functions.h>
#include <diagnostic_msgs/msg/detail/diagnostic_status__struct.h>
#include <diagnostic_msgs/msg/detail/diagnostic_status__type_support.h>

#include <stddef.h>
#include <stdint.h>
#include <string.h>

ERL_NIF_TERM nif_diagnostic_msgs_msg_diagnostic_status_type_support(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
  ignore_unused(argv);

  if (argc != 0) return enif_make_badarg(env);

  const rosidl_message_type_support_t *ts_p = ROSIDL_GET_MSG_TYPE_SUPPORT(diagnostic_msgs, msg, DiagnosticStatus);
  rosidl_message_type_support_t *obj = enif_alloc_resource(rt_rosidl_message_type_support_t, sizeof(rosidl_message_type_support_t));
  *obj = *ts_p;
  ERL_NIF_TERM term = enif_make_resource(env, obj);
  enif_release_resource(obj);

  return term;
}

ERL_NIF_TERM nif_diagnostic_msgs_msg_diagnostic_status_create(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
  ignore_unused(argv);

  if (argc != 0) return enif_make_badarg(env);

  diagnostic_msgs__msg__DiagnosticStatus *message_p = diagnostic_msgs__msg__DiagnosticStatus__create();
  if (message_p == NULL) return raise(env, __FILE__, __LINE__);

  void **obj = enif_alloc_resource(rt_ros_message, sizeof(void *));
  *obj = (void *)message_p;
  ERL_NIF_TERM term = enif_make_resource(env, obj);
  enif_release_resource(obj);

  return term;
}

ERL_NIF_TERM nif_diagnostic_msgs_msg_diagnostic_status_destroy(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
  if (argc != 1) return enif_make_badarg(env);

  void **ros_message_pp;
  if (!enif_get_resource(env, argv[0], rt_ros_message, (void **)&ros_message_pp))
    return enif_make_badarg(env);

  diagnostic_msgs__msg__DiagnosticStatus *message_p = (diagnostic_msgs__msg__DiagnosticStatus *)*ros_message_pp;
  diagnostic_msgs__msg__DiagnosticStatus__destroy(message_p);

  return atom_ok;
}

ERL_NIF_TERM nif_diagnostic_msgs_msg_diagnostic_status_set(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
  if (argc != 2) return enif_make_badarg(env);

  void **ros_message_pp;
  if (!enif_get_resource(env, argv[0], rt_ros_message, (void **)&ros_message_pp))
    return enif_make_badarg(env);

  diagnostic_msgs__msg__DiagnosticStatus *message_p = (diagnostic_msgs__msg__DiagnosticStatus *)*ros_message_pp;

  int arity;
  const ERL_NIF_TERM *tuple;
  if (!enif_get_tuple(env, argv[1], &arity, &tuple)) return enif_make_badarg(env);

  unsigned int level;
  if (!enif_get_uint(env, tuple[0], &level))
    return enif_make_badarg(env);
  message_p->level = (uint8_t)level;

  unsigned int name_length;
#if (ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION >= 17) // OTP-26 and later
  if (!enif_get_string_length(env, tuple[1], &name_length, ERL_NIF_LATIN1))
    return enif_make_badarg(env);
#else
  if (!enif_get_list_length(env, tuple[1], &name_length))
    return enif_make_badarg(env);
#endif

  char name[name_length + 1];
  if (enif_get_string(env, tuple[1], name, name_length + 1, ERL_NIF_LATIN1) <= 0)
    return enif_make_badarg(env);

  if (!rosidl_runtime_c__String__assign(&(message_p->name), name))
    return raise(env, __FILE__, __LINE__);

  unsigned int message_length;
#if (ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION >= 17) // OTP-26 and later
  if (!enif_get_string_length(env, tuple[2], &message_length, ERL_NIF_LATIN1))
    return enif_make_badarg(env);
#else
  if (!enif_get_list_length(env, tuple[2], &message_length))
    return enif_make_badarg(env);
#endif

  char message[message_length + 1];
  if (enif_get_string(env, tuple[2], message, message_length + 1, ERL_NIF_LATIN1) <= 0)
    return enif_make_badarg(env);

  if (!rosidl_runtime_c__String__assign(&(message_p->message), message))
    return raise(env, __FILE__, __LINE__);

  unsigned int hardware_id_length;
#if (ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION >= 17) // OTP-26 and later
  if (!enif_get_string_length(env, tuple[3], &hardware_id_length, ERL_NIF_LATIN1))
    return enif_make_badarg(env);
#else
  if (!enif_get_list_length(env, tuple[3], &hardware_id_length))
    return enif_make_badarg(env);
#endif

  char hardware_id[hardware_id_length + 1];
  if (enif_get_string(env, tuple[3], hardware_id, hardware_id_length + 1, ERL_NIF_LATIN1) <= 0)
    return enif_make_badarg(env);

  if (!rosidl_runtime_c__String__assign(&(message_p->hardware_id), hardware_id))
    return raise(env, __FILE__, __LINE__);

  unsigned int values_length;
  if (!enif_get_list_length(env, tuple[4], &values_length))
    return enif_make_badarg(env);

  diagnostic_msgs__msg__KeyValue__Sequence *values = diagnostic_msgs__msg__KeyValue__Sequence__create(values_length);
  if (values == NULL) return raise(env, __FILE__, __LINE__);
  message_p->values = *values;

  unsigned int values_i;
  ERL_NIF_TERM values_left, values_head, values_tail;
  for (values_i = 0, values_left = tuple[4]; values_i < values_length; ++values_i, values_left = values_tail)
  {
    if (!enif_get_list_cell(env, values_left, &values_head, &values_tail))
      return enif_make_badarg(env);

    int values_i_arity;
    const ERL_NIF_TERM *values_i_tuple;
    if (!enif_get_tuple(env, values_head, &values_i_arity, &values_i_tuple))
      return enif_make_badarg(env);

    unsigned int values_i_key_length;
#if (ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION >= 17) // OTP-26 and later
    if (!enif_get_string_length(env, values_i_tuple[0], &values_i_key_length, ERL_NIF_LATIN1))
      return enif_make_badarg(env);
#else
    if (!enif_get_list_length(env, values_i_tuple[0], &values_i_key_length))
      return enif_make_badarg(env);
#endif

    char values_i_key[values_i_key_length + 1];
    if (enif_get_string(env, values_i_tuple[0], values_i_key, values_i_key_length + 1, ERL_NIF_LATIN1) <= 0)
      return enif_make_badarg(env);

    if (!rosidl_runtime_c__String__assign(&(message_p->values.data[values_i].key), values_i_key))
      return raise(env, __FILE__, __LINE__);

    unsigned int values_i_value_length;
#if (ERL_NIF_MAJOR_VERSION == 2 && ERL_NIF_MINOR_VERSION >= 17) // OTP-26 and later
    if (!enif_get_string_length(env, values_i_tuple[1], &values_i_value_length, ERL_NIF_LATIN1))
      return enif_make_badarg(env);
#else
    if (!enif_get_list_length(env, values_i_tuple[1], &values_i_value_length))
      return enif_make_badarg(env);
#endif

    char values_i_value[values_i_value_length + 1];
    if (enif_get_string(env, values_i_tuple[1], values_i_value, values_i_value_length + 1, ERL_NIF_LATIN1) <= 0)
      return enif_make_badarg(env);

    if (!rosidl_runtime_c__String__assign(&(message_p->values.data[values_i].value), values_i_value))
      return raise(env, __FILE__, __LINE__);
  }

  return atom_ok;
}

ERL_NIF_TERM nif_diagnostic_msgs_msg_diagnostic_status_get(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
  if (argc != 1) return enif_make_badarg(env);

  void **ros_message_pp;
  if (!enif_get_resource(env, argv[0], rt_ros_message, (void **)&ros_message_pp))
    return enif_make_badarg(env);

  diagnostic_msgs__msg__DiagnosticStatus *message_p = (diagnostic_msgs__msg__DiagnosticStatus *)*ros_message_pp;

  ERL_NIF_TERM values[message_p->values.size];

  for (size_t values_i = 0; values_i < message_p->values.size; ++values_i)
  {
    values[values_i] = enif_make_tuple(env, 2,
      enif_make_string(env, message_p->values.data[values_i].key.data, ERL_NIF_LATIN1),
      enif_make_string(env, message_p->values.data[values_i].value.data, ERL_NIF_LATIN1)
    );
  }

  return enif_make_tuple(env, 5,
    enif_make_uint(env, message_p->level),
    enif_make_string(env, message_p->name.data, ERL_NIF_LATIN1),
    enif_make_string(env, message_p->message.data, ERL_NIF_LATIN1),
    enif_make_string(env, message_p->hardware_id.data, ERL_NIF_LATIN1),
    enif_make_list_from_array(env, values, message_p->values.size)
  );
}
// clang-format on