////////////////////////////////////////////////////////////////////////////////
// (c) Copyright, Ubisoft Entertainment Inc. ||  Created by Harbour           //
////////////////////////////////////////////////////////////////////////////////
#include "tests/config.h"
#include "tests/fixture/memoryCheckFixture.h"
#include <ubiservices/core/http/httpBinaryEntity.h>
#include <ubiservices/core/http/httpEntityBuffer.h>
#include <ubiservices/core/http/httpEntityReader.h>
#include <ubiservices/core/http/httpEntityWriter.h>
#include <ubiservices/core/http/httpStringEntity.h>
#include <ubiservices/core/http/httpStreamEntity.h>
#include <ubiservices/core/types/stringStream.h>

namespace US_NS {;
US_DEFINE_TEST(TestHttpEntity);
};

#ifndef US_DLL
namespace US_NS {;

typedef LeakChecker HTTP_ENTITY;

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderBinary)
{
    const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
    const uint32 dataSize = 20;
    const uint32 readSize = dataSize / 2;
    uint8 dest[dataSize];
    memset(dest, 0, dataSize);

    SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));

    HttpEntityReader reader(entity);
    EXPECT_EQ(dataSize, reader.getRemaining());

    uint32 byteRead = reader.read(dest, readSize);

    EXPECT_EQ(readSize, byteRead);
    EXPECT_EQ(dataSize - readSize, reader.getRemaining());

    byteRead = reader.read(dest + byteRead, readSize);

    EXPECT_EQ(readSize, byteRead);
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_TRUE(memcmp(data, dest, dataSize) == 0);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderBinaryDeferred)
{
    const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
    const uint32 dataSize = 20;
    const uint32 readSize = dataSize / 2;
    uint32 readBytes = 0;
    uint8 dest[dataSize];
    memset(dest, 0, dataSize);

    SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));

    HttpEntityReader reader(entity);
    EXPECT_EQ(dataSize, reader.getRemaining());

    HttpEntityBuffer buffer = reader.readDeferred(readSize);
    memcpy(dest, buffer.getPtr(), buffer.getSize());
    readBytes += buffer.getSize();

    reader.notifyReadDeferred(buffer.getSize());
    EXPECT_EQ(readSize, buffer.getSize());
    EXPECT_EQ(dataSize - readSize, reader.getRemaining());

    buffer = reader.readDeferred(readSize);
    memcpy(dest + readBytes, buffer.getPtr(), buffer.getSize());
    readBytes += buffer.getSize();

    reader.notifyReadDeferred(buffer.getSize());
    EXPECT_EQ(dataSize, readBytes);
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_TRUE(memcmp(data, dest, dataSize) == 0);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderString)
{
    const String data("Data of the entity!!"); // 20 chars
    const uint32 dataSize = static_cast<uint32>(data.getLength());
    const uint32 readSize = dataSize / 2;
    uint8* dest = US_NEW_ARRAY(uint8, dataSize + 1);
    memset(dest, 0, dataSize + 1);

    SmartPtr<HttpEntity> entity(US_NEW(HttpStringEntity, data));

    HttpEntityReader reader(entity);
    EXPECT_EQ(dataSize, reader.getRemaining());

    uint32 byteRead = reader.read(dest, readSize);

    EXPECT_EQ(readSize, byteRead);
    EXPECT_EQ(dataSize - readSize, reader.getRemaining());

    byteRead = reader.read(dest + byteRead, readSize);

    EXPECT_EQ(readSize, byteRead);
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_STREQ(data.getUtf8(), reinterpret_cast<char*>(dest));

    US_DELETE_ARRAY(dest);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderStringDeferred)
{
    const String data("Data of the entity!!"); // 20 chars
    const uint32 dataSize = static_cast<uint32>(data.getLength());
    const uint32 readSize = dataSize;
    uint8* dest = US_NEW_ARRAY(uint8, dataSize + 1);
    memset(dest, 0, dataSize + 1);
    StringStream sstream;

    SmartPtr<HttpEntity> entity(US_NEW(HttpStringEntity, data));

    HttpEntityReader reader(entity);
    EXPECT_EQ(dataSize, reader.getRemaining());

    const HttpEntityBuffer buffer = reader.readDeferred(readSize);
    memcpy(dest, buffer.getPtr(), buffer.getSize());
    sstream << reinterpret_cast<char*>(dest);

    reader.notifyReadDeferred(buffer.getSize());

    EXPECT_EQ(readSize, buffer.getSize());
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_STREQ(data.getUtf8(), sstream.getContent().getUtf8());

    US_DELETE_ARRAY(dest);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderPastEnd)
{
    const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
    const uint32 dataSize = 20;
    const uint32 readSize = dataSize;
    uint8 dest[dataSize];
    memset(dest, 0, dataSize);

    SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));

    HttpEntityReader reader(entity);
    EXPECT_EQ(dataSize, reader.getRemaining());

    uint32 byteRead = reader.read(dest, readSize);

    EXPECT_EQ(readSize, byteRead);
    EXPECT_EQ(0u, reader.getRemaining());

    // Try to read again, this shouldn't do anything
    byteRead = reader.read(dest, readSize);

    EXPECT_EQ(0u, byteRead);
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_TRUE(memcmp(data, dest, dataSize) == 0);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderReadAsString)
{
    const uint8* data = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
    const uint32 dataSize = 20;
    String dest;

    SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity, data, dataSize));

    dest = HttpEntityReader::readAllAsString(entity);

    EXPECT_STREQ(reinterpret_cast<const char*>(data), dest.getUtf8());
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityWriterBinary)
{
    const uint8* writeData = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
    const uint32 dataSize = 20;
    const uint32 writeSize = dataSize / 2;
    uint32 writePos = 0;

    SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity));
    HttpEntityWriter writer(entity);

    uint32 writeBytes = writer.write(writeData + writePos, writeSize);
    writePos += writeBytes;

    EXPECT_EQ(writeSize, writeBytes);
    EXPECT_EQ(writePos, entity->getDataSize());
    EXPECT_EQ(writePos, entity->getAllocatedSize());

    writeBytes = writer.write(writeData + writePos, writeSize);
    writePos += writeBytes;

    EXPECT_EQ(writeSize, writeBytes);
    EXPECT_EQ(dataSize, entity->getDataSize());
    EXPECT_EQ(dataSize, entity->getAllocatedSize());

    // Validate the write by reading everything
    uint8* dest = US_NEW_ARRAY(uint8, dataSize);
    HttpEntityReader reader(entity);

    reader.read(dest, dataSize);
    EXPECT_TRUE(memcmp(writeData, dest, dataSize) == 0);

    US_DELETE_ARRAY(dest);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityWriterBinaryDeferred)
{
    const uint8* writeData = reinterpret_cast<const uint8*>("Data of the entity!!"); // 20 chars
    const uint32 dataSize = 20;
    const uint32 writeSize = dataSize / 2;
    uint32 writePos = 0;

    SmartPtr<HttpEntity> entity(US_NEW(HttpBinaryEntity));
    HttpEntityWriter writer(entity);

    HttpEntityBuffer buffer = writer.writeDeferred(writeSize);
    memcpy(buffer.getPtr(), writeData + writePos, buffer.getSize());

    writer.notifyWriteDeferred(buffer.getSize());
    writePos += buffer.getSize();

    EXPECT_EQ(writeSize, buffer.getSize());
    EXPECT_EQ(writePos, entity->getDataSize());
    EXPECT_EQ(writePos, entity->getAllocatedSize());

    buffer = writer.writeDeferred(writeSize);
    memcpy(buffer.getPtr(), writeData + writePos, buffer.getSize());

    writer.notifyWriteDeferred(buffer.getSize());
    writePos += buffer.getSize();

    EXPECT_EQ(writeSize, buffer.getSize());
    EXPECT_EQ(dataSize, entity->getDataSize());
    EXPECT_EQ(dataSize, entity->getAllocatedSize());

    // Validate the write by reading everything
    uint8* dest = US_NEW_ARRAY(uint8, dataSize);
    HttpEntityReader reader(entity);

    reader.read(dest, dataSize);
    EXPECT_TRUE(memcmp(writeData, dest, dataSize) == 0);

    US_DELETE_ARRAY(dest);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpStreamEntityAvailableBuffers)
{
    const uint32 BUFFER_SIZE = 10;

    HttpStreamEntity streamEntity;
    
    // Position is zero based
    EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());

    streamEntity.pushBuffer(HttpEntityBuffer(US_NEW_ARRAY(uint8, BUFFER_SIZE), BUFFER_SIZE));
    EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
    EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE).size());
    EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE * 2).size());

    streamEntity.pushBuffer(HttpEntityBuffer(US_NEW_ARRAY(uint8, BUFFER_SIZE), BUFFER_SIZE));
    EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
    EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE).size());
    EXPECT_EQ(2, streamEntity.availableBuffers(BUFFER_SIZE * 2).size());

    uint8* bufferPtr = streamEntity.popBuffer().getPtr(); 
    US_DELETE_ARRAY(bufferPtr);

    EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE - 1).size());
    EXPECT_EQ(0u, streamEntity.availableBuffers(BUFFER_SIZE).size());
    EXPECT_EQ(0u, streamEntity.availableBuffers( (BUFFER_SIZE * 2) - 1).size());
    EXPECT_EQ(1, streamEntity.availableBuffers(BUFFER_SIZE * 2).size());

    bufferPtr = streamEntity.popBuffer().getPtr(); 
    US_DELETE_ARRAY(bufferPtr);
}


TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderStreamEntity)
{
    uint8 entityData[] = "Data of the entity!!"; // 20 chars
    const uint32 DATA_SIZE = 20;
    const uint32 BUFFER_SIZE = 5;

    uint8 dest[DATA_SIZE];
    memset(dest, 0, DATA_SIZE);

    // Prepare the entity
    SmartPtr<HttpStreamEntity> streamEntity(US_NEW(HttpStreamEntity, DATA_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(entityData, BUFFER_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE, BUFFER_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE * 2, BUFFER_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE * 3, BUFFER_SIZE));

    HttpEntityReader reader(SmartPtr<HttpEntity>(streamEntity.getPtr()));
    EXPECT_EQ(DATA_SIZE, reader.getRemaining());

    uint32 byteRead = reader.read(dest, DATA_SIZE);
    uint32 totalRead = byteRead;

    EXPECT_EQ(BUFFER_SIZE, byteRead);
    EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());

    byteRead = reader.read(dest + totalRead, DATA_SIZE);
    totalRead += byteRead;

    EXPECT_EQ(BUFFER_SIZE, byteRead);
    EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());

    byteRead = reader.read(dest + totalRead, DATA_SIZE);
    totalRead += byteRead;

    EXPECT_EQ(BUFFER_SIZE, byteRead);
    EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());

    byteRead = reader.read(dest + totalRead, DATA_SIZE);
    totalRead += byteRead;

    EXPECT_EQ(BUFFER_SIZE, byteRead);
    EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_TRUE(memcmp(entityData, dest, DATA_SIZE) == 0);
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityReaderStreamEntityOffset)
{
    uint8 entityData[] = "Data of the entity!!"; // 20 chars
    const uint32 DATA_SIZE = 20;
    const uint32 BUFFER_SIZE = DATA_SIZE / 2;

    uint8 dest[DATA_SIZE];
    memset(dest, 0, DATA_SIZE);

    // Prepare the entity
    SmartPtr<HttpStreamEntity> streamEntity(US_NEW(HttpStreamEntity, DATA_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(entityData, BUFFER_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(entityData + BUFFER_SIZE, BUFFER_SIZE));

    HttpEntityReader reader(SmartPtr<HttpEntity>(streamEntity.getPtr()));
    EXPECT_EQ(DATA_SIZE, reader.getRemaining());

    HttpEntityBuffer buffer = reader.readDeferred(DATA_SIZE);
    memcpy(dest, buffer.getPtr(), buffer.getSize());
    reader.notifyReadDeferred(buffer.getSize());
    uint32 totalRead = buffer.getSize();

    EXPECT_EQ(BUFFER_SIZE, buffer.getSize());
    EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());

    // Read a smaller buffer and validate that the returned buffer is offsetted
    const uint32 readSize = BUFFER_SIZE / 2;

    buffer = reader.readDeferred(readSize);
    memcpy(dest + totalRead, buffer.getPtr(), buffer.getSize());
    reader.notifyReadDeferred(buffer.getSize());
    totalRead += buffer.getSize();

    uint8* bufferPtr = buffer.getPtr();
    EXPECT_EQ(readSize, buffer.getSize());
    EXPECT_EQ(DATA_SIZE - totalRead, reader.getRemaining());

    buffer = reader.readDeferred(readSize);
    memcpy(dest + totalRead, buffer.getPtr(), buffer.getSize());
    reader.notifyReadDeferred(buffer.getSize());
    totalRead += buffer.getSize();

    EXPECT_NE(bufferPtr, buffer.getPtr());
    EXPECT_EQ(readSize, buffer.getSize());
    EXPECT_EQ(0u, reader.getRemaining());

    EXPECT_TRUE(memcmp(entityData, dest, DATA_SIZE) == 0);

    // Try to read when there's nothing left
    buffer = reader.readDeferred(readSize);
    EXPECT_EQ(0u, buffer.getSize());
}

TEST_F(HTTP_ENTITY, LOCAL_HttpEntityWriterStreamEntity)
{
    uint8 entityData[] = "Data of the entity!!"; // 20 chars
    const uint32 DATA_SIZE = 20;
    const uint32 BUFFER_SIZE = 5;

    uint8 dest[DATA_SIZE];
    memset(dest, 0, DATA_SIZE);

    // Prepare the entity
    SmartPtr<HttpStreamEntity> streamEntity(US_NEW(HttpStreamEntity));

    HttpEntityWriter writer(SmartPtr<HttpEntity>(streamEntity.getPtr()));

    uint32 byteWrite = writer.write(entityData, BUFFER_SIZE);
    uint32 totalWrite = byteWrite;
    EXPECT_EQ(0u, byteWrite);

    streamEntity->pushBuffer(HttpEntityBuffer(dest, BUFFER_SIZE));

    // Try to write more then a buffer
    byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE * 2);
    totalWrite += byteWrite;
    EXPECT_EQ(BUFFER_SIZE, byteWrite);

    streamEntity->pushBuffer(HttpEntityBuffer(dest + BUFFER_SIZE, BUFFER_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(dest + BUFFER_SIZE * 2, BUFFER_SIZE));
    streamEntity->pushBuffer(HttpEntityBuffer(dest + BUFFER_SIZE * 3, BUFFER_SIZE));

    byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE);
    totalWrite += byteWrite;
    EXPECT_EQ(BUFFER_SIZE, byteWrite);

    byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE);
    totalWrite += byteWrite;
    EXPECT_EQ(BUFFER_SIZE, byteWrite);

    byteWrite = writer.write(entityData + totalWrite, BUFFER_SIZE);
    totalWrite += byteWrite;
    EXPECT_EQ(BUFFER_SIZE, byteWrite);
    EXPECT_EQ(DATA_SIZE, totalWrite);

    EXPECT_TRUE(memcmp(entityData, dest, DATA_SIZE) == 0);
}


};

#endif