// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <iostream>

#include "banjo/ddk_generator.h"

#include "banjo/attributes.h"
#include "banjo/names.h"

namespace banjo {

namespace {

// Various string values are looked up or computed in these
// functions. Nothing else should be dealing in string literals, or
// computing strings from these or AST values.

constexpr const char kIndent[] = "    ";

// Functions named "Emit..." are called to actually emit to an std::ostream
// is here. No other functions should directly emit to the streams.

std::ostream& operator<<(std::ostream& stream, StringView view) {
    stream.rdbuf()->sputn(view.data(), view.size());
    return stream;
}

std::string ToSnakeCase(StringView name, bool upper = false) {
    const auto is_upper = [](char c) { return c >= 'A' && c <= 'Z'; };
    const auto is_lower = [](char c) { return c >= 'a' && c <= 'z'; };
    const auto to_upper = [&](char c) { return is_lower(c) ? c + ('A' - 'a') : c; };
    const auto to_lower = [&](char c) { return is_upper(c) ? c - ('A' - 'a') : c; };
    std::string snake;
    snake += name[0];
    for (auto it = name.begin() + 1; it != name.end(); ++it) {
        if (is_upper(*it) && *(it - 1) != '_' && !is_upper(*(it - 1))) {
            snake += '_';
        }
        snake += *it;
    }
    if (upper) {
        std::transform(snake.begin(), snake.end(), snake.begin(), to_upper);
    } else {
        std::transform(snake.begin(), snake.end(), snake.begin(), to_lower);
    }
    return snake;
}

std::string ToLispCase(StringView name) {
    std::string lisp = ToSnakeCase(name);
    const auto to_lisp = [&](char c) { return c == '_' ? '-' : c; };
    std::transform(lisp.begin(), lisp.end(), lisp.begin(), to_lisp);
    return lisp;
}

std::string NameBuffer(const DdkGenerator::Member& member) {
    return member.name + (member.element_type == "void" ? "_buffer" : "_list");
}

std::string NameCount(const DdkGenerator::Member& member) {
    return member.name + (member.element_type == "void" ? "_size" : "_count");
}

bool ReturnFirst(const std::vector<DdkGenerator::Member>& output) {
    return output.size() > 0 && (output[0].kind == flat::Type::Kind::kPrimitive ||
                                 (output[0].kind == flat::Type::Kind::kIdentifier &&
                                  output[0].decl_kind == flat::Decl::Kind::kEnum));
}

void EmitFileComment(std::ostream* file, banjo::StringView name) {
    *file << "// Copyright 2018 The Fuchsia Authors. All rights reserved.\n";
    *file << "// Use of this source code is governed by a BSD-style license that can be\n";
    *file << "// found in the LICENSE file.\n\n";
    *file << "// WARNING: THIS FILE IS MACHINE GENERATED. DO NOT EDIT.\n";
    *file << "//          MODIFY system/banjo/ddk-protocol-" << name <<  "/" << name
          << ".banjo INSTEAD.\n\n";
}

void EmitHeaderGuard(std::ostream* file) {
    // TODO(704) Generate an appropriate header guard name.
    *file << "#pragma once\n";
}

void EmitIncludeHeader(std::ostream* file, StringView header) {
    *file << "#include " << header << "\n";
}

void EmitNamespacePrologue(std::ostream* file, StringView name) {
    *file << "namespace " << name << " {\n";
}

void EmitNamespaceEpilogue(std::ostream* file, StringView name) {
    *file << "} // namespace " << name << "\n";
}

void EmitBlank(std::ostream* file) {
    *file << "\n";
}

std::vector<StringView> SplitString(const std::string& src, char delimiter) {
    std::vector<StringView> result;
    if (src.empty())
        return result;

    size_t start = 0;
    while (start != std::string::npos) {
        const size_t end = src.find(delimiter, start);

        if (end == std::string::npos) {
            StringView view(&src[start], src.size() - start);
            if (!view.empty()) result.push_back(view);
            start = std::string::npos;
        } else {
            StringView view(&src[start], end - start);
            if (!view.empty()) result.push_back(view);
            start = end + 1;
        }
    }
    return result;
}

template <typename T>
void EmitDocstring(std::ostream* file, const T& decl, bool indent) {
    if (!decl.doc.empty()) {
        const auto lines = SplitString(decl.doc, '\n');
        for (auto line : lines) {
            if (indent) {
                *file << kIndent;
            }
            *file << "//" << line << "\n";
        }
    }
}

void EmitMemberDecl(std::ostream* file, const DdkGenerator::Member& member, bool output = false) {
    const auto member_name = (output ? "* " : " ") + member.name;
    switch (member.kind) {
    case flat::Type::Kind::kArray:
        *file << member.type << member_name;
        for (uint32_t array_count : member.array_counts) {
            *file << "[" << array_count << "]";
        }
        break;
    case flat::Type::Kind::kVector:
        if (output) {
            *file << member.element_type << (output ? "* " : " ") << NameBuffer(member) << ";\n"
                  << kIndent << "size_t " << NameCount(member) << ";\n"
                  << kIndent << "size_t" << member_name << "_actual";
        } else {
            const auto prefix = member.nullability == types::Nullability::kNullable ? "" : "const ";
            *file << prefix << member.element_type << (output ? "** " : "* ")
                  << NameBuffer(member) << ";\n" << kIndent << "size_t " << NameCount(member);
        }
        break;
    case flat::Type::Kind::kString:
        if (member.array_counts.size() > 0) {
            *file << "char " << member_name;
            for (uint32_t array_count : member.array_counts) {
                *file << "[" << array_count << "]";
            }
        } else {
            *file << member.type << member_name;
        }
        break;
    case flat::Type::Kind::kHandle:
    case flat::Type::Kind::kRequestHandle:
    case flat::Type::Kind::kPrimitive:
        *file << member.type << member_name;
        break;
    case flat::Type::Kind::kIdentifier:
        switch (member.decl_kind) {
        case flat::Decl::Kind::kConst:
            assert(false && "bad decl kind for member");
            break;
        case flat::Decl::Kind::kEnum:
            *file << member.type << member_name;
            break;
        case flat::Decl::Kind::kInterface:
            *file << member.type << (output ? "*" : "") << member_name;
            break;
        case flat::Decl::Kind::kStruct:
        case flat::Decl::Kind::kUnion:
            *file << member.type << member_name;
            break;
        }
        break;
    }
}

void EmitMethodInParamDecl(std::ostream* file, const DdkGenerator::Member& member,
                           bool emit_name = true) {
    const auto member_name = emit_name ? " " + member.name : "";
    switch (member.kind) {
    case flat::Type::Kind::kArray:
        *file << "const " << member.type << member_name;
        for (uint32_t array_count : member.array_counts) {
            *file << "[" << array_count << "]";
        }
        break;
    case flat::Type::Kind::kVector:
        if (emit_name) {
            *file << "const " << member.element_type << "* " << NameBuffer(member) << ", "
                  << "size_t " << NameCount(member);
        } else {
            *file << "const " << member.element_type << "*, size_t";
        }
        break;
    case flat::Type::Kind::kString:
    case flat::Type::Kind::kHandle:
    case flat::Type::Kind::kRequestHandle:
    case flat::Type::Kind::kPrimitive:
        *file << member.type << member_name;
        break;
    case flat::Type::Kind::kIdentifier:
        switch (member.decl_kind) {
        case flat::Decl::Kind::kConst:
            assert(false && "bad decl kind for member");
            break;
        case flat::Decl::Kind::kEnum:
            *file << member.type << member_name;
            break;
        case flat::Decl::Kind::kInterface:
            *file << member.type << "*" << member_name;
            break;
        case flat::Decl::Kind::kStruct:
        case flat::Decl::Kind::kUnion:
            switch (member.nullability) {
            case types::Nullability::kNullable:
                // TODO: We are using nullability as a proxy for const...
                *file << member.type << member_name;
                break;
            case types::Nullability::kNonnullable:
                *file << "const " << member.type << "*" <<  member_name;
                break;
            }
            break;
        }
        break;
    }
}

void EmitMethodOutParamDecl(std::ostream* file, const DdkGenerator::Member& member,
                            bool emit_name = true) {
    const auto member_name = emit_name ? " out_" + member.name : "";
    switch (member.kind) {
    case flat::Type::Kind::kArray:
        *file << member.type << member_name;
        for (uint32_t array_count : member.array_counts) {
            *file << "[" << array_count << "]";
        }
    case flat::Type::Kind::kVector: {
        const auto buffer_name = emit_name ? " out_" + NameBuffer(member) : "";
        const auto count_name = emit_name ? " " + NameCount(member) : "";
        const auto actual_name = emit_name ? member_name + "_actual" : "";
        switch (member.nullability) {
        case types::Nullability::kNullable:
            *file << member.element_type << "**" << buffer_name << ", "
                  << "size_t*" << count_name;
            break;
        case types::Nullability::kNonnullable:
            *file << member.element_type << "*" << buffer_name << ", "
                  << "size_t" << count_name << ", "
                  << "size_t*" << actual_name;
            break;
        }
        break;
    }
    case flat::Type::Kind::kString:
        if (emit_name) {
            *file << "char*" << member_name << ", "
                  << "size_t " << member.name << "_capacity";
        } else {
            *file << "char*, size_t";
        }
        break;
    case flat::Type::Kind::kHandle:
    case flat::Type::Kind::kRequestHandle:
    case flat::Type::Kind::kPrimitive:
        *file << member.type << "*" << member_name;
        break;
    case flat::Type::Kind::kIdentifier:
        switch (member.decl_kind) {
        case flat::Decl::Kind::kConst:
            assert(false && "bad decl kind for member");
            break;
        case flat::Decl::Kind::kEnum:
        case flat::Decl::Kind::kInterface:
        case flat::Decl::Kind::kStruct:
        case flat::Decl::Kind::kUnion:
            *file << member.type << "*" << member_name;
            break;
        }
        break;
    }
}

void EmitMethodDeclHelper(std::ostream* file, StringView method_name,
                          const std::vector<DdkGenerator::Member>& input,
                          const std::vector<DdkGenerator::Member>& output,
                          StringView ctx) {
    const bool return_first = ReturnFirst(output);
    if (return_first) {
        *file << output[0].type << " ";
    } else {
        *file << "void ";
    }
    *file << method_name << "(";
    if (!ctx.empty()) {
        *file << ctx;
    }
    bool first = ctx.empty();
    for (const auto& member : input) {
        if (first) {
            first = false;
        } else {
            *file << ", ";
        }
        EmitMethodInParamDecl(file, member);
    }
    for (auto member = output.begin() + (return_first ? 1 : 0); member != output.end();
         member++) {
        if (first) {
            first = false;
        } else {
            *file << ", ";
        }
        EmitMethodOutParamDecl(file, *member);
    }
}

void EmitProtocolMethodDecl(std::ostream* file, StringView method_name,
                            const std::vector<DdkGenerator::Member>& input,
                            const std::vector<DdkGenerator::Member>& output) {
    EmitMethodDeclHelper(file, method_name, input, output, "");
}

void EmitProtocolMethodWithCtxDecl(std::ostream* file, StringView method_name,
                                   const std::vector<DdkGenerator::Member>& input,
                                   const std::vector<DdkGenerator::Member>& output) {
    EmitMethodDeclHelper(file, method_name, input, output, "void* ctx");
}

void EmitProtocolMethodWithSpecificCtxDecl(std::ostream* file, const std::string& protocol_name,
                                           banjo::StringView method_name,
                                           const std::vector<DdkGenerator::Member>& input,
                                           const std::vector<DdkGenerator::Member>& output) {
    EmitMethodDeclHelper(file, method_name, input, output,
                         "const " + protocol_name + "_t* proto");
}

void EmitProtocolMethodPtrDecl(std::ostream* file, const std::string& method_name,
                               const std::vector<DdkGenerator::Member>& input,
                               const std::vector<DdkGenerator::Member>& output) {
    EmitMethodDeclHelper(file, "(*" + method_name + ")", input, output, "void* ctx");
}

void EmitProtocolMethodTemplateDecl(std::ostream* file,
                                    const std::vector<DdkGenerator::Member>& input,
                                    const std::vector<DdkGenerator::Member>& output) {
    EmitMethodDeclHelper(file, "(C::*)", input, output, "");
    *file << "));\n";
}

void EmitMethodImplHelper(std::ostream* file, StringView method_name,
                          const std::vector<DdkGenerator::Member>& input,
                          const std::vector<DdkGenerator::Member>& output,
                          StringView ctx, bool save_ret=false) {
    const bool return_first = ReturnFirst(output);
    if (return_first)
        *file << (save_ret ? "auto ret = " : "return ");
    *file << method_name << "(";

    if (!ctx.empty()) {
        *file << ctx;
    }
    bool first = ctx.empty();
    for (const auto& member : input) {
        if (first) {
            first = false;
        } else {
            *file << ", ";
        }
        if (member.kind == flat::Type::Kind::kVector) {
            *file << NameBuffer(member) << ", " << NameCount(member);
        } else {
            *file << member.name;
        }
    }
    for (auto member = output.begin() + (return_first ? 1 : 0); member != output.end();
         member++) {
        if (first) {
            first = false;
        } else {
            *file << ", ";
        }

        if (member->kind == flat::Type::Kind::kVector) {
            *file << "out_" << NameBuffer(*member) << ", " << NameCount(*member);
            if (member->nullability == types::Nullability::kNonnullable) {
                *file << ", out_" << member->name << "_actual";
            }
        } else if (member->kind == flat::Type::Kind::kString) {
            *file << "out_" << member->name << ", " << member->name << "_capacity";
        } else {
            *file << (member->address_of ? "&" : "") << "out_" << member->name;
        }
    }
}

void EmitDdkProtocolMethodImpl(std::ostream* file, const std::string& method_name,
                               const std::vector<DdkGenerator::Member>& input,
                               const std::vector<DdkGenerator::Member>& output) {
    EmitMethodImplHelper(file,  "proto->ops->" + method_name, input, output,
                         "proto->ctx");
    *file << ");\n";
}

void EmitDdktlProtocolMethodImpl(std::ostream* file, const std::string& method_name,
                                 std::vector<DdkGenerator::Member> input,
                                 std::vector<DdkGenerator::Member> output,
                                 bool handle_wrappers) {
    if (handle_wrappers) {
        for (auto& member : input) {
            if (member.kind == flat::Type::Kind::kHandle) {
                member.name = member.type + "(" + member.name + ")";
            }
        }
        for (auto& member : output) {
            if (member.kind == flat::Type::Kind::kHandle) {
                *file << kIndent << kIndent <<  member.type << " out_" << member.name << "2;\n";
                member.name = member.name + "2";
                member.address_of = true;
            }
        }
        *file << kIndent << kIndent;
        EmitMethodImplHelper(file, "static_cast<D*>(ctx)->" + method_name, input, output, "", true);
        *file << ");\n";
        for (auto& member : output) {
            if (member.kind == flat::Type::Kind::kHandle) {
                *file << kIndent << kIndent <<  "*out_"
                      << member.name.substr(0, member.name.size() - 1) << " = out_"
                      << member.name << ".release();\n";
            }
        }
        if (ReturnFirst(output)) {
            *file << kIndent << kIndent << "return ret;\n";
        }
    } else {
        *file << kIndent << kIndent;
        EmitMethodImplHelper(file, "static_cast<D*>(ctx)->" + method_name, input, output, "");
        *file << ");\n";
    }
}

void EmitClientMethodImpl(std::ostream* file, const std::string& method_name,
                           std::vector<DdkGenerator::Member>& input,
                          std::vector<DdkGenerator::Member>& output,
                          bool handle_wrappers) {
    if (handle_wrappers) {
        for (auto& member : input) {
            if (member.kind == flat::Type::Kind::kHandle) {
                member.name = member.name + ".release()";
            }
        }
        for (auto& member : output) {
            if (member.kind == flat::Type::Kind::kHandle) {
                member.name = member.name + "->reset_and_get_address()";
            }
        }
    }
    EmitMethodImplHelper(file, "ops_->" + method_name, input, output, "ctx_");
    *file << ");\n";
}

void EmitCallbackMethodImpl(std::ostream* file, const std::string& method_name,
                            const std::vector<DdkGenerator::Member>& members) {
    *file << kIndent << "struct " << method_name << "_callback_context* ctx = cookie;\n";
    EmitBlank(file);
    for (const auto& member : members) {
        const auto& name = member.name;
        switch (member.kind) {
        case flat::Type::Kind::kArray:
            *file << kIndent << "memcpy(ctx->" << name << ", " << name << ", sizeof(" << name << "));\n";
            break;
        case flat::Type::Kind::kVector:
            *file << kIndent << "memcpy(ctx->" << NameBuffer(member) << ", " << NameBuffer(member)
                  << ", sizeof(*" << NameBuffer(member) <<  ") * " << NameCount(member) << ");\n";
            *file << kIndent << "*ctx->" << name << "_actual = " << NameCount(member) << ";\n";
            break;
        case flat::Type::Kind::kString:
            *file << kIndent << "strcpy(ctx->" << name << ", " << name << ");\n";
            break;
        case flat::Type::Kind::kHandle:
        case flat::Type::Kind::kRequestHandle:
        case flat::Type::Kind::kPrimitive:
            *file << kIndent << "*ctx->" << name << " = " << name << ";\n";
            break;
        case flat::Type::Kind::kIdentifier:
            switch (member.decl_kind) {
            case flat::Decl::Kind::kConst:
                assert(false && "bad decl kind for member");
                break;
            case flat::Decl::Kind::kEnum:
            case flat::Decl::Kind::kInterface:
                *file << kIndent << "*ctx->" << name << " = " << name << ";\n";
                break;
            case flat::Decl::Kind::kStruct:
            case flat::Decl::Kind::kUnion:
                switch (member.nullability) {
                case types::Nullability::kNullable:
                    *file << kIndent << "if (" << name << ") {\n";
                    *file << kIndent << kIndent << "*ctx->" << name << " = *" << name << ";\n";
                    *file << kIndent << "} else {\n";
                    // We don't have a great way of signaling that the optional response member
                    // was not in the message. That means these bindings aren't particularly
                    // useful when the client needs to extract that bit. The best we can do is
                    // zero out the value to make sure the client has defined behavior.
                    //
                    // In many cases, the response contains other information (e.g., a status code)
                    // that lets the client do something reasonable.
                    *file << kIndent << kIndent << "memset(ctx->" << name
                          << ", 0, sizeof(*ctx->" << name << "));\n";
                    *file << kIndent << "}\n";
                    break;
                case types::Nullability::kNonnullable:
                    *file << kIndent << "*ctx->" << name << " = *" << name << ";\n";
                    break;
                }
                break;
            }
            break;
        }
    }
    EmitBlank(file);
    *file << kIndent << "sync_completion_signal(&ctx->completion);\n";
}

void EmitSyncMethodImpl(std::ostream* file, const std::string& protocol_name,
                        const std::string& method_name,
                        const std::vector<DdkGenerator::Member>& input,
                        const std::vector<DdkGenerator::Member>& members) {
    *file << kIndent << "struct " << method_name << "_callback_context ctx;\n";
    *file << kIndent << "sync_completion_reset(&ctx.completion);\n";

    const bool return_first = ReturnFirst(members);
    if (return_first) {
        *file << kIndent << members[0].type << " _" << members[0].name << ";\n";
        *file << kIndent << members[0].type << "* out_" << members[0].name << " = &_"
              << members[0].name << ";\n";
    }
    EmitBlank(file);
    for (const auto& member : members) {
        const auto& name = member.name;
        switch (member.kind) {
        case flat::Type::Kind::kArray:
            *file << kIndent << "ctx." << name << " = out_" << name << "\n";
            break;
        case flat::Type::Kind::kVector:
            *file << kIndent << "ctx." << NameBuffer(member) << " = out_" << NameBuffer(member)
                  << ";\n";
            *file << kIndent << "ctx." << NameCount(member) << " = " << NameCount(member) << ";\n";
            *file << kIndent << "ctx." << name << "_actual = out_" << name << "_actual;\n";
            break;
        case flat::Type::Kind::kString:
            *file << kIndent << "ctx." << name << " = out_" << name << ";\n";
            *file << kIndent << "ctx." << name << "capacity = out_" << name << "capacity;\n";
            break;
        case flat::Type::Kind::kHandle:
        case flat::Type::Kind::kRequestHandle:
        case flat::Type::Kind::kPrimitive:
            *file << kIndent << "ctx." << name << " = out_" << name << ";\n";
            break;
        case flat::Type::Kind::kIdentifier:
            switch (member.decl_kind) {
            case flat::Decl::Kind::kConst:
                assert(false && "bad decl kind for member");
                break;
            case flat::Decl::Kind::kEnum:
            case flat::Decl::Kind::kInterface:
                *file << kIndent << "ctx." << name << " = out_" << name << ";\n";
                break;
            case flat::Decl::Kind::kStruct:
            case flat::Decl::Kind::kUnion:
                switch (member.nullability) {
                case types::Nullability::kNullable:
                    *file << kIndent << "ctx." << name << " = out_" << name << ";\n";
                    break;
                case types::Nullability::kNonnullable:
                    *file << kIndent << "ctx." << name << " = out_" << name << ";\n";
                    break;
                }
                break;
            }
            break;
        }
    }

    EmitBlank(file);
    *file << kIndent;
    EmitMethodImplHelper(file, method_name, input, {}, protocol_name);
    *file << ", " << method_name << "_cb, &ctx);\n";
    *file << kIndent
          << "zx_status_t status = sync_completion_wait(&ctx.completion, ZX_TIME_INFINITE);\n";
    if (return_first) {
        *file << kIndent << "if (status != ZX_OK) {\n";
        *file << kIndent << kIndent << "return status;\n";
        *file << kIndent << "}\n";
        *file << kIndent << "return _" << members[0].name << ";\n";
    } else {
        *file << kIndent << "assert(status == ZX_OK);\n";
    }
}

// Various computational helper routines.

void EnumValue(types::PrimitiveSubtype type, const flat::Constant* constant,
               const flat::Library* library, std::string* out_value) {
    std::ostringstream member_value;

    switch (type) {
    case types::PrimitiveSubtype::kInt8: {
        int8_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        // The char-sized overloads of operator<< here print
        // the character value, not the numeric value, so cast up.
        member_value << static_cast<int>(value);
        break;
    }
    case types::PrimitiveSubtype::kInt16: {
        int16_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        member_value << value;
        break;
    }
    case types::PrimitiveSubtype::kInt32: {
        int32_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        member_value << value;
        break;
    }
    case types::PrimitiveSubtype::kInt64: {
        int64_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        member_value << value;
        break;
    }
    case types::PrimitiveSubtype::kUint8: {
        uint8_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        // The char-sized overloads of operator<< here print
        // the character value, not the numeric value, so cast up.
        member_value << static_cast<unsigned int>(value);
        break;
    }
    case types::PrimitiveSubtype::kUint16: {
        uint16_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        member_value << value;
        break;
    }
    case types::PrimitiveSubtype::kUint32: {
        uint32_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        member_value << value;
        break;
    }
    case types::PrimitiveSubtype::kUint64: {
        uint64_t value;
        bool success = library->ParseIntegerConstant(constant, &value);
        if (!success) {
            __builtin_trap();
        }
        member_value << value;
        break;
    }
    case types::PrimitiveSubtype::kBool:
    case types::PrimitiveSubtype::kFloat32:
    case types::PrimitiveSubtype::kFloat64:
    case types::PrimitiveSubtype::kUSize:
    case types::PrimitiveSubtype::kISize:
    case types::PrimitiveSubtype::kVoidPtr:
        assert(false && "bad primitive type for an enum");
        break;
    }

    *out_value = member_value.str();
}

std::vector<uint32_t> ArrayCounts(const flat::Library* library, const flat::Type* type) {
    std::vector<uint32_t> array_counts;
    for (;;) {
        switch (type->kind) {
        default: { return array_counts; }
        case flat::Type::Kind::kArray: {
            auto array_type = static_cast<const flat::ArrayType*>(type);
            uint32_t element_count = array_type->element_count.Value();
            array_counts.push_back(element_count);
            type = array_type->element_type.get();
            continue;
        }
        case flat::Type::Kind::kString: {
            auto str_type = static_cast<const flat::StringType*>(type);
            uint32_t max_size = str_type->max_size.Value();
            if (max_size < flat::Size::Max().Value())
                array_counts.push_back(max_size);
            return array_counts;
        }
        }
    }
}

flat::Decl::Kind GetDeclKind(const flat::Library* library, const flat::Type* type) {
    if (type->kind != flat::Type::Kind::kIdentifier)
        return flat::Decl::Kind::kConst;
    auto identifier_type = static_cast<const flat::IdentifierType*>(type);
    auto named_decl = library->LookupDeclByName(identifier_type->name);
    assert(named_decl && "library must contain declaration");
    return named_decl->kind;
}

std::string HandleToZxWrapper(const flat::HandleType* handle_type) {
    switch (handle_type->subtype) {
    case types::HandleSubtype::kHandle:
        return "zx::handle";
    case types::HandleSubtype::kProcess:
        return "zx::process";
    case types::HandleSubtype::kThread:
        return "zx::thread";
    case types::HandleSubtype::kVmo:
        return "zx::vmo";
    case types::HandleSubtype::kChannel:
        return "zx::channel";
    case types::HandleSubtype::kEvent:
        return "zx::event";
    case types::HandleSubtype::kPort:
        return "zx::port";
    case types::HandleSubtype::kInterrupt:
        return "zx::interrupt";
    case types::HandleSubtype::kLog:
        return "zx::debuglog";
    case types::HandleSubtype::kSocket:
        return "zx::socket";
    case types::HandleSubtype::kResource:
        return "zx::resource";
    case types::HandleSubtype::kEventpair:
        return "zx::eventpair";
    case types::HandleSubtype::kJob:
        return "zx::job";
    case types::HandleSubtype::kVmar:
        return "zx::vmar";
    case types::HandleSubtype::kFifo:
        return "zx::fifo";
    case types::HandleSubtype::kGuest:
        return "zx::guest";
    case types::HandleSubtype::kTimer:
        return "zx::timer";
    case types::HandleSubtype::kBti:
        return "zx::bti";
    case types::HandleSubtype::kProfile:
        return "zx::profile";
    default: { abort(); }
    }
}

std::string NameType(const flat::Type* type, const flat::Decl::Kind& decl_kind,
                     bool handle_wrappers=false) {
    for (;;) {
        switch (type->kind) {
        case flat::Type::Kind::kHandle:
        case flat::Type::Kind::kRequestHandle: {
            if (handle_wrappers) {
                auto handle_type = static_cast<const flat::HandleType*>(type);
                return HandleToZxWrapper(handle_type);
            } else {
                return "zx_handle_t";
            }
        }

        case flat::Type::Kind::kString:
            return "const char*";

        case flat::Type::Kind::kPrimitive: {
            auto primitive_type = static_cast<const flat::PrimitiveType*>(type);
            if (primitive_type->subtype == types::PrimitiveSubtype::kInt32)
                return "zx_status_t";
            return NamePrimitiveCType(primitive_type->subtype);
        }

        case flat::Type::Kind::kArray: {
            auto array_type = static_cast<const flat::ArrayType*>(type);
            type = array_type->element_type.get();
            continue;
        }

        case flat::Type::Kind::kVector: {
            auto vector_type = static_cast<const flat::VectorType*>(type);
            type = vector_type->element_type.get();
            continue;
        }

        case flat::Type::Kind::kIdentifier: {
            auto identifier_type = static_cast<const flat::IdentifierType*>(type);
            switch (decl_kind) {
            case flat::Decl::Kind::kConst:
            case flat::Decl::Kind::kEnum:
            case flat::Decl::Kind::kStruct:
            case flat::Decl::Kind::kUnion: {
                std::string name = identifier_type->name.name().data();
                name = ToSnakeCase(name) + "_t";
                if (identifier_type->nullability == types::Nullability::kNullable) {
                    name.push_back('*');
                }
                return name;
            }
            case flat::Decl::Kind::kInterface: {
                return std::string(
                    "const " + ToSnakeCase(identifier_type->name.name().data()) + "_t");
            }
            default: { abort(); }
            }
        }
        default: { abort(); }
        }
    }
}

template <typename T>
DdkGenerator::Member CreateMember(const flat::Library* library, const T& decl,
                                  bool handle_wrappers=false) {
    std::string name = NameIdentifier(decl.name);
    const flat::Type* type = decl.type.get();
    auto decl_kind = GetDeclKind(library, type);
    auto type_name = NameType(type, decl_kind, handle_wrappers);
    std::vector<uint32_t> array_counts = ArrayCounts(library, type);
    std::string element_type_name;
    std::string doc = decl.GetAttribute("Doc");
    if (type->kind == flat::Type::Kind::kVector) {
        auto vector_type = static_cast<const flat::VectorType*>(type);
        const flat::Type* element_type = vector_type->element_type.get();
        element_type_name = NameType(element_type, GetDeclKind(library, element_type));
    }
    types::Nullability nullability = types::Nullability::kNonnullable;
    if (type->kind == flat::Type::Kind::kIdentifier) {
        auto identifier_type = static_cast<const flat::IdentifierType*>(type);
        nullability = identifier_type->nullability;
    } else if (type->kind == flat::Type::Kind::kVector) {
        auto identifier_type = static_cast<const flat::VectorType*>(type);
        nullability = identifier_type->nullability;
    }
    return DdkGenerator::Member{
        type->kind,
        decl_kind,
        std::move(type_name),
        std::move(name),
        std::move(element_type_name),
        std::move(doc),
        std::move(array_counts),
        nullability,
    };
}

template <typename T>
std::vector<DdkGenerator::Member>
GenerateMembers(const flat::Library* library, const std::vector<T>& decl_members) {
    std::vector<DdkGenerator::Member> members;
    members.reserve(decl_members.size());
    for (const auto& member : decl_members) {
        members.push_back(CreateMember(library, member, false));
    }
    return members;
}

void GetMethodParameters(const flat::Library* library,
                         const DdkGenerator::NamedMethod& method_info,
                         std::vector<DdkGenerator::Member>* input,
                         std::vector<DdkGenerator::Member>* output,
                         bool handle_wrappers=false) {
    input->reserve(method_info.input_parameters.size() + (method_info.async ? 2 : 0));
    for (const auto& parameter : method_info.input_parameters) {
        input->push_back(CreateMember(library, parameter, handle_wrappers));
    }

    if (method_info.async) {
        input->push_back(DdkGenerator::Member{
            .kind = flat::Type::Kind::kIdentifier,
            .decl_kind = flat::Decl::Kind::kStruct,
            .type = ToSnakeCase(method_info.protocol_name) + "_callback",
            .name = "callback",
            .element_type = "",
            .array_counts = {},
            .nullability = types::Nullability::kNullable,
        });
        input->push_back(DdkGenerator::Member{
            .kind = flat::Type::Kind::kPrimitive,
            .decl_kind = flat::Decl::Kind::kStruct,
            .type = "void*",
            .name = "cookie",
            .element_type = "",
            .array_counts = {},
            .nullability = types::Nullability::kNullable,
        });
    } else {
        output->reserve(method_info.output_parameters.size());
        for (const auto& parameter : method_info.output_parameters) {
            output->push_back(CreateMember(library, parameter, handle_wrappers));
        }
    }
}
} // namespace

void DdkGenerator::GeneratePrologues() {
    EmitFileComment(&file_, library_->name().back());
    EmitHeaderGuard(&file_);
    EmitBlank(&file_);

    for (const auto& dep_library : library_->dependencies()) {
        if (dep_library == library_)
            continue;
        if (dep_library->HasAttribute("Internal"))
            continue;
        EmitIncludeHeader(&file_, "<" +  ToLispCase(StringJoin(dep_library->name(), "/")) + ".h>");
    }
    EmitIncludeHeader(&file_, "<zircon/compiler.h>");
    EmitIncludeHeader(&file_, "<zircon/types.h>");

    EmitBlank(&file_);
    file_ <<  "__BEGIN_CDECLS;\n";
}

void DdktlGenerator::GeneratePrologues() {
    EmitFileComment(&file_, library_->name().back());
    EmitHeaderGuard(&file_);
    EmitBlank(&file_);
    EmitIncludeHeader(&file_, "<ddk/driver.h>");
    EmitIncludeHeader(&file_, "<" +  ToLispCase(LibraryName(library_, "/")) + ".h>");
    for (const auto& dep_library : library_->dependencies()) {
        if (dep_library == library_)
            continue;
        if (dep_library->HasAttribute("Internal"))
            continue;
        EmitIncludeHeader(&file_, "<" +  ToLispCase(StringJoin(dep_library->name(), "/")) + ".h>");
    }
    EmitIncludeHeader(&file_, "<ddktl/device-internal.h>");
    EmitIncludeHeader(&file_, "<zircon/assert.h>");
    EmitIncludeHeader(&file_, "<zircon/compiler.h>");
    EmitIncludeHeader(&file_, "<zircon/types.h>");

    // Enumerate list of includes based on zx_handle_t wrappers.
    std::set<std::string> includes;

    std::map<const flat::Decl*, NamedInterface> named_interfaces =
        NameInterfaces(library_->interface_declarations_);
    for (const auto& named_interface : named_interfaces) {
        for (const auto& method_info : named_interface.second.methods) {
            std::vector<Member> input;
            std::vector<Member> output;
            GetMethodParameters(library_, method_info, &input, &output, true);

            for (const auto& member : input) {
                if (member.kind == flat::Type::Kind::kHandle) {
                    includes.insert(std::string(member.type.substr(4)));
                }
            }
            for (const auto& member : output) {
                if (member.kind == flat::Type::Kind::kHandle) {
                    includes.insert(std::string(member.type.substr(4)));
                }
            }
        }
    }

    for (const auto& include : includes) {
        EmitIncludeHeader(&file_, "<lib/zx/" + include  + ".h>");
    }

    EmitBlank(&file_);

    const auto& libname = library_->name();
    EmitIncludeHeader(&file_, "\"" + ToLispCase(libname.back()) + "-internal.h\"");
    EmitBlank(&file_);
}

void DdkGenerator::GenerateEpilogues() {
    file_ <<  "__END_CDECLS;\n";
}

void DdktlGenerator::GenerateEpilogues() {
    EmitNamespaceEpilogue(&file_, "ddk");
}

void DdkGenerator::GenerateIntegerDefine(StringView name, types::PrimitiveSubtype subtype,
                                         StringView value) {
    std::string literal_macro = NamePrimitiveIntegerCConstantMacro(subtype);
    file_ << "#define " << name << " " << literal_macro << "(" << value << ")\n";
}

void DdkGenerator::GeneratePrimitiveDefine(StringView name, types::PrimitiveSubtype subtype,
                                           StringView value) {
    switch (subtype) {
    case types::PrimitiveSubtype::kInt8:
    case types::PrimitiveSubtype::kInt16:
    case types::PrimitiveSubtype::kInt32:
    case types::PrimitiveSubtype::kInt64:
    case types::PrimitiveSubtype::kUint8:
    case types::PrimitiveSubtype::kUint16:
    case types::PrimitiveSubtype::kUint32:
    case types::PrimitiveSubtype::kUint64: {
        std::string literal_macro = NamePrimitiveIntegerCConstantMacro(subtype);
        file_ << "#define " << name << " " << literal_macro << "(" << value << ")\n";
        break;
    }
    case types::PrimitiveSubtype::kBool:
    case types::PrimitiveSubtype::kFloat32:
    case types::PrimitiveSubtype::kFloat64: {
        file_ << "#define " << name << " "
              << "(" << value << ")\n";
        break;
    }
    default:
        abort();
    }
}

void DdkGenerator::GenerateStringDefine(StringView name, StringView value) {
    file_ << "#define " << name << " " << value << "\n";
}

#if 0
void DdktlGenerator::GeneratePrimitiveDefine(StringView name, types::PrimitiveSubtype subtype,
                                             StringView value) {
    std::string underlying_type = NamePrimitiveCType(subtype);
    file_ << "constexpr " << underlying_type << " " << name << " = " << value << ";\n";
}

void DdktlGenerator::GenerateStringDefine(StringView name, StringView value) {
    file_ << "constexpr const char" << name << "[] = " << value << "\n";
}
#endif

void DdkGenerator::GenerateIntegerTypedef(types::PrimitiveSubtype subtype, StringView name) {
    std::string underlying_type = NamePrimitiveCType(subtype);
    file_ << "typedef " << underlying_type << " " << name << ";\n";
}

void DdkGenerator::GenerateStructTypedef(StringView name, StringView type_name) {
    file_ << "typedef struct " << name << " " << type_name << ";\n";
}

void DdkGenerator::GenerateUnionTypedef(StringView name, StringView type_name) {
    file_ << "typedef union " << name << " " << type_name << ";\n";
}

void DdkGenerator::GenerateStructDeclaration(StringView name, const std::vector<Member>& members,
                                             bool packed, bool helper) {
    file_ << "struct " << name << " {\n";
    bool first = true;
    for (const auto& member : members) {
        if (!helper) {
            EmitDocstring(&file_, member, true);
        }
        file_ << kIndent;
        EmitMemberDecl(&file_, member, helper && !first);
        file_ << ";\n";
        if (first) first = false;
    }
    if (packed) {
        file_ << "} __attribute__((__packed__));\n";
    } else {
        file_ << "};\n";
    }
}

void DdkGenerator::GenerateTaggedUnionDeclaration(StringView name,
                                                  const std::vector<Member>& members) {
    file_ << "union " << name << " {\n";
    for (const auto& member : members) {
        EmitDocstring(&file_, member, true);
        file_ << kIndent;
        EmitMemberDecl(&file_, member);
        file_ << ";\n";
    }
    file_ << "};\n";
}

// TODO(TO-702) These should maybe check for global name
// collisions? Otherwise, is there some other way they should fail?
std::map<const flat::Decl*, DdkGenerator::NamedConst>
DdkGenerator::NameConsts(const std::vector<std::unique_ptr<flat::Const>>& const_infos) {
    std::map<const flat::Decl*, NamedConst> named_consts;
    for (const auto& const_info : const_infos) {
        std::string doc = const_info->GetAttribute("Doc");
        named_consts.emplace(const_info.get(),
                             NamedConst{NameIdentifier(const_info->name.name()), std::move(doc),
                                        *const_info});
    }
    return named_consts;
}

#if 0
std::map<const flat::Decl*, DdkGenerator::NamedConst>
DdktlGenerator::NameConsts(const std::vector<std::unique_ptr<flat::Const>>& const_infos) {
    std::map<const flat::Decl*, NamedConst> named_consts;
    for (const auto& const_info : const_infos) {
        named_consts.emplace(const_info.get(),
                             NamedConst{NameIdentifier(const_info->name.name()), *const_info});
    }
    return named_consts;
}
#endif

std::map<const flat::Decl*, DdkGenerator::NamedEnum>
DdkGenerator::NameEnums(const std::vector<std::unique_ptr<flat::Enum>>& enum_infos) {
    std::map<const flat::Decl*, NamedEnum> named_enums;
    for (const auto& enum_info : enum_infos) {
        std::string enum_name = ToSnakeCase(enum_info->name.name().data(), true);
        std::string type_name = ToSnakeCase(enum_info->name.name().data()) + "_t";
        std::string doc = enum_info->GetAttribute("Doc");
        named_enums.emplace(enum_info.get(),
                            NamedEnum{std::move(enum_name), std::move(type_name), std::move(doc),
                                      *enum_info});
    }
    return named_enums;
}

#if 0
std::map<const flat::Decl*, DdkGenerator::NamedEnum>
DdktlGenerator::NameEnums(const std::vector<std::unique_ptr<flat::Enum>>& enum_infos) {
    std::map<const flat::Decl*, NamedEnum> named_enums;
    for (const auto& enum_info : enum_infos) {
        std::string enum_name = enum_info->name.name().data();
        named_enums.emplace(enum_info.get(), NamedEnum{enum_name, enum_name, *enum_info});
    }
    return named_enums;
}
#endif

std::map<const flat::Decl*, DdkGenerator::NamedInterface>
DdkGenerator::NameInterfaces(const std::vector<std::unique_ptr<flat::Interface>>& interface_infos) {
    std::map<const flat::Decl*, NamedInterface> named_interfaces;
    for (const auto& interface_info : interface_infos) {
        const auto layout = interface_info->GetAttribute("Layout");
        InterfaceType intf_type;
        std::string name = interface_info->name.name().data();
        if (layout == "ddk-protocol") {
            name += "Protocol";
            intf_type = InterfaceType::kProtocol;
        } else if (layout == "ddk-interface") {
            intf_type = InterfaceType::kInterface;
        } else if (layout == "ddk-callback") {
            intf_type = InterfaceType::kCallback;
        } else {
            continue;
        }

        NamedInterface named_interface;
        named_interface.type = intf_type;
        named_interface.shortname = interface_info->name.name().data();
        named_interface.camel_case_name = name;
        named_interface.snake_case_name = ToSnakeCase(std::move(name));
        named_interface.doc = interface_info->GetAttribute("Doc");
        for (const auto& method_pointer : interface_info->all_methods) {
            assert(method_pointer != nullptr);
            const auto& method = *method_pointer;
            std::string c_name = ToSnakeCase(method.name.data());
            NamedMethod named_method = {
                .async = method.HasAttribute("Async"),
                .generate_sync_method = method.HasAttribute("GenerateSync"),
                .c_name = c_name,
                .protocol_name = ToSnakeCase(named_interface.shortname) + "_" + c_name,
                .proxy_name = "",
                .doc = method.GetAttribute("Doc"),
                .input_parameters = method.maybe_request->parameters,
                .output_parameters = method.maybe_response->parameters,
            };
            named_interface.methods.push_back(std::move(named_method));
        }
        named_interfaces.emplace(interface_info.get(), std::move(named_interface));
    }
    return named_interfaces;
}

std::map<const flat::Decl*, DdkGenerator::NamedInterface>
DdktlGenerator::NameInterfaces(const std::vector<std::unique_ptr<flat::Interface>>& interface_infos) {
    std::map<const flat::Decl*, NamedInterface> named_interfaces;
    for (const auto& interface_info : interface_infos) {
        const auto layout = interface_info->GetAttribute("Layout");
        InterfaceType intf_type;
        std::string name = interface_info->name.name().data();
        if (layout == "ddk-protocol") {
            name += "Protocol";
            intf_type = InterfaceType::kProtocol;
        } else if (layout == "ddk-interface") {
            intf_type = InterfaceType::kInterface;
        } else if (layout == "ddk-callback") {
            intf_type = InterfaceType::kCallback;
        } else {
            continue;
        }

        NamedInterface named_interface;
        named_interface.type = intf_type;
        named_interface.shortname = interface_info->name.name().data();
        named_interface.camel_case_name = name;
        named_interface.snake_case_name = ToSnakeCase(std::move(name));
        named_interface.doc = interface_info->GetAttribute("Doc");
        named_interface.handle_wrappers = interface_info->HasAttribute("HandleWrappers");
        for (const auto& method_pointer : interface_info->all_methods) {
            assert(method_pointer != nullptr);
            const auto& method = *method_pointer;
            std::string protocol_name = NameIdentifier(interface_info->name.name()) +
                                        NameIdentifier(method.name);
            std::string c_name = ToSnakeCase(method.name.data());
            std::string proxy_name = NameIdentifier(method.name);
            NamedMethod named_method = {
                .async = method.HasAttribute("Async"),
                .generate_sync_method = method.HasAttribute("GenerateSync"),
                .c_name = c_name,
                .protocol_name = protocol_name,
                .proxy_name = proxy_name,
                .doc = method.GetAttribute("Doc"),
                .input_parameters = method.maybe_request->parameters,
                .output_parameters = method.maybe_response->parameters,
            };
            named_interface.methods.push_back(std::move(named_method));
        }
        named_interfaces.emplace(interface_info.get(), std::move(named_interface));
    }
    return named_interfaces;
}

std::map<const flat::Decl*, DdkGenerator::NamedStruct>
DdkGenerator::NameStructs(const std::vector<std::unique_ptr<flat::Struct>>& struct_infos) {
    std::map<const flat::Decl*, NamedStruct> named_structs;
    for (const auto& struct_info : struct_infos) {
        const bool packed = struct_info->HasAttribute("Packed");
        std::string name = ToSnakeCase(struct_info->name.name().data());
        std::string type_name = name + "_t";
        std::string doc = struct_info->GetAttribute("Doc");
        named_structs.emplace(struct_info.get(),
                              NamedStruct{std::move(name), std::move(type_name), std::move(doc),
                                          packed, *struct_info});
    }
    return named_structs;
}

#if 0
std::map<const flat::Decl*, DdkGenerator::NamedStruct>
DdktlGenerator::NameStructs(const std::vector<std::unique_ptr<flat::Struct>>& struct_infos) {
    std::map<const flat::Decl*, NamedStruct> named_structs;
    for (const auto& struct_info : struct_infos) {
        const bool packed = struct_info->HasAttribute("Packed");
        if (struct_info->GetAttribute("repr") == "C") {
            std::string name = ToSnakeCase(struct_info->name.name().data());
            std::string type_name = name + "_t";
            named_structs.emplace(struct_info.get(),
                                  NamedStruct{std::move(name), std::move(type_name), packed,
                                              *struct_info});
        } else {
            const std::string name = struct_info->name.name().data();
            named_structs.emplace(struct_info.get(), NamedStruct{name, name, packed, *struct_info});
        }
    }
    return named_structs;
}
#endif

std::map<const flat::Decl*, DdkGenerator::NamedUnion>
DdkGenerator::NameUnions(const std::vector<std::unique_ptr<flat::Union>>& union_infos) {
    std::map<const flat::Decl*, NamedUnion> named_unions;
    for (const auto& union_info : union_infos) {
        std::string union_name = ToSnakeCase(union_info->name.name().data());
        std::string type_name = union_name + "_t";
        std::string doc = union_info->GetAttribute("Doc");
        named_unions.emplace(union_info.get(),
                             NamedUnion{std::move(union_name), std::move(type_name), std::move(doc),
                                        *union_info});
    }
    return named_unions;
}

#if 0
std::map<const flat::Decl*, DdkGenerator::NamedUnion>
DdktlGenerator::NameUnions(const std::vector<std::unique_ptr<flat::Union>>& union_infos) {
    std::map<const flat::Decl*, NamedUnion> named_unions;
    for (const auto& union_info : union_infos) {
        if (union_info->GetAttribute("repr") == "C") {
            std::string union_name = ToSnakeCase(union_info->name.name().data());
            std::string type_name = union_name + "_t";
            named_unions.emplace(union_info.get(),
                                 NamedUnion{std::move(union_name), std::move(type_name),
                                            *union_info});
        } else {
            const std::string union_name = union_info->name.name().data();
            named_unions.emplace(union_info.get(),
                                 NamedUnion{union_name, union_name, *union_info});
        }
    }
    return named_unions;
}
#endif

void DdkGenerator::ProduceConstForwardDeclaration(const NamedConst& named_const) {
    // TODO(TO-702)
}

void DdkGenerator::ProduceProtocolForwardDeclaration(const NamedInterface& named_interface) {
    GenerateStructTypedef(named_interface.snake_case_name, named_interface.snake_case_name + "_t");

    for (const auto& method_info : named_interface.methods) {
        if (method_info.async) {
            std::vector<Member> input;
            input.reserve(method_info.output_parameters.size());
            for (const auto& parameter : method_info.output_parameters) {
                input.push_back(CreateMember(library_, parameter));
            }

            file_ << "typedef ";
            const auto method_name = method_info.protocol_name + "_callback";
            EmitProtocolMethodPtrDecl(&file_, method_name, input, {});
            file_ << ");\n";
        }
    }
}

#if 0
void DdktlGenerator::ProduceProtocolForwardDeclaration(const NamedInterface& named_interface) {}
#endif

void DdkGenerator::ProduceEnumForwardDeclaration(const NamedEnum& named_enum) {
    types::PrimitiveSubtype subtype = named_enum.enum_info.type;
    EmitDocstring(&file_, named_enum, false);
    GenerateIntegerTypedef(subtype, named_enum.type_name);
    for (const auto& member : named_enum.enum_info.members) {
        std::string member_name = named_enum.name + "_" + NameIdentifier(member.name);
        std::string member_value;
        EnumValue(named_enum.enum_info.type, member.value.get(), library_, &member_value);
        struct {
            std::string doc;
        } temp = {member.GetAttribute("Doc")};
        EmitDocstring(&file_, temp, true);
        GenerateIntegerDefine(member_name, subtype, std::move(member_value));
    }

    EmitBlank(&file_);
}

#if 0
void DdktlGenerator::ProduceEnumForwardDeclaration(const NamedEnum& named_enum) {
    types::PrimitiveSubtype subtype = named_enum.enum_info.type;
    std::string underlying_type = NamePrimitiveCType(subtype);
    file_ << "enum class " << named_enum.name << " : " << underlying_type << " {\n";
    for (const auto& member : named_enum.enum_info.members) {
        std::string member_name = NameIdentifier(member.name);
        std::string member_value;
        EnumValue(named_enum.enum_info.type, member.value.get(), library_, &member_value);
        file_ << kIndent << member_name << " = " << member_value << ",\n";
    }
    file_ << "};\n";
}
#endif

void DdkGenerator::ProduceStructForwardDeclaration(const NamedStruct& named_struct) {
    // TODO: Hack - structs with no members are defined in a different header.
    if (named_struct.struct_info.members.empty()) return;

    GenerateStructTypedef(named_struct.name, named_struct.type_name);
}

void DdkGenerator::ProduceUnionForwardDeclaration(const NamedUnion& named_union) {
    GenerateUnionTypedef(named_union.name, named_union.type_name);
}

void DdkGenerator::ProduceConstDeclaration(const NamedConst& named_const) {
    const flat::Const& ci = named_const.const_info;

    // Some constants are not literals.  Odd.
    if (ci.value->kind != flat::Constant::Kind::kLiteral) {
        return;
    }

    EmitDocstring(&file_, named_const, false);
    switch (ci.type->kind) {
    case flat::Type::Kind::kPrimitive:
        GeneratePrimitiveDefine(
            named_const.name,
            static_cast<flat::PrimitiveType*>(ci.type.get())->subtype,
            static_cast<flat::LiteralConstant*>(ci.value.get())->literal->location().data());
        break;
    case flat::Type::Kind::kString:
        GenerateStringDefine(
            named_const.name,
            static_cast<flat::LiteralConstant*>(ci.value.get())->literal->location().data());
        break;
    default:
        abort();
    }
    EmitBlank(&file_);
}

void DdkGenerator::ProduceProtocolImplementation(const NamedInterface& named_interface) {
    const auto& proto_name = named_interface.snake_case_name;

    if (named_interface.type == InterfaceType::kCallback) {
        assert(named_interface.methods.size() == 1 && "callback should only have 1 function");

        file_ << "struct " << proto_name << " {\n";
        const auto& method_info = named_interface.methods[0];
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output, false);

        file_ << kIndent;
        EmitProtocolMethodPtrDecl(&file_, method_info.c_name, input, output);
        file_ << ");\n";
        file_ << kIndent << "void* ctx;\n";
        file_ << "};\n";
        EmitBlank(&file_);
        return;
    }

