// Copyright 2026 Google LLC
//
// 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 "formats/pdf/reader.h"

#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "absl/container/flat_hash_map.h"
#include "absl/status/status.h"
#include "absl/status/status_matchers.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/string_view.h"
#include "formats/pdf/objects.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "riegeli/bytes/reader.h"
#include "riegeli/bytes/string_reader.h"

namespace credentio {
namespace {

using ::absl_testing::IsOkAndHolds;
using ::absl_testing::StatusIs;
using ::testing::ElementsAre;
using ::testing::HasSubstr;
using ::testing::Pair;
using ::testing::UnorderedElementsAre;

#ifndef ASSERT_OK_AND_ASSIGN
#define ASSERT_OK_AND_ASSIGN_CONCAT2(x, y) x##y
#define ASSERT_OK_AND_ASSIGN_CONCAT(x, y) ASSERT_OK_AND_ASSIGN_CONCAT2(x, y)

#define ASSERT_OK_AND_ASSIGN(lhs, rexpr) \
  ASSERT_OK_AND_ASSIGN_IMPL(lhs, rexpr, __COUNTER__)

#define ASSERT_OK_AND_ASSIGN_IMPL(lhs, rexpr, id)             \
  auto ASSERT_OK_AND_ASSIGN_CONCAT(status_or_, id) = (rexpr); \
  ASSERT_THAT(ASSERT_OK_AND_ASSIGN_CONCAT(status_or_, id),    \
              ::absl_testing::IsOk());                        \
  lhs = std::move(*ASSERT_OK_AND_ASSIGN_CONCAT(status_or_, id))
#endif

Object CreateName(absl::string_view value) {
  return Object{.value = Object::Name{.value = std::string(value)}};
}

Object CreateInteger(int64_t value) {
  return Object{.value = Object::Integer{.value = value}};
}

Object CreateRealNumber(absl::string_view value) {
  return Object{.value = Object::RealNumber{.raw_value = std::string(value)}};
}

Object CreateIndirectRef(uint32_t object_number, uint32_t generation_number) {
  return Object{.value = Object::IndirectReference{
                    .object_number = object_number,
                    .generation_number = generation_number}};
}

Object CreateArray(std::vector<Object> values) {
  return Object{.value = Object::Array{.objects = std::move(values)}};
}

Object CreateStream(absl::string_view raw_value) {
  return Object{.value = Object::Stream{.raw_value = std::string(raw_value)}};
}

Object CreateDictionary(absl::flat_hash_map<std::string, Object> entries) {
  return Object{.value = Object::Dictionary{.entries = std::move(entries)}};
}

std::string GetTestPdfContent() {
  std::string content = R"(%PDF-1.7
%%%%%
1 0 obj
/test_name
endobj
2 0 obj
123.456
endobj
3 0 obj
<</Type /Catalog>>
endobj
xref
0 4
0000000000 65535 f@
0000000015 00000 n@
0000000041 00000 n@
0000000064 00000 n@
trailer
<</Root 3 0 R /Size 3>>
startxref
98
%%EOF)";
  return absl::StrReplaceAll(content, {{"@", " "}});
}

TEST(PdfReaderTest, ReadsAllObjects) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  std::vector<IndirectObject> objects;
  while (reader->HasNext()) {
    ASSERT_OK_AND_ASSIGN(auto obj, reader->Next());
    objects.push_back(std::move(obj));
  }

  EXPECT_THAT(
      objects,
      ElementsAre(IndirectObject{.object_number = 1,
                                 .generation_number = 0,
                                 .object = CreateName("test_name")},
                  IndirectObject{.object_number = 2,
                                 .generation_number = 0,
                                 .object = CreateRealNumber("123.456")},
                  IndirectObject{.object_number = 3,
                                 .generation_number = 0,
                                 .object = CreateDictionary(
                                     {{"Type", CreateName("Catalog")}})}));
}

TEST(PdfReaderTest, FailsWhenReadingPastAllObjects) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  int64_t count = 0;
  while (reader->HasNext()) {
    ASSERT_OK_AND_ASSIGN(auto obj, reader->Next());
    ++count;
  }

  EXPECT_EQ(count, 3);

  EXPECT_THAT(reader->Next(), StatusIs(absl::StatusCode::kOutOfRange,
                                       HasSubstr("No more objects to read")));
}

TEST(PdfReaderTest, GetFileTrailerDictionary) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  auto file_trailer_dict = reader->file_trailer_dictionary();
  EXPECT_THAT(file_trailer_dict.entries,
              UnorderedElementsAre(Pair("Root", CreateIndirectRef(3, 0)),
                                   Pair("Size", CreateInteger(3))));
}

