// Copyright (c) Facebook, Inc. and its affiliates.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "rsocket/framing/FrameSerializer_v1_0.h"

#include <folly/io/Cursor.h>

namespace rsocket {

constexpr const ProtocolVersion FrameSerializerV1_0::Version;
constexpr const size_t FrameSerializerV1_0::kFrameHeaderSize;
constexpr const size_t FrameSerializerV1_0::kMinBytesNeededForAutodetection;

namespace {
constexpr const uint32_t kMedatadaLengthSize = 3u; // bytes
constexpr const uint32_t kMaxMetadataLength = 0xFFFFFFu; // 24bit max value
} // namespace

ProtocolVersion FrameSerializerV1_0::protocolVersion() const {
  return Version;
}

static FrameType deserializeFrameType(uint16_t frameType) {
  if (frameType > static_cast<uint8_t>(FrameType::RESUME_OK) &&
      frameType != static_cast<uint8_t>(FrameType::EXT)) {
    return FrameType::RESERVED;
  }
  return static_cast<FrameType>(frameType);
}

static void serializeHeaderInto(
    folly::io::QueueAppender& appender,
    const FrameHeader& header) {
  appender.writeBE<int32_t>(static_cast<int32_t>(header.streamId));

  auto type = static_cast<uint8_t>(header.type); // 6 bit
  auto flags = static_cast<uint16_t>(header.flags); // 10 bit
  appender.write(static_cast<uint8_t>((type << 2) | (flags >> 8)));
  appender.write(static_cast<uint8_t>(flags)); // lower 8 bits
}

static void deserializeHeaderFrom(folly::io::Cursor& cur, FrameHeader& header) {
  auto streamId = cur.readBE<int32_t>();
  if (streamId < 0) {
    throw std::runtime_error("invalid stream id");
  }
  header.streamId = static_cast<StreamId>(streamId);
  uint16_t type = cur.readBE<uint8_t>(); // |Frame Type |I|M|
  header.type = deserializeFrameType(type >> 2);
  header.flags =
      static_cast<FrameFlags>(((type & 0x3) << 8) | cur.readBE<uint8_t>());
}

static void serializeMetadataInto(
    folly::io::QueueAppender& appender,
    std::unique_ptr<folly::IOBuf> metadata) {
  if (metadata == nullptr) {
    return;
  }

  // metadata length field not included in the medatadata length
  uint32_t metadataLength =
      static_cast<uint32_t>(metadata->computeChainDataLength());
  CHECK_LT(metadataLength, kMaxMetadataLength)
      << "Metadata is too big to serialize";

  appender.write(static_cast<uint8_t>(metadataLength >> 16)); // first byte
  appender.write(
      static_cast<uint8_t>((metadataLength >> 8) & 0xFF)); // second byte
  appender.write(static_cast<uint8_t>(metadataLength & 0xFF)); // third byte

  appender.insert(std::move(metadata));
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::deserializeMetadataFrom(
    folly::io::Cursor& cur,
    FrameFlags flags) {
  if (!(flags & FrameFlags::METADATA)) {
    return nullptr;
  }

  uint32_t metadataLength = 0;
  metadataLength |= static_cast<uint32_t>(cur.read<uint8_t>() << 16);
  metadataLength |= static_cast<uint32_t>(cur.read<uint8_t>() << 8);
  metadataLength |= cur.read<uint8_t>();

  CHECK_LE(metadataLength, kMaxMetadataLength)
      << "Read out the 24-bit integer incorrectly somehow";

  std::unique_ptr<folly::IOBuf> metadata;
  cur.clone(metadata, metadataLength);
  return metadata;
}

static std::unique_ptr<folly::IOBuf> deserializeDataFrom(
    folly::io::Cursor& cur) {
  std::unique_ptr<folly::IOBuf> data;
  auto totalLength = cur.totalLength();

  if (totalLength > 0) {
    cur.clone(data, totalLength);
  }
  return data;
}

static Payload deserializePayloadFrom(
    folly::io::Cursor& cur,
    FrameFlags flags) {
  auto metadata = FrameSerializerV1_0::deserializeMetadataFrom(cur, flags);
  auto data = deserializeDataFrom(cur);
  return Payload(std::move(data), std::move(metadata));
}

static void serializePayloadInto(
    folly::io::QueueAppender& appender,
    Payload&& payload) {
  serializeMetadataInto(appender, std::move(payload.metadata));
  if (payload.data) {
    appender.insert(std::move(payload.data));
  }
}

static uint32_t payloadFramingSize(const Payload& payload) {
  return (payload.metadata != nullptr ? kMedatadaLengthSize : 0);
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOutInternal(
    Frame_REQUEST_Base&& frame) const {
  auto queue = createBufferQueue(
      FrameSerializerV1_0::kFrameHeaderSize + sizeof(uint32_t) +
      payloadFramingSize(frame.payload_));

  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);

  appender.writeBE<int32_t>(static_cast<int32_t>(frame.requestN_));
  serializePayloadInto(appender, std::move(frame.payload_));
  return queue.move();
}

static bool deserializeFromInternal(
    Frame_REQUEST_Base& frame,
    std::unique_ptr<folly::IOBuf> in) {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);

    auto requestN = cur.readBE<int32_t>();
    // TODO(lehecka): requestN <= 0
    if (requestN < 0) {
      throw std::runtime_error("invalid request N");
    }
    frame.requestN_ = static_cast<uint32_t>(requestN);
    frame.payload_ = deserializePayloadFrom(cur, frame.header_.flags);
  } catch (...) {
    return false;
  }
  return true;
}

