// Copyright 2019 The Fuchsia 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 "vk_strings.h"

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include "tests/common/utils.h"

//
//
//

// TODO(digit): Decide what to do to make ring buffer allocation thread-safe
// if this becomes an issue. There are essentially two ways to do it:
//
//  A) Make |s_ring| below thread_local. Not supported by C99 by default but
//     easy to add with compiler-specific extensions for GCC, Clang and MSVC.
//     A bit wasteful though.
//
//  B) Use atomic loads and compare-and-swaps to use a single global buffer
//     with an atomically-managed |pos| pointer below. A little more difficult
//     to implement due to the lack of <stdatomic.h> in C99. Again,
//     compiler-specific extensions can be used.
//

// A global ring buffer for temporary string buffers used by these functions.
#define RING_SIZE (2048u - sizeof(size_t))

typedef struct
{
  size_t pos;
  char   data[RING_SIZE];
} Ring;

static char *
ring_alloc(Ring * ring, size_t size)
{
  ASSERT_MSG(size < RING_SIZE,
             "String ring allocation too large %u > %u\n",
             (uint32_t)size,
             RING_SIZE);
  size_t avail  = RING_SIZE - ring->pos;
  char * result = ring->data + ring->pos;
  if (size <= avail)
    {
      ring->pos += size;
    }
  else
    {
      result    = ring->data;
      ring->pos = 0;
    }
  return result;
}

// TODO(digit): Make this thread_local eventually to make all functions here
// thread-safe. For now, just use a single static ring.
static Ring s_ring;

// Allocate |size_| bytes of data from the current thread's string ring.
#define DECLARE_TEMP_ARRAY(temp_, size_) char * temp_ = ring_alloc(&s_ring, size_)

//
//
//

// Helper type for a fixed-size buffer that can accept formatted data.
typedef struct
{
  char * data;
  size_t capacity;
  size_t pos;
} Buffer;

void
buffer_init(Buffer * buffer, char * data, size_t data_size)
{
  ASSERT_MSG(data_size > 0, "Cannot create buffer with size of 0\n");
  buffer->data     = data;
  buffer->pos      = 0;
  buffer->capacity = data_size - 1;
  buffer->data[0]  = 0;
  ;
}

void
buffer_add(Buffer * buffer, const char * str, size_t size)
{
  size_t avail = buffer->capacity;
  if (size > avail)
    size = avail;
  memmove(buffer->data + buffer->pos, str, size);
  buffer->pos += size;
  buffer->data[buffer->pos] = 0;
}

void
buffer_add_s(Buffer * buffer, const char * str)
{
  buffer_add(buffer, str, strlen(str));
}

void
buffer_add_formatv(Buffer * buffer, const char * fmt, va_list args)
{
  size_t avail = buffer->capacity;
  if (!avail)
    return;

  int len = vsnprintf(buffer->data + buffer->pos, avail, fmt, args);
  ASSERT_MSG(len >= 0, "vsnprintf() error!\n");
  if ((size_t)len >= avail)
    buffer->pos = buffer->capacity;
  else
    buffer->pos += len;
  buffer->data[buffer->pos] = 0;
}

void
buffer_add_format(Buffer * buffer, const char * fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  buffer_add_formatv(buffer, fmt, args);
  va_end(args);
}