TEST(PdfReaderTest, FreeEntries) {
  std::string content = R"(%PDF-1.7
xref
0 8
0000000003 65535 f@
0000000015 00000 n@
0000000081 00000 n@
0000000005 00000 f@
0000000331 00000 n@
0000000000 00000 f@
0000000409 00000 n@
0000000555 00000 n@
trailer
<<>>
startxref
9
%%EOF)";
  content = absl::StrReplaceAll(content, {{"@", " "}});
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));
  EXPECT_THAT(reader->free_entries(),
              ElementsAre(Object::IndirectReference{.object_number = 0,
                                                    .generation_number = 65535},
                          Object::IndirectReference{.object_number = 3,
                                                    .generation_number = 0},
                          Object::IndirectReference{.object_number = 5,
                                                    .generation_number = 0}));
}

TEST(PdfReaderTest, GetObjectOffset) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  EXPECT_THAT(
      reader->GetObjectOffset(/*object_number=*/2, /*generation_number=*/0),
      IsOkAndHolds(41));
}

TEST(PdfReaderTest, GetNonExistentObjectOffsetFailure) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  EXPECT_THAT(
      reader->GetObjectOffset(/*object_number=*/10, /*generation_number=*/0),
      StatusIs(absl::StatusCode::kNotFound, HasSubstr("No offset found")));
}

TEST(PdfReaderTest, GetSpecificObject) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  ASSERT_OK_AND_ASSIGN(auto obj, reader->GetObject(2, 0));
  EXPECT_THAT(obj, (IndirectObject{.object_number = 2,
                                   .generation_number = 0,
                                   .object = CreateRealNumber("123.456")}));
}

TEST(PdfReaderTest, GetNonExistentObjectFailure) {
  std::string content = GetTestPdfContent();
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  EXPECT_THAT(reader->GetObject(10, 0), StatusIs(absl::StatusCode::kNotFound,
                                                 HasSubstr("No offset found")));
}

TEST(PdfReaderTest, ShortFileCausesInitializationFailure) {
  std::string content = "file is too short";
  riegeli::StringReader<> input(content);
  EXPECT_THAT(PdfReader::Create(&input),
              StatusIs(absl::StatusCode::kDataLoss,
                       HasSubstr("Failed to seek to offset")));
}

TEST(PdfReaderTest, MissingXrefOffsetCausesInitializationFailure) {
  std::string content = R"(%PDF-1.7
xref
0 1
0000000000 65536 f
startxref
%%EOF)";
  riegeli::StringReader<> input(content);
  EXPECT_THAT(PdfReader::Create(&input),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       HasSubstr("Failed to find cross-reference table offset "
                                 "in the following payload")));
}

TEST(PdfReaderTest, InvalidXrefOffsetCausesInitializationFailure) {
  std::string content = R"(%PDF-1.7
xref
0 1
0000000000 65536 f
startxref
2
%%EOF)";
  riegeli::StringReader<> input(content);
  EXPECT_THAT(
      PdfReader::Create(&input),
      StatusIs(
          absl::StatusCode::kInvalidArgument,
          HasSubstr(
              "Malformed cross-reference table. Expected 'xref' but got")));
}

TEST(PdfReaderTest, MalformedXrefTableCausesInitializationFailure) {
  std::string content = R"(%PDF-1.7
xref
0 2
0000000000 65536 f
0000000 00001 n
startxref
9
%%EOF)";
  riegeli::StringReader<> input(content);
  EXPECT_THAT(
      PdfReader::Create(&input),
      StatusIs(
          absl::StatusCode::kInvalidArgument,
          HasSubstr(
              "Failed to parse cross-reference table entry. Invalid value")));
}

TEST(PdfReaderTest, InvalidPrevXrefOffsetTypeCausesInitializationFailure) {
  std::string content = R"(%PDF-1.7
xref
0 1
0000000000 65535 f@
trailer
<</Prev /NotAnInteger /Size 1>>
startxref
9
%%EOF)";
  content = absl::StrReplaceAll(content, {{"@", " "}});
  riegeli::StringReader<> input(content);
  EXPECT_THAT(
      PdfReader::Create(&input),
      StatusIs(absl::StatusCode::kInvalidArgument,
               HasSubstr("Object is not a credentio::Object::Integer")));
}