static size_t getResumeIdTokenFramingLength(
    FrameFlags flags,
    const ResumeIdentificationToken& token) {
  return !!(flags & FrameFlags::RESUME_ENABLE)
      ? sizeof(uint16_t) + token.data().size()
      : 0;
}

FrameType FrameSerializerV1_0::peekFrameType(const folly::IOBuf& in) const {
  folly::io::Cursor cur(&in);
  try {
    cur.skip(sizeof(int32_t)); // streamId
    uint8_t type = cur.readBE<uint8_t>(); // |Frame Type |I|M|
    return deserializeFrameType(type >> 2);
  } catch (...) {
    return FrameType::RESERVED;
  }
}

folly::Optional<StreamId> FrameSerializerV1_0::peekStreamId(
    const folly::IOBuf& in,
    bool skipFrameLengthBytes) const {
  folly::io::Cursor cur(&in);
  try {
    if (skipFrameLengthBytes) {
      cur.skip(3); // skip 3 bytes for frame length
    }
    auto streamId = cur.readBE<int32_t>();
    if (streamId < 0) {
      return folly::none;
    }
    return folly::make_optional(static_cast<StreamId>(streamId));
  } catch (...) {
    return folly::none;
  }
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_REQUEST_STREAM&& frame) const {
  return serializeOutInternal(std::move(frame));
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_REQUEST_CHANNEL&& frame) const {
  return serializeOutInternal(std::move(frame));
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_REQUEST_RESPONSE&& frame) const {
  auto queue =
      createBufferQueue(kFrameHeaderSize + payloadFramingSize(frame.payload_));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  serializePayloadInto(appender, std::move(frame.payload_));
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_REQUEST_FNF&& frame) const {
  auto queue =
      createBufferQueue(kFrameHeaderSize + payloadFramingSize(frame.payload_));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  serializePayloadInto(appender, std::move(frame.payload_));
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_REQUEST_N&& frame) const {
  auto queue = createBufferQueue(kFrameHeaderSize + sizeof(uint32_t));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  appender.writeBE<int32_t>(static_cast<int32_t>(frame.requestN_));
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_METADATA_PUSH&& frame) const {
  auto queue = createBufferQueue(kFrameHeaderSize);
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  if (frame.metadata_) {
    appender.insert(std::move(frame.metadata_));
  }
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_CANCEL&& frame) const {
  auto queue = createBufferQueue(kFrameHeaderSize);
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_PAYLOAD&& frame) const {
  auto queue =
      createBufferQueue(kFrameHeaderSize + payloadFramingSize(frame.payload_));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  serializePayloadInto(appender, std::move(frame.payload_));
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_ERROR&& frame) const {
  auto queue = createBufferQueue(
      kFrameHeaderSize + sizeof(uint32_t) + payloadFramingSize(frame.payload_));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  appender.writeBE(static_cast<uint32_t>(frame.errorCode_));
  serializePayloadInto(appender, std::move(frame.payload_));
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_KEEPALIVE&& frame) const {
  auto queue = createBufferQueue(kFrameHeaderSize + sizeof(int64_t));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  appender.writeBE<int64_t>(static_cast<int64_t>(frame.position_));
  if (frame.data_) {
    appender.insert(std::move(frame.data_));
  }
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_SETUP&& frame) const {
  auto queue = createBufferQueue(
      kFrameHeaderSize + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(int32_t) +
      sizeof(int32_t) +
      getResumeIdTokenFramingLength(frame.header_.flags, frame.token_) +
      +sizeof(uint8_t) + frame.metadataMimeType_.length() + sizeof(uint8_t) +
      frame.dataMimeType_.length() + payloadFramingSize(frame.payload_));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);

  serializeHeaderInto(appender, frame.header_);
  CHECK(
      frame.versionMajor_ != ProtocolVersion::Unknown.major ||
      frame.versionMinor_ != ProtocolVersion::Unknown.minor);
  appender.writeBE<uint16_t>(frame.versionMajor_);
  appender.writeBE<uint16_t>(frame.versionMinor_);
  appender.writeBE(static_cast<int32_t>(frame.keepaliveTime_));
  appender.writeBE(static_cast<int32_t>(frame.maxLifetime_));

  if (!!(frame.header_.flags & FrameFlags::RESUME_ENABLE)) {
    appender.writeBE<uint16_t>(
        static_cast<uint16_t>(frame.token_.data().size()));
    appender.push(frame.token_.data().data(), frame.token_.data().size());
  }

  CHECK(
      frame.metadataMimeType_.length() <= std::numeric_limits<uint8_t>::max());
  appender.writeBE(static_cast<uint8_t>(frame.metadataMimeType_.length()));
  appender.push(
      reinterpret_cast<const uint8_t*>(frame.metadataMimeType_.data()),
      frame.metadataMimeType_.length());

  CHECK(frame.dataMimeType_.length() <= std::numeric_limits<uint8_t>::max());
  appender.writeBE(static_cast<uint8_t>(frame.dataMimeType_.length()));
  appender.push(
      reinterpret_cast<const uint8_t*>(frame.dataMimeType_.data()),
      frame.dataMimeType_.length());

  serializePayloadInto(appender, std::move(frame.payload_));
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_LEASE&& frame) const {
  auto queue =
      createBufferQueue(kFrameHeaderSize + sizeof(int32_t) + sizeof(int32_t));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  appender.writeBE(static_cast<int32_t>(frame.ttl_));
  appender.writeBE(static_cast<int32_t>(frame.numberOfRequests_));
  if (frame.metadata_) {
    appender.insert(std::move(frame.metadata_));
  }
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_RESUME&& frame) const {
  auto queue = createBufferQueue(
      kFrameHeaderSize + sizeof(uint16_t) + sizeof(uint16_t) +
      sizeof(uint16_t) + frame.token_.data().size() + sizeof(int32_t) +
      sizeof(int32_t));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);

  CHECK(
      frame.versionMajor_ != ProtocolVersion::Unknown.major ||
      frame.versionMinor_ != ProtocolVersion::Unknown.minor);
  appender.writeBE(static_cast<uint16_t>(frame.versionMajor_));
  appender.writeBE(static_cast<uint16_t>(frame.versionMinor_));

  appender.writeBE<uint16_t>(static_cast<uint16_t>(frame.token_.data().size()));
  appender.push(frame.token_.data().data(), frame.token_.data().size());

  appender.writeBE<int64_t>(frame.lastReceivedServerPosition_);
  appender.writeBE<int64_t>(frame.clientPosition_);
  return queue.move();
}

