// Copyright 2020 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 "pw_protobuf/decoder.h"

#include "gtest/gtest.h"
#include "pw_preprocessor/util.h"

namespace pw::protobuf {
namespace {

class TestDecodeHandler : public DecodeHandler {
 public:
  Status ProcessField(CallbackDecoder& decoder,
                      uint32_t field_number) override {
    std::string_view str;

    switch (field_number) {
      case 1:
        EXPECT_EQ(OkStatus(), decoder.ReadInt32(&test_int32));
        break;
      case 2:
        EXPECT_EQ(OkStatus(), decoder.ReadSint32(&test_sint32));
        break;
      case 3:
        EXPECT_EQ(OkStatus(), decoder.ReadBool(&test_bool));
        break;
      case 4:
        EXPECT_EQ(OkStatus(), decoder.ReadDouble(&test_double));
        break;
      case 5:
        EXPECT_EQ(OkStatus(), decoder.ReadFixed32(&test_fixed32));
        break;
      case 6:
        EXPECT_EQ(OkStatus(), decoder.ReadString(&str));
        std::memcpy(test_string, str.data(), str.size());
        test_string[str.size()] = '\0';
        break;
    }

    called = true;
    return OkStatus();
  }

  bool called = false;
  int32_t test_int32 = 0;
  int32_t test_sint32 = 0;
  bool test_bool = true;
  double test_double = 0;
  uint32_t test_fixed32 = 0;
  char test_string[16];
};

TEST(Decoder, Decode) {
  // clang-format off
  uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    0x08, 0x2a,
    // type=sint32, k=2, v=-13
    0x10, 0x19,
    // type=bool, k=3, v=false
    0x18, 0x00,
    // type=double, k=4, v=3.14159
    0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40,
    // type=fixed32, k=5, v=0xdeadbeef
    0x2d, 0xef, 0xbe, 0xad, 0xde,
    // type=string, k=6, v="Hello world"
    0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd',
  };
  // clang-format on

  Decoder decoder(as_bytes(span(encoded_proto)));

  int32_t v1 = 0;
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 1u);
  EXPECT_EQ(decoder.ReadInt32(&v1), OkStatus());
  EXPECT_EQ(v1, 42);

  int32_t v2 = 0;
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 2u);
  EXPECT_EQ(decoder.ReadSint32(&v2), OkStatus());
  EXPECT_EQ(v2, -13);

  bool v3 = true;
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 3u);
  EXPECT_EQ(decoder.ReadBool(&v3), OkStatus());
  EXPECT_FALSE(v3);

  double v4 = 0;
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 4u);
  EXPECT_EQ(decoder.ReadDouble(&v4), OkStatus());
  EXPECT_EQ(v4, 3.14159);

  uint32_t v5 = 0;
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 5u);
  EXPECT_EQ(decoder.ReadFixed32(&v5), OkStatus());
  EXPECT_EQ(v5, 0xdeadbeef);

  std::string_view v6;
  char buffer[16];
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 6u);
  EXPECT_EQ(decoder.ReadString(&v6), OkStatus());
  std::memcpy(buffer, v6.data(), v6.size());
  buffer[v6.size()] = '\0';
  EXPECT_STREQ(buffer, "Hello world");

  EXPECT_EQ(decoder.Next(), Status::OutOfRange());
}

TEST(Decoder, Decode_SkipsUnusedFields) {
  // clang-format off
  uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    0x08, 0x2a,
    // type=sint32, k=2, v=-13
    0x10, 0x19,
    // type=bool, k=3, v=false
    0x18, 0x00,
    // type=double, k=4, v=3.14159
    0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40,
    // type=fixed32, k=5, v=0xdeadbeef
    0x2d, 0xef, 0xbe, 0xad, 0xde,
    // type=string, k=6, v="Hello world"
    0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd',
  };
  // clang-format on

  Decoder decoder(as_bytes(span(encoded_proto)));

  // Don't process any fields except for the fourth. Next should still iterate
  // correctly despite field values not being consumed.
  EXPECT_EQ(decoder.Next(), OkStatus());
  EXPECT_EQ(decoder.Next(), OkStatus());
  EXPECT_EQ(decoder.Next(), OkStatus());
  EXPECT_EQ(decoder.Next(), OkStatus());
  ASSERT_EQ(decoder.FieldNumber(), 4u);
  EXPECT_EQ(decoder.Next(), OkStatus());
  EXPECT_EQ(decoder.Next(), OkStatus());
  EXPECT_EQ(decoder.Next(), Status::OutOfRange());
}

TEST(Decoder, Decode_BadFieldNumber) {
  // clang-format off
  constexpr uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    0x08, 0x2a,
    // type=int32, k=19001, v=42 (invalid field number)
    0xc8, 0xa3, 0x09, 0x2a,
    // type=bool, k=3, v=false
    0x18, 0x00,
  };
  // clang-format on

  Decoder decoder(as_bytes(span(encoded_proto)));
  int32_t value;

  EXPECT_EQ(decoder.Next(), OkStatus());
  EXPECT_EQ(decoder.FieldNumber(), 1u);
  ASSERT_EQ(decoder.ReadInt32(&value), OkStatus());
  EXPECT_EQ(value, 42);

  // Bad field.
  EXPECT_EQ(decoder.Next(), Status::DataLoss());
  EXPECT_EQ(decoder.FieldNumber(), 0u);
  EXPECT_EQ(decoder.ReadInt32(&value), Status::DataLoss());
}

