/*

 * Copyright (c) 2021, Matthew Olsson <mattco@serenityos.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#pragma once

#include <AK/ByteString.h>

#include <AK/Debug.h>

#include <AK/Function.h>

#include <AK/ScopeGuard.h>

#include <AK/Span.h>

#include <AK/Vector.h>

#include <LibPDF/Error.h>

namespace PDF {

class Reader {

public:

    explicit Reader(ReadonlyBytes bytes)

        : m_bytes(bytes)

    {

    }

    ALWAYS_INLINE ReadonlyBytes bytes() const { return m_bytes; }

    ALWAYS_INLINE size_t offset() const { return m_offset; }

    bool done() const

    {

        if (m_forwards)

            return offset() >= bytes().size();

        return m_offset < 0;

    }

    size_t remaining() const

    {

        if (done())

            return 0;

        if (m_forwards)

            return bytes().size() - offset();

        return offset() + 1;

    }

    void move_by(ssize_t count)

    {

        if (m_forwards) {

            m_offset += count;

        } else {

            m_offset -= count;

        }

    }

    template<typename T = char>

    T read()

    {

        T value = reinterpret_cast<T const*>(m_bytes.offset(m_offset))[0];

        move_by(sizeof(T));

        return value;

    }

    template<typename T = char>

    PDFErrorOr<T> try_read()

    {

        if (sizeof(T) + m_offset > m_bytes.size()) {

            auto message = ByteString::formatted("Cannot read {} bytes at offset {} of ReadonlyBytes of size {}", sizeof(T), m_offset, m_bytes.size());

            return Error { Error::Type::Parse, message };

        }

        return read<T>();

    }

    char peek(size_t shift = 0) const

    {

        auto offset = m_offset + shift * (m_forwards ? 1 : -1);

        return static_cast<char>(m_bytes.at(offset));

    }

    template<typename... T>

    bool matches_any(T... elements) const

    {

        if (done())

            return false;

        auto ch = peek();

        return ((ch == elements) || ...);

    }

bool PDF::Reader::matches_any<char, char>(char, char) const

Line

Count

Source

81

8

    {

82

8

        if (done())

83

0

            return false;

84

8

        auto ch = peek();

85

16

        return ((ch == elements) || ...);

86

8

    }

bool PDF::Reader::matches_any<char, char, char, char, char, char, char, char, char, char>(char, char, char, char, char, char, char, char, char, char) const

Line

Count

Source

81

306

    {

82

306

        if (done())

83

0

            return false;

84

306

        auto ch = peek();

85

5.50k

        return ((ch == elements) || ...);

86

306

    }

    bool matches(char ch) const

    {

        return !done() && peek() == ch;

    }

    bool matches(char const* chars) const

    {

        ByteString string(chars);

        if (remaining() < string.length())

            return false;

        if (!m_forwards)

            string = string.reverse();

        for (size_t i = 0; i < string.length(); i++) {

            if (peek(i) != string[i])

                return false;

        }

        return true;

    }

    template<typename T = char>

    void move_to(size_t offset)

    {

        VERIFY(offset <= m_bytes.size());

        m_offset = static_cast<ssize_t>(offset);

    }

    void move_until(char ch)

    {

        while (!done() && peek() != ch)

            move_by(1);

    }

    void move_until(AK::Function<bool(char)> predicate)

    {

        while (!done() && !predicate(peek()))

            move_by(1);

    }

    ALWAYS_INLINE void move_while(AK::Function<bool(char)> predicate)

    {

        move_until([&predicate](char t) { return !predicate(t); });

    }

    static bool is_eol(char);

    static bool is_whitespace(char);

    static bool is_non_eol_whitespace(char);

    bool matches_eol() const;

    bool matches_whitespace() const;

    bool matches_non_eol_whitespace() const;

    bool matches_number() const;

    bool matches_delimiter() const;

    bool matches_regular_character() const;

    bool consume_eol();

    bool consume_whitespace();

    bool consume_non_eol_whitespace();

    char consume();

    void consume(int amount);

    bool consume(char);

    ALWAYS_INLINE void set_reading_forwards() { m_forwards = true; }

    ALWAYS_INLINE void set_reading_backwards() { m_forwards = false; }

    ALWAYS_INLINE void save() { m_saved_offsets.append(m_offset); }

    ALWAYS_INLINE void load() { m_offset = m_saved_offsets.take_last(); }

    ALWAYS_INLINE void discard() { m_saved_offsets.take_last(); }

#ifdef PDF_DEBUG

    void dump_state() const

    {

        dbgln("Reader State (offset={} size={})", offset(), bytes().size());

        size_t from = max(0, static_cast<int>(offset()) - 10);

        size_t to = min(bytes().size() - 1, offset() + 10);

        for (auto i = from; i <= to; i++) {

            char value = static_cast<char>(bytes().at(i));

            auto line = ByteString::formatted("  {}: '{}' (value={:3d}) ", i, value, static_cast<u8>(value));

            if (i == offset()) {

                dbgln("{} <<< current location, forwards={}", line, m_forwards);

            } else {

                dbgln("{}", line);

            }

        }

        dbgln();

    }

#endif

private:

    ReadonlyBytes m_bytes;

    ssize_t m_offset { 0 };

    Vector<ssize_t> m_saved_offsets;

    bool m_forwards { true };

};

}