/**
 * NowStream.h
 */

#ifndef NOW_STREAM_H
#define NOW_STREAM_H

#include <winpr/crt.h>
#include <winpr/endian.h>

#include <Wayk/Now.h>

#ifdef __cplusplus
extern "C" {
#endif

struct now_stream
{
    uint8_t* buffer;
    uint8_t* pointer;
    size_t length;
    size_t capacity;
    bool owner;
};
typedef struct now_stream NowStream;

#define now_stream_read_n8(_t, _s, _v, _p) do { _v = \
    (_t)(*_s->pointer); \
    _s->pointer += _p; } while (0)

#define now_stream_read_n16_le(_t, _s, _v, _p) do { _v = \
    (_t)(*_s->pointer) + \
    (((_t)(*(_s->pointer + 1))) << 8); \
    if (_p) _s->pointer += 2; } while (0)

#define now_stream_read_n16_be(_t, _s, _v, _p) do { _v = \
    (((_t)(*_s->pointer)) << 8) + \
    (_t)(*(_s->pointer + 1)); \
    if (_p) _s->pointer += 2; } while (0)

#define now_stream_read_n32_le(_t, _s, _v, _p) do { _v = \
    (_t)(*_s->pointer) + \
    (((_t)(*(_s->pointer + 1))) << 8) + \
    (((_t)(*(_s->pointer + 2))) << 16) + \
    (((_t)(*(_s->pointer + 3))) << 24); \
    if (_p) _s->pointer += 4; } while (0)

#define now_stream_read_n32_be(_t, _s, _v, _p) do { _v = \
    (((_t)(*(_s->pointer))) << 24) + \
    (((_t)(*(_s->pointer + 1))) << 16) + \
    (((_t)(*(_s->pointer + 2))) << 8) + \
    (((_t)(*(_s->pointer + 3)))); \
    if (_p) _s->pointer += 4; } while (0)

#define now_stream_read_n64_le(_t, _s, _v, _p) do { _v = \
    (_t)(*_s->pointer) + \
    (((_t)(*(_s->pointer + 1))) << 8) + \
    (((_t)(*(_s->pointer + 2))) << 16) + \
    (((_t)(*(_s->pointer + 3))) << 24) + \
    (((_t)(*(_s->pointer + 4))) << 32) + \
    (((_t)(*(_s->pointer + 5))) << 40) + \
    (((_t)(*(_s->pointer + 6))) << 48) + \
    (((_t)(*(_s->pointer + 7))) << 56); \
    if (_p) _s->pointer += 8; } while (0)

#define now_stream_read_n64_be(_t, _s, _v, _p) do { _v = \
    (((_t)(*(_s->pointer))) << 56) + \
    (((_t)(*(_s->pointer + 1))) << 48) + \
    (((_t)(*(_s->pointer + 2))) << 40) + \
    (((_t)(*(_s->pointer + 3))) << 32) + \
    (((_t)(*(_s->pointer + 4))) << 24) + \
    (((_t)(*(_s->pointer + 5))) << 16) + \
    (((_t)(*(_s->pointer + 6))) << 8) + \
    (((_t)(*(_s->pointer + 7)))); \
    if (_p) _s->pointer += 8; } while (0)


#define NowStream_Read_UINT8(_s, _v) now_stream_read_n8(UINT8, _s, _v, 1)
#define NowStream_Read_INT8(_s, _v) now_stream_read_n8(INT8, _s, _v, 1)

#define NowStream_Read_UINT16(_s, _v) now_stream_read_n16_le(UINT16, _s, _v, 1)
#define NowStream_Read_INT16(_s, _v) now_stream_read_n16_le(INT16, _s, _v, 1)

#define NowStream_Read_UINT16_BE(_s, _v) now_stream_read_n16_be(UINT16, _s, _v, 1)
#define NowStream_Read_INT16_BE(_s, _v) now_stream_read_n16_be(INT16, _s, _v, 1)

#define NowStream_Read_UINT32(_s, _v) now_stream_read_n32_le(UINT32, _s, _v, 1)
#define NowStream_Read_INT32(_s, _v) now_stream_read_n32_le(INT32, _s, _v, 1)

#define NowStream_Read_UINT32_BE(_s, _v) now_stream_read_n32_be(UINT32, _s, _v, 1)
#define NowStream_Read_INT32_BE(_s, _v) now_stream_read_n32_be(INT32, _s, _v, 1)

#define NowStream_Read_UINT64(_s, _v) now_stream_read_n64_le(UINT64, _s, _v, 1)
#define NowStream_Read_INT64(_s, _v) now_stream_read_n64_le(INT64, _s, _v, 1)