TEST(CallbackDecoder, Decode) {
  CallbackDecoder decoder;
  TestDecodeHandler handler;

  // clang-format off
  uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    0x08, 0x2a,
    // type=sint32, k=2, v=-13
    0x10, 0x19,
    // type=bool, k=3, v=false
    0x18, 0x00,
    // type=double, k=4, v=3.14159
    0x21, 0x6e, 0x86, 0x1b, 0xf0, 0xf9, 0x21, 0x09, 0x40,
    // type=fixed32, k=5, v=0xdeadbeef
    0x2d, 0xef, 0xbe, 0xad, 0xde,
    // type=string, k=6, v="Hello world"
    0x32, 0x0b, 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd',
  };
  // clang-format on

  decoder.set_handler(&handler);
  EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), OkStatus());
  EXPECT_TRUE(handler.called);
  EXPECT_EQ(handler.test_int32, 42);
  EXPECT_EQ(handler.test_sint32, -13);
  EXPECT_FALSE(handler.test_bool);
  EXPECT_EQ(handler.test_double, 3.14159);
  EXPECT_EQ(handler.test_fixed32, 0xdeadbeef);
  EXPECT_STREQ(handler.test_string, "Hello world");
}

TEST(CallbackDecoder, Decode_OverridesDuplicateFields) {
  CallbackDecoder decoder;
  TestDecodeHandler handler;

  // clang-format off
  uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    0x08, 0x2a,
    // type=int32, k=1, v=43
    0x08, 0x2b,
    // type=int32, k=1, v=44
    0x08, 0x2c,
  };
  // clang-format on

  decoder.set_handler(&handler);
  EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), OkStatus());
  EXPECT_TRUE(handler.called);
  EXPECT_EQ(handler.test_int32, 44);
}

TEST(CallbackDecoder, Decode_Empty) {
  CallbackDecoder decoder;
  TestDecodeHandler handler;

  decoder.set_handler(&handler);
  EXPECT_EQ(decoder.Decode(span<std::byte>()), OkStatus());
  EXPECT_FALSE(handler.called);
  EXPECT_EQ(handler.test_int32, 0);
  EXPECT_EQ(handler.test_sint32, 0);
}

TEST(CallbackDecoder, Decode_BadData) {
  CallbackDecoder decoder;
  TestDecodeHandler handler;

  // Field key without a value.
  uint8_t encoded_proto[] = {0x08};

  decoder.set_handler(&handler);
  EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::DataLoss());
}

// Only processes fields numbered 1 or 3.
class OneThreeDecodeHandler : public DecodeHandler {
 public:
  Status ProcessField(CallbackDecoder& decoder,
                      uint32_t field_number) override {
    switch (field_number) {
      case 1:
        EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
        break;
      case 3:
        EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
        break;
      default:
        // Do nothing.
        break;
    }

    called = true;
    return OkStatus();
  }

  bool called = false;
  int32_t field_one = 0;
  int32_t field_three = 0;
};

TEST(CallbackDecoder, Decode_SkipsUnprocessedFields) {
  CallbackDecoder decoder;
  OneThreeDecodeHandler handler;

  // clang-format off
  uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    // Should be read.
    0x08, 0x2a,
    // type=sint32, k=2, v=-13
    // Should be ignored.
    0x10, 0x19,
    // type=int32, k=2, v=3
    // Should be ignored.
    0x10, 0x03,
    // type=int32, k=3, v=99
    // Should be read.
    0x18, 0x63,
    // type=int32, k=4, v=16
    // Should be ignored.
    0x20, 0x10,
  };
  // clang-format on

  decoder.set_handler(&handler);
  EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), OkStatus());
  EXPECT_TRUE(handler.called);
  EXPECT_EQ(handler.field_one, 42);
  EXPECT_EQ(handler.field_three, 99);
}

// Only processes fields numbered 1 or 3, and stops the decode after hitting 1.
class ExitOnOneDecoder : public DecodeHandler {
 public:
  Status ProcessField(CallbackDecoder& decoder,
                      uint32_t field_number) override {
    switch (field_number) {
      case 1:
        EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
        return Status::Cancelled();
      case 3:
        EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
        break;
      default:
        // Do nothing.
        break;
    }

    return OkStatus();
  }

  int32_t field_one = 0;
  int32_t field_three = 1111;
};

TEST(CallbackDecoder, Decode_StopsOnNonOkStatus) {
  CallbackDecoder decoder;
  ExitOnOneDecoder handler;

  // clang-format off
  uint8_t encoded_proto[] = {
    // type=int32, k=1, v=42
    // Should be read.
    0x08, 0x2a,
    // type=int32, k=3, v=99
    // Should be skipped.
    0x18, 0x63,
    // type=int32, k=2, v=16
    // Should be skipped.
    0x08, 0x10,
  };
  // clang-format on

  decoder.set_handler(&handler);
  EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::Cancelled());
  EXPECT_EQ(handler.field_one, 42);
  EXPECT_EQ(handler.field_three, 1111);
}

}  // namespace
}  // namespace pw::protobuf