    file_ << "typedef struct " << proto_name << "_ops {\n";
    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output, false);

        file_ << kIndent;
        EmitProtocolMethodPtrDecl(&file_, method_info.c_name, input, output);
        file_ << ");\n";
    }
    file_ << "} " << proto_name << "_ops_t;\n";
    EmitBlank(&file_);

    // Emit Protocol.
    EmitDocstring(&file_, named_interface, false);
    file_ << "struct " << proto_name << " {\n";
    file_ << kIndent << proto_name << "_ops_t* ops;\n";
    file_ << kIndent << "void* ctx;\n";
    file_ << "};\n";
    EmitBlank(&file_);

    // Emit Protocol helper functions.
    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output, false);

        EmitDocstring(&file_, method_info, false);
        file_ << "static inline ";
        EmitProtocolMethodWithSpecificCtxDecl(
            &file_, proto_name, method_info.protocol_name, input, output);
        file_ << ") {\n"
              << kIndent;
        EmitDdkProtocolMethodImpl(&file_, method_info.c_name, input, output);
        file_ << "}\n";
    }
    EmitBlank(&file_);

    // Emit Protocol async helper functions.
    for (const auto& method_info : named_interface.methods) {
        if (!method_info.async || !method_info.generate_sync_method) continue;
        // Generate context struct.
        std::vector<DdkGenerator::Member> members;
        members.reserve(method_info.output_parameters.size() + 1);
        members.push_back(DdkGenerator::Member{
            .kind = flat::Type::Kind::kIdentifier,
            .decl_kind = flat::Decl::Kind::kStruct,
            .type = "sync_completion_t",
            .name = "completion",
            .element_type = "",
            .array_counts = {},
            .nullability = types::Nullability::kNonnullable,
        });
        for (const auto& member : method_info.output_parameters) {
            members.push_back(CreateMember(library_, member, false));
        }
        GenerateStructDeclaration(method_info.protocol_name + "_callback_context", members, false,
                                  true);
        EmitBlank(&file_);

        // Generate callback function.
        members.erase(members.begin());
        file_ << "static ";
        EmitMethodDeclHelper(&file_, method_info.protocol_name + "_cb", members, {},
                             "void* cookie");
        file_ << ") {\n";
        EmitCallbackMethodImpl(&file_, method_info.protocol_name, members);
        file_ << "}\n";
        EmitBlank(&file_);

        // Generated sync version of helper function.
        auto method_info2 = method_info;
        method_info2.async = false;
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info2, &input, &output, false);

        file_ << "static inline ";
        EmitProtocolMethodWithSpecificCtxDecl(
            &file_, proto_name, method_info.protocol_name + "_sync", input,
            output);
        file_ << ") {\n";

        input.clear();
        output.clear();
        GetMethodParameters(library_, method_info, &input, &output, false);
        EmitSyncMethodImpl(&file_, proto_name, method_info.protocol_name, input, members);
        file_ << "}\n";
    }
}

