/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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 <cassert>
#include <ctime>

#include <cctype>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <vector>

#include <stdexcept>
#include <sys/stat.h>

#include "thrift/generate/t_oop_generator.h"
#include "thrift/platform.h"

using std::map;
using std::ostream;
using std::ostringstream;
using std::set;
using std::setfill;
using std::setw;
using std::string;
using std::stringstream;
using std::vector;

static const string KOTLIN_RESERVED_WORDS[] = {
    "as",      "as?",      "break",    "class",   "continue",  "do",          "else",
    "false",   "for",      "fun",      "if",      "in",        "!in",         "interface",
    "is",      "!is",      "null",     "object",  "package",   "return",      "super",
    "this",    "throw",    "true",     "try",     "typealias", "typeof",      "val",
    "var",     "when",     "while",    "by",      "catch",     "constructor", "delegate",
    "dynamic", "field",    "file",     "finally", "get",       "import",      "init",
    "param",   "property", "receiver", "set",     "setparam",  "value",       "where",
};

const set<string> KOTLIN_RESERVED_WORDS_SET(KOTLIN_RESERVED_WORDS,
                                            KOTLIN_RESERVED_WORDS
                                                + sizeof(KOTLIN_RESERVED_WORDS)
                                                      / sizeof(KOTLIN_RESERVED_WORDS[0]));

/**
 * Kotlin code generator.
 */
class t_kotlin_generator : public t_oop_generator {
public:
  t_kotlin_generator(t_program* program,
                     const std::map<std::string, std::string>& /*parsed_options*/,
                     const std::string& /*option_string*/)
    : t_oop_generator(program) {}

  /**
   * Init and close methods
   */

  void init_generator() override;
  void close_generator() override;
  std::string display_name() const override;

  void generate_consts(std::vector<t_const*> consts) override;

  /**
   * Program-level generation functions
   */

  void generate_typedef(t_typedef* ttypedef) override;
  void generate_enum(t_enum* tenum) override;
  void generate_struct(t_struct* tstruct) override;
  // void generate_union(t_struct* tunion);
  void generate_xception(t_struct* txception) override;
  void generate_service(t_service* tservice) override;

private:
  std::string package_name_;
  std::string package_dir_;
  ofstream_with_content_based_conditional_update f_types_;

  std::string kotlin_package();
  std::string warning_surpressions();
  std::string constant_name(std::string name);
  std::string type_to_enum(t_type* type);
  std::string inner_enum_type_name(t_type* ttype);
  bool is_enum_set(t_type* ttype);
  bool is_enum_map(t_type* ttype);
  std::string type_name(t_type* ttype,
                        bool in_init = false,
                        bool skip_generic = false,
                        bool force_namespace = false);
  std::string base_type_name(t_base_type* tbase);
  std::string function_signature(t_function* tfunction, std::string prefix = "");

  std::string base_type_write_expression(t_base_type* tbase, std::string it = "it");
  std::string base_type_read_expression(t_base_type* tbase);

  bool is_reserved(const string& name);

  string kotlin_safe_name(const string& name);

  void generate_kdoc_comment(std::ostream& out, t_doc* tdoc);

  void generate_kotlin_struct(t_struct* tstruct, bool is_exception);

  void generate_service_interface(t_service* tservice);
  void generate_service_client(t_service* tservice);
  void generate_client_call(std::ostream& out, t_service* tservice, t_function* tfunc);
  void generate_service_processor(t_service* tservice);
  void generate_service_process_function(ostream& out, t_service* tservice, t_function* tfunc);

  void generate_service_args_helpers(t_service* tservice);
  void generate_service_result_helpers(t_service* tservice);

  void generate_union_definition(std::ostream& out,
                                 t_struct* tunion,
                                 std::string additional_interface = "");
  void generate_union_standard_scheme(std::ostream& out, t_struct* tunion);
  void generate_union_tuple_scheme(std::ostream& out, t_struct* tunion);
  void generate_union_standard_scheme_read(std::ostream& out, t_struct* tunion);
  void generate_union_standard_scheme_write(std::ostream& out, t_struct* tunion);
  void generate_union_methods_definitions(std::ostream& out, t_struct* tunion);
  void generate_union_method_check_type(std::ostream& out, t_struct* tunion);

