// Copyright 2020 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 <zircon/assert.h>

#include <algorithm>
#include <optional>
#include <sstream>
#include <string_view>
#include <type_traits>
#include <utility>

#include "tools/kazoo/alias_workaround.h"
#include "tools/kazoo/output_util.h"
#include "tools/kazoo/outputs.h"
#include "tools/kazoo/string_util.h"

using namespace std::literals;

namespace {

std::string ToSingular(const std::string& s) {
  if (s.size() > 1 && s[s.size() - 1] == 's') {
    return s.substr(0, s.size() - 1);
  }
  return s;
}

class Formatter {
 public:
  explicit Formatter(const SyscallLibrary* library) : library_(library) {}

  struct Names {
    std::string base_name;  // signals
    std::string type_name;  // zxio_signals_t
  };

  Names Format(const Alias& alias) {
    return Names{
        .base_name = alias.base_name(),
        .type_name = library_->name() + "_" + alias.base_name() + "_t",
    };
  }

  Names Format(const Enum& e) {
    return Names{
        .base_name = e.base_name(),
        .type_name = library_->name() + "_" + e.base_name() + "_t",
    };
  }

  struct StructNames {
    std::string base_name;      // signals
    std::string type_name;      // zxio_dirent_t
    std::string c_struct_name;  // zxio_dirent
  };

  StructNames Format(const Table& table) {
    return StructNames{
        .base_name = table.base_name(),
        .type_name = library_->name() + "_" + table.base_name() + "_t",
        .c_struct_name = library_->name() + "_" + table.base_name(),
    };
  }

  std::string FormatMember(const Enum& e, const std::string& member_name) {
    return ToUpperAscii(library_->name()) + "_" + ToUpperAscii(ToSingular(e.base_name())) + "_" +
           member_name;
  }

  std::string TypeName(const Type& type) {
    return std::visit(
        [this](auto&& type) -> std::string {
          using T = std::decay_t<decltype(type)>;
          if constexpr (std::is_same_v<T, TypeBool>) {
            return "bool";
          }
          if constexpr (std::is_same_v<T, TypeChar>) {
            return "char";
          }
          if constexpr (std::is_same_v<T, TypeInt8>) {
            return "int8_t";
          }
          if constexpr (std::is_same_v<T, TypeInt16>) {
            return "int16_t";
          }
          if constexpr (std::is_same_v<T, TypeInt32>) {
            return "int32_t";
          }
          if constexpr (std::is_same_v<T, TypeInt64>) {
            return "int64_t";
          }
          if constexpr (std::is_same_v<T, TypeSizeT>) {
            return "size_t";
          }
          if constexpr (std::is_same_v<T, TypeUint8>) {
            return "uint8_t";
          }
          if constexpr (std::is_same_v<T, TypeUint16>) {
            return "uint16_t";
          }
          if constexpr (std::is_same_v<T, TypeUint32>) {
            return "uint32_t";
          }
          if constexpr (std::is_same_v<T, TypeUint64>) {
            return "uint64_t";
          }
          if constexpr (std::is_same_v<T, TypeUintptrT>) {
            return "uintptr_t";
          }
          if constexpr (std::is_same_v<T, TypeVoid>) {
            return "void";
          }
          if constexpr (std::is_same_v<T, TypeZxBasicAlias>) {
            return type.name();
          }
          if constexpr (std::is_same_v<T, TypeAlias>) {
            return Format(type.alias_data()).type_name;
          }
          if constexpr (std::is_same_v<T, TypeEnum>) {
            return Format(type.enum_data()).type_name;
          }
          if constexpr (std::is_same_v<T, TypeHandle>) {
            return "zx_handle_t";
          }
          if constexpr (std::is_same_v<T, TypePointer>) {
            return TypeName(type.pointed_to_type()) + "*";
          }
          ZX_ASSERT(false && "Unhandled type in TypeName");
        },
        type.type_data());
  }

