// Copyright 2022 The Pigweed Authors
//
// 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
//
//     https://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 "proto_bloat.h"
#include "pw_bloat/bloat_this_binary.h"
#include "pw_protobuf/decoder.h"
#include "pw_protobuf/encoder.h"
#include "pw_protobuf/stream_decoder.h"
#include "pw_protobuf_test_protos/size_report.pwpb.h"
#include "pw_result/result.h"
#include "pw_status/status.h"

#ifndef _PW_PROTOBUF_SIZE_REPORT_NO_CODEGEN
#define _PW_PROTOBUF_SIZE_REPORT_NO_CODEGEN 0
#endif  // _PW_PROTOBUF_SIZE_REPORT_NO_CODEGEN

#ifndef _PW_PROTOBUF_SIZE_REPORT_WIRE_FORMAT
#define _PW_PROTOBUF_SIZE_REPORT_WIRE_FORMAT 0
#endif  // _PW_PROTOBUF_SIZE_REPORT_WIRE_FORMAT

#ifndef _PW_PROTOBUF_SIZE_REPORT_MESSAGE
#define _PW_PROTOBUF_SIZE_REPORT_MESSAGE 0
#endif  // _PW_PROTOBUF_SIZE_REPORT_MESSAGE

namespace pw::protobuf_size_report {
namespace {

template <typename T>
PW_NO_INLINE void ConsumeValue(T val) {
  [[maybe_unused]] volatile T no_optimize = val;
}

#if _PW_PROTOBUF_SIZE_REPORT_NO_CODEGEN

std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> encode_buffer;
pw::protobuf::MemoryEncoder encoder(encode_buffer);

PW_NO_INLINE void BasicEncode() {
  pw::Status status;
  volatile enum KeyType : uint32_t {
    NONE = 0,
    KEY_STRING = 1,
    KEY_TOKEN = 2,
  } which_key = KeyType::KEY_STRING;
  volatile bool has_timestamp = true;
  volatile bool has_has_value = false;
  if (which_key == KeyType::KEY_STRING) {
    encoder.WriteString(1, "test");
  } else if (which_key == KeyType::KEY_TOKEN) {
    encoder.WriteFixed32(2, 99999);
  }

  if (has_timestamp) {
    encoder.WriteInt64(3, 1663003467);
  }

  if (has_has_value) {
    encoder.WriteBool(4, true);
  }

  {
    pw::protobuf::StreamEncoder submessage_encoder =
        encoder.GetNestedEncoder(5);
    status.Update(submessage_encoder.WriteInt64(1, 0x5001DBADFEEDBEE5));
    status.Update(submessage_encoder.WriteInt32(2, 128));
    status.Update(submessage_encoder.WriteInt32(3, 2));
  }
  ConsumeValue(status);
}

std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> decode_buffer;
pw::protobuf::Decoder decoder(decode_buffer);

PW_NO_INLINE void DecodeItemInfo(pw::ConstByteSpan data) {
  pw::protobuf::Decoder submessage_decoder(data);
  while (submessage_decoder.Next().ok()) {
    switch (submessage_decoder.FieldNumber()) {
      case static_cast<uint32_t>(ItemInfo::Fields::OFFSET): {
        uint64_t value;
        if (submessage_decoder.ReadUint64(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case static_cast<uint32_t>(ItemInfo::Fields::SIZE): {
        uint32_t value;
        if (submessage_decoder.ReadUint32(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case static_cast<uint32_t>(ItemInfo::Fields::ACCESS_LEVEL): {
        uint32_t value;

        if (submessage_decoder.ReadUint32(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
    }
  }
}

PW_NO_INLINE void BasicDecode() {
  volatile enum KeyType : uint32_t {
    NONE = 0,
    KEY_STRING = 1,
    KEY_TOKEN = 2,
  } which_key = KeyType::NONE;
  volatile bool has_timestamp = false;
  volatile bool has_has_value = false;

  while (decoder.Next().ok()) {
    switch (decoder.FieldNumber()) {
      case static_cast<uint32_t>(ResponseInfo::Fields::KEY_STRING): {
        which_key = KeyType::KEY_STRING;
        std::string_view value;
        if (decoder.ReadString(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case static_cast<uint32_t>(ResponseInfo::Fields::KEY_TOKEN): {
        which_key = KeyType::KEY_TOKEN;
        uint32_t value;
        if (decoder.ReadUint32(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case static_cast<uint32_t>(ResponseInfo::Fields::TIMESTAMP): {
        uint64_t value;
        has_timestamp = true;
        if (decoder.ReadUint64(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case static_cast<uint32_t>(ResponseInfo::Fields::HAS_VALUE): {
        bool value;
        has_has_value = true;
        if (decoder.ReadBool(&value).ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case static_cast<uint32_t>(ResponseInfo::Fields::ITEM_INFO): {
        pw::ConstByteSpan value;
        if (decoder.ReadBytes(&value).ok()) {
          DecodeItemInfo(value);
        }
        break;
      }
    }
  }
  ConsumeValue(which_key);
  ConsumeValue(has_timestamp);
  ConsumeValue(has_has_value);
}

#endif  // _PW_PROTOBUF_SIZE_REPORT_NO_CODEGEN

#if _PW_PROTOBUF_SIZE_REPORT_WIRE_FORMAT

std::array<std::byte, ResponseInfo::kMaxEncodedSizeBytes> encode_buffer;
ResponseInfo::MemoryEncoder encoder(encode_buffer);

PW_NO_INLINE void BasicEncode() {
  pw::Status status;
  volatile enum KeyType : uint32_t {
    NONE = 0,
    KEY_STRING = 1,
    KEY_TOKEN = 2,
  } which_key = KeyType::KEY_STRING;
  volatile bool has_timestamp = true;
  volatile bool has_has_value = false;
  if (which_key == KeyType::KEY_STRING) {
    encoder.WriteKeyString("test");
  } else if (which_key == KeyType::KEY_TOKEN) {
    encoder.WriteKeyToken(99999);
  }

  if (has_timestamp) {
    encoder.WriteTimestamp(1663003467);
  }

  if (has_has_value) {
    encoder.WriteHasValue(true);
  }

  {
    ItemInfo::StreamEncoder submessage_encoder = encoder.GetItemInfoEncoder();
    status.Update(submessage_encoder.WriteOffset(0x5001DBADFEEDBEE5));
    status.Update(submessage_encoder.WriteSize(128));
    status.Update(submessage_encoder.WriteAccessLevel(ItemInfo::Access::WRITE));
  }
  ConsumeValue(status);
}

std::array<std::byte, ResponseInfo::kMaxEncodedSizeBytes> decode_buffer;
pw::stream::MemoryReader reader(decode_buffer);
ResponseInfo::StreamDecoder decoder(reader);

PW_NO_INLINE void DecodeItemInfo(ItemInfo::StreamDecoder& submessage_decoder) {
  while (submessage_decoder.Next().ok()) {
    pw::Result<ItemInfo::Fields> field = submessage_decoder.Field();
    if (!field.ok()) {
      ConsumeValue(field.status());
      return;
    }

    switch (field.value()) {
      case ItemInfo::Fields::OFFSET: {
        pw::Result<uint64_t> value = submessage_decoder.ReadOffset();
        if (value.ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case ItemInfo::Fields::SIZE: {
        pw::Result<uint32_t> value = submessage_decoder.ReadSize();
        if (value.ok()) {
          ConsumeValue(value);
        }
        break;
      }
      case ItemInfo::Fields::ACCESS_LEVEL: {
        pw::Result<ItemInfo::Access> value =
            submessage_decoder.ReadAccessLevel();
        if (value.ok()) {
          ConsumeValue(value);
        }
        break;
      }
    }
  }
}

PW_NO_INLINE void BasicDecode() {
  volatile enum KeyType : uint32_t {
    NONE = 0,
    KEY_STRING = 1,
    KEY_TOKEN = 2,
  } which_key = KeyType::NONE;
  volatile bool has_timestamp = false;
  volatile bool has_has_value = false;

  while (decoder.Next().ok()) {
    while (decoder.Next().ok()) {
      pw::Result<ResponseInfo::Fields> field = decoder.Field();
      if (!field.ok()) {
        ConsumeValue(field.status());
        return;
      }

      switch (field.value()) {
        case ResponseInfo::Fields::KEY_STRING: {
          which_key = KeyType::KEY_STRING;
          std::array<char, 8> value;
          pw::StatusWithSize status = decoder.ReadKeyString(value);
          if (status.ok()) {
            ConsumeValue(pw::span(value));
          }
          break;
        }
        case ResponseInfo::Fields::KEY_TOKEN: {
          which_key = KeyType::KEY_TOKEN;
          pw::Result<uint32_t> value = decoder.ReadKeyToken();
          if (value.ok()) {
            ConsumeValue(value);
          }
          break;
        }
        case ResponseInfo::Fields::TIMESTAMP: {
          has_timestamp = true;
          pw::Result<int64_t> value = decoder.ReadTimestamp();
          if (value.ok()) {
            ConsumeValue(value);
          }
          break;
        }
        case ResponseInfo::Fields::HAS_VALUE: {
          has_has_value = true;
          pw::Result<bool> value = decoder.ReadHasValue();
          if (value.ok()) {
            ConsumeValue(value);
          }
          break;
        }
        case ResponseInfo::Fields::ITEM_INFO: {
          ItemInfo::StreamDecoder submessage_decoder =
              decoder.GetItemInfoDecoder();
          DecodeItemInfo(submessage_decoder);
          break;
        }
      }
    }
  }
  ConsumeValue(which_key);
  ConsumeValue(has_timestamp);
  ConsumeValue(has_has_value);
}
#endif  // _PW_PROTOBUF_SIZE_REPORT_WIRE_FORMAT

#if _PW_PROTOBUF_SIZE_REPORT_MESSAGE

ResponseInfo::Message message;

std::array<std::byte, ResponseInfo::kMaxEncodedSizeBytes> encode_buffer;
ResponseInfo::MemoryEncoder encoder(encode_buffer);

PW_NO_INLINE void BasicEncode() {
  volatile enum KeyType : uint32_t {
    NONE = 0,
    KEY_STRING = 1,
    KEY_TOKEN = 2,
  } which_key = KeyType::KEY_STRING;
  volatile bool has_timestamp = true;
  volatile bool has_has_value = false;
  if (which_key == KeyType::KEY_STRING) {
    message.key_string.SetEncoder(
        [](ResponseInfo::StreamEncoder& key_string_encoder) -> pw::Status {
          key_string_encoder.WriteKeyString("test");
          return pw::OkStatus();
        });
  } else if (which_key == KeyType::KEY_TOKEN) {
    message.key_token = 99999;
  }
  message.timestamp =
      has_timestamp ? std::optional<uint32_t>(1663003467) : std::nullopt;
  message.has_value = has_has_value ? std::optional<bool>(false) : std::nullopt;

  message.item_info.offset = 0x5001DBADFEEDBEE5;
  message.item_info.size = 128;
  message.item_info.access_level = ItemInfo::Access::WRITE;
  ConsumeValue(encoder.Write(message));
}

std::array<std::byte, ResponseInfo::kMaxEncodedSizeBytes> decode_buffer;
pw::stream::MemoryReader reader(decode_buffer);
ResponseInfo::StreamDecoder decoder(reader);

PW_NO_INLINE void BasicDecode() {
  volatile enum KeyType : uint32_t {
    NONE = 0,
    KEY_STRING = 1,
    KEY_TOKEN = 2,
  } which_key = KeyType::NONE;
  volatile bool has_timestamp = false;
  volatile bool has_has_value = false;
  if (pw::Status status = decoder.Read(message); status.ok()) {
    ConsumeValue(status);
    has_timestamp = message.timestamp.has_value();
    has_has_value = message.has_value.has_value();
  }
  ConsumeValue(which_key);
  ConsumeValue(has_timestamp);
  ConsumeValue(has_has_value);
}
#endif  // _PW_PROTOBUF_SIZE_REPORT_MESSAGE

}  // namespace
}  // namespace pw::protobuf_size_report

int main() {
  pw::bloat::BloatThisBinary();
  pw::protobuf_size_report::BloatWithBase();
  pw::protobuf_size_report::BloatWithEncoder();
  pw::protobuf_size_report::BloatWithStreamDecoder();
  pw::protobuf_size_report::BloatWithDecoder();
  pw::protobuf_size_report::BloatWithTableEncoder();
  pw::protobuf_size_report::BloatWithTableDecoder();
  pw::protobuf_size_report::BasicEncode();
  pw::protobuf_size_report::BasicDecode();
  return 0;
}