TEST(PdfReaderTest, ContainingPreviousXrefTable) {
  std::string content = R"(%PDF-1.7
1 0 obj
<< /Type /Catalog
/Pages 2 0 R
>>
endobj
2 0 obj
<< /Type /Pages
/Kids [3 0 R]
/Count 1
>>
endobj
3 0 obj
<< /Type /Page
/Parent 2 0 R
/MediaBox [0 0 100 100]
/Contents 4 0 R
>>
endobj
4 0 obj
<< /Length 35 >>
stream
BT /F1 12 Tf 35 50 Td (Hello) Tj ET
endstream
endobj
xref
0 5
0000000000 65535 f@
0000000009 00000 n@
0000000058 00000 n@
0000000115 00000 n@
0000000202 00000 n@
trailer
<< /Size 5
/Root 1 0 R
>>
startxref
287
%%EOF
5 0 obj
<< /Type /Catalog
/Pages 6 0 R
>>
endobj
6 0 obj
<< /Type /Pages
/Kids [7 0 R  3 0 R]
/Count 2
>>
endobj
7 0 obj
<< /Type /Page
/Parent 6 0 R
/MediaBox [0 0 50 50]
/Contents 8 0 R
>>
endobj
8 0 obj
<< /Length 35 >>
stream
BT /F1 12 Tf 10 20 Td (Hello) Tj ET
endstream
endobj
xref
5 4
0000000450 00000 n@
0000000499 00000 n@
0000000563 00000 n@
0000000648 00000 n@
trailer
<< /Size 9
/Root 5 0 R
/Prev 287
>>
startxref
733
%%EOF)";
  // Replace all @ with space to avoid presubmit failing trailing whitespace.
  content = absl::StrReplaceAll(content, {{"@", " "}});

  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));

  std::vector<IndirectObject> objects;
  while (reader->HasNext()) {
    ASSERT_OK_AND_ASSIGN(auto obj, reader->Next());
    objects.push_back(std::move(obj));
  }

  ASSERT_THAT(
      objects,
      ElementsAre(
          IndirectObject{.object_number = 1,
                         .generation_number = 0,
                         .object = CreateDictionary({
                             {"Type", CreateName("Catalog")},
                             {"Pages", CreateIndirectRef(2, 0)},
                         })},
          IndirectObject{.object_number = 2,
                         .generation_number = 0,
                         .object = CreateDictionary({
                             {"Kids", CreateArray({CreateIndirectRef(3, 0)})},
                             {"Type", CreateName("Pages")},
                             {"Count", CreateInteger(1)},
                         })},
          IndirectObject{.object_number = 3,
                         .generation_number = 0,
                         .object = CreateDictionary({
                             {"Parent", CreateIndirectRef(2, 0)},
                             {"Type", CreateName("Page")},
                             {"MediaBox", CreateArray({
                                              CreateInteger(0),
                                              CreateInteger(0),
                                              CreateInteger(100),
                                              CreateInteger(100),
                                          })},
                             {"Contents", CreateIndirectRef(4, 0)},
                         })},
          IndirectObject{
              .object_number = 4,
              .generation_number = 0,
              .stream_dictionary =
                  Object::Dictionary{
                      .entries = {{"Length", CreateInteger(35)}}},
              .object = CreateStream("BT /F1 12 Tf 35 50 Td (Hello) Tj ET")},
          IndirectObject{.object_number = 5,
                         .generation_number = 0,
                         .object = CreateDictionary({
                             {"Type", CreateName("Catalog")},
                             {"Pages", CreateIndirectRef(6, 0)},
                         })},
          IndirectObject{.object_number = 6,
                         .generation_number = 0,
                         .object = CreateDictionary({
                             {"Kids", CreateArray({CreateIndirectRef(7, 0),
                                                   CreateIndirectRef(3, 0)})},
                             {"Type", CreateName("Pages")},
                             {"Count", CreateInteger(2)},
                         })},
          IndirectObject{.object_number = 7,
                         .generation_number = 0,
                         .object = CreateDictionary({
                             {"Parent", CreateIndirectRef(6, 0)},
                             {"Type", CreateName("Page")},
                             {"MediaBox", CreateArray({
                                              CreateInteger(0),
                                              CreateInteger(0),
                                              CreateInteger(50),
                                              CreateInteger(50),
                                          })},
                             {"Contents", CreateIndirectRef(8, 0)},
                         })},
          IndirectObject{
              .object_number = 8,
              .generation_number = 0,
              .stream_dictionary =
                  Object::Dictionary{
                      .entries = {{"Length", CreateInteger(35)}}},
              .object = CreateStream("BT /F1 12 Tf 10 20 Td (Hello) Tj ET")}));
}

riegeli::Reader* GetNullReader() { return nullptr; }

TEST(PdfReaderTest, NullInputFailure)
__attribute__((no_sanitize("nullability"))) {
  EXPECT_THAT(PdfReader::Create(GetNullReader()),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       HasSubstr("input cannot be null")));
}

