#include <bfbs_gen_lua.h>

#include <bfbs_gen_nim.h>

#include <flatbuffers/flatc.h>

#include <idl_gen_binary.h>

#include <idl_gen_csharp.h>

#include <idl_gen_dart.h>

#include <idl_gen_fbs.h>

#include <idl_gen_go.h>

#include <idl_gen_java.h>

#include <idl_gen_json_schema.h>

#include <idl_gen_kotlin.h>

#include <idl_gen_lobster.h>

#include <idl_gen_php.h>

#include <idl_gen_python.h>

#include <idl_gen_rust.h>

#include <idl_gen_swift.h>

#include <idl_gen_text.h>

#include <idl_gen_ts.h>

#include <stddef.h>

#include <stdint.h>

#include <iostream>

#include <memory>

#include <string>

#include "flatbuffers/code_generator.h"

#include "flatbuffers/idl.h"  // For Parser and generation functions

#include "idl_gen_cpp.h"      // For C++ generator

#include "test_init.h"

static constexpr size_t kMinInputLength = 1;

static constexpr size_t kMaxInputLength = 16384;

static constexpr uint8_t flags_strict_json = 0x80;

static constexpr uint8_t flags_skip_unexpected_fields_in_json = 0x40;

static constexpr uint8_t flags_allow_non_utf8 = 0x20;

// Utility for test run.

OneTimeTestInit OneTimeTestInit::one_time_init_;

static const char* g_program_name = nullptr;

static void Warn(const flatbuffers::FlatCompiler* flatc,

                 const std::string& warn, bool show_exe_name) {

  (void)flatc;

  if (show_exe_name) {

    printf("%s: ", g_program_name);

  }

  fprintf(stderr, "\nwarning:\n  %s\n\n", warn.c_str());

}

static void Error(const flatbuffers::FlatCompiler* flatc,

                  const std::string& err, bool usage, bool show_exe_name) {

  if (show_exe_name) {

    printf("%s: ", g_program_name);

  }

  if (usage && flatc) {

    fprintf(stderr, "%s\n", flatc->GetShortUsageString(g_program_name).c_str());

  }

  fprintf(stderr, "\nerror:\n  %s\n\n", err.c_str());

  exit(1);

}

namespace flatbuffers {

void LogCompilerWarn(const std::string& warn) {

  Warn(static_cast<const flatbuffers::FlatCompiler*>(nullptr), warn, true);

}

void LogCompilerError(const std::string& err) {

  Error(static_cast<const flatbuffers::FlatCompiler*>(nullptr), err, false,

        true);

}

}  // namespace flatbuffers

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {

  // Reserve one byte for Parser flags and one byte for repetition counter.

  if (size < 3) return 0;

  const uint8_t flags = data[0];

  (void)data[1];  //  reserved

  data += 2;

  size -= 2;  // bypass

  const std::string original(reinterpret_cast<const char*>(data), size);

  auto input = std::string(original.c_str());  // until '\0'

  if (input.size() < kMinInputLength || input.size() > kMaxInputLength)

    return 0;

  flatbuffers::IDLOptions opts;

  opts.strict_json = (flags & flags_strict_json);

  opts.skip_unexpected_fields_in_json =

      (flags & flags_skip_unexpected_fields_in_json);

  opts.allow_non_utf8 = (flags & flags_allow_non_utf8);

  flatbuffers::Parser parser(opts);

  // Guarantee 0-termination in the input.

  auto parse_input = input.c_str();

  // Parse the input schema

  if (parser.Parse(parse_input)) {

    parser.Serialize();

    const uint8_t* buf = parser.builder_.GetBufferPointer();

    flatbuffers::Verifier verifier(buf, parser.builder_.GetSize());

    TEST_EQ(true, reflection::VerifySchemaBuffer(verifier));

    auto root = flatbuffers::GetRoot<flatbuffers::Table>(buf);

    if (verifier.VerifyTableStart(buf) && root->VerifyTableStart(verifier)) {

      if (parser.root_struct_def_) {

        std::string json_output;

        flatbuffers::GenText(parser, parser.builder_.GetBufferPointer(),

                             &json_output);

      }

    }

    std::string temp_filename = "fuzzer_generated";

    const std::string flatbuffers_version(flatbuffers::FLATBUFFERS_VERSION());

    std::vector<std::unique_ptr<flatbuffers::CodeGenerator>> generators;

    generators.emplace_back(flatbuffers::NewBinaryCodeGenerator());

    generators.emplace_back(flatbuffers::NewCppCodeGenerator());

    generators.emplace_back(flatbuffers::NewCSharpCodeGenerator());

    generators.emplace_back(flatbuffers::NewDartCodeGenerator());

    generators.emplace_back(flatbuffers::NewFBSCodeGenerator());

    generators.emplace_back(flatbuffers::NewGoCodeGenerator());

    generators.emplace_back(flatbuffers::NewJavaCodeGenerator());

    generators.emplace_back(flatbuffers::NewJsonSchemaCodeGenerator());

    generators.emplace_back(flatbuffers::NewKotlinCodeGenerator());

    generators.emplace_back(flatbuffers::NewKotlinKMPCodeGenerator());

    generators.emplace_back(flatbuffers::NewLobsterCodeGenerator());

    generators.emplace_back(

        flatbuffers::NewLuaBfbsGenerator(flatbuffers_version));

    generators.emplace_back(

        flatbuffers::NewNimBfbsGenerator(flatbuffers_version));

    generators.emplace_back(flatbuffers::NewPythonCodeGenerator());

    generators.emplace_back(flatbuffers::NewPhpCodeGenerator());

    generators.emplace_back(flatbuffers::NewRustCodeGenerator());

    generators.emplace_back(flatbuffers::NewTextCodeGenerator());

    generators.emplace_back(flatbuffers::NewSwiftCodeGenerator());

    generators.emplace_back(flatbuffers::NewTsCodeGenerator());

    for (auto& gen : generators) {

      auto p = gen.get();

      std::string temp_path = "/tmp/";

      auto status = p->GenerateCode(parser, temp_path, "fuzzer_generated");

      if (status != flatbuffers::CodeGenerator::Status::OK) {

        TEST_OUTPUT_LINE("GenerateCode failed %d", status);

      }

      // test gRPC code generation

      auto grpc_status =

          p->GenerateGrpcCode(parser, temp_path, "fuzzer_generated");

      if (grpc_status != flatbuffers::CodeGenerator::Status::OK) {

        TEST_OUTPUT_LINE("GenerateGrpcCode failed %d", grpc_status);

      }

    }

  }

  return 0;

}