  std::string FormatConstant(const Enum& e, uint64_t raw) {
    return std::visit(
        [raw](auto&& type) -> std::string {
          std::stringstream stream;
          stream << std::hex << raw;
          std::string num_str = "0x" + stream.str();
          using T = std::decay_t<decltype(type)>;
          if constexpr (std::is_same_v<T, TypeUint8>) {
            return num_str;
          }
          if constexpr (std::is_same_v<T, TypeUint16>) {
            return num_str;
          }
          if constexpr (std::is_same_v<T, TypeUint32>) {
            return num_str + "u";
          }
          if constexpr (std::is_same_v<T, TypeUint64>) {
            return num_str + "ul";
          }
          if constexpr (std::is_same_v<T, TypeChar>) {
            return num_str;
          }
          if constexpr (std::is_same_v<T, TypeInt8>) {
            return num_str;
          }
          if constexpr (std::is_same_v<T, TypeInt16>) {
            return num_str;
          }
          if constexpr (std::is_same_v<T, TypeInt32>) {
            return num_str;
          }
          if constexpr (std::is_same_v<T, TypeInt64>) {
            return num_str + "l";
          }
          ZX_PANIC("Unhandled primitive type");
        },
        e.underlying_type().type_data());
  }

 private:
  const SyscallLibrary* library_;
};

std::string MakeTitleLine(const std::string& base_name) {
  std::vector<std::string> words = SplitString(base_name, '_', kTrimWhitespace);
  std::for_each(words.begin(), words.end(), [](std::string& s) { s[0] = ToUpperASCII(s[0]); });
  std::string title = JoinStrings(words, " ");
  // Pad up to 80 columns. 4 is to account for space characters around.
  int trailing_length = 80 - static_cast<int>(title.size()) - 4;
  if (trailing_length > 0) {
    return "// " + title + " " + std::string(trailing_length, '-');
  }
  return "// " + title;
}

void PrintDocComments(const std::vector<std::string>& lines, Writer* writer,
                      uint32_t indent_level = 0) {
  if (!lines.empty()) {
    writer->PrintSpacerLine();
  }
  std::string indent(2 * indent_level, ' ');
  for (const auto& line : lines) {
    if (!line.empty()) {
      writer->Printf("%s// %s\n", indent.c_str(), line.c_str());
    } else {
      writer->Printf("%s//\n", indent.c_str());
    }
  }
}

}  // namespace