  void generate_struct_definition(std::ostream& out,
                                  t_struct* tstruct,
                                  bool is_xception = false,
                                  std::string additional_interface = "");
  void generate_struct_field_name_constants(std::ostream& out, t_struct* tstruct);
  void generate_struct_companion_object(std::ostream& out, t_struct* tstruct);
  void generate_field_value_meta_data(std::ostream& out, t_type* ttype);
  void generate_metadata_for_field_annotations(std::ostream& out, t_field* tfield);
  void generate_struct_standard_scheme(std::ostream& out, t_struct* tstruct);
  void generate_struct_standard_scheme_read(std::ostream& out, t_struct* tstruct);
  void generate_struct_standard_scheme_write(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_deep_copy(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_compare_to(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_field_for_id(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_set_field_value(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_get_field_value(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_is_set(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_clear(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_validate(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_read(std::ostream& out, t_struct* tstruct);
  void generate_struct_method_write(std::ostream& out, t_struct* tstruct);

  void generate_serialize_value(ostream& out, t_type* ttype, std::string it = "it");
  void generate_serialize_field(ostream& out, t_field* tfield);
  void generate_serialize_container(ostream& out, t_type* ttype, std::string it = "it");

  void generate_deserialize_value(ostream& out, t_type* ttype);
  void generate_deserialize_field(ostream& out, t_field* tfield, string prefix);
  void generate_deserialize_container(ostream& out, t_type* ttype);

  void generate_kotlin_union(t_struct* tstruct);
};

/**
 * Prepares for file generation by opening up the necessary file output
 * streams.
 *
 * @param tprogram The program to generate
 */
void t_kotlin_generator::init_generator() {
  // Make output directory
  MKDIR(get_out_dir().c_str());
  package_name_ = program_->get_namespace("java");
  string dir = package_name_;
  string subdir = get_out_dir();
  string::size_type loc;
  while ((loc = dir.find(".")) != string::npos) {
    subdir = subdir + "/" + dir.substr(0, loc);
    MKDIR(subdir.c_str());
    dir = dir.substr(loc + 1);
  }
  if (dir.size() > 0) {
    subdir = subdir + "/" + dir;
    MKDIR(subdir.c_str());
  }

  package_dir_ = subdir;

  string f_types_name = package_dir_ + "/" + program_->get_name() + "Constants.kt";
  f_types_.open(f_types_name);
  f_types_ << autogen_comment() << kotlin_package();
}

/**
 * Nothing in Kotlin generator
 */
void t_kotlin_generator::close_generator() {
  f_types_ << '\n';
  f_types_.close();
}

/**
 * Generates a typedef. This is not done in Java, since it does
 * not support arbitrary name replacements, and it'd be a wacky waste
 * of overhead to make wrapper classes.
 *
 * @param ttypedef The type definition
 */
void t_kotlin_generator::generate_typedef(t_typedef* ttypedef) {
  f_types_ << "typealias " << ttypedef->get_symbolic() << " = "
           << type_name(ttypedef->get_type(), true) << '\n';
}

void t_kotlin_generator::generate_enum(t_enum* tenum) {
  // Make output file
  string f_enum_name = package_dir_ + "/" + (tenum->get_name()) + ".kt";
  ofstream_with_content_based_conditional_update f_enum;
  f_enum.open(f_enum_name.c_str());

  f_enum << autogen_comment() << kotlin_package();

  indent(f_enum) << "enum class " << kotlin_safe_name(tenum->get_name())
                 << "(private val value: kotlin.Int) : org.apache.thrift.TEnum {";
  indent_up();
  indent(f_enum);

  auto first = true;
  auto enum_values = tenum->get_constants();
  for (auto& enum_value : enum_values) {
    f_enum << (first ? "" : ",") << '\n';
    first = false;
    indent(f_enum) << enum_value->get_name() << "(" << enum_value->get_value() << ")";
  }
  if (first) {
    indent(f_enum);
  }
  f_enum << ";" << '\n' << '\n';
  indent(f_enum) << "override fun getValue() = value" << '\n' << '\n';
  {
    indent(f_enum) << "companion object {" << '\n';
    indent_up();
    {
      indent(f_enum) << "@kotlin.jvm.JvmStatic" << '\n';
      indent(f_enum) << "fun findByValue(i: kotlin.Int): " << kotlin_safe_name(tenum->get_name())
                     << "? {" << '\n';
      indent_up();
      {
        indent(f_enum) << "return when (i) {" << '\n';
        indent_up();
        {
          auto enum_values = tenum->get_constants();
          for (auto& enum_value : enum_values) {
            indent(f_enum) << enum_value->get_value() << " -> " << enum_value->get_name() << '\n';
          }
          indent(f_enum) << "else -> null" << '\n';
        }
        scope_down(f_enum);
      }
      scope_down(f_enum);
    }
    scope_down(f_enum);
  }
  scope_down(f_enum);
  f_enum.close();
}

void t_kotlin_generator::generate_consts(std::vector<t_const*> consts) {
  for (auto const_value : consts) {
    auto const_type = const_value->get_type();
    if (const_type->is_base_type()) {
      f_types_ << "const ";
    }
    f_types_ << "val " << kotlin_safe_name(const_value->get_name()) << ": " << type_name(const_type)
             << " = ";

    auto value = const_value->get_value();
    if (const_type->is_base_type()) {
      t_base_type::t_base tbase = ((t_base_type*)const_type)->get_base();
      switch (tbase) {
      case t_base_type::TYPE_STRING:
        f_types_ << "\"" << value->get_string() << "\"";
        break;
      case t_base_type::TYPE_BOOL:
        f_types_ << ((value->get_integer() > 0) ? "true" : "false");
        break;
      case t_base_type::TYPE_I8:
      case t_base_type::TYPE_I16:
      case t_base_type::TYPE_I32:
        f_types_ << value->get_integer();
        break;
      case t_base_type::TYPE_DOUBLE:
        if (value->get_type() == t_const_value::CV_INTEGER) {
          f_types_ << value->get_integer() << ".";
        } else {
          f_types_ << emit_double_as_string(value->get_double());
        }
        break;
      default:
        f_types_ << value->get_integer();
        break;
      }
    } else if (const_type->is_enum()) {
      auto namespace_prefix = const_type->get_program()->get_namespace("java");
      if (namespace_prefix.length() > 0) {
        namespace_prefix += ".";
      }
      f_types_ << namespace_prefix + value->get_identifier_with_parent();
    } else {
      // TODO
    }
    f_types_ << '\n';
  }
}

string t_kotlin_generator::base_type_name(t_base_type* type) {
  t_base_type::t_base tbase = type->get_base();

  switch (tbase) {
  case t_base_type::TYPE_VOID:
    return "kotlin.Unit";
  case t_base_type::TYPE_STRING:
    if (type->is_binary()) {
      return "kotlin.ByteArray";
    } else {
      return "kotlin.String";
    }
  case t_base_type::TYPE_BOOL:
    return "kotlin.Boolean";
  case t_base_type::TYPE_I8:
    return "kotlin.Byte";
  case t_base_type::TYPE_I16:
    return "kotlin.Short";
  case t_base_type::TYPE_I32:
    return "kotlin.Int";
  case t_base_type::TYPE_I64:
    return "kotlin.Long";
  case t_base_type::TYPE_UUID:
    return "java.util.UUID";
  case t_base_type::TYPE_DOUBLE:
    return "kotlin.Double";
  default:
    throw "compiler error: no Kotlin name for base type " + t_base_type::t_base_name(tbase);
  }
}

string t_kotlin_generator::type_name(t_type* ttype,
                                     bool in_init,
                                     bool skip_generic,
                                     bool force_namespace) {
  ttype = get_true_type(ttype);
  string prefix;
  if (ttype->is_base_type()) {
    return base_type_name((t_base_type*)ttype);
  } else if (ttype->is_map()) {
    t_map* tmap = (t_map*)ttype;
    if (in_init) {
      prefix = "kotlin.collections.Map";
    } else {
      prefix = "kotlin.collections.Map";
    }
    return prefix
           + (skip_generic ? ""
                           : "<" + type_name(tmap->get_key_type(), true) + ", "
                                 + type_name(tmap->get_val_type(), true) + ">");
  } else if (ttype->is_set()) {
    t_set* tset = (t_set*)ttype;
    if (in_init) {
      prefix = "kotlin.collections.Set";
    } else {
      prefix = "kotlin.collections.Set";
    }
    return prefix + (skip_generic ? "" : "<" + type_name(tset->get_elem_type(), true) + ">");
  } else if (ttype->is_list()) {
    t_list* tlist = (t_list*)ttype;
    if (in_init) {
      prefix = "kotlin.collections.List";
    } else {
      prefix = "kotlin.collections.List";
    }
    return prefix + (skip_generic ? "" : "<" + type_name(tlist->get_elem_type(), true) + ">");
  }

  // Check for namespacing
  t_program* program = ttype->get_program();
  if ((program != nullptr) && ((program != program_) || force_namespace)) {
    string package = program->get_namespace("java");
    if (!package.empty()) {
      return package + "." + kotlin_safe_name(ttype->get_name());
    }
  }

  return kotlin_safe_name(ttype->get_name());
}

/**
 * Generates a struct definition for a thrift data type. This will be a org.apache.thrift.TBase
 * implementor.
 *
 * @param tstruct The struct definition
 */
void t_kotlin_generator::generate_struct(t_struct* tstruct) {
  if (tstruct->is_union()) {
    generate_kotlin_union(tstruct);
  } else {
    generate_kotlin_struct(tstruct, false);
  }
}

void t_kotlin_generator::generate_kotlin_union(t_struct* tunion) {
  string f_union_name = package_dir_ + "/" + (tunion->get_name()) + ".kt";
  ofstream_with_content_based_conditional_update f_union;
  f_union.open(f_union_name.c_str());
  f_union << autogen_comment() << warning_surpressions() << kotlin_package();
  generate_union_definition(f_union, tunion);
  f_union.close();
}

void t_kotlin_generator::generate_kotlin_struct(t_struct* tstruct, bool is_exception) {
  string f_struct_name = package_dir_ + "/" + (tstruct->get_name()) + ".kt";
  ofstream_with_content_based_conditional_update f_struct;
  f_struct.open(f_struct_name.c_str());
  f_struct << autogen_comment() << warning_surpressions() << kotlin_package();
  generate_struct_definition(f_struct, tstruct, is_exception);
  f_struct.close();
}

void t_kotlin_generator::generate_struct_field_name_constants(std::ostream& out,
                                                              t_struct* tstruct) {
  indent(out) << "enum class _Fields(private val thriftFieldId: kotlin.Short, private val "
                 "fieldName: kotlin.String) : org.apache.thrift.TFieldIdEnum {"
              << '\n';
  indent_up();
  {
    // fields
    {
      bool first = true;
      for (auto& field : tstruct->get_members()) {
        if (!first) {
          out << "," << '\n';
        }
        first = false;
        indent(out) << constant_name(field->get_name()) << "(" << field->get_key() << ", \""
                    << field->get_name() << "\")";
      }
      if (first) {
        indent(out);
      }
      out << ";" << '\n' << '\n';
    }

    // methods
    indent(out) << "override fun getThriftFieldId() = thriftFieldId" << '\n' << '\n';
    indent(out) << "override fun getFieldName() = fieldName" << '\n' << '\n';

    // companion object
    indent(out) << "companion object {" << '\n';
    indent_up();
    {
      indent(out) << "@kotlin.jvm.JvmStatic" << '\n';
      indent(out) << "fun findByValue(value: kotlin.Int): _Fields? {" << '\n';
      indent_up();
      {
        indent(out) << "return when (value) {" << '\n';
        indent_up();
        {
          for (auto& field : tstruct->get_members()) {
            indent(out) << field->get_key() << " -> " << constant_name(field->get_name()) << '\n';
          }
          indent(out) << "else -> null" << '\n';
        }
        scope_down(out);
      }
      scope_down(out);
    }

    out << '\n';

    {
      indent(out) << "@kotlin.jvm.JvmStatic" << '\n';
      indent(out) << "fun findByName(name: kotlin.String): _Fields? {" << '\n';
      indent_up();
      {
        indent(out) << "return when (name) {" << '\n';
        indent_up();
        {
          for (auto& field : tstruct->get_members()) {
            indent(out) << "\"" << field->get_name() << "\""
                        << " -> " << constant_name(field->get_name()) << '\n';
          }
          indent(out) << "else -> null" << '\n';
        }
        scope_down(out);
      }
      scope_down(out);
    }

    scope_down(out);
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_companion_object(std::ostream& out, t_struct* tstruct) {
  indent(out) << "companion object {" << '\n';
  indent_up();
  {
    indent(out) << "private val STRUCT_DESC: org.apache.thrift.protocol.TStruct = "
                   "org.apache.thrift.protocol.TStruct(\""
                << tstruct->get_name() << "\")" << '\n';
    {
      for (auto& field : tstruct->get_members()) {
        // field desc
        indent(out) << "private val " << constant_name(field->get_name())
                    << "_FIELD_DESC: org.apache.thrift.protocol.TField = "
                       "org.apache.thrift.protocol.TField(\""
                    << field->get_name() << "\", " << type_to_enum(field->get_type()) << ", "
                    << field->get_key() << ")" << '\n';
        // field metadata
        indent(out) << "private val " << constant_name(field->get_name())
                    << "_FIELD_META_DATA: org.apache.thrift.meta_data.FieldMetaData = "
                       "org.apache.thrift.meta_data.FieldMetaData("
                    << '\n';
        indent_up();
        {
          indent(out) << '"' << field->get_name() << '"' << ',' << '\n';
          indent(out) << "org.apache.thrift.TFieldRequirementType.";
          if (field->get_req() == t_field::T_REQUIRED) {
            out << "REQUIRED";
          } else if (field->get_req() == t_field::T_OPTIONAL) {
            out << "OPTIONAL";
          } else {
            out << "DEFAULT";
          }
          out << ',' << '\n';
          generate_field_value_meta_data(indent(out), field->get_type());
          out << ',' << '\n';
          generate_metadata_for_field_annotations(indent(out), field);
        }
        out << ")" << '\n';
        indent_down();
      }
    }

    // all fields in a map
    indent(out)
        << "private val metadata: Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> = mapOf("
        << '\n';
    indent_up();
    for (auto& field : tstruct->get_members()) {
      indent(out) << "_Fields." << constant_name(field->get_name()) << " to "
                  << constant_name(field->get_name()) << "_FIELD_META_DATA," << '\n';
    }
    indent_down();
    indent(out) << ")" << '\n';

    indent(out) << "init {" << '\n';
    indent_up();
    indent(out) << "org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap("
                << tstruct->get_name() << "::class.java, metadata)" << '\n';
    scope_down(out);
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_metadata_for_field_annotations(std::ostream& out,
                                                                 t_field* field) {
  if (field->annotations_.size() == 0) {
    out << "emptyMap()";
  } else {
    out << "mapOf(" << '\n';
    indent_up();
    for (auto& annotation : field->annotations_) {
      indent(out) << "\"" + annotation.first + "\" to \"" + annotation.second.back() + "\"," << '\n';
    }
    indent_down();
    indent(out) << ")";
  }
}

void t_kotlin_generator::generate_field_value_meta_data(std::ostream& out, t_type* type) {
  static const string ttype_class = "org.apache.thrift.protocol.TType.";
  static const string meta_package = "org.apache.thrift.meta_data.";
  out << meta_package;
  if (type->is_struct() || type->is_xception()) {
    out << "StructMetaData(" << ttype_class << "STRUCT, " << type_name(type) << "::class.java";
  } else if (type->is_container()) {
    if (type->is_list()) {
      out << "ListMetaData(" << ttype_class << "LIST," << '\n';
      indent_up();
      t_type* elem_type = ((t_list*)type)->get_elem_type();
      generate_field_value_meta_data(indent(out), elem_type);
      indent_down();
    } else if (type->is_set()) {
      out << "SetMetaData(" << ttype_class << "SET," << '\n';
      indent_up();
      t_type* elem_type = ((t_set*)type)->get_elem_type();
      generate_field_value_meta_data(indent(out), elem_type);
      indent_down();
    } else {
      out << "MapMetaData(" << ttype_class << "MAP," << '\n';
      indent_up();
      t_type* key_type = ((t_map*)type)->get_key_type();
      t_type* val_type = ((t_map*)type)->get_val_type();
      generate_field_value_meta_data(indent(out), key_type);
      out << "," << '\n';
      generate_field_value_meta_data(indent(out), val_type);
      indent_down();
    }
  } else if (type->is_enum()) {
    out << "EnumMetaData(" << ttype_class << "ENUM, " << type_name(type) << "::class.java";
  } else {
    out << "FieldValueMetaData(" << type_to_enum(type);
    if (type->is_typedef()) {
      out << ", \"" << ((t_typedef*)type)->get_symbolic() << "\"";
    } else if (type->is_binary()) {
      out << ", true";
    }
  }
  out << ")";
}

void t_kotlin_generator::generate_struct_method_deep_copy(std::ostream& out, t_struct* tstruct) {
  indent(out) << "override fun deepCopy(): " << tstruct->get_name() << " {" << '\n';
  indent_up();
  {
    indent(out) << "return " << tstruct->get_name() << " (" << '\n';
    indent_up();
    {
      for (auto& field : tstruct->get_members()) {
        indent(out) << kotlin_safe_name(field->get_name()) << "," << '\n';
      }
    }
    indent_down();
    indent(out) << ")" << '\n';
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_compare_to(std::ostream& out, t_struct* tstruct) {
  indent(out) << "override fun compareTo(other: " << tstruct->get_name() << "?): kotlin.Int {"
              << '\n';
  indent_up();
  {
    indent(out) << "val comparator = compareBy<" << tstruct->get_name()
                << "> { it::class.java.name }" << '\n';
    indent_up();
    for (auto& field : tstruct->get_members()) {
      indent(out) << ".thenBy";
      auto field_type = field->get_type();
      if (field_type->is_list() || field_type->is_set() || field_type->is_map()
          || field_type->is_binary()) {
        out << "(org.apache.thrift.TBaseHelper::compareTo)";
      }
      out << " { it." << kotlin_safe_name(field->get_name()) << " } " << '\n';
    }
    indent_down();
    indent(out) << "return nullsFirst(comparator).compare(this, other)" << '\n';
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_field_for_id(std::ostream& out,
                                                             t_struct* /*tstruct*/) {
  indent(out) << "override fun fieldForId(fieldId: kotlin.Int): _Fields {" << '\n';
  indent_up();
  {
    indent(out) << "return _Fields.findByValue(fieldId) ?: throw "
                   "kotlin.IllegalArgumentException(\"invalid fieldId $fieldId\")"
                << '\n';
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_is_set(std::ostream& out, t_struct* tstruct) {
  indent(out) << "override fun isSet(field: _Fields): kotlin.Boolean {" << '\n';
  indent_up();
  {
    indent(out) << "return when (field) {" << '\n';
    indent_up();
    {
      auto members = tstruct->get_members();
      if (members.size() > 0) {
        for (auto& field : members) {
          indent(out) << "_Fields." << constant_name(field->get_name()) << " -> ";
          if (field->get_req() == t_field::T_REQUIRED) {
            out << "this._" << field->get_name() << " != null";
          } else {
            out << "this." << kotlin_safe_name(field->get_name()) << " != null";
          }
          out << '\n';
        }
      } else {
        indent(out) << "else -> false" << '\n';
      }
    }
    scope_down(out);
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_clear(std::ostream& out, t_struct* tstruct) {
  indent(out) << "override fun clear(): kotlin.Unit {" << '\n';
  indent_up();
  {
    for (auto& field : tstruct->get_members()) {
      auto is_required = field->get_req() == t_field::T_REQUIRED;
      indent(out) << (is_required ? "_" + field->get_name() : kotlin_safe_name(field->get_name()))
                  << " = null" << '\n';
    }
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_validate(std::ostream& out, t_struct* tstruct) {
  indent(out) << "@kotlin.jvm.Throws(org.apache.thrift.TException::class)" << '\n';
  indent(out) << "fun validate(): kotlin.Unit {" << '\n';
  indent_up();
  {
    for (auto& field : tstruct->get_members()) {
      bool is_required = field->get_req() == t_field::T_REQUIRED;
      if (is_required) {
        indent(out) << "if (_" << field->get_name() << " == null) {" << '\n';
        indent_up();
        {
          indent(out) << "throw org.apache.thrift.TException(\"Required field `"
                      << field->get_name()
                      << "' is null, "
                         "struct is: $this\")"
                      << '\n';
        }
        scope_down(out);
      }
    }
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_set_field_value(std::ostream& out,
                                                                t_struct* tstruct) {
  indent(out) << "@Suppress(\"UNCHECKED_CAST\")" << '\n';
  indent(out) << "override fun setFieldValue(field: _Fields, value: kotlin.Any?): kotlin.Unit {"
              << '\n';
  indent_up();
  {
    const vector<t_field*>& members = tstruct->get_members();
    if (members.size() > 0) {
      indent(out) << "when (field) {" << '\n';
      indent_up();
      {
        for (auto& field : tstruct->get_members()) {
          auto is_required = field->get_req() == t_field::T_REQUIRED;
          indent(out) << "_Fields." << constant_name(field->get_name()) << " -> this."
                      << (is_required ? "_" + field->get_name()
                                      : kotlin_safe_name(field->get_name()))
                      << " = value as " << type_name(field->get_type()) << "?" << '\n';
        }
      }
      scope_down(out);
    } else {
      indent(out) << "return" << '\n';
    }
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_get_field_value(std::ostream& out,
                                                                t_struct* tstruct) {
  indent(out) << "override fun getFieldValue(field: _Fields): kotlin.Any? {" << '\n';
  indent_up();
  {
    auto members = tstruct->get_members();
    if (members.size() > 0) {
      indent(out) << "return when (field) {" << '\n';
      indent_up();
      {
        for (auto& field : tstruct->get_members()) {
          indent(out) << "_Fields." << constant_name(field->get_name()) << " -> this."
                      << kotlin_safe_name(field->get_name()) << '\n';
        }
      }
      scope_down(out);
    } else {
      indent(out) << "return null" << '\n';
    }
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_method_read(std::ostream& out, t_struct* tstruct) {
  indent(out) << "override fun read(iproto: org.apache.thrift.protocol.TProtocol): kotlin.Unit {"
              << '\n';
  indent_up();
  {
    indent(out)
        << "require(org.apache.thrift.scheme.StandardScheme::class.java == iproto.scheme) { "
           "\"only standard scheme is "
           "supported for now\" }"
        << '\n';
    indent(out) << tstruct->get_name() << "StandardScheme.read(iproto, this)" << '\n';
  }
  scope_down(out);
  out << '\n';
}
void t_kotlin_generator::generate_struct_method_write(std::ostream& out, t_struct* tstruct) {
  indent(out) << "override fun write(oproto: org.apache.thrift.protocol.TProtocol): kotlin.Unit {"
              << '\n';
  indent_up();
  {
    indent(out)
        << "require(org.apache.thrift.scheme.StandardScheme::class.java == oproto.scheme) { "
           "\"only standard scheme is "
           "supported for now\" }"
        << '\n';
    indent(out) << tstruct->get_name() << "StandardScheme.write(oproto, this)" << '\n';
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_standard_scheme_read(std::ostream& out,
                                                              t_struct* tstruct) {
  indent(out) << "override fun read(iproto: org.apache.thrift.protocol.TProtocol, struct: "
              << tstruct->get_name() << ") {" << '\n';
  indent_up();
  {
    indent(out) << "iproto.apply {" << '\n';
    indent_up();
    {
      indent(out) << "readStruct {" << '\n';
      indent_up();
      {
        indent(out) << "var stopped = false" << '\n';
        indent(out) << "while (!stopped) {" << '\n';
        indent_up();
        {
          indent(out) << "stopped = readField {" << '\n';
          indent_up();
          {
            indent(out) << "val skipNext = { "
                           "org.apache.thrift.protocol.TProtocolUtil.skip(iproto, it.type) }"
                        << '\n';

            indent(out) << "when (it.id.toInt()) {" << '\n';
            indent_up();
            {
              for (auto& field : tstruct->get_members()) {
                indent(out) << field->get_key() << " -> {" << '\n';
                indent_up();
                {
                  indent(out) << "if (it.type == " << type_to_enum(field->get_type()) << ") {"
                              << '\n';
                  indent_up();
                  generate_deserialize_field(out, field, "struct.");
                  indent_down();
                  indent(out) << "} else {" << '\n';
                  indent_up();
                  indent(out) << "skipNext()" << '\n';
                  indent_down();
                  indent(out) << "}" << '\n';
                }
                scope_down(out);
              }
              indent(out) << "else -> skipNext()" << '\n';
            }
            scope_down(out);
          }
          scope_down(out);
        }
        scope_down(out);
        indent(out) << "struct.validate()" << '\n';
      }
      scope_down(out);
    }
    scope_down(out);
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_standard_scheme_write(std::ostream& out,
                                                               t_struct* tstruct) {
  indent(out) << "override fun write(oproto: org.apache.thrift.protocol.TProtocol, struct: "
              << tstruct->get_name() << ") {" << '\n';
  indent_up();
  {
    indent(out) << "struct.validate()" << '\n';
    indent(out) << "oproto.apply {" << '\n';
    indent_up();
    {
      indent(out) << "writeStruct(STRUCT_DESC) {" << '\n';
      indent_up();
      {
        for (auto& field : tstruct->get_members()) {
          auto is_required = field->get_req() == t_field::T_REQUIRED;
          indent(out) << "struct." << kotlin_safe_name(field->get_name())
                      << (is_required ? "" : "?") << ".let { "
                      << kotlin_safe_name(field->get_name()) << " ->" << '\n';
          indent_up();
          {
            indent(out) << "writeField(" << constant_name(field->get_name()) << "_FIELD_DESC) {"
                        << '\n';
            indent_up();
            generate_serialize_field(out, field);
            scope_down(out);
          }
          scope_down(out);
        }
      }
      indent(out) << "writeFieldStop()" << '\n';
      scope_down(out);
    }
    scope_down(out);
  }
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_struct_standard_scheme(std::ostream& out, t_struct* tstruct) {
  indent(out) << "private object " << tstruct->get_name()
              << "StandardScheme : org.apache.thrift.scheme.StandardScheme<" << tstruct->get_name()
              << ">() {" << '\n';
  indent_up();
  generate_struct_standard_scheme_read(out, tstruct);
  generate_struct_standard_scheme_write(out, tstruct);
  scope_down(out);
  out << '\n';
}

void t_kotlin_generator::generate_union_tuple_scheme(std::ostream& out, t_struct* /*tunion*/) {
  indent(out) << "override fun tupleSchemeReadValue(iproto: org.apache.thrift.protocol.TProtocol, "
                 "fieldID: kotlin.Short) = throw kotlin.UnsupportedOperationException(\"only "
                 "standard scheme is supported for now\")"
              << '\n';
  indent(out)
      << "override fun tupleSchemeWriteValue(oproto: org.apache.thrift.protocol.TProtocol) = "
         "throw kotlin.UnsupportedOperationException(\"only standard scheme is supported for "
         "now\")"
      << '\n';
}

void t_kotlin_generator::generate_union_standard_scheme(std::ostream& out, t_struct* tunion) {
  generate_union_standard_scheme_read(out, tunion);
  generate_union_standard_scheme_write(out, tunion);
}

void t_kotlin_generator::generate_union_standard_scheme_read(std::ostream& out, t_struct* tunion) {
  indent(out)
      << "override fun standardSchemeReadValue(iproto: org.apache.thrift.protocol.TProtocol, "
         "field: org.apache.thrift.protocol.TField): Any? ="
      << '\n';
  indent_up();
  indent(out) << "when (_Fields.findByValue(field.id.toInt())) {" << '\n';
  indent_up();
  for (auto& member : tunion->get_members()) {
    auto expect_type = type_name(member->get_type());
    indent(out) << "_Fields." << constant_name(member->get_name()) << " -> {" << '\n';
    indent_up();
    {
      indent(out) << "if (field.type == " << constant_name(member->get_name())
                  << "_FIELD_DESC.type) {" << '\n';
      indent_up();
      indent(out) << "iproto.run {" << '\n';
      indent_up();
      indent(out);
      generate_deserialize_value(out, member->get_type());
      out << '\n';
      scope_down(out);
      indent_down();
      indent(out) << "} else {" << '\n';
      indent_up();
      indent(out) << "org.apache.thrift.protocol.TProtocolUtil.skip(iproto, field.type)" << '\n';
      indent(out) << "null" << '\n';
      scope_down(out);
    }
    scope_down(out);
  }
  indent(out) << "null -> {" << '\n';
  indent_up();
  indent(out) << "org.apache.thrift.protocol.TProtocolUtil.skip(iproto, field.type)" << '\n';
  indent(out) << "null" << '\n';
  scope_down(out);
  scope_down(out);
  indent_down();
}

void t_kotlin_generator::generate_union_standard_scheme_write(std::ostream& out, t_struct* tunion) {
  indent(out) << "@Suppress(\"UNCHECKED_CAST\")" << '\n';
  indent(out)
      << "override fun standardSchemeWriteValue(oproto: org.apache.thrift.protocol.TProtocol) {"
      << '\n';
  indent_up();
  indent(out) << "when (setField_) {" << '\n';
  indent_up();
  for (auto& member : tunion->get_members()) {
    indent(out) << "_Fields." << constant_name(member->get_name()) << " -> {" << '\n';
    indent_up();
    {
      indent(out) << "val it = value_ as " << type_name(member->get_type()) << '\n';
      indent(out) << "oproto.apply {" << '\n';
      indent_up();
      {
        indent(out);
        generate_serialize_value(out, member->get_type());
        out << '\n';
      }
      scope_down(out);
    }
    scope_down(out);
  }
  indent(out) << "null -> throw kotlin.IllegalStateException(\"Cannot write union with unknown "
                 "field $setField_\")"
              << '\n';
  scope_down(out);
  scope_down(out);
}
void t_kotlin_generator::generate_union_methods_definitions(std::ostream& out, t_struct* tunion) {
  {
    // this is a hack to reuse code
    t_struct union_fields(program_, tunion->get_name());
    t_enum enum_type(program_);
    enum_type.set_name("setField_");
    t_field set_field(&enum_type, "setField_", 0);
    t_base_type value_type("value_", t_base_type::TYPE_STRING);
    value_type.set_binary(true);
    t_field value(&value_type, "value_", 1);
    union_fields.append(&set_field);
    union_fields.append(&value);
    generate_struct_method_compare_to(out, &union_fields);
  }

  auto union_class_name = kotlin_safe_name(tunion->get_name());
  { indent(out) << "override fun deepCopy() = " << union_class_name << "(this)" << '\n'; }
  { indent(out) << "override fun enumForId(id: kotlin.Short) = fieldForId(id.toInt())" << '\n'; }
  { indent(out) << "override fun getStructDesc() = STRUCT_DESC" << '\n'; }
  {
    indent(out) << "override fun getFieldDesc(setField: _Fields) = when (setField) {" << '\n';
    indent_up();
    for (auto& member : tunion->get_members()) {
      indent(out) << "_Fields." << constant_name(member->get_name()) << " -> "
                  << constant_name(member->get_name()) << "_FIELD_DESC" << '\n';
    }
    scope_down(out);
  }
}

void t_kotlin_generator::generate_union_method_check_type(std::ostream& out, t_struct* tunion) {
  indent(out) << "@Suppress(\"UNCHECKED_CAST\")" << '\n';
  indent(out) << "override fun checkType(setField: _Fields, value: kotlin.Any?) {" << '\n';
  indent_up();
  indent(out) << "when (setField) {" << '\n';
  indent_up();
  for (auto& member : tunion->get_members()) {
    auto expect_type = type_name(member->get_type());
    indent(out) << "_Fields." << constant_name(member->get_name()) << " -> value as? "
                << expect_type
                << " ?: throw kotlin.ClassCastException(\"Was expecting value of type `"
                << expect_type << "' for field `" << member->get_name()
                << "', but got ${value?.javaClass}\")" << '\n';
  }
  scope_down(out);
  scope_down(out);
}

void t_kotlin_generator::generate_union_definition(std::ostream& out,
                                                   t_struct* tunion,
                                                   string /*additional interface*/) {
  auto union_class_name = kotlin_safe_name(tunion->get_name());
  indent(out) << "class " << union_class_name << " : org.apache.thrift.TUnion<" << union_class_name
              << ", " << union_class_name << "._Fields> {" << '\n';
  indent_up();
  indent(out) << "constructor(setField: _Fields, value: kotlin.Any) : super(setField, value)"
              << '\n';
  indent(out) << "constructor(other: " << union_class_name << ") : super(other)" << '\n';
  indent(out) << "constructor() : super()" << '\n';

  generate_struct_field_name_constants(out, tunion);
  generate_struct_companion_object(out, tunion);
  generate_struct_method_field_for_id(out, tunion);
  generate_union_methods_definitions(out, tunion);
  generate_union_method_check_type(out, tunion);
  generate_union_standard_scheme(out, tunion);
  generate_union_tuple_scheme(out, tunion);
  indent_down();
  indent(out) << "}" << '\n';
}

void t_kotlin_generator::generate_struct_definition(std::ostream& out,
                                                    t_struct* tstruct,
                                                    bool is_exception,
                                                    string additional_interface) {
  generate_kdoc_comment(out, tstruct);
  auto members = tstruct->get_members();
  if (members.size() > 0) {
    indent(out) << "data class ";
  } else {
    indent(out) << "class ";
  }
  out << kotlin_safe_name(tstruct->get_name()) << "(";

  indent_up();
  auto sep = "";
  for (auto field : members) {
    out << sep << '\n';
    sep = ",";
    generate_kdoc_comment(out, field);
    auto is_required = field->get_req() == t_field::T_REQUIRED;
    if (is_required) {
      indent(out) << "private var _" << field->get_name();
    } else if (is_exception && field->get_name() == "message") {
      // special handling for exception when field name is message - needs override
      if (!field->get_type()->is_string()) {
        throw "type error: for `message' field in an exception struct, it must be a string";
      }
      indent(out) << "override var message";
    } else {
      indent(out) << "var " << kotlin_safe_name(field->get_name());
    }
    out << ": " << type_name(field->get_type()) << "? = null";
  }
  indent_down();
  out << '\n';
  indent(out) << ") : ";
  if (is_exception) {
    out << "org.apache.thrift.TException(), ";
  }
  if (additional_interface != "") {
    additional_interface = ", " + additional_interface;
  }
  out << "org.apache.thrift.TBase<" << tstruct->get_name() << ", " << tstruct->get_name()
      << "._Fields>" << additional_interface << " {" << '\n';

  indent_up();

  for (auto field : members) {
    if (field->get_req() == t_field::T_REQUIRED) {
      indent(out);
      // special handling for exception when field name is message - needs override
      if (is_exception && field->get_name() == "message") {
        out << "override ";
      }
      out << "val " << kotlin_safe_name(field->get_name()) << ": " << type_name(field->get_type())
          << " get() = _" + kotlin_safe_name(field->get_name()) << "!!" << '\n';
    }
  }

  generate_struct_field_name_constants(out, tstruct);
  generate_struct_companion_object(out, tstruct);
  generate_struct_standard_scheme(out, tstruct);
  generate_struct_method_compare_to(out, tstruct);
  generate_struct_method_field_for_id(out, tstruct);
  generate_struct_method_get_field_value(out, tstruct);
  generate_struct_method_set_field_value(out, tstruct);
  generate_struct_method_is_set(out, tstruct);
  generate_struct_method_deep_copy(out, tstruct);
  generate_struct_method_clear(out, tstruct);
  generate_struct_method_validate(out, tstruct);
  generate_struct_method_read(out, tstruct);
  generate_struct_method_write(out, tstruct);

  indent_down();
  indent(out) << "}" << '\n';
}

string t_kotlin_generator::base_type_write_expression(t_base_type* tbase, string it) {
  switch (tbase->get_base()) {
  case t_base_type::TYPE_VOID:
    throw "compiler error: no void in base types";
  case t_base_type::TYPE_STRING:
    if (tbase->is_binary()) {
      return "writeBinary(java.nio.ByteBuffer.wrap(" + it + "))";
    } else {
      return "writeString(" + it + ")";
    }
  case t_base_type::TYPE_BOOL:
    return "writeBool(" + it + ")";
  case t_base_type::TYPE_I8:
    return "writeByte(" + it + ")";
  case t_base_type::TYPE_I16:
    return "writeI16(" + it + ")";
  case t_base_type::TYPE_I32:
    return "writeI32(" + it + ")";
  case t_base_type::TYPE_I64:
    return "writeI64(" + it + ")";
  case t_base_type::TYPE_UUID:
    return "writeUuid(" + it + ")";
  case t_base_type::TYPE_DOUBLE:
    return "writeDouble(" + it + ")";
  default:
    throw "compiler error: no Kotlin name for base type "
        + t_base_type::t_base_name(tbase->get_base());
  }
}

string t_kotlin_generator::base_type_read_expression(t_base_type* tbase) {
  switch (tbase->get_base()) {
  case t_base_type::TYPE_VOID:
    throw "compiler error: no void in base types";
  case t_base_type::TYPE_STRING:
    if (tbase->is_binary()) {
      return "org.apache.thrift.TBaseHelper.byteBufferToByteArray(readBinary())";
    } else {
      return "readString()";
    }
  case t_base_type::TYPE_BOOL:
    return "readBool()";
  case t_base_type::TYPE_I8:
    return "readByte()";
  case t_base_type::TYPE_I16:
    return "readI16()";
  case t_base_type::TYPE_I32:
    return "readI32()";
  case t_base_type::TYPE_I64:
    return "readI64()";
  case t_base_type::TYPE_UUID:
    return "readUuid()";
  case t_base_type::TYPE_DOUBLE:
    return "readDouble()";
  default:
    throw "compiler error: no Kotlin name for base type "
        + t_base_type::t_base_name(tbase->get_base());
  }
}

void t_kotlin_generator::generate_serialize_value(ostream& out, t_type* type, string it) {
  t_type* ttype = get_true_type(type);
  if (ttype->is_struct() || ttype->is_xception()) {
    out << it << ".write(this)";
  } else if (ttype->is_container()) {
    generate_serialize_container(out, ttype, it);
  } else if (ttype->is_base_type()) {
    out << base_type_write_expression((t_base_type*)ttype, it);
  } else if (ttype->is_enum()) {
    out << "writeI32(" << it << ".value)";
  } else {
    printf("cannot deserialize type '%s'\n", type_name(ttype).c_str());
  }
}

void t_kotlin_generator::generate_deserialize_value(ostream& out, t_type* type) {
  t_type* ttype = get_true_type(type);
  if (ttype->is_struct() || ttype->is_xception()) {
    out << type_name(ttype) << "().apply { read(iproto) }";
  } else if (ttype->is_container()) {
    generate_deserialize_container(out, ttype);
  } else if (ttype->is_base_type()) {
    out << base_type_read_expression((t_base_type*)ttype);
  } else if (ttype->is_enum()) {
    out << "requireNotNull(" << type_name(ttype, false, false, true) + ".findByValue(readI32()))";
  } else {
    printf("cannot deserialize type '%s'\n", type_name(ttype).c_str());
  }
}

/**
 * Serializes a field of any type.
 *
 * @param tfield The field
 */
void t_kotlin_generator::generate_serialize_field(ostream& out, t_field* tfield) {
  t_type* type = get_true_type(tfield->get_type());
  if (type->is_void()) {
    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + tfield->get_name();
  }
  indent(out);
  generate_serialize_value(out, type, kotlin_safe_name(tfield->get_name()));
  out << '\n';
}

/**
 * Deserializes a field of any type.
 *
 * @param tfield The field
 * @param prefix The variable name or container for this field
 */
void t_kotlin_generator::generate_deserialize_field(ostream& out, t_field* tfield, string prefix) {
  t_type* type = get_true_type(tfield->get_type());
  if (type->is_void()) {
    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name();
  }
  auto is_required = tfield->get_req() == t_field::T_REQUIRED;
  string name
      = prefix + (is_required ? "_" + tfield->get_name() : kotlin_safe_name(tfield->get_name()));
  indent(out) << name << " = ";
  generate_deserialize_value(out, type);
  out << '\n';
}

/**
 * Serializes a container by writing its size and then iterating
 */
void t_kotlin_generator::generate_serialize_container(ostream& out, t_type* ttype, string it) {
  if (ttype->is_map()) {
    out << "writeMap(" << type_to_enum(((t_map*)ttype)->get_key_type()) << ", "
        << type_to_enum(((t_map*)ttype)->get_val_type()) << ", " << it << ") { (key, value) ->"
        << '\n';
    indent_up();
    {
      generate_serialize_value(indent(out), ((t_map*)ttype)->get_key_type(), "key");
      out << '\n';
      generate_serialize_value(indent(out), ((t_map*)ttype)->get_val_type(), "value");
      out << '\n';
      indent_down();
    }
    indent(out) << "}";
  } else if (ttype->is_set()) {
    out << "writeSet(" << type_to_enum(((t_set*)ttype)->get_elem_type()) << ", " << it << ") {"
        << '\n';
    indent_up();
    {
      generate_serialize_value(indent(out), ((t_set*)ttype)->get_elem_type());
      out << '\n';
      indent_down();
    }
    indent(out) << "}";
  } else if (ttype->is_list()) {
    out << "writeList(" << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", " << it << ") {"
        << '\n';
    {
      indent_up();
      generate_serialize_value(indent(out), ((t_list*)ttype)->get_elem_type());
      out << '\n';
      indent_down();
    }
    indent(out) << "}";
  } else {
    throw "not a container type: " + ttype->get_name();
  }
}

/**
 * Deserializes a container by reading its size and then iterating
 */
void t_kotlin_generator::generate_deserialize_container(ostream& out, t_type* ttype) {
  if (ttype->is_map()) {
    out << "readMap { tmap ->" << '\n';
    indent_up();
    indent(out) << "kotlin.collections.List(tmap.size) {" << '\n';
    indent_up();
    indent(out);
    generate_deserialize_value(out, ((t_map*)ttype)->get_key_type());
    out << " to ";
    generate_deserialize_value(out, ((t_map*)ttype)->get_val_type());
    out << '\n';
    indent_down();
    indent(out) << "}.associate { it }" << '\n';
    indent_down();
    indent(out) << "}";
  } else if (ttype->is_set()) {
    out << "readSet { tset ->" << '\n';
    indent_up();
    indent(out) << "kotlin.collections.List(tset.size) {" << '\n';
    indent_up();
    indent(out);
    generate_deserialize_value(out, ((t_set*)ttype)->get_elem_type());
    out << '\n';
    indent_down();
    indent(out) << "}.toSet()" << '\n';
    indent_down();
    indent(out) << "}";
  } else if (ttype->is_list()) {
    out << "readList { tlist ->" << '\n';
    indent_up();
    indent(out) << "kotlin.collections.List(tlist.size) {" << '\n';
    indent_up();
    indent(out);
    generate_deserialize_value(out, ((t_list*)ttype)->get_elem_type());
    out << '\n';
    indent_down();
    indent(out) << "}" << '\n';
    indent_down();
    indent(out) << "}";
  } else {
    throw "not a container type: " + ttype->get_name();
  }
}

string t_kotlin_generator::function_signature(t_function* tfunction, string prefix) {
  auto result = "suspend fun " + prefix + tfunction->get_name() + "(";
  auto arguments = tfunction->get_arglist();
  bool first = true;
  for (t_field* tfield : arguments->get_members()) {
    if (first) {
      first = false;
    } else {
      result += ", ";
    }
    result += tfield->get_name() + ": " + type_name(tfield->get_type());
  }
  result += "): ";
  result += type_name(tfunction->get_returntype());
  return result;
}

void t_kotlin_generator::generate_service_interface(t_service* tservice) {
  string f_service_name = package_dir_ + "/" + tservice->get_name() + ".kt";
  ofstream_with_content_based_conditional_update out;
  out.open(f_service_name.c_str());
  out << autogen_comment() << kotlin_package();
  out << "interface " << tservice->get_name() << " {" << '\n';
  indent_up();
  for (auto tfunc : tservice->get_functions()) {
    generate_kdoc_comment(out, tfunc);
    indent(out) << function_signature(tfunc) << '\n';
  }
  scope_down(out);
  out << '\n' << '\n';
  out.close();
}

void t_kotlin_generator::generate_service_client(t_service* tservice) {
  string f_service_name = package_dir_ + "/" + tservice->get_name() + "Client.kt";
  ofstream_with_content_based_conditional_update out;
  out.open(f_service_name.c_str());
  out << autogen_comment() << warning_surpressions() << kotlin_package();
  generate_docstring_comment(out, "/**\n", " * ",
                             "client implementation for [" + tservice->get_name() + "]", " */\n");
  indent(out) << "class " << tservice->get_name() << "Client(" << '\n';
  indent_up();
  indent(out) << "protocolFactory: org.apache.thrift.protocol.TProtocolFactory," << '\n';
  indent(out) << "clientManager: org.apache.thrift.async.TAsyncClientManager," << '\n';
  indent(out) << "transport: org.apache.thrift.transport.TNonblockingTransport" << '\n';
  indent_down();
  out << "): org.apache.thrift.async.TAsyncClient(protocolFactory, clientManager, transport), "
      << tservice->get_name() << " {" << '\n'
      << '\n';

  indent_up();
  {
    indent(out) << "private val seqId = java.util.concurrent.atomic.AtomicInteger()" << '\n'
                << '\n';
    for (auto tfunc : tservice->get_functions()) {
      indent(out) << "override " << function_signature(tfunc) << " {" << '\n';
      indent_up();
      {
        string args_name = tservice->get_name() + "FunctionArgs." + tfunc->get_name() + "_args";
        indent(out) << "val args = " << args_name << "(";
        auto first = true;
        for (auto tfield : tfunc->get_arglist()->get_members()) {
          if (!first) {
            out << ", ";
          }
          first = false;
          out << tfield->get_name();
        }
        out << ")" << '\n';
        indent(out) << "return transformCallback {" << '\n';
        indent_up();
        {
          indent(out) << "checkReady()" << '\n';
          indent(out)
              << "___currentMethod = ProcessCall." << tfunc->get_name()
              << "Call(args, seqId.getAndIncrement(), this, ___protocolFactory, ___transport, it)"
              << '\n';
          indent(out) << "___manager.call(___currentMethod)" << '\n';
        }
        scope_down(out);
      }
      scope_down(out);
    }

    indent(out) << "private suspend fun <R> "
                   "org.apache.thrift.async.TAsyncClient.transformCallback(action: "
                   "(org.apache.thrift.async.AsyncMethodCallback<R>) -> Unit): R {"
                << '\n';
    indent_up();
    indent(out) << "val deferred = kotlinx.coroutines.CompletableDeferred<R>()" << '\n';
    indent(out) << "val callback = object : org.apache.thrift.async.AsyncMethodCallback<R> {"
                << '\n';
    indent_up();
    indent(out) << "override fun onComplete(response: R) { deferred.complete(response) }" << '\n';
    indent(out) << "override fun onError(exception: java.lang.Exception) { "
                   "deferred.completeExceptionally(exception) }"
                << '\n';
    scope_down(out);
    indent(out) << "action(callback)" << '\n';
    indent(out) << "return deferred.await()" << '\n';
    scope_down(out);

    indent(out) << "sealed interface ProcessCall {" << '\n';
    indent_up();
    for (auto tfunc : tservice->get_functions()) {
      generate_client_call(out, tservice, tfunc);
    }
    scope_down(out);
  }
  scope_down(out);
  out << '\n' << '\n';
  out.close();
}

void t_kotlin_generator::generate_client_call(std::ostream& out,
                                              t_service* tservice,
                                              t_function* tfunc) {
  string funname = tfunc->get_name();
  string funclassname = funname + "Call";
  string rtype = type_name(tfunc->get_returntype(), true);

  indent(out) << "class " + funclassname + "(" << '\n';
  indent_up();
  string args_name = tservice->get_name() + "FunctionArgs." + tfunc->get_name() + "_args";
  indent(out) << "val args: " << args_name << "," << '\n';
  indent(out) << "val seqId: kotlin.Int," << '\n';
  indent(out) << "client: org.apache.thrift.async.TAsyncClient," << '\n';
  indent(out) << "protocolFactory: org.apache.thrift.protocol.TProtocolFactory," << '\n';
  indent(out) << "transport: org.apache.thrift.transport.TNonblockingTransport," << '\n';
  indent(out) << "resultHandler: org.apache.thrift.async.AsyncMethodCallback<" << rtype << ">,"
              << '\n';
  indent_down();
  indent(out) << ") : org.apache.thrift.async.TAsyncMethodCall<" << rtype
              << ">(client, protocolFactory, transport, resultHandler, "
              << (tfunc->is_oneway() ? "true" : "false") << "), ProcessCall {" << '\n';

  indent_up();
  indent(out) << "override fun write_args(protocol: org.apache.thrift.protocol.TProtocol) {"
              << '\n';
  indent_up();
  indent(out) << "val marker = org.apache.thrift.protocol.TMessage(\"" << tfunc->get_name()
              << "\", org.apache.thrift.protocol.TMessageType.CALL, seqId)" << '\n';
  indent(out) << "protocol.writeMessage(marker) { args.write(protocol) }" << '\n';
  scope_down(out);

  indent(out) << "override fun getResult(): " << rtype << " {" << '\n';
  indent_up();
  indent(out) << "check(state == org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { "
                 "\"Method call not finished!\" }"
              << '\n';
  indent(out) << "val memoryTransport = "
                 "org.apache.thrift.transport.TMemoryInputTransport(frameBuffer.array())"
              << '\n';
  indent(out) << "val protocol = client.protocolFactory.getProtocol(memoryTransport)" << '\n';

  if (tfunc->is_oneway()) {
    indent(out) << "// one way function, nothing to read" << '\n';
  } else {
    indent(out) << "return protocol.readMessage {" << '\n';
    indent_up();
    {
      indent(out) << "if (it.type == org.apache.thrift.protocol.TMessageType.EXCEPTION) {" << '\n';
      indent_up();
      indent(out) << "val ex = org.apache.thrift.TApplicationException().apply { read(protocol) }"
                  << '\n';
      indent(out) << "throw ex" << '\n';
      scope_down(out);
      indent(out) << "if (it.seqid != seqId) {" << '\n';
      indent_up();
      indent(out) << "throw org.apache.thrift.TApplicationException(" << '\n';
      indent_up();
      indent(out) << "org.apache.thrift.TApplicationException.BAD_SEQUENCE_ID," << '\n';
      indent(out) << "\"" << funname
                  << " failed: out of sequence response: expected $seqId but got ${it.seqid}\""
                  << '\n';
      indent_down();
      indent(out) << ")" << '\n';
      scope_down(out);
      string result_name = tservice->get_name() + "FunctionResult." + tfunc->get_name() + "_result";
      indent(out) << "val result = " << result_name << "().apply { read(protocol) }" << '\n';
      for (auto xception : tfunc->get_xceptions()->get_members()) {
        indent(out) << "result." << xception->get_name() << "?.let { throw it }" << '\n';
      }
      if (!tfunc->get_returntype()->is_void()) {
        indent(out)
            << "result.success ?: throw "
               "org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException."
               "MISSING_RESULT, \"returnString failed: unknown result\")"
            << '\n';
      }
    }
    scope_down(out);
  }
  scope_down(out);
  scope_down(out);
}

void t_kotlin_generator::generate_service_processor(t_service* tservice) {
  string f_service_name = package_dir_ + "/" + tservice->get_name() + "Processor.kt";
  ofstream_with_content_based_conditional_update out;
  out.open(f_service_name.c_str());
  out << autogen_comment() << warning_surpressions() << kotlin_package();
  auto service_imports = {"import kotlinx.coroutines.future.future"};
  for (auto service_import : service_imports) {
    out << service_import << '\n';
  }
  out << '\n';

  generate_docstring_comment(out, "/**\n", " * ",
                             "server implementation for [" + tservice->get_name() + "]", " */\n");
  indent(out) << "class " << tservice->get_name() << "Processor(" << '\n';
  indent_up();
  indent(out) << "handler: " << tservice->get_name() << "," << '\n';
  indent(out) << "private val scope: kotlinx.coroutines.CoroutineScope," << '\n';
  indent(out) << "private val processMap: kotlin.collections.Map<kotlin.String, "
                 "org.apache.thrift.AsyncProcessFunction<"
              << tservice->get_name()
              << ", out org.apache.thrift.TBase<*, "
                 "*>, out kotlin.Any, out org.apache.thrift.TBase<*, *>>> = mapOf("
              << '\n';
  indent_up();
  {
    for (auto tfunc : tservice->get_functions()) {
      indent(out) << '"' << tfunc->get_name() << '"' << " to ProcessFunction." << tfunc->get_name()
                  << "(scope)," << '\n';
    }
  }
  indent_down();
  indent(out) << ")" << '\n';
  indent_down();
  out << "): org.apache.thrift.TBaseAsyncProcessor<" << tservice->get_name()
      << ">(handler, processMap) {" << '\n';
  indent_up();
  indent(out) << "companion object {" << '\n';
  indent_up();
  indent(out) << "internal val logger: org.slf4j.Logger = "
                 "org.slf4j.LoggerFactory.getLogger("
              << tservice->get_name() << "Processor::class.java)" << '\n';
  scope_down(out);

  indent(out) << "sealed interface ProcessFunction {" << '\n';
  indent_up();

  {
    for (auto tfunc : tservice->get_functions()) {
      generate_service_process_function(out, tservice, tfunc);
    }
  }
  scope_down(out);
  scope_down(out);
  out << '\n' << '\n';
  out.close();
}

void t_kotlin_generator::generate_service_process_function(ostream& out,
                                                           t_service* tservice,
                                                           t_function* tfunc) {
  string args_name = tservice->get_name() + "FunctionArgs." + tfunc->get_name() + "_args";
  string rtype = type_name(tfunc->get_returntype(), true);
  string resultname = tservice->get_name() + "FunctionResult." + tfunc->get_name() + "_result";

  indent(out) << "class " << tfunc->get_name() << "<I : " << tservice->get_name()
              << ">(private val scope: kotlinx.coroutines.CoroutineScope) : "
                 "org.apache.thrift.AsyncProcessFunction<I, "
              << args_name << ", " << rtype << ", "
              << (tfunc->is_oneway() ? "org.apache.thrift.TBase<*, *>" : resultname)
              << ">(\"" << tfunc->get_name() << "\"), ProcessFunction {"
              << '\n';
  indent_up();
  {
    indent(out) << "override fun isOneway() = " << (tfunc->is_oneway() ? "true" : "false") << '\n';
    indent(out) << "override fun getEmptyArgsInstance() = " << args_name << "()" << '\n';
    indent(out) << "override fun getEmptyResultInstance() = ";
    if (tfunc->is_oneway()) {
      out << "null" << '\n';
    }
    else {
      out << resultname << "()" << '\n';
    }
    indent(out) << '\n';
    indent(out) << "override fun start(iface: I, args: " << args_name
                << ", resultHandler: org.apache.thrift.async.AsyncMethodCallback<" << rtype
                << ">) {" << '\n';
    indent_up();
    indent(out) << "scope.future {" << '\n';
    indent_up();
    indent(out) << "iface." << tfunc->get_name() << "(";
    {
      auto arguments = tfunc->get_arglist();
      bool first = true;
      for (t_field* tfield : arguments->get_members()) {
        if (first) {
          first = false;
        } else {
          out << ", ";
        }
        out << "args." << tfield->get_name() << "!!";
      }
    }
    out << ")" << '\n';
    indent_down();
    indent(out) << "}.whenComplete { r, t ->" << '\n';
    {
      indent_up();
      indent(out) << "if (t != null) {" << '\n';
      indent_up();
      indent(out) << "resultHandler.onError(t as java.lang.Exception)" << '\n';
      indent_down();
      indent(out) << "} else {" << '\n';
      indent_up();
      indent(out) << "resultHandler.onComplete(r)" << '\n';
    }
    scope_down(out);
    scope_down(out);
    scope_down(out);

    indent(out) << "override fun getResultHandler(fb: "
                   "org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer, seqid: "
                   "Int) ="
                << '\n';
    indent_up();
    {
      indent(out) << "object : org.apache.thrift.async.AsyncMethodCallback<" << rtype << ">{"
                  << '\n';
      indent_up();
      {
        indent(out) << "override fun onComplete(response: " << rtype << ") {" << '\n';
        indent_up();
        if (tfunc->is_oneway()) {
          indent(out) << "// one way function, no result handling" << '\n';
        } else {
          string result_name
              = tservice->get_name() + "FunctionResult." + tfunc->get_name() + "_result";
          indent(out) << "val result = " << result_name << "()" << '\n';
          if (!tfunc->get_returntype()->is_void()) {
            indent(out) << "result.success = response" << '\n';
          }
          indent(out) << "try {" << '\n';
          indent_up();
          indent(out)
              << "sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid)"
              << '\n';
          indent_down();
          indent(out) << "} catch (e: org.apache.thrift.transport.TTransportException) {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"TTransportException writing to internal frame buffer\", e)"
                      << '\n';
          indent(out) << "fb.close()" << '\n';
          indent_down();
          indent(out) << "} catch (e: Exception) {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"Exception writing to internal frame buffer\", e)" << '\n';
          indent(out) << "onError(e)" << '\n';
          scope_down(out);
        }
        scope_down(out);
      }
      {
        indent(out) << "override fun onError(exception: kotlin.Exception) {" << '\n';
        indent_up();
        if (tfunc->is_oneway()) {
          indent(out) << "if (exception is org.apache.thrift.transport.TTransportException) {"
                      << '\n';
          indent_up();
          indent(out) << "logger.error(\"TTransportException inside handler\", exception)" << '\n';
          indent(out) << "fb.close()" << '\n';
          indent_down();
          indent(out) << "} else {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"Exception inside oneway handler\", exception)" << '\n';
          scope_down(out);
        } else {
          indent(out) << "val (msgType, msg) = when (exception) {" << '\n';
          indent_up();

          auto xceptions = tfunc->get_xceptions()->get_members();
          for (auto xception : xceptions) {
            indent(out) << "is " << type_name(xception->get_type()) << " -> {" << '\n';
            indent_up();
            string result_name
                = tservice->get_name() + "FunctionResult." + tfunc->get_name() + "_result";
            indent(out) << "val result = " << result_name << "()" << '\n';
            indent(out) << "result." << xception->get_name() << " = exception" << '\n';
            indent(out) << "org.apache.thrift.protocol.TMessageType.REPLY to result" << '\n';
            scope_down(out);
          }

          indent(out) << "is org.apache.thrift.transport.TTransportException -> {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"TTransportException inside handler\", exception)" << '\n';
          indent(out) << "fb.close()" << '\n';
          indent(out) << "return" << '\n';
          scope_down(out);

          indent(out) << "is org.apache.thrift.TApplicationException -> {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"TApplicationException inside handler\", exception)"
                      << '\n';
          indent(out) << "org.apache.thrift.protocol.TMessageType.EXCEPTION to exception" << '\n';
          scope_down(out);

          indent(out) << "else -> {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"Exception inside handler\", exception)" << '\n';
          indent(out) << "org.apache.thrift.protocol.TMessageType.EXCEPTION to "
                         "org.apache.thrift.TApplicationException(org.apache.thrift."
                         "TApplicationException.INTERNAL_ERROR, exception.message)"
                      << '\n';
          scope_down(out);
          scope_down(out);

          indent(out) << "try {" << '\n';
          indent_up();
          indent(out) << "sendResponse(fb, msg, msgType, seqid)" << '\n';
          indent_down();
          indent(out) << "} catch (ex: java.lang.Exception) {" << '\n';
          indent_up();
          indent(out) << "logger.error(\"Exception writing to internal frame buffer\", ex)" << '\n';
          indent(out) << "fb.close()" << '\n';
          scope_down(out);
        }

        scope_down(out);
      }
      scope_down(out);
    }
    indent_down();
  }
  scope_down(out);
}

void t_kotlin_generator::generate_service_result_helpers(t_service* tservice) {
  string f_service_result_name = package_dir_ + "/" + tservice->get_name() + "FunctionResult.kt";
  ofstream_with_content_based_conditional_update out;
  out.open(f_service_result_name.c_str());
  out << autogen_comment() << warning_surpressions() << kotlin_package();

  generate_docstring_comment(out, "/**\n", " * ",
                             "function result for [" + tservice->get_name() + "]", " */\n");
  indent(out) << "sealed interface " << tservice->get_name() << "FunctionResult {" << '\n';
  indent_up();
  for (auto func : tservice->get_functions()) {
    if (func->is_oneway()) {
      continue;
    }
    t_struct result(program_, func->get_name() + "_result");
    t_field success(func->get_returntype(), "success", 0);
    if (!func->get_returntype()->is_void()) {
      result.append(&success);
    }
    for (auto& member : func->get_xceptions()->get_members()) {
      result.append(member);
    }
    generate_struct_definition(out, &result, false, tservice->get_name() + "FunctionResult");
  }
  scope_down(out);
  out.close();
}

void t_kotlin_generator::generate_service_args_helpers(t_service* tservice) {
  string f_service_args_name = package_dir_ + "/" + tservice->get_name() + "FunctionArgs.kt";
  ofstream_with_content_based_conditional_update out;
  out.open(f_service_args_name.c_str());
  out << autogen_comment() << warning_surpressions() << kotlin_package();
  generate_docstring_comment(out, "/**\n", " * ",
                             "function arguments for [" + tservice->get_name() + "]", " */\n");
  indent(out) << "sealed interface " << tservice->get_name() << "FunctionArgs {" << '\n';
  indent_up();
  for (auto func : tservice->get_functions()) {
    t_struct* ts = func->get_arglist();
    generate_struct_definition(out, ts, false, tservice->get_name() + "FunctionArgs");
    out << '\n';
  }
  scope_down(out);
  out.close();
}

void t_kotlin_generator::generate_service(t_service* tservice) {
  generate_service_interface(tservice);
  generate_service_client(tservice);
  generate_service_processor(tservice);
  generate_service_args_helpers(tservice);
  generate_service_result_helpers(tservice);
}

void t_kotlin_generator::generate_xception(t_struct* txception) {
  generate_kotlin_struct(txception, true);
}

/**
 * Converts the parse type to a Java enum string for the given type.
 */
string t_kotlin_generator::type_to_enum(t_type* type) {
  type = get_true_type(type);

  if (type->is_base_type()) {
    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
    switch (tbase) {
    case t_base_type::TYPE_VOID:
      throw "NO T_VOID CONSTRUCT";
    case t_base_type::TYPE_STRING:
      return "org.apache.thrift.protocol.TType.STRING";
    case t_base_type::TYPE_BOOL:
      return "org.apache.thrift.protocol.TType.BOOL";
    case t_base_type::TYPE_I8:
      return "org.apache.thrift.protocol.TType.BYTE";
    case t_base_type::TYPE_I16:
      return "org.apache.thrift.protocol.TType.I16";
    case t_base_type::TYPE_I32:
      return "org.apache.thrift.protocol.TType.I32";
    case t_base_type::TYPE_I64:
      return "org.apache.thrift.protocol.TType.I64";
    case t_base_type::TYPE_UUID:
      return "org.apache.thrift.protocol.TType.UUID";
    case t_base_type::TYPE_DOUBLE:
      return "org.apache.thrift.protocol.TType.DOUBLE";
    default:
      throw "compiler error: unhandled type";
    }
  } else if (type->is_enum()) {
    return "org.apache.thrift.protocol.TType.I32";
  } else if (type->is_struct() || type->is_xception()) {
    return "org.apache.thrift.protocol.TType.STRUCT";
  } else if (type->is_map()) {
    return "org.apache.thrift.protocol.TType.MAP";
  } else if (type->is_set()) {
    return "org.apache.thrift.protocol.TType.SET";
  } else if (type->is_list()) {
    return "org.apache.thrift.protocol.TType.LIST";
  }

  throw "INVALID TYPE IN type_to_enum: " + type->get_name();
}

string t_kotlin_generator::inner_enum_type_name(t_type* ttype) {
  ttype = get_true_type(ttype);
  if (ttype->is_map()) {
    t_map* tmap = (t_map*)ttype;
    t_type* key_type = get_true_type(tmap->get_key_type());
    return type_name(key_type, true) + ".class";
  } else if (ttype->is_set()) {
    t_set* tset = (t_set*)ttype;
    t_type* elem_type = get_true_type(tset->get_elem_type());
    return type_name(elem_type, true) + ".class";
  }
  return "";
}

bool t_kotlin_generator::is_enum_set(t_type* ttype) {
  ttype = get_true_type(ttype);
  if (ttype->is_set()) {
    t_set* tset = (t_set*)ttype;
    t_type* elem_type = get_true_type(tset->get_elem_type());
    return elem_type->is_enum();
  }
  return false;
}

bool t_kotlin_generator::is_enum_map(t_type* ttype) {
  ttype = get_true_type(ttype);
  if (ttype->is_map()) {
    t_map* tmap = (t_map*)ttype;
    t_type* key_type = get_true_type(tmap->get_key_type());
    return key_type->is_enum();
  }
  return false;
}

/**
 * Packages the generated file
 *
 * @return String of the package, i.e. "package org.apache.thriftdemo"
 */
string t_kotlin_generator::kotlin_package() {
  if (!package_name_.empty()) {
    return string("package ") + package_name_ + "\n" + "\n";
  }
  return "";
}

string t_kotlin_generator::warning_surpressions() {
  return "@file:Suppress(\"ClassName\", \"PropertyName\", \"RedundantUnitReturnType\", "
         "\"NestedLambdaShadowedImplicitParameter\", "
         "\"RemoveRedundantQualifierName\")\n";
}

string t_kotlin_generator::constant_name(string name) {
  string constant_name;
  bool is_first = true;
  bool was_previous_char_upper = false;
  for (char character : name) {
    bool is_upper = isupper(character);
    if (is_upper && !is_first && !was_previous_char_upper) {
      constant_name += '_';
    }
    constant_name += toupper(character);
    is_first = false;
    was_previous_char_upper = is_upper;
  }
  return constant_name;
}

bool t_kotlin_generator::is_reserved(const string& name) {
  return KOTLIN_RESERVED_WORDS_SET.find(name) != KOTLIN_RESERVED_WORDS_SET.end();
}

string t_kotlin_generator::kotlin_safe_name(const string& name) {
  if (is_reserved(name)) {
    return "`" + name + "`";
  } else {
    return name;
  }
}

void t_kotlin_generator::generate_kdoc_comment(ostream& out, t_doc* tdoc) {
  if (tdoc->has_doc()) {
    generate_docstring_comment(out, "/**\n", " * ", tdoc->get_doc(), " */\n");
  }
}

std::string t_kotlin_generator::display_name() const {
  return "Kotlin";
}


THRIFT_REGISTER_GENERATOR(kotlin, "Kotlin", "")