#define NowStream_Read_UINT64_BE(_s, _v) now_stream_read_n64_be(UINT64, _s, _v, 1)
#define NowStream_Read_INT64_BE(_s, _v) now_stream_read_n64_be(INT64, _s, _v, 1)

#define NowStream_Read(_s, _b, _n) do { \
    memcpy(_b, (_s->pointer), (_n)); \
    _s->pointer += (_n); \
    } while (0)


#define NowStream_Peek_UINT8(_s, _v) now_stream_read_n8(UINT8, _s, _v, 0)
#define NowStream_Peek_INT8(_s, _v) now_stream_read_n8(INT8, _s, _v, 0)

#define NowStream_Peek_UINT16(_s, _v) now_stream_read_n16_le(UINT16, _s, _v, 0)
#define NowStream_Peek_INT16(_s, _v) now_stream_read_n16_le(INT16, _s, _v, 0)

#define NowStream_Peek_UINT16_BE(_s, _v) now_stream_read_n16_be(UINT16, _s, _v, 0)
#define NowStream_Peek_INT16_BE(_s, _v) now_stream_read_n16_be(INT16, _s, _v, 0)

#define NowStream_Peek_UINT32(_s, _v) now_stream_read_n32_le(UINT32, _s, _v, 0)
#define NowStream_Peek_INT32(_s, _v) now_stream_read_n32_le(INT32, _s, _v, 0)

#define NowStream_Peek_UINT32_BE(_s, _v) now_stream_read_n32_be(UINT32, _s, _v, 0)
#define NowStream_Peek_INT32_BE(_s, _v) now_stream_read_n32_be(INT32, _s, _v, 0)

#define NowStream_Peek_UINT64(_s, _v) now_stream_read_n64_le(UINT64, _s, _v, 0)
#define NowStream_Peek_INT64(_s, _v) now_stream_read_n64_le(INT64, _s, _v, 0)

#define NowStream_Peek_UINT64_BE(_s, _v) now_stream_read_n64_be(UINT64, _s, _v, 0)
#define NowStream_Peek_INT64_BE(_s, _v) now_stream_read_n64_be(INT64, _s, _v, 0)

#define NowStream_Peek(_s, _b, _n) do { \
    memcpy(_b, (_s->pointer), (_n)); \
    } while (0)


#define NowStream_Write_UINT8(_s, _v) do { \
    *_s->pointer++ = (UINT8)(_v); } while (0)
#define NowStream_Write_INT8 NowStream_Write_UINT8

#define NowStream_Write_UINT16(_s, _v) do { \
    *_s->pointer++ = (_v) & 0xFF; \
    *_s->pointer++ = ((_v) >> 8) & 0xFF; } while (0)
#define NowStream_Write_INT16 NowStream_Write_UINT16

#define NowStream_Write_UINT16_BE(_s, _v) do { \
    *_s->pointer++ = ((_v) >> 8) & 0xFF; \
    *_s->pointer++ = (_v) & 0xFF; } while (0)
#define NowStream_Write_INT16_BE NowStream_Write_UINT16_BE

#define NowStream_Write_UINT32(_s, _v) do { \
    *_s->pointer++ = (_v) & 0xFF; \
    *_s->pointer++ = ((_v) >> 8) & 0xFF; \
    *_s->pointer++ = ((_v) >> 16) & 0xFF; \
    *_s->pointer++ = ((_v) >> 24) & 0xFF; } while (0)
#define NowStream_Write_INT32 NowStream_Write_UINT32

#define NowStream_Write_UINT32_BE(_s, _v) do { \
        NowStream_Write_UINT16_BE(_s, ((_v) >> 16 & 0xFFFF)); \
        NowStream_Write_UINT16_BE(_s, ((_v) & 0xFFFF)); \
    } while (0)
#define NowStream_Write_INT32_BE NowStream_Write_UINT32_BE

#define NowStream_Write_UINT64(_s, _v) do { \
    *_s->pointer++ = (UINT64)(_v) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 8) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 16) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 24) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 32) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 40) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 48) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 56) & 0xFF; } while (0)
#define NowStream_Write_INT64 NowStream_Write_UINT64

#define NowStream_Write_UINT64_BE(_s, _v) do { \
    *_s->pointer++ = ((UINT64)(_v) >> 56) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 48) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 40) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 32) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 24) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 16) & 0xFF; \
    *_s->pointer++ = ((UINT64)(_v) >> 8) & 0xFF; \
    *_s->pointer++ = (UINT64)(_v) & 0xFF; } while (0)
#define NowStream_Write_INT64_BE NowStream_Write_UINT64_BE