TEST(PdfReaderTest, CircularXrefTableFailure) {
  std::string content = R"(%PDF-1.7
1 0 obj
<< /Type /Catalog
/Pages 2 0 R
>>
endobj
2 0 obj
<< /Type /Pages
/Kids [3 0 R]
/Count 1
>>
endobj
3 0 obj
<< /Type /Page
/Parent 2 0 R
/MediaBox [0 0 100 100]
/Contents 4 0 R
>>
endobj
4 0 obj
<< /Length 35 >>
stream
BT /F1 12 Tf 35 50 Td (Hello) Tj ET
endstream
endobj
xref
0 5
0000000000 65535 f@
0000000009 00000 n@
0000000058 00000 n@
0000000115 00000 n@
0000000202 00000 n@
trailer
<< /Size 5
/Root 1 0 R
/Prev 743
>>
startxref
287
%%EOF
5 0 obj
<< /Type /Catalog
/Pages 6 0 R
>>
endobj
6 0 obj
<< /Type /Pages
/Kids [7 0 R  3 0 R]
/Count 2
>>
endobj
7 0 obj
<< /Type /Page
/Parent 6 0 R
/MediaBox [0 0 50 50]
/Contents 8 0 R
>>
endobj
8 0 obj
<< /Length 35 >>
stream
BT /F1 12 Tf 10 20 Td (Hello) Tj ET
endstream
endobj
xref
5 4
0000000460 00000 n@
0000000509 00000 n@
0000000573 00000 n@
0000000658 00000 n@
trailer
<< /Size 9
/Root 5 0 R
/Prev 287
>>
startxref
743
%%EOF)";
  content = absl::StrReplaceAll(content, {{"@", " "}});
  riegeli::StringReader<> input(content);
  EXPECT_THAT(PdfReader::Create(&input),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       HasSubstr("Circular cross-reference table detected")));
}

TEST(PdfReaderTest, CollisionInUseEntriesFailure) {
  std::string content = R"(%PDF-1.7
1 0 obj
<< /Type /Catalog
/Pages 2 0 R
>>
endobj
2 0 obj
<< /Type /Pages
/Kids [3 0 R]
/Count 1
>>
endobj
3 0 obj
<< /Type /Page
/Parent 2 0 R
/MediaBox [0 0 100 100]
/Contents 4 0 R
>>
endobj
4 0 obj
<< /Length 35 >>
stream
BT /F1 12 Tf 35 50 Td (Hello) Tj ET
endstream
endobj
xref
0 5
0000000000 65535 f@
0000000009 00000 n@
0000000058 00000 n@
0000000115 00000 n@
0000000202 00000 n@
trailer
<< /Size 5
/Root 1 0 R
>>
startxref
287
%%EOF
5 0 obj
<< /Type /Catalog
/Pages 6 0 R
>>
endobj
6 0 obj
<< /Type /Pages
/Kids [7 0 R  3 0 R]
/Count 2
>>
endobj
7 0 obj
<< /Type /Page
/Parent 6 0 R
/MediaBox [0 0 50 50]
/Contents 8 0 R
>>
endobj
8 0 obj
<< /Length 35 >>
stream
BT /F1 12 Tf 10 20 Td (Hello) Tj ET
endstream
endobj
xref
1 1
0000000450 00000 n@
5 4
0000000450 00000 n@
0000000499 00000 n@
0000000563 00000 n@
0000000648 00000 n@
trailer
<< /Size 9
/Root 5 0 R
/Prev 287
>>
startxref
733
%%EOF)";
  content = absl::StrReplaceAll(content, {{"@", " "}});
  riegeli::StringReader<> input(content);
  EXPECT_THAT(PdfReader::Create(&input),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       HasSubstr("Collision detected in cross-reference table "
                                 "for in-use entries")));
}

TEST(PdfReaderTest, CyclicStreamLengthFailure) {
  std::string content = R"(%PDF-1.7
%%%%%
1 0 obj
<< /Length 1 0 R >>
stream
abc
endstream
endobj
xref
0 2
0000000000 65535 f@
0000000015 00000 n@
trailer
<< /Size 2 >>
startxref
71
%%EOF)";
  content = absl::StrReplaceAll(content, {{"@", " "}});
  riegeli::StringReader<> input(content);
  ASSERT_OK_AND_ASSIGN(auto reader, PdfReader::Create(&input));
  EXPECT_THAT(reader->GetObject(1, 0),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       HasSubstr("Circular reference detected")));
}

}  // namespace
}  // namespace credentio