void DdktlGenerator::ProduceExample(const NamedInterface& named_interface) {
    if (named_interface.type == InterfaceType::kCallback ||
        named_interface.type == InterfaceType::kInterface)
        return;

    const auto& shortname = named_interface.shortname;
    const auto& sc_name = named_interface.snake_case_name;
    const auto& cc_name = named_interface.camel_case_name;
    const auto lc_name = ToLispCase(sc_name);

    file_ << "// DDK " << ToLispCase(sc_name) << " support\n";
    file_ << "//\n";
    file_ << "// :: Proxies ::\n";
    file_ << "//\n";
    file_ << "// ddk::" << cc_name << "Client is a simple wrapper around\n";
    file_ << "// " << sc_name << "_t. It does not own the pointers passed to it\n";
    file_ << "//\n";
    file_ << "// :: Mixins ::\n";
    file_ << "//\n";
    file_ << "// ddk::" << cc_name << " is a mixin class that simplifies writing DDK "
          << "drivers\n";
    file_ << "// that implement the " << ToLispCase(shortname)
          << " protocol. It doesn't set the base protocol.\n";
    file_ << "//\n";
    file_ << "// :: Examples ::\n";
    file_ << "//\n";
    file_ << "// // A driver that implements a ZX_PROTOCOL_" << ToSnakeCase(shortname, true)
          << " device.\n";
    file_ << "// class " << shortname << "Device {\n";
    file_ << "// using " << shortname << "DeviceType = ddk::Device<" << shortname
          << "Device, /* ddk mixins */>;\n";
    file_ << "//\n";
    file_ << "// class " << shortname << "Device : public " << shortname << "DeviceType,\n";
    file_ << "// " << std::string(shortname.size() + 15, ' ') << "public ddk::" << cc_name << "<"
          << shortname << "Device> {\n";
    file_ << "//   public:\n";
    file_ << "// " << kIndent << shortname << "Device(zx_device_t* parent)\n";
    file_ << "// " << kIndent << kIndent << ": " << shortname << "DeviceType(\"my-" << lc_name
          << "-device\", parent) {}\n";
    file_ << "//\n";
    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output,
                            named_interface.handle_wrappers);

        file_ << "// " << kIndent;
        EmitProtocolMethodDecl(&file_, method_info.protocol_name, input, output);
        file_ << ");\n";
        file_ << "//\n";
    }
    file_ << "// " << kIndent << "...\n";
    file_ << "// };\n";
    EmitBlank(&file_);
}