#define NowStream_Write(_s, _b, _n) do { \
    memcpy(_s->pointer, (_b), (_n)); \
    _s->pointer += (_n); \
    } while (0)


#define NowStream_Seek(_s,_offset)      _s->pointer += (_offset)
#define NowStream_Rewind(_s,_offset)        _s->pointer -= (_offset)

#define NowStream_Seek_UINT8(_s)        NowStream_Seek(_s, 1)
#define NowStream_Seek_UINT16(_s)       NowStream_Seek(_s, 2)
#define NowStream_Seek_UINT32(_s)       NowStream_Seek(_s, 4)
#define NowStream_Seek_UINT64(_s)       NowStream_Seek(_s, 8)

#define NowStream_Rewind_UINT8(_s)      NowStream_Rewind(_s, 1)
#define NowStream_Rewind_UINT16(_s)     NowStream_Rewind(_s, 2)
#define NowStream_Rewind_UINT32(_s)     NowStream_Rewind(_s, 4)
#define NowStream_Rewind_UINT64(_s)     NowStream_Rewind(_s, 8)

#define NowStream_Zero(_s, _n) do { \
    memset(_s->pointer, 0, (_n)); \
    _s->pointer += (_n); \
    } while (0)

#define NowStream_Fill(_s, _v, _n) do { \
    memset(_s->pointer, _v, (_n)); \
    _s->pointer += (_n); \
    } while (0)

#define NowStream_Copy(_dst, _src, _n) do { \
    memcpy(_dst->pointer, _src->pointer, _n); \
    _dst->pointer += _n; \
    _src->pointer += _n; \
    } while (0)

#define NowStream_Buffer(_s)            _s->buffer
#define NowStream_GetBuffer(_s, _b)     _b = _s->buffer
#define NowStream_SetBuffer(_s, _b)     _s->buffer = _b

#define NowStream_Pointer(_s)           _s->pointer
#define NowStream_GetPointer(_s, _p)        _p = _s->pointer
#define NowStream_SetPointer(_s, _p)        _s->pointer = _p

#define NowStream_Length(_s)            _s->length
#define NowStream_GetLength(_s, _l)     _l = _s->length
#define NowStream_SetLength(_s, _l)     _s->length = _l

#define NowStream_Capacity(_s)          _s->capacity
#define NowStream_GetCapacity(_s, _c)       _c = _s->capacity
#define NowStream_SetCapacity(_s, _c)       _s->capacity = _c

#define NowStream_GetPosition(_s)       (_s->pointer - _s->buffer)
#define NowStream_SetPosition(_s, _p)       _s->pointer = _s->buffer + (_p)

#define NowStream_SealLength(_s)        _s->length = (_s->pointer - _s->buffer)
#define NowStream_GetRemainingLength(_s)    (_s->length - (_s->pointer - _s->buffer))
#define NowStream_GetRemainingCapacity(_s)  (_s->capacity - (_s->pointer - _s->buffer))

#define NowStream_Clear(_s)         memset(_s->buffer, 0, _s->capacity)

static INLINE bool NowStream_SafeSeek(NowStream* s, size_t size)
{
    if (NowStream_GetRemainingLength(s) < size)
        return false;

    NowStream_Seek(s, size);
    return true;
}

WAYK_EXPORT bool NowStream_EnsureCapacity(NowStream* s, size_t size);
WAYK_EXPORT bool NowStream_EnsureRemainingCapacity(NowStream* s, size_t size);

WAYK_EXPORT bool NowStream_CheckSafeRead(NowStream* s, size_t size);
WAYK_EXPORT bool NowStream_CheckSafeWrite(NowStream* s, size_t size);

WAYK_EXPORT int NowStream_Format(NowStream* s, const char* format, ...);

/**
 * Search for |pattern| from the current position in the stream. If pattern is found, |offset|
 * contains the offset from the current position where the |pattern| begins.
 */
bool NowStream_Find(NowStream* s, const uint8_t* pattern, size_t pattern_length, size_t* offset);

WAYK_EXPORT NowStream* NowStream_Init(NowStream* s, uint8_t* buffer, size_t size, bool owner);
WAYK_EXPORT void NowStream_Uninit(NowStream* s);

WAYK_EXPORT NowStream* NowStream_New(uint8_t* buffer, size_t size, bool owner);
WAYK_EXPORT void NowStream_Free(NowStream* s);

#ifdef __cplusplus
}
#endif

#endif /* NOW_STREAM_H */

