/*
 *
 * Copyright 2023 Oleg Borodin  <borodin@unix7.org>
 *
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>

#include <bstream.h>


#define STREAM_INITCAPA 512

bstream_t* bstream_init(bstream_t* stream) {
    stream->data = malloc(STREAM_INITCAPA);
    if (stream->data == NULL) {
            return NULL;
    }
    stream->wpos = 0;
    stream->rpos = 0;
    stream->capa = STREAM_INITCAPA;
    return stream;
}

size_t bstream_dump(bstream_t * stream) {
    for (size_t i = 0; i < stream->wpos; i++) {
            printf("%c", stream->data[i]);
    }
    return stream->wpos;
}


ssize_t bstream_write(bstream_t * stream, void* buffer, size_t size) {
    if ((stream->wpos + size) > stream->capa) {
        size_t newcapa = stream->capa * 2;

        uint8_t* newdata = realloc(stream->data, (size_t)newcapa);
        if (newdata == NULL) {
                return (ssize_t)-1;
        }
        stream->data = newdata;
        stream->capa = newcapa;
    }
    if (buffer != NULL) {
        memcpy(&(stream->data[stream->wpos]), buffer, (size_t)size);
    }
    stream->wpos += size;
    return (ssize_t) size;
}

ssize_t bstream_read(bstream_t* stream, void* buffer, size_t size) {
    size_t unread = stream->wpos - stream->rpos;

    if (size > unread) {
            size = unread;
    }
    if (buffer != NULL) {
        memcpy(buffer, &(stream->data[stream->rpos]), size);
    }
    stream->rpos += size;
    return (ssize_t) size;
}

#define BUFFER_SIZE 1024


ssize_t bstream_fread(bstream_t * stream, char* filename) {
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
            return (ssize_t)-1;
    }
    char buffer[BUFFER_SIZE];
    size_t rsize = 0;
    size_t tsize = 0;

    while ((rsize = (size_t)read(fd, buffer, BUFFER_SIZE)) > 0) {
            if ((stream->wpos + rsize) > stream->capa) {
                    size_t newcapa = stream->capa * 2 + rsize;
                    stream->data = realloc(stream->data, (size_t)newcapa);
                    stream->capa = newcapa;
            }
            if (buffer != NULL) {
                    memcpy(&(stream->data[stream->wpos]), buffer, (size_t)rsize);
            }
            stream->wpos += rsize;
            tsize += rsize;
    }
    close(fd);
    return (ssize_t)tsize;
}


char bstream_getc(bstream_t* stream) {
    size_t unread = stream->wpos - stream->rpos;
    if (unread == 0) {
            return EOF;
    }
    return (char)stream->data[stream->rpos++];
}


char bstream_getnc(bstream_t* stream, int fd) {
    size_t unread = stream->wpos - stream->rpos;
    if (unread == 0) {
        char* buffer[BUFFER_SIZE];
        size_t rsize = read(fd, buffer, sizeof(buffer));
        if (rsize == 0) {
                return EOF;
        }
        if ((stream->wpos + rsize) > stream->capa) {
            size_t newcapa = stream->capa * 2 + rsize;
            uint8_t* newdata = realloc(stream->data, (size_t)newcapa);
            if (newdata == NULL) {
                    return (ssize_t)-1;
            }
            stream->data = newdata;
            stream->capa = newcapa;
        }
        memcpy(&(stream->data[stream->wpos]), buffer, (size_t)rsize);
        stream->wpos += rsize;
    }
    return (char)stream->data[stream->rpos++];
}


size_t bstream_wpos(bstream_t* stream) {
    return stream->wpos;
}

size_t bstream_rpos(bstream_t* stream) {
    return stream->rpos;
}

void bstream_destroy(bstream_t* stream) {
    if (stream != NULL) {
            free(stream->data);
    }
}