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

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

#include <cdynarr.h>


#define INIT_CAPA 64

/* Integer array */
cintarr_t* new_cintarr(void) {
        cintarr_t* arr = malloc(sizeof(cintarr_t));
        if (arr == NULL) return NULL;
        if (cintarr_init(arr) == NULL) {
            cintarr_free(arr);
            return NULL;
        }
        return arr;
}

void* cintarr_init(cintarr_t* array) {
    array->data = malloc(INIT_CAPA * sizeof(int64_t));
    if (array->data == NULL) return NULL;
    memset(array->data, 0, INIT_CAPA);
    array->capa = INIT_CAPA;
    array->size = 0;
    return array->data;
}

void* cintarr_append(cintarr_t* array, int64_t add) {
    if (array->size + 1 > array->capa) {
        size_t newcapa = (array->capa * 10) / 6;
        size_t memsize = newcapa * sizeof(int64_t);
        int64_t* newarray = realloc(array->data, memsize);
        if (newarray == NULL) return NULL;
        array->capa = newcapa;
        array->data = newarray;
    }
    array->data[array->size++] = add;
    return array->data;
}

int64_t* cintarr_getref(cintarr_t* array) {
    return array->data;
}

void cintarr_destroy(cintarr_t* array) {
    if (array == NULL) return;
    free(array->data);
}

void cintarr_free(cintarr_t* array) {
    if (array == NULL) return;
    cintarr_destroy(array);
    free(array);
}


/* Float array */
cfltarr_t* new_cfltarr(void) {
        cfltarr_t* arr = malloc(sizeof(cfltarr_t));
        if (arr == NULL) return NULL;
        if (cfltarr_init(arr) == NULL) {
            cfltarr_free(arr);
            return NULL;
        }
        return arr;
}

void* cfltarr_init(cfltarr_t* array) {
    array->data = malloc(INIT_CAPA * sizeof(double));
    if (array->data == NULL) return NULL;
    memset(array->data, 0, INIT_CAPA);
    array->capa = INIT_CAPA;
    array->size = 0;
    return array->data;
}

void* cfltarr_append(cfltarr_t* array, double add) {
    if (array->size + 1 > array->capa) {
        size_t newcapa = (array->capa * 10) / 6;
        size_t memsize = newcapa * sizeof(double);
        double* newarray = realloc(array->data, memsize);
        if (newarray == NULL) return NULL;
        array->capa = newcapa;
        array->data = newarray;
    }
    array->data[array->size++] = add;
    return array->data;
}

double* cfltarr_getref(cfltarr_t* array) {
    return array->data;
}

void cfltarr_destroy(cfltarr_t* array) {
    if (array == NULL) return;
    free(array->data);
}

void cfltarr_free(cfltarr_t* array) {
    if (array == NULL) return;
    cfltarr_destroy(array);
    free(array);
}

/* Bool array */
cboolarr_t* new_cboolarr(void) {
        cboolarr_t* arr = malloc(sizeof(cboolarr_t));
        if (arr == NULL) return NULL;
        if (cboolarr_init(arr) == NULL) {
            cboolarr_free(arr);
            return NULL;
        }
        return arr;
}

void* cboolarr_init(cboolarr_t* array) {
    array->data = malloc(INIT_CAPA * sizeof(bool));
    if (array->data == NULL) return NULL;
    memset(array->data, 0, INIT_CAPA);
    array->capa = INIT_CAPA;
    array->size = 0;
    return array->data;
}

void* cboolarr_append(cboolarr_t* array, bool add) {
    if (array->size + 1 > array->capa) {
        size_t newcapa = (array->capa * 10) / 6;
        size_t memsize = newcapa * sizeof(bool);
        bool* newarray = realloc(array->data, memsize);
        if (newarray == NULL) return NULL;
        array->capa = newcapa;
        array->data = newarray;
    }
    array->data[array->size++] = add;
    return array->data;
}

bool* cboolarr_getref(cboolarr_t* array) {
    return array->data;
}

void cboolarr_destroy(cboolarr_t* array) {
    if (array == NULL) return;
    free(array->data);
}

void cboolarr_free(cboolarr_t* array) {
    if (array == NULL) return;
    cboolarr_destroy(array);
    free(array);
}