void DdktlGenerator::ProduceProtocolImplementation(const NamedInterface& named_interface) {
    if (named_interface.type == InterfaceType::kCallback) return;

    const auto& sc_name = named_interface.snake_case_name;
    const auto& cc_name = named_interface.camel_case_name;

    const auto& ops = sc_name + "_ops_";

    EmitDocstring(&file_, named_interface, false);
    file_ << "template <typename D, typename Base = internal::base_mixin>\n";
    file_ << "class " << cc_name << " : public Base {\n";
    file_ << "public:\n";
    file_ << kIndent << cc_name << "() {\n";
    file_ << kIndent << kIndent << "internal::Check" << cc_name << "Subclass<D>();\n";
    for (const auto& method_info : named_interface.methods) {
        file_ << kIndent << kIndent << ops << "." << method_info.c_name
              << " = " << method_info.protocol_name << ";\n";
    }
    if (named_interface.type != InterfaceType::kInterface) {
        EmitBlank(&file_);
        file_ << kIndent << kIndent << "if constexpr (internal::is_base_proto<Base>::value) {\n";
        file_ << kIndent << kIndent << kIndent << "auto dev = static_cast<D*>(this);\n";
        file_ << kIndent << kIndent << kIndent
              << "// Can only inherit from one base_protocol implementation.\n";
        file_ << kIndent << kIndent << kIndent << "ZX_ASSERT(dev->ddk_proto_id_ == 0);\n";
        file_ << kIndent << kIndent << kIndent << "dev->ddk_proto_id_ = ZX_PROTOCOL_"
            << ToSnakeCase(named_interface.shortname, true) << ";\n";
        file_ << kIndent << kIndent << kIndent << "dev->ddk_proto_ops_ = &" << ops << ";\n";
        file_ << kIndent << kIndent << "}\n";
    }
    file_ << kIndent << "}\n";
    EmitBlank(&file_);
    file_ << "protected:\n";
    file_ << kIndent << sc_name << "_ops_t " << ops << " = {};\n";
    EmitBlank(&file_);
    file_ << "private:\n";
    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output, false);

        EmitDocstring(&file_, method_info, true);
        file_ << kIndent << "static ";
        EmitProtocolMethodWithCtxDecl(&file_, method_info.protocol_name, input, output);
        file_ << ") {\n";
        if (named_interface.handle_wrappers) {
            std::vector<Member> input2;
            std::vector<Member> output2;
            GetMethodParameters(library_, method_info, &input2, &output2, true);
            EmitDdktlProtocolMethodImpl(&file_, method_info.protocol_name, input2, output2, true);
        } else {
            EmitDdktlProtocolMethodImpl(&file_, method_info.protocol_name, input, output, false);
        }
        file_ << kIndent << "}\n";
    }
    file_ << "};\n";
    EmitBlank(&file_);

    ProduceClientImplementation(named_interface);
}

