/*
 * Copyright 2017 WebAssembly Community Group participants
 *
 * 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.
 */

#include "binary-reader-logging.h"

#include <cinttypes>

#include "stream.h"

namespace wabt {

#define INDENT_SIZE 2

#define LOGF_NOINDENT(...) stream->Writef(__VA_ARGS__)

#define LOGF(...)               \
  do {                          \
    WriteIndent();              \
    LOGF_NOINDENT(__VA_ARGS__); \
  } while (0)

namespace {

void sprint_limits(char* dst, size_t size, const Limits* limits) {
  int result;
  if (limits->has_max) {
    result = wabt_snprintf(dst, size, "initial: %" PRIu64 ", max: %" PRIu64,
                           limits->initial, limits->max);
  } else {
    result = wabt_snprintf(dst, size, "initial: %" PRIu64, limits->initial);
  }
  WABT_USE(result);
  assert(static_cast<size_t>(result) < size);
}

}  // namespace

BinaryReaderLogging::BinaryReaderLogging(Stream* stream, BinaryReader* forward)
    : stream(stream), reader(forward), indent(0) {}

void BinaryReaderLogging::Indent() {
  indent += INDENT_SIZE;
}

void BinaryReaderLogging::Dedent() {
  indent -= INDENT_SIZE;
  assert(indent >= 0);
}

void BinaryReaderLogging::WriteIndent() {
  static char s_indent[] =
      "                                                                       "
      "                                                                       ";
  static const size_t s_indent_len = sizeof(s_indent) - 1;
  size_t i = indent;
  while (i > s_indent_len) {
    stream->WriteData(s_indent, s_indent_len);
    i -= s_indent_len;
  }
  if (i > 0) {
    stream->WriteData(s_indent, indent);
  }
}

void BinaryReaderLogging::LogTypes(uint32_t type_count, Type* types) {
  LOGF_NOINDENT("[");
  for (uint32_t i = 0; i < type_count; ++i) {
    LOGF_NOINDENT("%s", get_type_name(types[i]));
    if (i != type_count - 1)
      LOGF_NOINDENT(", ");
  }
  LOGF_NOINDENT("]");
}

bool BinaryReaderLogging::OnError(const char* message) {
  return reader->OnError(message);
}

void BinaryReaderLogging::OnSetState(const State* s) {
  BinaryReader::OnSetState(s);
  reader->OnSetState(s);
}

Result BinaryReaderLogging::BeginModule(uint32_t version) {
  LOGF("BeginModule(version: %u)\n", version);
  Indent();
  return reader->BeginModule(version);
}

Result BinaryReaderLogging::BeginSection(BinarySection section_type,
                                         uint32_t size) {
  return reader->BeginSection(section_type, size);
}

Result BinaryReaderLogging::BeginCustomSection(uint32_t size,
                                               StringSlice section_name) {
  LOGF("BeginCustomSection('" PRIstringslice "', size: %d)\n",
       WABT_PRINTF_STRING_SLICE_ARG(section_name), size);
  Indent();
  return reader->BeginCustomSection(size, section_name);
}

Result BinaryReaderLogging::OnType(uint32_t index,
                                   uint32_t param_count,
                                   Type* param_types,
                                   uint32_t result_count,
                                   Type* result_types) {
  LOGF("OnType(index: %u, params: ", index);
  LogTypes(param_count, param_types);
  LOGF_NOINDENT(", results: ");
  LogTypes(result_count, result_types);
  LOGF_NOINDENT(")\n");
  return reader->OnType(index, param_count, param_types, result_count,
                        result_types);
}

Result BinaryReaderLogging::OnImport(uint32_t index,
                                     StringSlice module_name,
                                     StringSlice field_name) {
  LOGF("OnImport(index: %u, module: \"" PRIstringslice
       "\", field: \"" PRIstringslice "\")\n",
       index, WABT_PRINTF_STRING_SLICE_ARG(module_name),
       WABT_PRINTF_STRING_SLICE_ARG(field_name));
  return reader->OnImport(index, module_name, field_name);
}

Result BinaryReaderLogging::OnImportFunc(uint32_t import_index,
                                         StringSlice module_name,
                                         StringSlice field_name,
                                         uint32_t func_index,
                                         uint32_t sig_index) {
  LOGF("OnImportFunc(import_index: %u, func_index: %u, sig_index: %u)\n",
       import_index, func_index, sig_index);
  return reader->OnImportFunc(import_index, module_name, field_name, func_index,
                              sig_index);
}

Result BinaryReaderLogging::OnImportTable(uint32_t import_index,
                                          StringSlice module_name,
                                          StringSlice field_name,
                                          uint32_t table_index,
                                          Type elem_type,
                                          const Limits* elem_limits) {
  char buf[100];
  sprint_limits(buf, sizeof(buf), elem_limits);
  LOGF("OnImportTable(import_index: %u, table_index: %u, elem_type: %s, %s)\n",
       import_index, table_index, get_type_name(elem_type), buf);
  return reader->OnImportTable(import_index, module_name, field_name,
                               table_index, elem_type, elem_limits);
}

Result BinaryReaderLogging::OnImportMemory(uint32_t import_index,
                                           StringSlice module_name,
                                           StringSlice field_name,
                                           uint32_t memory_index,
                                           const Limits* page_limits) {
  char buf[100];
  sprint_limits(buf, sizeof(buf), page_limits);
  LOGF("OnImportMemory(import_index: %u, memory_index: %u, %s)\n", import_index,
       memory_index, buf);
  return reader->OnImportMemory(import_index, module_name, field_name,
                                memory_index, page_limits);
}

Result BinaryReaderLogging::OnImportGlobal(uint32_t import_index,
                                           StringSlice module_name,
                                           StringSlice field_name,
                                           uint32_t global_index,
                                           Type type,
                                           bool mutable_) {
  LOGF(
      "OnImportGlobal(import_index: %u, global_index: %u, type: %s, mutable: "
      "%s)\n",
      import_index, global_index, get_type_name(type),
      mutable_ ? "true" : "false");
  return reader->OnImportGlobal(import_index, module_name, field_name,
                                global_index, type, mutable_);
}

Result BinaryReaderLogging::OnTable(uint32_t index,
                                    Type elem_type,
                                    const Limits* elem_limits) {
  char buf[100];
  sprint_limits(buf, sizeof(buf), elem_limits);
  LOGF("OnTable(index: %u, elem_type: %s, %s)\n", index,
       get_type_name(elem_type), buf);
  return reader->OnTable(index, elem_type, elem_limits);
}

Result BinaryReaderLogging::OnMemory(uint32_t index,
                                     const Limits* page_limits) {
  char buf[100];
  sprint_limits(buf, sizeof(buf), page_limits);
  LOGF("OnMemory(index: %u, %s)\n", index, buf);
  return reader->OnMemory(index, page_limits);
}

Result BinaryReaderLogging::BeginGlobal(uint32_t index,
                                        Type type,
                                        bool mutable_) {
  LOGF("BeginGlobal(index: %u, type: %s, mutable: %s)\n", index,
       get_type_name(type), mutable_ ? "true" : "false");
  return reader->BeginGlobal(index, type, mutable_);
}

Result BinaryReaderLogging::OnExport(uint32_t index,
                                     ExternalKind kind,
                                     uint32_t item_index,
                                     StringSlice name) {
  LOGF("OnExport(index: %u, kind: %s, item_index: %u, name: \"" PRIstringslice
       "\")\n",
       index, get_kind_name(kind), item_index,
       WABT_PRINTF_STRING_SLICE_ARG(name));
  return reader->OnExport(index, kind, item_index, name);
}

Result BinaryReaderLogging::OnLocalDecl(uint32_t decl_index,
                                        uint32_t count,
                                        Type type) {
  LOGF("OnLocalDecl(index: %u, count: %u, type: %s)\n", decl_index, count,
       get_type_name(type));
  return reader->OnLocalDecl(decl_index, count, type);
}

Result BinaryReaderLogging::OnBlockExpr(uint32_t num_types, Type* sig_types) {
  LOGF("OnBlockExpr(sig: ");
  LogTypes(num_types, sig_types);
  LOGF_NOINDENT(")\n");
  return reader->OnBlockExpr(num_types, sig_types);
}

Result BinaryReaderLogging::OnBrExpr(uint32_t depth) {
  LOGF("OnBrExpr(depth: %u)\n", depth);
  return reader->OnBrExpr(depth);
}

Result BinaryReaderLogging::OnBrIfExpr(uint32_t depth) {
  LOGF("OnBrIfExpr(depth: %u)\n", depth);
  return reader->OnBrIfExpr(depth);
}

Result BinaryReaderLogging::OnBrTableExpr(uint32_t num_targets,
                                          uint32_t* target_depths,
                                          uint32_t default_target_depth) {
  LOGF("OnBrTableExpr(num_targets: %u, depths: [", num_targets);
  for (uint32_t i = 0; i < num_targets; ++i) {
    LOGF_NOINDENT("%u", target_depths[i]);
    if (i != num_targets - 1)
      LOGF_NOINDENT(", ");
  }
  LOGF_NOINDENT("], default: %u)\n", default_target_depth);
  return reader->OnBrTableExpr(num_targets, target_depths,
                               default_target_depth);
}

Result BinaryReaderLogging::OnF32ConstExpr(uint32_t value_bits) {
  float value;
  memcpy(&value, &value_bits, sizeof(value));
  LOGF("OnF32ConstExpr(%g (0x04%x))\n", value, value_bits);
  return reader->OnF32ConstExpr(value_bits);
}

Result BinaryReaderLogging::OnF64ConstExpr(uint64_t value_bits) {
  double value;
  memcpy(&value, &value_bits, sizeof(value));
  LOGF("OnF64ConstExpr(%g (0x08%" PRIx64 "))\n", value, value_bits);
  return reader->OnF64ConstExpr(value_bits);
}

Result BinaryReaderLogging::OnI32ConstExpr(uint32_t value) {
  LOGF("OnI32ConstExpr(%u (0x%x))\n", value, value);
  return reader->OnI32ConstExpr(value);
}

Result BinaryReaderLogging::OnI64ConstExpr(uint64_t value) {
  LOGF("OnI64ConstExpr(%" PRIu64 " (0x%" PRIx64 "))\n", value, value);
  return reader->OnI64ConstExpr(value);
}

Result BinaryReaderLogging::OnIfExpr(uint32_t num_types, Type* sig_types) {
  LOGF("OnIfExpr(sig: ");
  LogTypes(num_types, sig_types);
  LOGF_NOINDENT(")\n");
  return reader->OnIfExpr(num_types, sig_types);
}

Result BinaryReaderLogging::OnLoadExpr(Opcode opcode,
                                       uint32_t alignment_log2,
                                       uint32_t offset) {
  LOGF("OnLoadExpr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n",
       get_opcode_name(opcode), static_cast<unsigned>(opcode), alignment_log2,
       offset);
  return reader->OnLoadExpr(opcode, alignment_log2, offset);
}

Result BinaryReaderLogging::OnLoopExpr(uint32_t num_types, Type* sig_types) {
  LOGF("OnLoopExpr(sig: ");
  LogTypes(num_types, sig_types);
  LOGF_NOINDENT(")\n");
  return reader->OnLoopExpr(num_types, sig_types);
}

Result BinaryReaderLogging::OnStoreExpr(Opcode opcode,
                                        uint32_t alignment_log2,
                                        uint32_t offset) {
  LOGF("OnStoreExpr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n",
       get_opcode_name(opcode), static_cast<unsigned>(opcode), alignment_log2,
       offset);
  return reader->OnStoreExpr(opcode, alignment_log2, offset);
}

Result BinaryReaderLogging::OnDataSegmentData(uint32_t index,
                                              const void* data,
                                              uint32_t size) {
  LOGF("OnDataSegmentData(index:%u, size:%u)\n", index, size);
  return reader->OnDataSegmentData(index, data, size);
}

Result BinaryReaderLogging::OnFunctionNameSubsection(uint32_t index,
                                                     uint32_t name_type,
                                                     uint32_t subsection_size) {
  LOGF("OnFunctionNameSubsection(index:%u, nametype:%u, size:%u)\n", index,
       name_type, subsection_size);
  return reader->OnFunctionNameSubsection(index, name_type, subsection_size);
}

Result BinaryReaderLogging::OnFunctionName(uint32_t index, StringSlice name) {
  LOGF("OnFunctionName(index: %u, name: \"" PRIstringslice "\")\n", index,
       WABT_PRINTF_STRING_SLICE_ARG(name));
  return reader->OnFunctionName(index, name);
}

Result BinaryReaderLogging::OnLocalNameSubsection(uint32_t index,
                                                  uint32_t name_type,
                                                  uint32_t subsection_size) {
  LOGF("OnLocalNameSubsection(index:%u, nametype:%u, size:%u)\n", index,
       name_type, subsection_size);
  return reader->OnLocalNameSubsection(index, name_type, subsection_size);
}

Result BinaryReaderLogging::OnLocalName(uint32_t func_index,
                                        uint32_t local_index,
                                        StringSlice name) {
  LOGF("OnLocalName(func_index: %u, local_index: %u, name: \"" PRIstringslice
       "\")\n",
       func_index, local_index, WABT_PRINTF_STRING_SLICE_ARG(name));
  return reader->OnLocalName(func_index, local_index, name);
}

Result BinaryReaderLogging::OnInitExprF32ConstExpr(uint32_t index,
                                                   uint32_t value_bits) {
  float value;
  memcpy(&value, &value_bits, sizeof(value));
  LOGF("OnInitExprF32ConstExpr(index: %u, value: %g (0x04%x))\n", index, value,
       value_bits);
  return reader->OnInitExprF32ConstExpr(index, value_bits);
}

Result BinaryReaderLogging::OnInitExprF64ConstExpr(uint32_t index,
                                                   uint64_t value_bits) {
  double value;
  memcpy(&value, &value_bits, sizeof(value));
  LOGF("OnInitExprF64ConstExpr(index: %u value: %g (0x08%" PRIx64 "))\n", index,
       value, value_bits);
  return reader->OnInitExprF64ConstExpr(index, value_bits);
}

Result BinaryReaderLogging::OnInitExprI32ConstExpr(uint32_t index,
                                                   uint32_t value) {
  LOGF("OnInitExprI32ConstExpr(index: %u, value: %u)\n", index, value);
  return reader->OnInitExprI32ConstExpr(index, value);
}

Result BinaryReaderLogging::OnInitExprI64ConstExpr(uint32_t index,
                                                   uint64_t value) {
  LOGF("OnInitExprI64ConstExpr(index: %u, value: %" PRIu64 ")\n", index, value);
  return reader->OnInitExprI64ConstExpr(index, value);
}

Result BinaryReaderLogging::OnRelocCount(uint32_t count,
                                         BinarySection section_code,
                                         StringSlice section_name) {
  LOGF("OnRelocCount(count: %d, section: %s, section_name: " PRIstringslice
       ")\n",
       count, get_section_name(section_code),
       WABT_PRINTF_STRING_SLICE_ARG(section_name));
  return reader->OnRelocCount(count, section_code, section_name);
}

Result BinaryReaderLogging::OnReloc(RelocType type,
                                    uint32_t offset,
                                    uint32_t index,
                                    uint32_t addend) {
  int32_t signed_addend = static_cast<int32_t>(addend);
  LOGF("OnReloc(type: %s, offset: %u, index: %u, addend: %d)\n",
       get_reloc_type_name(type), offset, index, signed_addend);
  return reader->OnReloc(type, offset, index, addend);
}

#define DEFINE_BEGIN(name)                          \
  Result BinaryReaderLogging::name(uint32_t size) { \
    LOGF(#name "(%u)\n", size);                     \
    Indent();                                       \
    return reader->name(size);                      \
  }

#define DEFINE_END(name)               \
  Result BinaryReaderLogging::name() { \
    Dedent();                          \
    LOGF(#name "\n");                  \
    return reader->name();             \
  }

#define DEFINE_UINT32(name)                          \
  Result BinaryReaderLogging::name(uint32_t value) { \
    LOGF(#name "(%u)\n", value);                     \
    return reader->name(value);                      \
  }

#define DEFINE_UINT32_DESC(name, desc)               \
  Result BinaryReaderLogging::name(uint32_t value) { \
    LOGF(#name "(" desc ": %u)\n", value);           \
    return reader->name(value);                      \
  }

#define DEFINE_UINT32_UINT32(name, desc0, desc1)                       \
  Result BinaryReaderLogging::name(uint32_t value0, uint32_t value1) { \
    LOGF(#name "(" desc0 ": %u, " desc1 ": %u)\n", value0, value1);    \
    return reader->name(value0, value1);                               \
  }

#define DEFINE_OPCODE(name)                                \
  Result BinaryReaderLogging::name(Opcode opcode) {        \
    LOGF(#name "(\"%s\" (%u))\n", get_opcode_name(opcode), \
         static_cast<unsigned>(opcode));                   \
    return reader->name(opcode);                           \
  }

#define DEFINE0(name)                  \
  Result BinaryReaderLogging::name() { \
    LOGF(#name "\n");                  \
    return reader->name();             \
  }

DEFINE_END(EndModule)

DEFINE_END(EndCustomSection)

DEFINE_BEGIN(BeginTypeSection)
DEFINE_UINT32(OnTypeCount)
DEFINE_END(EndTypeSection)

DEFINE_BEGIN(BeginImportSection)
DEFINE_UINT32(OnImportCount)
DEFINE_END(EndImportSection)

DEFINE_BEGIN(BeginFunctionSection)
DEFINE_UINT32(OnFunctionCount)
DEFINE_UINT32_UINT32(OnFunction, "index", "sig_index")
DEFINE_END(EndFunctionSection)

DEFINE_BEGIN(BeginTableSection)
DEFINE_UINT32(OnTableCount)
DEFINE_END(EndTableSection)

DEFINE_BEGIN(BeginMemorySection)
DEFINE_UINT32(OnMemoryCount)
DEFINE_END(EndMemorySection)

DEFINE_BEGIN(BeginGlobalSection)
DEFINE_UINT32(OnGlobalCount)
DEFINE_UINT32(BeginGlobalInitExpr)
DEFINE_UINT32(EndGlobalInitExpr)
DEFINE_UINT32(EndGlobal)
DEFINE_END(EndGlobalSection)

DEFINE_BEGIN(BeginExportSection)
DEFINE_UINT32(OnExportCount)
DEFINE_END(EndExportSection)

DEFINE_BEGIN(BeginStartSection)
DEFINE_UINT32(OnStartFunction)
DEFINE_END(EndStartSection)

DEFINE_BEGIN(BeginCodeSection)
DEFINE_UINT32(OnFunctionBodyCount)
DEFINE_UINT32(BeginFunctionBody)
DEFINE_UINT32(EndFunctionBody)
DEFINE_UINT32(OnLocalDeclCount)
DEFINE_OPCODE(OnBinaryExpr)
DEFINE_UINT32_DESC(OnCallExpr, "func_index")
DEFINE_UINT32_DESC(OnCallIndirectExpr, "sig_index")
DEFINE_OPCODE(OnCompareExpr)
DEFINE_OPCODE(OnConvertExpr)
DEFINE0(OnCurrentMemoryExpr)
DEFINE0(OnDropExpr)
DEFINE0(OnElseExpr)
DEFINE0(OnEndExpr)
DEFINE_UINT32_DESC(OnGetGlobalExpr, "index")
DEFINE_UINT32_DESC(OnGetLocalExpr, "index")
DEFINE0(OnGrowMemoryExpr)
DEFINE0(OnNopExpr)
DEFINE0(OnReturnExpr)
DEFINE0(OnSelectExpr)
DEFINE_UINT32_DESC(OnSetGlobalExpr, "index")
DEFINE_UINT32_DESC(OnSetLocalExpr, "index")
DEFINE_UINT32_DESC(OnTeeLocalExpr, "index")
DEFINE0(OnUnreachableExpr)
DEFINE_OPCODE(OnUnaryExpr)
DEFINE_END(EndCodeSection)

DEFINE_BEGIN(BeginElemSection)
DEFINE_UINT32(OnElemSegmentCount)
DEFINE_UINT32_UINT32(BeginElemSegment, "index", "table_index")
DEFINE_UINT32(BeginElemSegmentInitExpr)
DEFINE_UINT32(EndElemSegmentInitExpr)
DEFINE_UINT32_UINT32(OnElemSegmentFunctionIndexCount, "index", "count")
DEFINE_UINT32_UINT32(OnElemSegmentFunctionIndex, "index", "func_index")
DEFINE_UINT32(EndElemSegment)
DEFINE_END(EndElemSection)

DEFINE_BEGIN(BeginDataSection)
DEFINE_UINT32(OnDataSegmentCount)
DEFINE_UINT32_UINT32(BeginDataSegment, "index", "memory_index")
DEFINE_UINT32(BeginDataSegmentInitExpr)
DEFINE_UINT32(EndDataSegmentInitExpr)
DEFINE_UINT32(EndDataSegment)
DEFINE_END(EndDataSection)

DEFINE_BEGIN(BeginNamesSection)
DEFINE_UINT32(OnFunctionNamesCount)
DEFINE_UINT32(OnLocalNameFunctionCount)
DEFINE_UINT32_UINT32(OnLocalNameLocalCount, "index", "count")
DEFINE_END(EndNamesSection)

DEFINE_BEGIN(BeginRelocSection)
DEFINE_END(EndRelocSection)
DEFINE_UINT32_UINT32(OnInitExprGetGlobalExpr, "index", "global_index")

// We don't need to log these (the individual opcodes are logged instead), but
// we still need to forward the calls.
Result BinaryReaderLogging::OnOpcode(Opcode opcode) {
  return reader->OnOpcode(opcode);
}

Result BinaryReaderLogging::OnOpcodeBare() {
  return reader->OnOpcodeBare();
}

Result BinaryReaderLogging::OnOpcodeUint32(uint32_t value) {
  return reader->OnOpcodeUint32(value);
}

Result BinaryReaderLogging::OnOpcodeUint32Uint32(uint32_t value,
                                                 uint32_t value2) {
  return reader->OnOpcodeUint32Uint32(value, value2);
}

Result BinaryReaderLogging::OnOpcodeUint64(uint64_t value) {
  return reader->OnOpcodeUint64(value);
}

Result BinaryReaderLogging::OnOpcodeF32(uint32_t value) {
  return reader->OnOpcodeF32(value);
}

Result BinaryReaderLogging::OnOpcodeF64(uint64_t value) {
  return reader->OnOpcodeF64(value);
}

Result BinaryReaderLogging::OnOpcodeBlockSig(uint32_t num_types,
                                             Type* sig_types) {
  return reader->OnOpcodeBlockSig(num_types, sig_types);
}

Result BinaryReaderLogging::OnEndFunc() {
  return reader->OnEndFunc();
}

}  // namespace wabt