std::unique_ptr<folly::IOBuf> FrameSerializerV1_0::serializeOut(
    Frame_RESUME_OK&& frame) const {
  auto queue = createBufferQueue(kFrameHeaderSize + sizeof(int64_t));
  folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
  serializeHeaderInto(appender, frame.header_);
  appender.writeBE<int64_t>(frame.position_);
  return queue.move();
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_REQUEST_STREAM& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  return deserializeFromInternal(frame, std::move(in));
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_REQUEST_CHANNEL& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  return deserializeFromInternal(frame, std::move(in));
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_REQUEST_RESPONSE& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    frame.payload_ = deserializePayloadFrom(cur, frame.header_.flags);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_REQUEST_FNF& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    frame.payload_ = deserializePayloadFrom(cur, frame.header_.flags);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_REQUEST_N& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    auto requestN = cur.readBE<int32_t>();
    if (requestN <= 0) {
      throw std::runtime_error("invalid request n");
    }
    frame.requestN_ = static_cast<uint32_t>(requestN);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_METADATA_PUSH& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    // metadata takes the rest of the frame, just like data in other frames
    // that's why we use deserializeDataFrom
    frame.metadata_ = deserializeDataFrom(cur);
  } catch (...) {
    return false;
  }
  return frame.metadata_ != nullptr;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_CANCEL& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_PAYLOAD& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    frame.payload_ = deserializePayloadFrom(cur, frame.header_.flags);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_ERROR& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    frame.errorCode_ = static_cast<ErrorCode>(cur.readBE<uint32_t>());
    frame.payload_ = deserializePayloadFrom(cur, frame.header_.flags);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_KEEPALIVE& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    auto position = cur.readBE<int64_t>();
    if (position < 0) {
      throw std::runtime_error("invalid value for position");
    }
    frame.position_ = static_cast<ResumePosition>(position);
    frame.data_ = deserializeDataFrom(cur);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_SETUP& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);

    frame.versionMajor_ = cur.readBE<uint16_t>();
    frame.versionMinor_ = cur.readBE<uint16_t>();

    auto keepaliveTime = cur.readBE<int32_t>();
    if (keepaliveTime <= 0) {
      throw std::runtime_error("invalid keepalive time");
    }
    frame.keepaliveTime_ = static_cast<uint32_t>(keepaliveTime);

    auto maxLifetime = cur.readBE<int32_t>();
    if (maxLifetime <= 0) {
      throw std::runtime_error("invalid maxLife time");
    }
    frame.maxLifetime_ = static_cast<uint32_t>(maxLifetime);

    if (!!(frame.header_.flags & FrameFlags::RESUME_ENABLE)) {
      auto resumeTokenSize = cur.readBE<uint16_t>();
      std::vector<uint8_t> data(resumeTokenSize);
      cur.pull(data.data(), data.size());
      frame.token_.set(std::move(data));
    } else {
      frame.token_ = ResumeIdentificationToken();
    }

    auto mdmtLen = cur.readBE<uint8_t>();
    frame.metadataMimeType_ = cur.readFixedString(mdmtLen);

    auto dmtLen = cur.readBE<uint8_t>();
    frame.dataMimeType_ = cur.readFixedString(dmtLen);
    frame.payload_ = deserializePayloadFrom(cur, frame.header_.flags);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_LEASE& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);

    auto ttl = cur.readBE<int32_t>();
    if (ttl <= 0) {
      throw std::runtime_error("invalid ttl value");
    }
    frame.ttl_ = static_cast<uint32_t>(ttl);

    auto numberOfRequests = cur.readBE<int32_t>();
    if (numberOfRequests <= 0) {
      throw std::runtime_error("invalid numberOfRequests value");
    }
    frame.numberOfRequests_ = static_cast<uint32_t>(numberOfRequests);
    frame.metadata_ = deserializeDataFrom(cur);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_RESUME& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);
    frame.versionMajor_ = cur.readBE<uint16_t>();
    frame.versionMinor_ = cur.readBE<uint16_t>();

    auto resumeTokenSize = cur.readBE<uint16_t>();
    std::vector<uint8_t> data(resumeTokenSize);
    cur.pull(data.data(), data.size());
    frame.token_.set(std::move(data));

    auto lastReceivedServerPosition = cur.readBE<int64_t>();
    if (lastReceivedServerPosition < 0) {
      throw std::runtime_error("invalid value for lastReceivedServerPosition");
    }
    frame.lastReceivedServerPosition_ =
        static_cast<ResumePosition>(lastReceivedServerPosition);

    auto clientPosition = cur.readBE<int64_t>();
    if (clientPosition < 0) {
      throw std::runtime_error("invalid value for clientPosition");
    }
    frame.clientPosition_ = static_cast<ResumePosition>(clientPosition);
  } catch (...) {
    return false;
  }
  return true;
}