void DdktlGenerator::ProduceClientImplementation(const NamedInterface& named_interface) {
    if (named_interface.type == InterfaceType::kCallback) return;

    const auto& sc_name = named_interface.snake_case_name;
    const auto& cc_name = named_interface.camel_case_name;

    const auto type = sc_name + "_t";
    const auto proto_id = "ZX_PROTOCOL_" + ToSnakeCase(named_interface.shortname, true);

    file_ << "class " << cc_name << "Client {\n";
    file_ << "public:\n";
    file_ << kIndent << cc_name << "Client()\n";
    file_ << kIndent << kIndent << ": ops_(nullptr), ctx_(nullptr) {}\n";
    file_ << kIndent << cc_name << "Client(const " << type << "* proto)\n";
    file_ << kIndent << kIndent << ": ops_(proto->ops), ctx_(proto->ctx) {}\n";
    if (named_interface.type != InterfaceType::kInterface) {
        EmitBlank(&file_);
        file_ << kIndent << cc_name << "Client(zx_device_t* parent) {\n";
        file_ << kIndent << kIndent << type << " proto;\n";
        file_ << kIndent << kIndent << "if (device_get_protocol(parent, " << proto_id
              << ", &proto) == ZX_OK) {\n";
        file_ << kIndent << kIndent << kIndent << "ops_ = proto.ops;\n";
        file_ << kIndent << kIndent << kIndent << "ctx_ = proto.ctx;\n";
        file_ << kIndent << kIndent << "} else {\n";
        file_ << kIndent << kIndent << kIndent << "ops_ = nullptr;\n";
        file_ << kIndent << kIndent << kIndent << "ctx_ = nullptr;\n";
        file_ << kIndent << kIndent << "}\n";
        file_ << kIndent << "}\n";
    }
    EmitBlank(&file_);
    file_ << kIndent << "void GetProto(" << type << "* proto) const {\n";
    file_ << kIndent << kIndent << "proto->ctx = ctx_;\n";
    file_ << kIndent << kIndent << "proto->ops = ops_;\n";
    file_ << kIndent << "}\n";
    file_ << kIndent << "bool is_valid() const {\n";
    file_ << kIndent << kIndent << "return ops_ != nullptr;\n";
    file_ << kIndent << "}\n";
    file_ << kIndent << "void clear() {\n";
    file_ << kIndent << kIndent << "ctx_ = nullptr;\n";
    file_ << kIndent << kIndent << "ops_ = nullptr;\n";
    file_ << kIndent << "}\n";
    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output,
                            named_interface.handle_wrappers);

        EmitDocstring(&file_, method_info, true);
        file_ << kIndent;
        EmitProtocolMethodDecl(&file_, method_info.proxy_name, input, output);
        file_ << ") const {\n"
              << kIndent << kIndent;
        EmitClientMethodImpl(&file_, method_info.c_name, input, output,
                             named_interface.handle_wrappers);
        file_ << kIndent << "}\n";
    }
    EmitBlank(&file_);
    file_ << "private:\n";
    file_ << kIndent << sc_name << "_ops_t* ops_;\n";
    file_ << kIndent << "void* ctx_;\n";
    file_ << "};\n";
    EmitBlank(&file_);
}