/**
 * NowStream.c
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>

#include <Wayk/NowStream.h>

bool NowStream_Find(NowStream* s, const uint8_t* pattern, size_t pattern_length, size_t* offset)
{
    NowStream* _s = NULL;
    bool result = false;

    if (NowStream_GetRemainingLength(s) < pattern_length)
        return false;

    _s = NowStream_New(s->pointer, NowStream_GetRemainingLength(s), false);

    while (NowStream_CheckSafeRead(_s, pattern_length))
    {
        if (memcmp(_s->pointer, pattern, pattern_length) == 0)
        {
            result = true;
            *offset = _s->pointer - s->pointer;
            goto exit;
        }

        NowStream_Seek(_s, 1);
    }

exit:
    NowStream_Free(_s);

    return result;
}

bool NowStream_EnsureCapacity(NowStream* s, size_t size)
{
    if (!s->capacity)
        return false;

    if (s->capacity < size)
    {
        uint8_t* new_buf;
        size_t position;
        size_t old_capacity;
        size_t new_capacity;

        old_capacity = s->capacity;
        new_capacity = old_capacity;

        do
        {
            new_capacity *= 2;
        }
        while (new_capacity < size);

        position = NowStream_GetPosition(s);

        if (s->owner)
        {
            new_buf = (uint8_t*) realloc(s->buffer, new_capacity);

            if (!new_buf)
                return false;
        }
        else
        {
            new_buf = (uint8_t*) malloc(new_capacity);

            if (!new_buf)
                return false;

            CopyMemory(new_buf, s->buffer, old_capacity);

            s->owner = true;
        }

        s->buffer = new_buf;
        s->capacity = new_capacity;
        s->length = new_capacity;
        ZeroMemory(&s->buffer[old_capacity], s->capacity - old_capacity);

        NowStream_SetPosition(s, position);
    }

    return true;
}

bool NowStream_EnsureRemainingCapacity(NowStream* s, size_t size)
{
    if ((NowStream_GetPosition(s) + size) > NowStream_Capacity(s))
        return NowStream_EnsureCapacity(s, NowStream_Capacity(s) + size);

    return true;
}

bool NowStream_CheckSafeRead(NowStream* s, size_t size)
{
    size_t offset;

    if (s->buffer > s->pointer)
        return false;

    offset = s->pointer - s->buffer;

    if (s->length < offset)
        return false;

    int remaining_length = s->length - (s->pointer - s->buffer);

    if (remaining_length < size)
        return false;

    return true;
}

bool NowStream_CheckSafeWrite(NowStream* s, size_t size)
{
    if ((NowStream_GetPosition(s) + size) > NowStream_Capacity(s))
    {
        return NowStream_EnsureCapacity(s, NowStream_Capacity(s) + size);
    }

    return true;
}

int NowStream_Format(NowStream* s, const char* format, ...)
{
    int status;
    size_t size;
    va_list args;

    /* vsnprintf: http://www.cplusplus.com/reference/cstdio/vsnprintf/ */

    va_start(args, format);
    size = s->capacity - NowStream_GetPosition(s);
    status = vsnprintf((char*) s->pointer, size, format, args);
    va_end(args);

    if (status < 0)
        return -1;

    if (status < size)
    {
        NowStream_Seek(s, (size_t) status);
    }
    else
    {
        if (!NowStream_CheckSafeWrite(s, status + 1))
            return -1;

        va_start(args, format);
        size = s->capacity - NowStream_GetPosition(s);
        status = vsnprintf((char*) s->pointer, size, format, args);
        va_end(args);

        if ((status < 0) || (status >= size))
            return -1;

        NowStream_Seek(s, (size_t) status);
    }

    return status;
}

NowStream* NowStream_Init(NowStream* s, uint8_t* buffer, size_t size, bool owner)
{
    if (!s)
        return NULL;

    s->owner = owner;

    if (buffer)
    {
        s->buffer = buffer;
    }
    else
    {
        s->buffer = (uint8_t*) malloc(size);
        s->owner = true;
    }

    if (!s->buffer)
        return NULL;

    s->pointer = s->buffer;
    s->capacity = size;
    s->length = size;

    return s;
}

void NowStream_Uninit(NowStream* s)
{
    if (!s)
        return;

    if (s->owner)
    {
        free(s->buffer);
        s->buffer = NULL;
    }

    s->owner = false;
    s->pointer = NULL;
    s->capacity = 0;
    s->length = 0;
}

NowStream* NowStream_New(uint8_t* buffer, size_t size, bool owner)
{
    NowStream* s;

    s = malloc(sizeof(NowStream));

    if (!s)
        return NULL;

    if (!NowStream_Init(s, buffer, size, owner))
    {
        free(s);
        return NULL;
    }

    return s;
}

void NowStream_Free(NowStream* s)
{
    if (!s)
        return;

    NowStream_Uninit(s);

    free(s);
}