bool CUlibHeaderOutput(const SyscallLibrary& library, Writer* writer) {
  CopyrightHeaderWithCppComments(writer);

  std::string prelude = R"(
#ifndef LIB_ZXIO_TYPES_H_
#define LIB_ZXIO_TYPES_H_

#include <stdbool.h>
#include <stdint.h>
#include <zircon/compiler.h>

// This header defines the public types used in the zxio and zxio_ops interface.

__BEGIN_CDECLS
)";
  writer->Printf("%s\n", TrimString(prelude, "\n").c_str());
  writer->Puts("\n");

  Formatter formatter(&library);
  for (const auto& bits : library.bits()) {
    auto names = formatter.Format(*bits);
    std::string title_line = MakeTitleLine(names.base_name);
    writer->Printf("%s\n", title_line.c_str());
    writer->Puts("\n");
    PrintDocComments(bits->description(), writer);
    writer->Printf("typedef %s %s;\n", formatter.TypeName(bits->underlying_type()).c_str(),
                   names.type_name.c_str());
    writer->Puts("\n");
    writer->Printf("#define %s ((%s)%s)\n", formatter.FormatMember(*bits, "NONE").c_str(),
                   names.type_name.c_str(), formatter.FormatConstant(*bits, 0).c_str());
    writer->Puts("\n");
    uint64_t all = 0;
    for (const auto& k : bits->members()) {
      auto v = bits->ValueForMember(k);
      PrintDocComments(v.description, writer);
      writer->Printf("#define %s ((%s)%s)\n", formatter.FormatMember(*bits, k).c_str(),
                     names.type_name.c_str(), formatter.FormatConstant(*bits, v.value).c_str());
      all |= v.value;
    }
    writer->Puts("\n");
    writer->Printf("#define %s ((%s)%s)\n", formatter.FormatMember(*bits, "ALL").c_str(),
                   names.type_name.c_str(), formatter.FormatConstant(*bits, all).c_str());
    writer->Puts("\n");
  }

  for (const auto& e : library.enums()) {
    if (e->id() == "zx/obj_type") {
      // TODO(fxbug.dev/51001): This will emit a correct, but not yet
      // wanted duplicate definition of ZX_OBJ_TYPE_xyz.
      continue;
    }
    auto names = formatter.Format(*e);
    std::string title_line = MakeTitleLine(names.base_name);
    writer->Printf("%s\n", title_line.c_str());
    writer->Puts("\n");
    PrintDocComments(e->description(), writer);
    writer->Printf("typedef %s %s;\n", formatter.TypeName(e->underlying_type()).c_str(),
                   names.type_name.c_str());
    writer->Printf("\n");
    for (const auto& k : e->members()) {
      auto v = e->ValueForMember(k);
      PrintDocComments(v.description, writer);
      writer->Printf("#define %s ((%s)%s)\n", formatter.FormatMember(*e, k).c_str(),
                     names.type_name.c_str(), formatter.FormatConstant(*e, v.value).c_str());
    }
    writer->Puts("\n");
  }

  for (const auto& alias : library.type_aliases()) {
    Type workaround_type;
    if (AliasWorkaround(alias->original_name(), library, &workaround_type)) {
      // Hide workaround types
      continue;
    }

    auto names = formatter.Format(*alias);
    PrintDocComments(alias->description(), writer);
    writer->Printf("typedef %s %s;\n",
                   formatter.TypeName(library.TypeFromName(alias->partial_type_ctor())).c_str(),
                   names.type_name.c_str());
    writer->Puts("\n");
  }

  for (const auto& table : library.tables()) {
    bool all_required = true;
    for (const auto& member : table->members()) {
      if (member.required() == Required::kNo) {
        all_required = false;
        break;
      }
    }

    auto names = formatter.Format(*table);
    std::string setter_macro_name = ToUpperAscii(names.c_struct_name) + "_SET";
    PrintDocComments(table->description(), writer);
    if (!all_required) {
      writer->Printf(R"(//
// Optional fields have corresponding presence indicators. When creating
// a new object, it is desirable to use the %s helper macro
// to set the fields, to avoid forgetting to change the presence indicator.
)",
                     setter_macro_name.c_str());
    }
    writer->Printf("typedef struct %s {", names.c_struct_name.c_str());
    writer->Puts("\n");
    // Pack optional fields together
    for (const auto& member : table->members()) {
      if (member.required() == Required::kYes) {
        continue;
      }
      PrintDocComments(member.description(), writer, 1);
      writer->Printf("  %s %s;\n", formatter.TypeName(member.type()).c_str(),
                     member.name().c_str());
    }

    if (!all_required) {
      std::string presence_bits_name = names.c_struct_name + "_has_t";
      writer->Printf(R"(
  // Presence indicator for these fields.
  //
  // If a particular field is absent, it should be set to zero/none,
  // and the corresponding presence indicator will be false.
  // Therefore, a completely empty |%s| may be conveniently
  // obtained via value-initialization e.g. `%s a = {};`.
)",
                     names.type_name.c_str(), names.type_name.c_str());
      writer->Printf("  struct %s {\n", presence_bits_name.c_str());
      for (const auto& member : table->members()) {
        if (member.required() == Required::kYes) {
          continue;
        }
        writer->Printf("    bool %s;\n", member.name().c_str());
      }
      writer->Printf("  } has;\n");
    }

    // Followed by required fields
    for (const auto& member : table->members()) {
      if (member.required() == Required::kNo) {
        continue;
      }
      PrintDocComments(member.description(), writer, 1);
      writer->Printf("  %s %s;\n", formatter.TypeName(member.type()).c_str(),
                     member.name().c_str());
    }

    writer->Printf("} %s;\n", names.type_name.c_str());
    writer->Printf(R"(
#define %s(%s, field_name, value) \
  do { \
    %s* _tmp_%s= &(%s); \
    _tmp_%s->field_name = value; \
    _tmp_%s->has.field_name = true; \
  } while (0)
)",
                   setter_macro_name.c_str(), names.base_name.c_str(), names.type_name.c_str(),
                   names.base_name.c_str(), names.base_name.c_str(), names.base_name.c_str(),
                   names.base_name.c_str());
    writer->Puts("\n");
  }

  std::string epilogue = R"(
__END_CDECLS

#endif  // LIB_ZXIO_TYPES_H_
)";
  writer->Printf("%s\n", TrimString(epilogue, "\n").c_str());

  return true;
}