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

// This file was automatically generated with:
// ../../ui/gfx/x/gen_xproto.py \
//    ../../third_party/xcbproto/src \
//    gen/ui/gfx/x \
//    bigreq \
//    composite \
//    damage \
//    dpms \
//    dri2 \
//    dri3 \
//    ge \
//    glx \
//    present \
//    randr \
//    record \
//    render \
//    res \
//    screensaver \
//    shape \
//    shm \
//    sync \
//    xc_misc \
//    xevie \
//    xf86dri \
//    xf86vidmode \
//    xfixes \
//    xinerama \
//    xinput \
//    xkb \
//    xprint \
//    xproto \
//    xselinux \
//    xtest \
//    xv \
//    xvmc

#include "res.h"

#include <xcb/xcb.h>
#include <xcb/xcbext.h>

#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
#include "ui/gfx/x/xproto_internal.h"

namespace x11 {

Res::Res(Connection* connection, const x11::QueryExtensionReply& info)
    : connection_(connection), info_(info) {}

Future<Res::QueryVersionReply> Res::QueryVersion(
    const Res::QueryVersionRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& client_major = request.client_major;
  auto& client_minor = request.client_minor;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 0;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // client_major
  buf.Write(&client_major);

  // client_minor
  buf.Write(&client_minor);

  Align(&buf, 4);

  return connection_->SendRequest<Res::QueryVersionReply>(
      &buf, "Res::QueryVersion", false);
}

Future<Res::QueryVersionReply> Res::QueryVersion(const uint8_t& client_major,
                                                 const uint8_t& client_minor) {
  return Res::QueryVersion(
      Res::QueryVersionRequest{client_major, client_minor});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Res::QueryVersionReply> detail::ReadReply<
    Res::QueryVersionReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Res::QueryVersionReply>();

  auto& sequence = (*reply).sequence;
  auto& server_major = (*reply).server_major;
  auto& server_minor = (*reply).server_minor;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // server_major
  Read(&server_major, &buf);

  // server_minor
  Read(&server_minor, &buf);

  Align(&buf, 4);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Res::QueryClientsReply> Res::QueryClients(
    const Res::QueryClientsRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 1;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  Align(&buf, 4);

  return connection_->SendRequest<Res::QueryClientsReply>(
      &buf, "Res::QueryClients", false);
}

Future<Res::QueryClientsReply> Res::QueryClients() {
  return Res::QueryClients(Res::QueryClientsRequest{});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Res::QueryClientsReply> detail::ReadReply<
    Res::QueryClientsReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Res::QueryClientsReply>();

  auto& sequence = (*reply).sequence;
  uint32_t num_clients{};
  auto& clients = (*reply).clients;
  size_t clients_len = clients.size();

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // num_clients
  Read(&num_clients, &buf);

  // pad1
  Pad(&buf, 20);

  // clients
  clients.resize(num_clients);
  for (auto& clients_elem : clients) {
    // clients_elem
    {
      auto& resource_base = clients_elem.resource_base;
      auto& resource_mask = clients_elem.resource_mask;

      // resource_base
      Read(&resource_base, &buf);

      // resource_mask
      Read(&resource_mask, &buf);
    }
  }

  Align(&buf, 4);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Res::QueryClientResourcesReply> Res::QueryClientResources(
    const Res::QueryClientResourcesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& xid = request.xid;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 2;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // xid
  buf.Write(&xid);

  Align(&buf, 4);

  return connection_->SendRequest<Res::QueryClientResourcesReply>(
      &buf, "Res::QueryClientResources", false);
}

Future<Res::QueryClientResourcesReply> Res::QueryClientResources(
    const uint32_t& xid) {
  return Res::QueryClientResources(Res::QueryClientResourcesRequest{xid});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Res::QueryClientResourcesReply> detail::ReadReply<
    Res::QueryClientResourcesReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Res::QueryClientResourcesReply>();

  auto& sequence = (*reply).sequence;
  uint32_t num_types{};
  auto& types = (*reply).types;
  size_t types_len = types.size();

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // num_types
  Read(&num_types, &buf);

  // pad1
  Pad(&buf, 20);

  // types
  types.resize(num_types);
  for (auto& types_elem : types) {
    // types_elem
    {
      auto& resource_type = types_elem.resource_type;
      auto& count = types_elem.count;

      // resource_type
      Read(&resource_type, &buf);

      // count
      Read(&count, &buf);
    }
  }

  Align(&buf, 4);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Res::QueryClientPixmapBytesReply> Res::QueryClientPixmapBytes(
    const Res::QueryClientPixmapBytesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& xid = request.xid;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 3;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // xid
  buf.Write(&xid);

  Align(&buf, 4);

  return connection_->SendRequest<Res::QueryClientPixmapBytesReply>(
      &buf, "Res::QueryClientPixmapBytes", false);
}

Future<Res::QueryClientPixmapBytesReply> Res::QueryClientPixmapBytes(
    const uint32_t& xid) {
  return Res::QueryClientPixmapBytes(Res::QueryClientPixmapBytesRequest{xid});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Res::QueryClientPixmapBytesReply> detail::ReadReply<
    Res::QueryClientPixmapBytesReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Res::QueryClientPixmapBytesReply>();

  auto& sequence = (*reply).sequence;
  auto& bytes = (*reply).bytes;
  auto& bytes_overflow = (*reply).bytes_overflow;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // bytes
  Read(&bytes, &buf);

  // bytes_overflow
  Read(&bytes_overflow, &buf);

  Align(&buf, 4);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Res::QueryClientIdsReply> Res::QueryClientIds(
    const Res::QueryClientIdsRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  uint32_t num_specs{};
  auto& specs = request.specs;
  size_t specs_len = specs.size();

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 4;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // num_specs
  num_specs = specs.size();
  buf.Write(&num_specs);

  // specs
  DCHECK_EQ(static_cast<size_t>(num_specs), specs.size());
  for (auto& specs_elem : specs) {
    // specs_elem
    {
      auto& client = specs_elem.client;
      auto& mask = specs_elem.mask;

      // client
      buf.Write(&client);

      // mask
      uint32_t tmp0;
      tmp0 = static_cast<uint32_t>(mask);
      buf.Write(&tmp0);
    }
  }

  Align(&buf, 4);

  return connection_->SendRequest<Res::QueryClientIdsReply>(
      &buf, "Res::QueryClientIds", false);
}

Future<Res::QueryClientIdsReply> Res::QueryClientIds(
    const std::vector<ClientIdSpec>& specs) {
  return Res::QueryClientIds(Res::QueryClientIdsRequest{specs});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Res::QueryClientIdsReply> detail::ReadReply<
    Res::QueryClientIdsReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Res::QueryClientIdsReply>();

  auto& sequence = (*reply).sequence;
  uint32_t num_ids{};
  auto& ids = (*reply).ids;
  size_t ids_len = ids.size();

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // num_ids
  Read(&num_ids, &buf);

  // pad1
  Pad(&buf, 20);

  // ids
  ids.resize(num_ids);
  for (auto& ids_elem : ids) {
    // ids_elem
    {
      auto& spec = ids_elem.spec;
      auto& length = ids_elem.length;
      auto& value = ids_elem.value;
      size_t value_len = value.size();

      // spec
      {
        auto& client = spec.client;
        auto& mask = spec.mask;

        // client
        Read(&client, &buf);

        // mask
        uint32_t tmp1;
        Read(&tmp1, &buf);
        mask = static_cast<Res::ClientIdMask>(tmp1);
      }

      // length
      Read(&length, &buf);

      // value
      value.resize((length) / (4));
      for (auto& value_elem : value) {
        // value_elem
        Read(&value_elem, &buf);
      }
    }
  }

  Align(&buf, 4);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Res::QueryResourceBytesReply> Res::QueryResourceBytes(
    const Res::QueryResourceBytesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& client = request.client;
  uint32_t num_specs{};
  auto& specs = request.specs;
  size_t specs_len = specs.size();

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 5;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // client
  buf.Write(&client);

  // num_specs
  num_specs = specs.size();
  buf.Write(&num_specs);

  // specs
  DCHECK_EQ(static_cast<size_t>(num_specs), specs.size());
  for (auto& specs_elem : specs) {
    // specs_elem
    {
      auto& resource = specs_elem.resource;
      auto& type = specs_elem.type;

      // resource
      buf.Write(&resource);

      // type
      buf.Write(&type);
    }
  }

  Align(&buf, 4);

  return connection_->SendRequest<Res::QueryResourceBytesReply>(
      &buf, "Res::QueryResourceBytes", false);
}

Future<Res::QueryResourceBytesReply> Res::QueryResourceBytes(
    const uint32_t& client,
    const std::vector<ResourceIdSpec>& specs) {
  return Res::QueryResourceBytes(Res::QueryResourceBytesRequest{client, specs});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Res::QueryResourceBytesReply> detail::ReadReply<
    Res::QueryResourceBytesReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Res::QueryResourceBytesReply>();

  auto& sequence = (*reply).sequence;
  uint32_t num_sizes{};
  auto& sizes = (*reply).sizes;
  size_t sizes_len = sizes.size();

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // num_sizes
  Read(&num_sizes, &buf);

  // pad1
  Pad(&buf, 20);

  // sizes
  sizes.resize(num_sizes);
  for (auto& sizes_elem : sizes) {
    // sizes_elem
    {
      auto& size = sizes_elem.size;
      uint32_t num_cross_references{};
      auto& cross_references = sizes_elem.cross_references;
      size_t cross_references_len = cross_references.size();

      // size
      {
        auto& spec = size.spec;
        auto& bytes = size.bytes;
        auto& ref_count = size.ref_count;
        auto& use_count = size.use_count;

        // spec
        {
          auto& resource = spec.resource;
          auto& type = spec.type;

          // resource
          Read(&resource, &buf);

          // type
          Read(&type, &buf);
        }

        // bytes
        Read(&bytes, &buf);

        // ref_count
        Read(&ref_count, &buf);

        // use_count
        Read(&use_count, &buf);
      }

      // num_cross_references
      Read(&num_cross_references, &buf);

      // cross_references
      cross_references.resize(num_cross_references);
      for (auto& cross_references_elem : cross_references) {
        // cross_references_elem
        {
          auto& spec = cross_references_elem.spec;
          auto& bytes = cross_references_elem.bytes;
          auto& ref_count = cross_references_elem.ref_count;
          auto& use_count = cross_references_elem.use_count;

          // spec
          {
            auto& resource = spec.resource;
            auto& type = spec.type;

            // resource
            Read(&resource, &buf);

            // type
            Read(&type, &buf);
          }

          // bytes
          Read(&bytes, &buf);

          // ref_count
          Read(&ref_count, &buf);

          // use_count
          Read(&use_count, &buf);
        }
      }
    }
  }

  Align(&buf, 4);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

}  // namespace x11