#include "Reader.h"

#include "Text.h"

using namespace Framework;

//! \param buffer der Buffer der gelesen werden soll
//! \param length Die länge des buffers
//! \param deleteBuffer true, wenn der buffer automatisch mit delete[] gelöscht
//! werden soll
ByteArrayReader::ByteArrayReader(
    const char* buffer, int length, bool deleteBuffer)
    : ReferenceCounter(),
      length(length),
      buffer(buffer),
      deleteBuffer(deleteBuffer),
      position(0)
{}

ByteArrayReader::~ByteArrayReader()
{
    if (deleteBuffer) delete[] buffer;
}

//! Ließt aus der Datei
//! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
//! \param len Wie viele Bytes aus der Resource gelesen werden sollen
void ByteArrayReader::lese(char* bytes, int len)
{
    if (position < length)
        memcpy(bytes, buffer + position, min(len, length - position));
    position = min(position + len, length);
}

//! Ließt die nächste zeile der Resource ein
//! \return Die gelesene Zeile als Text mit zeilenumbruch
Text* ByteArrayReader::leseZeile()
{
    if (position >= length) return 0;
    int start = position;
    for (; buffer[position] != '\n' && position < length; position++)
        ;
    Text* ret = new Text("");
    ret->fillText('\0', position - start + 1);
    lese((char*)ret->getText(), position - start + 1);
    return ret;
}

//! Prüft, ob die Resource vollständig gelesen wurde
//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
bool ByteArrayReader::istEnde() const
{
    return position >= length;
}

//! Setzt die Position des Bytes, das als nächstes gelesen werden soll
//! \param pos Der Index des Bytes
//! \param ende 1, wenn der Index vom ende der Resource zählt. 0, wenn der Index
//! vom Beginn der Resource zählt
void ByteArrayReader::setLPosition(__int64 pos, bool ende)
{
    position = ende ? max(length - (int)pos, 0) : min((int)pos, length);
}

//! Gibt den Index des Bytes aus der Resource zurück, welches als nächstes
//! gelesen werden würde return -1, falls ein Fehler aufgetreten ist. Sonst die
//! Position des Lesezeigers
__int64 ByteArrayReader::getLPosition() const
{
    return position;
}

//! Gibt die Anzahl der zu lesenden Bytes zurück
__int64 ByteArrayReader::getSize() const
{
    return length;
}