void DdktlGenerator::ProduceProtocolSubclass(const NamedInterface& named_interface) {
    if (named_interface.type == InterfaceType::kCallback) return;

    const auto& sc_name = named_interface.snake_case_name;
    const auto& cc_name = named_interface.camel_case_name;

    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output,
                            named_interface.handle_wrappers);

        file_ << "DECLARE_HAS_MEMBER_FN_WITH_SIGNATURE(has_" << sc_name << "_" << method_info.c_name
              << ", " << method_info.protocol_name << ",\n";
        file_ << kIndent << kIndent;
        EmitProtocolMethodTemplateDecl(&file_, input, output);
    }
    EmitBlank(&file_);

    file_ << "template <typename D>\n";
    file_ << "constexpr void Check" << cc_name << "Subclass() {\n";
    for (const auto& method_info : named_interface.methods) {
        std::vector<Member> input;
        std::vector<Member> output;
        GetMethodParameters(library_, method_info, &input, &output,
                            named_interface.handle_wrappers);

        file_ << kIndent << "static_assert(internal::has_" << sc_name << "_" << method_info.c_name
              << "<D>::value,\n";
        file_ << kIndent << kIndent << "\"" << cc_name << " subclasses must implement \"\n";
        file_ << kIndent << kIndent << "\"";
        EmitProtocolMethodDecl(&file_, method_info.protocol_name, input, output);
        file_ << "\");\n";
    }
    file_ << "}\n";
    EmitBlank(&file_);
}

