/*
 * 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.
 *
 * Contains some contributions under the Thrift Software License.
 * Please see doc/old-thrift-license.txt in the Thrift distribution for
 * details.
 */

#include <cassert>

#include <fstream>
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <vector>

#include <sys/stat.h>

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

using std::map;
using std::ofstream;
using std::ostream;
using std::ostringstream;
using std::set;
using std::string;
using std::vector;

/**
 * D code generator.
 *
 * generate_*() functions are called by the base class to emit code for the
 * given entity, print_*() functions write a piece of code to the passed
 * stream, and render_*() return a string containing the D representation of
 * the passed entity.
 */
class t_d_generator : public t_oop_generator {
public:
  t_d_generator(t_program* program,
                const std::map<string, string>& parsed_options,
                const string& option_string)
    : t_oop_generator(program) {
    (void)option_string;
    std::map<std::string, std::string>::const_iterator iter;

    /* no options yet */
    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
      throw "unknown option d:" + iter->first;
    }

    out_dir_base_ = "gen-d";
  }
  std::string display_name() const override;

protected:

  // D reserved words are suffixed with an underscore
  static string suffix_if_reserved(const string& name) {
    const bool isIn = std::binary_search(std::begin(d_reserved_words), std::end(d_reserved_words), name);
    string ret = isIn ? name + "_" : name;
    return ret;
  }

  void init_generator() override {
    // Make output directory
    MKDIR(get_out_dir().c_str());

    string dir = program_->get_namespace("d");
    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.empty()) {
      subdir = subdir + "/" + dir;
      MKDIR(subdir.c_str());
    }

    package_dir_ = subdir + "/";

    // Make output file
    string f_types_name = package_dir_ + program_name_ + "_types.d";
    f_types_.open(f_types_name.c_str());

    // Print header
    f_types_ << autogen_comment() << "module " << render_package(*program_) << program_name_
             << "_types;" << '\n' << '\n';

    print_default_imports(f_types_);

    // Include type modules from other imported programs.
    const vector<t_program*>& includes = program_->get_includes();
    for (auto include : includes) {
      f_types_ << "public import " << render_package(*include) << include->get_name()
               << "_types;" << '\n';
    }
    if (!includes.empty())
      f_types_ << '\n';
  }

  void close_generator() override {
    // Close output file
    f_types_.close();
  }

  void generate_consts(std::vector<t_const*> consts) override {
    if (!consts.empty()) {
      string f_consts_name = package_dir_ + program_name_ + "_constants.d";
      ofstream_with_content_based_conditional_update f_consts;
      f_consts.open(f_consts_name.c_str());

      f_consts << autogen_comment() << "module " << render_package(*program_) << program_name_
               << "_constants;" << '\n' << '\n';

      print_default_imports(f_consts);

      f_consts << "import " << render_package(*get_program()) << program_name_ << "_types;" << '\n'
               << '\n';

      vector<t_const*>::iterator c_iter;
      for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
        this->emit_doc(*c_iter, f_consts);
        string name = suffix_if_reserved((*c_iter)->get_name());
        t_type* type = (*c_iter)->get_type();
        indent(f_consts) << "immutable(" << render_type_name(type) << ") " << name << ";" << '\n';
      }

      f_consts << '\n' << "shared static this() {" << '\n';
      indent_up();

      bool first = true;
      for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
        if (first) {
          first = false;
        } else {
          f_consts << '\n';
        }
        t_type* type = (*c_iter)->get_type();
        indent(f_consts) << suffix_if_reserved((*c_iter)->get_name()) << " = ";
        if (!is_immutable_type(type)) {
          f_consts << "cast(immutable(" << render_type_name(type) << ")) ";
        }
        f_consts << render_const_value(type, (*c_iter)->get_value()) << ";" << '\n';
      }
      indent_down();
      indent(f_consts) << "}" << '\n';
    }
  }

  void generate_typedef(t_typedef* ttypedef) override {
    this->emit_doc(ttypedef, f_types_);
    f_types_ << indent() << "alias " << render_type_name(ttypedef->get_type()) << " "
             << ttypedef->get_symbolic() << ";" << '\n' << '\n';
  }

  void generate_enum(t_enum* tenum) override {
    vector<t_enum_value*> constants = tenum->get_constants();

    this->emit_doc(tenum, f_types_);
    string enum_name = suffix_if_reserved(tenum->get_name());
    f_types_ << indent() << "enum " << enum_name << " {" << '\n';

    indent_up();

    vector<t_enum_value*>::const_iterator c_iter;
    for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
      this->emit_doc(*c_iter, f_types_);
      indent(f_types_) << suffix_if_reserved((*c_iter)->get_name());
      f_types_ << " = " << (*c_iter)->get_value() << ",";
    }

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

    f_types_ << '\n';
  }

  void generate_struct(t_struct* tstruct) override {
    print_struct_definition(f_types_, tstruct, false);
  }

  void generate_xception(t_struct* txception) override {
    print_struct_definition(f_types_, txception, true);
  }

  void generate_service(t_service* tservice) override {
    string svc_name = suffix_if_reserved(tservice->get_name());

    // Service implementation file includes
    string f_servicename = package_dir_ + svc_name + ".d";
    ofstream_with_content_based_conditional_update f_service;
    f_service.open(f_servicename.c_str());
    f_service << autogen_comment() << "module " << suffix_if_reserved(render_package(*program_)) << svc_name << ";"
              << '\n' << '\n';

    print_default_imports(f_service);

    f_service << "import " << suffix_if_reserved(render_package(*get_program())) << program_name_ << "_types;" << '\n';

    t_service* extends_service = tservice->get_extends();
    if (extends_service != nullptr) {
      f_service << "import " << suffix_if_reserved(render_package(*(extends_service->get_program())))
                << suffix_if_reserved(extends_service->get_name()) << ";" << '\n';
    }

    f_service << '\n';

    string extends = "";
    if (tservice->get_extends() != nullptr) {
      extends = " : " + suffix_if_reserved(render_type_name(tservice->get_extends()));
    }

    this->emit_doc(tservice, f_service);
    f_service << indent() << "interface " << svc_name << extends << " {" << '\n';
    indent_up();

    // Collect all the exception types service methods can throw so we can
    // emit the necessary aliases later.
    set<t_type*> exception_types;

    // Print the method signatures.
    vector<t_function*> functions = tservice->get_functions();
    vector<t_function*>::iterator fn_iter;
    for (fn_iter = functions.begin(); fn_iter != functions.end(); ++fn_iter) {
      this->emit_doc(*fn_iter, f_service);
      f_service << indent();
      print_function_signature(f_service, *fn_iter);
      f_service << ";" << '\n';

      const vector<t_field*>& exceptions = (*fn_iter)->get_xceptions()->get_members();
      vector<t_field*>::const_iterator ex_iter;
      for (ex_iter = exceptions.begin(); ex_iter != exceptions.end(); ++ex_iter) {
        exception_types.insert((*ex_iter)->get_type());
      }
    }

    // Alias the exception types into the current scope.
    if (!exception_types.empty())
      f_service << '\n';
    set<t_type*>::const_iterator et_iter;
    for (et_iter = exception_types.begin(); et_iter != exception_types.end(); ++et_iter) {
      indent(f_service) << "alias " << render_package(*(*et_iter)->get_program())
                        << (*et_iter)->get_program()->get_name() << "_types"
                        << "." << (*et_iter)->get_name() << " " << (*et_iter)->get_name() << ";"
                        << '\n';
    }

    // Write the method metadata.
    ostringstream meta;
    indent_up();
    bool first = true;
    for (fn_iter = functions.begin(); fn_iter != functions.end(); ++fn_iter) {
      if ((*fn_iter)->get_arglist()->get_members().empty()
          && (*fn_iter)->get_xceptions()->get_members().empty() && !(*fn_iter)->is_oneway()) {
        continue;
      }

      if (first) {
        first = false;
      } else {
        meta << ",";
      }

      meta << '\n' << indent() << "TMethodMeta(`" << suffix_if_reserved((*fn_iter)->get_name()) << "`, " << '\n';
      indent_up();
      indent(meta) << "[";

      bool first = true;
      const vector<t_field*>& params = (*fn_iter)->get_arglist()->get_members();
      vector<t_field*>::const_iterator p_iter;
      for (p_iter = params.begin(); p_iter != params.end(); ++p_iter) {
        if (first) {
          first = false;
        } else {
          meta << ", ";
        }

        meta << "TParamMeta(`" << suffix_if_reserved((*p_iter)->get_name()) << "`, " << (*p_iter)->get_key();

        t_const_value* cv = (*p_iter)->get_value();
        if (cv != nullptr) {
          meta << ", q{" << render_const_value((*p_iter)->get_type(), cv) << "}";
        }
        meta << ")";
      }

      meta << "]";

      if (!(*fn_iter)->get_xceptions()->get_members().empty() || (*fn_iter)->is_oneway()) {
        meta << "," << '\n' << indent() << "[";

        bool first = true;
        const vector<t_field*>& exceptions = (*fn_iter)->get_xceptions()->get_members();
        vector<t_field*>::const_iterator ex_iter;
        for (ex_iter = exceptions.begin(); ex_iter != exceptions.end(); ++ex_iter) {
          if (first) {
            first = false;
          } else {
            meta << ", ";
          }

          meta << "TExceptionMeta(`" << suffix_if_reserved((*ex_iter)->get_name()) << "`, "
               << (*ex_iter)->get_key() << ", `" << (*ex_iter)->get_type()->get_name() << "`)";
        }

        meta << "]";
      }

      if ((*fn_iter)->is_oneway()) {
        meta << "," << '\n' << indent() << "TMethodType.ONEWAY";
      }

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

    string meta_str(meta.str());
    if (!meta_str.empty()) {
      f_service << '\n' << indent() << "enum methodMeta = [" << meta_str << '\n' << indent() << "];"
                << '\n';
    }

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

    // Server skeleton generation.
    string f_skeletonname = package_dir_ + svc_name + "_server.skeleton.d";
    ofstream_with_content_based_conditional_update f_skeleton;
    f_skeleton.open(f_skeletonname.c_str());
    print_server_skeleton(f_skeleton, tservice);
    f_skeleton.close();
  }

  void emit_doc(t_doc *doc, std::ostream& out) {
    if (!doc->has_doc()) {
      return;
    }
    indent(out) << "/**" << '\n';
    indent_up();
    // No line break -- comments reliably have a newline at the end.
    // This is true even for stuff like:
    //     /** method infos */ void foo(/** huh?*/ 1: i64 stuff)
    indent(out) << doc->get_doc();
    indent_down();
    indent(out) << "*/" << '\n';
  }

private:
  /**
   * Writes a server skeleton for the passed service to out.
   */

  void print_server_skeleton(ostream& out, t_service* tservice) {
    string svc_name = suffix_if_reserved(tservice->get_name());

    out << "/*" << '\n'
        << " * This auto-generated skeleton file illustrates how to build a server. If you" << '\n'
        << " * intend to customize it, you should edit a copy with another file name to " << '\n'
        << " * avoid overwriting it when running the generator again." << '\n' << " */" << '\n'
        << "module " << render_package(*tservice->get_program()) << svc_name << "_server;" << '\n'
        << '\n' << "import std.stdio;" << '\n' << "import thrift.codegen.processor;" << '\n'
        << "import thrift.protocol.binary;" << '\n' << "import thrift.server.simple;" << '\n'
        << "import thrift.server.transport.socket;" << '\n' << "import thrift.transport.buffered;"
        << '\n' << "import thrift.util.hashset;" << '\n' << '\n' << "import "
        << render_package(*tservice->get_program()) << svc_name << ";" << '\n' << "import "
        << render_package(*get_program()) << program_name_ << "_types;" << '\n' << '\n' << '\n'
        << "class " << svc_name << "Handler : " << svc_name << " {" << '\n';

    indent_up();
    out << indent() << "this() {" << '\n' << indent() << "  // Your initialization goes here."
        << '\n' << indent() << "}" << '\n' << '\n';

    vector<t_function*> functions = tservice->get_functions();
    vector<t_function*>::iterator f_iter;
    for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
      out << indent();
      print_function_signature(out, *f_iter);
      out << " {" << '\n';

      indent_up();

      out << indent() << "// Your implementation goes here." << '\n' << indent() << "writeln(\""
          << suffix_if_reserved((*f_iter)->get_name()) << " called\");" << '\n';

      t_type* rt = (*f_iter)->get_returntype();
      if (!rt->is_void()) {
        indent(out) << "return typeof(return).init;" << '\n';
      }

      indent_down();

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

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

    out << indent() << "void main() {" << '\n';
    indent_up();
    out << indent() << "auto protocolFactory = new TBinaryProtocolFactory!();" << '\n' << indent()
        << "auto processor = new TServiceProcessor!" << svc_name << "(new " << svc_name
        << "Handler);" << '\n' << indent() << "auto serverTransport = new TServerSocket(9090);"
        << '\n' << indent() << "auto transportFactory = new TBufferedTransportFactory;" << '\n'
        << indent() << "auto server = new TSimpleServer(" << '\n' << indent()
        << "  processor, serverTransport, transportFactory, protocolFactory);" << '\n' << indent()
        << "server.serve();" << '\n';
    indent_down();
    out << "}" << '\n';
  }

  /**
   * Writes the definition of a struct or an exception type to out.
   */

  void print_struct_definition(ostream& out, t_struct* tstruct, bool is_exception) {
    const vector<t_field*>& members = tstruct->get_members();

    if (is_exception) {
      indent(out) << "class " << suffix_if_reserved(tstruct->get_name()) << " : TException {" << '\n';
    } else {
      indent(out) << "struct " << suffix_if_reserved(tstruct->get_name()) << " {" << '\n';
    }
    indent_up();

    // Declare all fields.
    vector<t_field*>::const_iterator m_iter;
    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
      indent(out) << render_type_name((*m_iter)->get_type()) << " " << suffix_if_reserved((*m_iter)->get_name()) << ";"
                  << '\n';
    }

    if (!members.empty())
      indent(out) << '\n';
    indent(out) << "mixin TStructHelpers!(";

    if (!members.empty()) {
      // If there are any fields, construct the TFieldMeta array to pass to
      // TStructHelpers. We can't just pass an empty array if not because []
      // doesn't pass the TFieldMeta[] constraint.
      out << "[";
      indent_up();

      bool first = true;
      vector<t_field*>::const_iterator m_iter;
      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
        if (first) {
          first = false;
        } else {
          out << ",";
        }
        out << '\n';

        indent(out) << "TFieldMeta(`" << suffix_if_reserved((*m_iter)->get_name()) << "`, " << (*m_iter)->get_key();

        t_const_value* cv = (*m_iter)->get_value();
        t_field::e_req req = (*m_iter)->get_req();
        out << ", " << render_req(req);
        if (cv != nullptr) {
          out << ", q{" << render_const_value((*m_iter)->get_type(), cv) << "}";
        }
        out << ")";
      }

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

    out << ");" << '\n';

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

  /**
   * Prints the D function signature (including return type) for the given
   * method.
   */

  void print_function_signature(ostream& out, t_function* fn) {
    out << render_type_name(fn->get_returntype()) << " " << suffix_if_reserved(fn->get_name()) << "(";

    const vector<t_field*>& fields = fn->get_arglist()->get_members();
    vector<t_field*>::const_iterator f_iter;
    bool first = true;
    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
      if (first) {
        first = false;
      } else {
        out << ", ";
      }
      out << render_type_name((*f_iter)->get_type(), true) << " " << suffix_if_reserved((*f_iter)->get_name());
    }

    out << ")";
  }

  /**
   * Returns the D representation of value. The result is guaranteed to be a
   * single expression; for complex types, immediately called delegate
   * literals are used to achieve this.
   */
  string render_const_value(t_type* type, t_const_value* value) {
    // Resolve any typedefs.
    type = get_true_type(type);

    ostringstream out;
    if (type->is_base_type()) {
      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
      switch (tbase) {
      case t_base_type::TYPE_STRING:
        out << '"' << get_escaped_string(value) << '"';
        break;
      case t_base_type::TYPE_BOOL:
        out << ((value->get_integer() > 0) ? "true" : "false");
        break;
      case t_base_type::TYPE_I8:
      case t_base_type::TYPE_I16:
        out << "cast(" << render_type_name(type) << ")" << value->get_integer();
        break;
      case t_base_type::TYPE_I32:
        out << value->get_integer();
        break;
      case t_base_type::TYPE_I64:
        out << value->get_integer() << "L";
        break;
      case t_base_type::TYPE_DOUBLE:
        if (value->get_type() == t_const_value::CV_INTEGER) {
          out << value->get_integer();
        } else {
          out << value->get_double();
        }
        break;
      default:
        throw "Compiler error: No const of base type " + t_base_type::t_base_name(tbase);
      }
    } else if (type->is_enum()) {
      out << "cast(" << render_type_name(type) << ")" << value->get_integer();
    } else {
      out << "{" << '\n';
      indent_up();

      indent(out) << render_type_name(type) << " v;" << '\n';
      if (type->is_struct() || type->is_xception()) {
        indent(out) << "v = " << (type->is_xception() ? "new " : "") << render_type_name(type)
                    << "();" << '\n';

        const vector<t_field*>& fields = ((t_struct*)type)->get_members();
        vector<t_field*>::const_iterator f_iter;
        const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
        map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
        for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
          t_type* field_type = nullptr;
          for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
            if ((*f_iter)->get_name() == v_iter->first->get_string()) {
              field_type = (*f_iter)->get_type();
            }
          }
          if (field_type == nullptr) {
            throw "Type error: " + type->get_name() + " has no field "
                + v_iter->first->get_string();
          }
          string val = render_const_value(field_type, v_iter->second);
          indent(out) << "v.set!`" << v_iter->first->get_string() << "`(" << val << ");" << '\n';
        }
      } else if (type->is_map()) {
        t_type* ktype = ((t_map*)type)->get_key_type();
        t_type* vtype = ((t_map*)type)->get_val_type();
        const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
        map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
        for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
          string key = render_const_value(ktype, v_iter->first);
          string val = render_const_value(vtype, v_iter->second);
          indent(out) << "v[";
          if (!is_immutable_type(ktype)) {
            out << "cast(immutable(" << render_type_name(ktype) << "))";
          }
          out << key << "] = " << val << ";" << '\n';
        }
      } else if (type->is_list()) {
        t_type* etype = ((t_list*)type)->get_elem_type();
        const vector<t_const_value*>& val = value->get_list();
        vector<t_const_value*>::const_iterator v_iter;
        for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
          string val = render_const_value(etype, *v_iter);
          indent(out) << "v ~= " << val << ";" << '\n';
        }
      } else if (type->is_set()) {
        t_type* etype = ((t_set*)type)->get_elem_type();
        const vector<t_const_value*>& val = value->get_list();
        vector<t_const_value*>::const_iterator v_iter;
        for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
          string val = render_const_value(etype, *v_iter);
          indent(out) << "v ~= " << val << ";" << '\n';
        }
      } else {
        throw "Compiler error: Invalid type in render_const_value: " + type->get_name();
      }
      indent(out) << "return v;" << '\n';

      indent_down();
      indent(out) << "}()";
    }

    return out.str();
  }

  /**
   * Returns the D package to which modules for program are written (with a
   * trailing dot, if not empty).
   */
  string render_package(const t_program& program) const {
    string package = program.get_namespace("d");
    if (package.size() == 0)
      return "";
    return package + ".";
  }

  /**
   * Returns the name of the D repesentation of ttype.
   *
   * If isArg is true, a const reference to the type will be returned for
   * structs.
   */
  string render_type_name(const t_type* ttype, bool isArg = false) const {
    if (ttype->is_base_type()) {
      t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
      switch (tbase) {
      case t_base_type::TYPE_VOID:
        return "void";
      case t_base_type::TYPE_STRING:
        return "string";
      case t_base_type::TYPE_BOOL:
        return "bool";
      case t_base_type::TYPE_I8:
        return "byte";
      case t_base_type::TYPE_I16:
        return "short";
      case t_base_type::TYPE_I32:
        return "int";
      case t_base_type::TYPE_I64:
        return "long";
      case t_base_type::TYPE_DOUBLE:
        return "double";
      default:
        throw "Compiler error: No D type name for base type " + t_base_type::t_base_name(tbase);
      }
    }

    if (ttype->is_container()) {
      t_container* tcontainer = (t_container*)ttype;
      if (tcontainer->has_cpp_name()) {
        return tcontainer->get_cpp_name();
      } else if (ttype->is_map()) {
        t_map* tmap = (t_map*)ttype;
        t_type* ktype = tmap->get_key_type();

        string name = render_type_name(tmap->get_val_type()) + "[";
        if (!is_immutable_type(ktype)) {
          name += "immutable(";
        }
        name += render_type_name(ktype);
        if (!is_immutable_type(ktype)) {
          name += ")";
        }
        name += "]";
        return name;
      } else if (ttype->is_set()) {
        t_set* tset = (t_set*)ttype;
        return "HashSet!(" + render_type_name(tset->get_elem_type()) + ")";
      } else if (ttype->is_list()) {
        t_list* tlist = (t_list*)ttype;
        return render_type_name(tlist->get_elem_type()) + "[]";
      }
    }

    if (ttype->is_struct() && isArg) {
      return "ref const(" + ttype->get_name() + ")";
    } else {
      return ttype->get_name();
    }
  }

  /**
   * Returns the D TReq enum member corresponding to req.
   */
  string render_req(t_field::e_req req) const {
    switch (req) {
    case t_field::T_OPT_IN_REQ_OUT:
      return "TReq.OPT_IN_REQ_OUT";
    case t_field::T_OPTIONAL:
      return "TReq.OPTIONAL";
    case t_field::T_REQUIRED:
      return "TReq.REQUIRED";
    default: {
      std::stringstream ss;
      ss << "Compiler error: Invalid requirement level " << req;
      throw ss.str();
    }
    }
  }

  /**
   * Writes the default list of imports (which are written to every generated
   * module) to f.
   */

  void print_default_imports(ostream& out) {
    indent(out) << "import thrift.base;" << '\n' << "import thrift.codegen.base;" << '\n'
                << "import thrift.util.hashset;" << '\n' << '\n';
  }

  /**
   * Returns whether type is »intrinsically immutable«, in the sense that
   * a value of that type is implicitly castable to immutable(type), and it is
   * allowed for AA keys without an immutable() qualifier.
   */
  bool is_immutable_type(t_type* type) const {
    t_type* ttype = get_true_type(type);
    return ttype->is_base_type() || ttype->is_enum();
  }

  /*
   * File streams, stored here to avoid passing them as parameters to every
   * function.
   */
  ofstream_with_content_based_conditional_update f_types_;
  ofstream_with_content_based_conditional_update f_header_;

  string package_dir_;

  protected:
   static vector<string> d_reserved_words;

};