bool FrameSerializerV1_0::deserializeFrom(
    Frame_RESUME_OK& frame,
    std::unique_ptr<folly::IOBuf> in) const {
  folly::io::Cursor cur(in.get());
  try {
    deserializeHeaderFrom(cur, frame.header_);

    auto position = cur.readBE<int64_t>();
    if (position < 0) {
      throw std::runtime_error("invalid value for position");
    }
    frame.position_ = static_cast<ResumePosition>(position);
  } catch (...) {
    return false;
  }
  return true;
}

ProtocolVersion FrameSerializerV1_0::detectProtocolVersion(
    const folly::IOBuf& firstFrame,
    size_t skipBytes) {
  // SETUP frame
  //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  //  |                         Stream ID = 0                         |
  //  +-----------+-+-+-+-+-----------+-------------------------------+
  //  |Frame Type |0|M|R|L|  Flags    |
  //  +-----------+-+-+-+-+-----------+-------------------------------+
  //  |         Major Version         |        Minor Version          |
  //  +-------------------------------+-------------------------------+
  //                                 ...
  //  +-------------------------------+-------------------------------+

  // RESUME frame
  //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  //  |                         Stream ID = 0                         |
  //  +-----------+-+-+---------------+-------------------------------+
  //  |Frame Type |0|0|    Flags      |
  //  +-------------------------------+-------------------------------+
  //  |        Major Version          |         Minor Version         |
  //  +-------------------------------+-------------------------------+
  //                                 ...
  //  +-------------------------------+-------------------------------+

  folly::io::Cursor cur(&firstFrame);
  try {
    cur.skip(skipBytes);

    auto streamId = cur.readBE<int32_t>();
    auto frameType = cur.readBE<uint8_t>() >> 2;
    cur.skip(sizeof(uint8_t)); // flags
    auto majorVersion = cur.readBE<uint16_t>();
    auto minorVersion = cur.readBE<uint16_t>();

    constexpr static const auto kSETUP = 0x01;
    constexpr static const auto kRESUME = 0x0D;

    VLOG(4) << "frameType=" << frameType << "streamId=" << streamId
            << " majorVersion=" << majorVersion
            << " minorVersion=" << minorVersion;

    if (streamId == 0 && (frameType == kSETUP || frameType == kRESUME) &&
        majorVersion == FrameSerializerV1_0::Version.major &&
        minorVersion == FrameSerializerV1_0::Version.minor) {
      return FrameSerializerV1_0::Version;
    }
  } catch (...) {
  }
  return ProtocolVersion::Unknown;
}

size_t FrameSerializerV1_0::frameLengthFieldSize() const {
  return 3; // bytes
}
} // namespace rsocket