#include "blob.h"
#include <arpa/inet.h>
#include <string>

W::Blob::Blob():
    W::Object(),
    hasData(false),
    dataSize(0),
    data(0),
    qDataView()
{
}

W::Blob::Blob(uint32_t size, char* p_data):
    W::Object(),
    hasData(true),
    dataSize(size),
    data(p_data),
    qDataView(QByteArray::fromRawData(p_data, size))
{
}

W::Blob::Blob(const W::Blob& original):
    W::Object(),
    hasData(original.data),
    dataSize(original.dataSize),
    data(0),
    qDataView()
{
    if (hasData) {
        data = new char[dataSize];
        std::copy(original.data, original.data + dataSize, data);
        qDataView = QByteArray::fromRawData(data, dataSize);
    }
}

W::Blob::~Blob()
{
    if (hasData) {
        delete [] data;
    }
}

W::Blob & W::Blob::operator=(const W::Blob& original)
{
    if (&original != this) 
    {
        if (hasData) {
            delete [] data;
            qDataView = QByteArray();
        }
        hasData = original.hasData;
        dataSize = original.dataSize;
        if (hasData) {
            data = new char[dataSize];
            std::copy(original.data, original.data + dataSize, data);
            qDataView = QByteArray::fromRawData(data, dataSize);
        }
    }
    return *this;
}

W::Object * W::Blob::copy() const
{
    return new W::Blob(*this);
}

W::Object::objectType W::Blob::getType() const
{
    return type;
}

W::Object::size_type W::Blob::length() const
{
    return dataSize;
}

void W::Blob::serialize(W::ByteArray& out) const
{
    out.push32(length());
    for (uint32_t i = 0; i < dataSize; ++i) {
        out.push8(data[i]);
    }
}

void W::Blob::deserialize(W::ByteArray& in)
{
    if (hasData) {
        delete [] data;
        qDataView = QByteArray();
    }
    
    dataSize = in.pop32();
    if (dataSize > 0) {
        hasData = true;
        data = new char[dataSize];
        for (uint32_t i = 0; i < dataSize; ++i) {
            data[i] = in.pop8();
        }
        qDataView = QByteArray::fromRawData(data, dataSize);
    } else {
        hasData = false;
    }
}

W::Object::StdStr W::Blob::toString() const
{
    return "Blob <" + std::to_string(dataSize) + ">";
}

bool W::Blob::operator==(const W::Blob& other) const
{
    if (dataSize != other.dataSize) {
        return false;
    } else {
        bool equals = true;
        uint64_t i = 0;
        
        while (equals && i < dataSize) {
            equals = data[i] == other.data[i];      //TODO not sure about the c++ syntax if i'm comparing values or addresses this time
            ++i;
        }
        
        return equals;
    }
}

bool W::Blob::operator==(const W::Object& other) const
{
    if (sameType(other)) {
        return operator==(static_cast<const W::Blob&>(other));
    } else {
        return false;
    }
}

W::Object::size_type W::Blob::size() const
{
    return dataSize + 4;
}

const QByteArray & W::Blob::byteArray() const
{
    return qDataView;
}

const unsigned char * W::Blob::uchar() const
{
    return (unsigned char*) data;
}

W::Blob* W::Blob::slice(uint64_t start, uint64_t length) const
{
    char* n_data = new char[length];
    for (int i = 0; i < length; ++i) {
        n_data[i] = data[start + i];
    }
    
    return new W::Blob(length, n_data);
}