vector<string> t_d_generator::d_reserved_words = {
    // The keywords are extracted from https://dlang.org/spec/lex.html
    // and sorted for use with std::binary_search
    "__FILE_FULL_PATH__", "__FILE__", "__FUNCTION__", "__LINE__", "__MODULE__",
    "__PRETTY_FUNCTION__", "__gshared", "__parameters", "__traits", "__vector",
    "abstract", "alias", "align", "asm", "assert", "auto", "body", "bool",
    "break", "byte", "case", "cast", "catch", "cdouble", "cent", "cfloat",
    "char", "class", "const", "continue", "creal", "dchar", "debug", "default",
    "delegate", "delete", "deprecated", "do", "double", "else", "enum",
    "export", "extern", "false", "final", "finally", "float", "for", "foreach",
    "foreach_reverse", "function", "goto", "idouble", "if", "ifloat", "immutable",
    "import", "in", "inout", "int", "interface", "invariant", "ireal", "is",
    "lazy", "long", "macro ", "mixin", "module", "new", "nothrow", "null", "out",
    "override", "package", "pragma", "private", "protected", "public", "pure",
    "real", "ref", "return", "scope", "shared", "short", "static", "struct",
    "super", "switch", "synchronized", "template", "this", "throw", "true", "try",
    "typeid", "typeof", "ubyte", "ucent", "uint", "ulong", "union", "unittest",
    "ushort", "version", "void", "wchar", "while", "with"
};

std::string t_d_generator::display_name() const {
  return "D";
}


THRIFT_REGISTER_GENERATOR(d, "D", "")