void DdkGenerator::ProduceStructDeclaration(const NamedStruct& named_struct) {
    // TODO: Hack - structs with no members are defined in a different header.
    if (named_struct.struct_info.members.empty()) return;

    std::vector<DdkGenerator::Member> members =
        GenerateMembers(library_, named_struct.struct_info.members);
    EmitDocstring(&file_, named_struct, false);
    GenerateStructDeclaration(named_struct.name, members, named_struct.packed);

    EmitBlank(&file_);
}

void DdkGenerator::ProduceUnionDeclaration(const NamedUnion& named_union) {
    std::vector<DdkGenerator::Member> members =
        GenerateMembers(library_, named_union.union_info.members);
    EmitDocstring(&file_, named_union, false);
    GenerateTaggedUnionDeclaration(named_union.name, members);

    EmitBlank(&file_);
}

std::ostringstream DdkGenerator::ProduceHeader() {
    std::map<const flat::Decl*, NamedConst> named_consts =
        NameConsts(library_->const_declarations_);
    std::map<const flat::Decl*, NamedEnum> named_enums = NameEnums(library_->enum_declarations_);
    std::map<const flat::Decl*, NamedInterface> named_interfaces =
        NameInterfaces(library_->interface_declarations_);
    std::map<const flat::Decl*, NamedStruct> named_structs =
        NameStructs(library_->struct_declarations_);
    std::map<const flat::Decl*, NamedUnion> named_unions =
        NameUnions(library_->union_declarations_);

    GeneratePrologues();

    file_ << "\n// Forward declarations\n\n";

    for (const auto* decl : library_->declaration_order_) {
        switch (decl->kind) {
        case flat::Decl::Kind::kConst: {
            auto iter = named_consts.find(decl);
            if (iter != named_consts.end()) {
                ProduceConstForwardDeclaration(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kEnum: {
            auto iter = named_enums.find(decl);
            if (iter != named_enums.end()) {
                ProduceEnumForwardDeclaration(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kInterface: {
            auto iter = named_interfaces.find(decl);
            if (iter != named_interfaces.end()) {
                ProduceProtocolForwardDeclaration(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kStruct: {
            auto iter = named_structs.find(decl);
            if (iter != named_structs.end()) {
                ProduceStructForwardDeclaration(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kUnion: {
            auto iter = named_unions.find(decl);
            if (iter != named_unions.end()) {
                ProduceUnionForwardDeclaration(iter->second);
            }
            break;
        }
        default:
            abort();
        }
    }

    file_ << "\n// Declarations\n\n";

    for (const auto* decl : library_->declaration_order_) {
        switch (decl->kind) {
        case flat::Decl::Kind::kConst: {
            auto iter = named_consts.find(decl);
            if (iter != named_consts.end()) {
                ProduceConstDeclaration(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kEnum:
            // Enums can be entirely forward declared, as they have no
            // dependencies other than standard headers.
            break;
        case flat::Decl::Kind::kInterface: {
            auto iter = named_interfaces.find(decl);
            if (iter != named_interfaces.end()) {
                ProduceProtocolImplementation(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kStruct: {
            auto iter = named_structs.find(decl);
            if (iter != named_structs.end()) {
                ProduceStructDeclaration(iter->second);
            }
            break;
        }
        case flat::Decl::Kind::kUnion: {
            auto iter = named_unions.find(decl);
            if (iter != named_unions.end()) {
                ProduceUnionDeclaration(iter->second);
            }
            break;
        }
        default:
            abort();
        }
    }

    GenerateEpilogues();

    return std::move(file_);
}

std::ostringstream DdktlGenerator::ProduceHeader() {
    std::map<const flat::Decl*, NamedInterface> named_interfaces =
        NameInterfaces(library_->interface_declarations_);

    GeneratePrologues();
    for (const auto& iter : named_interfaces) {
        ProduceExample(iter.second);
    }

    EmitNamespacePrologue(&file_, "ddk");
    EmitBlank(&file_);

    for (const auto* decl : library_->declaration_order_) {
        switch (decl->kind) {
        case flat::Decl::Kind::kInterface: {
            auto iter = named_interfaces.find(decl);
            if (iter != named_interfaces.end()) {
                ProduceProtocolImplementation(iter->second);
            }
            break;
        }
        default:
            continue;
        }
    }

    GenerateEpilogues();

    return std::move(file_);
}

std::ostringstream DdktlGenerator::ProduceInternalHeader() {
    std::map<const flat::Decl*, NamedInterface> named_interfaces =
        NameInterfaces(library_->interface_declarations_);

    EmitFileComment(&file_, library_->name().back());
    EmitHeaderGuard(&file_);
    EmitBlank(&file_);
    EmitIncludeHeader(&file_, "<" + ToLispCase(StringJoin(library_->name(), "/")) + ".h>");
    EmitIncludeHeader(&file_, "<type_traits>");
    EmitBlank(&file_);
    EmitNamespacePrologue(&file_, "ddk");
    EmitNamespacePrologue(&file_, "internal");
    EmitBlank(&file_);

    for (const auto* decl : library_->declaration_order_) {
        switch (decl->kind) {
        case flat::Decl::Kind::kInterface: {
            auto iter = named_interfaces.find(decl);
            if (iter != named_interfaces.end()) {
                ProduceProtocolSubclass(iter->second);
            }
            break;
        }
        default:
            break;
        }
    }

    EmitNamespaceEpilogue(&file_, "internal");
    EmitNamespaceEpilogue(&file_, "ddk");

    return std::move(file_);
}
} // namespace banjo