// Declare a static temporary buffer. This could become thread_local if we
// really need to make these functions thread-safe.
#define DECLARE_TEMP_BUFFER(temp_, size_)                                                          \
  DECLARE_TEMP_ARRAY(MACRO_EXPAND(temp_##_data), size_);                                           \
  Buffer temp_[1];                                                                                 \
  buffer_init(temp_, temp_##_data, size_)

extern const char *
vk_device_size_to_string(VkDeviceSize size)
{
  DECLARE_TEMP_ARRAY(temp, 16);
  if (size < 65536)
    {
      snprintf(temp, sizeof(temp), "%u", (unsigned)size);
    }
  else if (size < 1024 * 1024)
    {
      snprintf(temp, sizeof(temp), "%.1f kiB", size / 1024.);
    }
  else if (size < 1024 * 1024 * 1024)
    {
      snprintf(temp, sizeof(temp), "%.1f MiB", size / (1024. * 1024.));
    }
  else
    {
      snprintf(temp, sizeof(temp), "%1.f GiB", size / (1024. * 1024. * 1024.));
    }
  return temp;
}

const char *
vk_queue_family_index_to_string(uint32_t queue_family_index)
{
  if (queue_family_index == UINT32_MAX)
    return "NONE";

  DECLARE_TEMP_ARRAY(temp, 10);
  snprintf(temp, sizeof(temp), "%u", queue_family_index);
  return temp;
}

const char *
vk_memory_heap_to_string(const VkMemoryHeap * memory_heap)
{
  DECLARE_TEMP_BUFFER(temp, 64);
  uint32_t flags = memory_heap->flags;
  buffer_add_format(temp,
                    "size=%-8s flags=0x%08X",
                    vk_device_size_to_string(memory_heap->size),
                    flags);
#define FLAG_BIT(name_)                                                                            \
  if ((flags & VK_MEMORY_HEAP_##name_##_BIT) != 0)                                                 \
    buffer_add_format(temp, " %s", #name_);

  FLAG_BIT(DEVICE_LOCAL);
  FLAG_BIT(MULTI_INSTANCE);
#undef FLAG_BIT
  return temp->data;
}

const char *
vk_memory_type_to_string(const VkMemoryType * memory_type)
{
  DECLARE_TEMP_BUFFER(temp, 64);
  uint32_t flags = memory_type->propertyFlags;
  buffer_add_format(temp, "heap=%-2d flags=0x%08X", memory_type->heapIndex, flags);

#define FLAG_BIT(name_)                                                                            \
  if ((flags & VK_MEMORY_PROPERTY_##name_##_BIT))                                                  \
    buffer_add_format(temp, " %s", #name_);

  FLAG_BIT(DEVICE_LOCAL);
  FLAG_BIT(HOST_VISIBLE);
  FLAG_BIT(HOST_COHERENT);
  FLAG_BIT(HOST_CACHED);
  FLAG_BIT(LAZILY_ALLOCATED);
  FLAG_BIT(PROTECTED);

#undef FLAG_BIT
  return temp->data;
}

const char *
vk_present_mode_khr_to_string(VkPresentModeKHR arg)
{
#define CASE(arg_)                                                                                 \
  case VK_PRESENT_MODE_##arg_:                                                                     \
    return "VK_PRESENT_MODE_" #arg_
  switch (arg)
    {
      CASE(IMMEDIATE_KHR);
      CASE(MAILBOX_KHR);
      CASE(FIFO_KHR);
      CASE(FIFO_RELAXED_KHR);
      default:;
    }
#undef CASE
  DECLARE_TEMP_ARRAY(temp, 16);
  snprintf(temp, sizeof(temp), "UNKNOWN(%u)", (unsigned)arg);
  return temp;
}

const char *
vk_format_to_string(VkFormat arg)
{
#define CASE(arg_)                                                                                 \
  case VK_FORMAT_##arg_:                                                                           \
    return "VK_FORMAT_" #arg_
  switch (arg)
    {
      CASE(UNDEFINED);
      CASE(B8G8R8A8_UNORM);
      CASE(B8G8R8A8_SRGB);
      CASE(R8G8B8A8_UNORM);
      CASE(R8G8B8A8_SRGB);
      default:;
    }
#undef CASE
  DECLARE_TEMP_ARRAY(temp, 16);
  snprintf(temp, sizeof(temp), "UNKNOWN(%u)", (unsigned)arg);
  return temp;
}

const char *
vk_colorspace_khr_to_string(VkColorSpaceKHR arg)
{
#define CASE(arg_)                                                                                 \
  case VK_COLOR_SPACE_##arg_:                                                                      \
    return "VK_COLOR_SPACE_" #arg_
  switch (arg)
    {
      CASE(SRGB_NONLINEAR_KHR);
      default:;
    }
#undef CASE
  DECLARE_TEMP_ARRAY(temp, 16);
  snprintf(temp, sizeof(temp), "UNKNOWN(%u)", (unsigned)arg);
  return temp;
}

const char *
vk_surface_format_khr_to_string(VkSurfaceFormatKHR format)
{
  DECLARE_TEMP_ARRAY(temp, 32);
  snprintf(temp,
           sizeof(temp),
           "%s(%s)",
           vk_format_to_string(format.format),
           vk_colorspace_khr_to_string(format.colorSpace));
  return temp;
}

const char *
vk_format_feature_flags_to_string(VkFormatFeatureFlags flags)
{
  DECLARE_TEMP_BUFFER(temp, 128);

#define CHECK_FLAG(flag_)                                                                          \
  if ((flags & VK_FORMAT_FEATURE_##flag_##_BIT) != 0)                                              \
    buffer_add_format(temp, " %s", #flag_);

  CHECK_FLAG(SAMPLED_IMAGE)
  CHECK_FLAG(STORAGE_IMAGE)
  CHECK_FLAG(STORAGE_IMAGE_ATOMIC)
  CHECK_FLAG(UNIFORM_TEXEL_BUFFER)
  CHECK_FLAG(STORAGE_TEXEL_BUFFER)
  CHECK_FLAG(STORAGE_TEXEL_BUFFER_ATOMIC)
  CHECK_FLAG(VERTEX_BUFFER)
  CHECK_FLAG(COLOR_ATTACHMENT)
  CHECK_FLAG(COLOR_ATTACHMENT_BLEND)
  CHECK_FLAG(DEPTH_STENCIL_ATTACHMENT)
  CHECK_FLAG(BLIT_SRC)
  CHECK_FLAG(BLIT_DST)

#undef CHECK_FLAG

  return temp->data;
}

#define LIST_VK_IMAGE_USAGE_BITS(macro)                                                            \
  macro(TRANSFER_SRC) macro(TRANSFER_DST) macro(SAMPLED) macro(STORAGE) macro(COLOR_ATTACHMENT)    \
    macro(DEPTH_STENCIL_ATTACHMENT) macro(TRANSIENT_ATTACHMENT) macro(INPUT_ATTACHMENT)

const char *
vk_image_usage_flags_to_string(VkImageUsageFlags flags)
{
  uint32_t bits = (uint32_t)flags;

  if (!bits)
    return "NONE";

#define TEST_BIT(bit_) ((bits & VK_IMAGE_USAGE_##bit_##_BIT) != 0)

    // First, count the number of known bits set.
#define COUNT_BIT(bit_)                                                                            \
  if (TEST_BIT(bit_))                                                                              \
    count++;
  int count = 0;
  LIST_VK_IMAGE_USAGE_BITS(COUNT_BIT)
#undef COUNT_BIT

  DECLARE_TEMP_BUFFER(temp, 64);
  if (!count)
    {
      buffer_add_format(temp, "UNKNOWN(0x%X)", bits);
      return temp->data;
    }

#define NAME_BIT(bit_) #bit_,
  static const char * const kBitNames[] = { LIST_VK_IMAGE_USAGE_BITS(NAME_BIT) };
#undef NAME_BIT

  buffer_add_s(temp, "VK_IMAGE_USAGE_");
  if (count > 1)
    buffer_add(temp, "[", 1);

  const char * separator = "";
  unsigned     bit_index = 0;

#define ADD_BIT(bit_)                                                                              \
  if (TEST_BIT(bit_))                                                                              \
    {                                                                                              \
      buffer_add_s(temp, separator);                                                               \
      buffer_add_s(temp, kBitNames[bit_index]);                                                    \
      separator = "|";                                                                             \
    }                                                                                              \
  bit_index++;

  LIST_VK_IMAGE_USAGE_BITS(ADD_BIT)

#undef ADD_BIT

  if (count > 1)
    buffer_add(temp, "]", 1);

  buffer_add(temp, "_BIT", 4);
  return temp->data;

#undef TEST_BIT
}

#define LIST_VK_BUFFER_USAGE_BITS(macro)                                                           \
  macro(TRANSFER_SRC) macro(TRANSFER_DST) macro(UNIFORM_TEXEL_BUFFER) macro(STORAGE_TEXEL_BUFFER)  \
    macro(UNIFORM_BUFFER) macro(STORAGE_BUFFER) macro(INDEX_BUFFER) macro(VERTEX_BUFFER)           \
      macro(INDIRECT_BUFFER)

const char *
vk_buffer_usage_flags_to_string(VkBufferUsageFlags flags)
{
  uint32_t bits = (uint32_t)flags;

  if (!bits)
    return "NONE";

#define TEST_BIT(bit_) ((bits & VK_BUFFER_USAGE_##bit_##_BIT) != 0)

    // First, count the number of known bits set.
#define COUNT_BIT(bit_)                                                                            \
  if (TEST_BIT(bit_))                                                                              \
    count++;
  int count = 0;
  LIST_VK_BUFFER_USAGE_BITS(COUNT_BIT)
#undef COUNT_BIT

  // Special case if there are no known bits.
  DECLARE_TEMP_BUFFER(temp, 64);
  if (!count)
    {
      buffer_add_format(temp, "UNKNOWN(0x%X)", bits);
      return temp->data;
    }

#define NAME_BIT(bit_) #bit_,
  static const char * const kBitNames[] = { LIST_VK_BUFFER_USAGE_BITS(NAME_BIT) };
#undef NAME_BIT

  buffer_add_s(temp, "VK_BUFFER_USAGE_");
  if (count > 1)
    buffer_add(temp, "[", 1);

  const char * separator = "";
  unsigned     bit_index = 0;

#define ADD_BIT(bit_)                                                                              \
  if (TEST_BIT(bit_))                                                                              \
    {                                                                                              \
      buffer_add(temp, separator, 1);                                                              \
      buffer_add_s(temp, kBitNames[bit_index]);                                                    \
      separator = "|";                                                                             \
    }                                                                                              \
  bit_index++;

  LIST_VK_BUFFER_USAGE_BITS(ADD_BIT)

#undef ADD_BIT

  if (count > 1)
    buffer_add(temp, "]", 1);

  buffer_add(temp, "_BIT", 4);
  return temp->data;

#undef TEST_BIT
}

const char *
vk_physical_device_type_to_string(VkPhysicalDeviceType device_type)
{
#define CASE(type_) case VK_PHYSICAL_DEVICE_TYPE_ ## type_: return #type_;
  switch (device_type)
    {
      CASE(OTHER)
      CASE(INTEGRATED_GPU)
      CASE(DISCRETE_GPU)
      CASE(VIRTUAL_GPU)
      CASE(CPU)
      default:;
    }
#undef CASE
  DECLARE_TEMP_ARRAY(temp, 16);
  snprintf(temp, sizeof(temp), "UKNOWN(%u)", device_type);
  return temp;
}