#include <qpdf/BufferInputSource.hh>

#include <qpdf/InputSource_private.hh>

#include <qpdf/Buffer.hh>

#include <qpdf/QIntC.hh>

#include <algorithm>

#include <cstring>

#include <sstream>

using namespace qpdf;

#ifndef QPDF_FUTURE

BufferInputSource::BufferInputSource(std::string const& description, Buffer* buf, bool own_memory) :

    own_memory(own_memory),

    description(description),

    buf(buf),

    cur_offset(0),

    max_offset(buf ? QIntC::to_offset(buf->getSize()) : 0)

{

}

BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :

    own_memory(true),

    description(description),

    buf(new Buffer(contents.length())),

    cur_offset(0),

    max_offset(QIntC::to_offset(buf->getSize()))

{

    memcpy(buf->getBuffer(), contents.c_str(), contents.length());

}

BufferInputSource::~BufferInputSource()

{

    if (own_memory) {

        delete buf;

    }

}

qpdf_offset_t

BufferInputSource::findAndSkipNextEOL()

{

    if (cur_offset < 0) {

        throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");

    }

    qpdf_offset_t end_pos = max_offset;

    if (cur_offset >= end_pos) {

        last_offset = end_pos;

        cur_offset = end_pos;

        return end_pos;

    }

    qpdf_offset_t result = 0;

    unsigned char const* buffer = buf->getBuffer();

    unsigned char const* end = buffer + end_pos;

    unsigned char const* p = buffer + cur_offset;

    while ((p < end) && !((*p == '\r') || (*p == '\n'))) {

        ++p;

    }

    if (p < end) {

        result = p - buffer;

        cur_offset = result + 1;

        ++p;

        while ((cur_offset < end_pos) && ((*p == '\r') || (*p == '\n'))) {

            ++p;

            ++cur_offset;

        }

    } else {

        cur_offset = end_pos;

        result = end_pos;

    }

    return result;

}

std::string const&

BufferInputSource::getName() const

{

    return description;

}

qpdf_offset_t

BufferInputSource::tell()

{

    return cur_offset;

}

void

BufferInputSource::seek(qpdf_offset_t offset, int whence)

{

    switch (whence) {

    case SEEK_SET:

        cur_offset = offset;

        break;

    case SEEK_END:

        QIntC::range_check(max_offset, offset);

        cur_offset = max_offset + offset;

        break;

    case SEEK_CUR:

        QIntC::range_check(cur_offset, offset);

        cur_offset += offset;

        break;

    default:

        throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");

        break;

    }

    if (cur_offset < 0) {

        throw std::runtime_error(description + ": seek before beginning of buffer");

    }

}

void

BufferInputSource::rewind()

{

    cur_offset = 0;

}

size_t

BufferInputSource::read(char* buffer, size_t length)

{

    if (cur_offset < 0) {

        throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");

    }

    qpdf_offset_t end_pos = max_offset;

    if (cur_offset >= end_pos) {

        last_offset = end_pos;

        return 0;

    }

    last_offset = cur_offset;

    size_t len = std::min(QIntC::to_size(end_pos - cur_offset), length);

    memcpy(buffer, buf->getBuffer() + cur_offset, len);

    cur_offset += QIntC::to_offset(len);

    return len;

}

void

BufferInputSource::unreadCh(char ch)

{

    if (cur_offset > 0) {

        --cur_offset;

    }

}

#else

class BufferInputSource::Members

{

  public:

    Members(std::string const& description, Buffer* buf, bool own_memory) :

        buf(own_memory ? buf : nullptr),

        is(description,

           buf && buf->getSize() > 0

               ? std::string_view(reinterpret_cast<const char*>(buf->getBuffer()), buf->getSize())

               : std::string_view())

    {

    }

    Members(std::string const& description, std::string const& str) :

        content(str),

        is(description, content)

    {

    }

    ~Members() = default;

    std::unique_ptr<Buffer> buf{nullptr};

    std::string content;

    is::OffsetBuffer is;

};

BufferInputSource::BufferInputSource(std::string const& description, Buffer* buf, bool own_memory) :

    m(std::make_unique<Members>(description, buf, own_memory))

{

}

BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :

    m(std::make_unique<Members>(description, contents))

{

}

BufferInputSource::~BufferInputSource() = default;

qpdf_offset_t

BufferInputSource::findAndSkipNextEOL()

{

    auto result = m->is.findAndSkipNextEOL();

    last_offset = m->is.getLastOffset();

    return result;

}

std::string const&

BufferInputSource::getName() const

{

    return m->is.getName();

}

qpdf_offset_t

BufferInputSource::tell()

{

    return m->is.tell();

}

void

BufferInputSource::seek(qpdf_offset_t offset, int whence)

{

    m->is.seek(offset, whence);

}

void

BufferInputSource::rewind()

{

    m->is.rewind();

}

size_t

BufferInputSource::read(char* buffer, size_t length)

{

    auto result = m->is.read(buffer, length);

    last_offset = m->is.getLastOffset();

    return result;

}

void

BufferInputSource::unreadCh(char ch)

{

    m->is.unreadCh(ch);

}

#endif // QPDF_FUTURE

qpdf_offset_t

is::OffsetBuffer::findAndSkipNextEOL()

{

    if (pos < 0) {

        throw std::logic_error("INTERNAL ERROR: is::OffsetBuffer offset < 0");

    }

    auto end_pos = static_cast<qpdf_offset_t>(view_.size());

    if (pos >= end_pos) {

        last_offset = end_pos + global_offset;

        pos = end_pos;

        return end_pos + global_offset;

    }

    qpdf_offset_t result = 0;

    auto buffer = view_.begin();

    auto end = view_.end();

    auto p = buffer + static_cast<std::ptrdiff_t>(pos);

    while (p < end && !(*p == '\r' || *p == '\n')) {

        ++p;

    }

    if (p < end) {

        result = p - buffer;

        pos = result + 1;

        ++p;

        while (pos < end_pos && (*p == '\r' || *p == '\n')) {

            ++p;

            ++pos;

        }

    } else {

        pos = end_pos;

        result = end_pos;

    }

    return result + global_offset;

}

void

is::OffsetBuffer::seek(qpdf_offset_t offset, int whence)

{

    switch (whence) {

    case SEEK_SET:

        pos = offset - global_offset;

        break;

    case SEEK_END:

        QIntC::range_check(static_cast<qpdf_offset_t>(view_.size()), offset);

        pos = static_cast<qpdf_offset_t>(view_.size()) + offset;

        break;

    case SEEK_CUR:

        QIntC::range_check(pos, offset);

        pos += offset;

        break;

    default:

        throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");

        break;

    }

    if (pos < 0) {

        throw std::runtime_error(description + ": seek before beginning of buffer");

    }

}

size_t

is::OffsetBuffer::read(char* buffer, size_t length)

{

    if (pos < 0) {

        throw std::logic_error("INTERNAL ERROR: is::OffsetBuffer offset < 0");

    }

    auto end_pos = static_cast<qpdf_offset_t>(view_.size());

    if (pos >= end_pos) {

        last_offset = end_pos + global_offset;

        return 0;

    }

    last_offset = pos + global_offset;

    size_t len = std::min(QIntC::to_size(end_pos - pos), length);

    memcpy(buffer, view_.data() + pos, len);

    pos += QIntC::to_offset(len);

    return len;

}