///usr/bin/true; gcc -std=c2x -Wall -Wextra -Wpedantic -pedantic-errors -fanalyzer -Wanalyzer-too-complex -ggdb -g3 -O0 main.c -o main && ./main; exit $?

// #include <errno.h>
// #include <error.h>
// #include <stdio.h>
// #include <threads.h>
// #include <unistd.h>
// #include <string.h>

#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <string.h>
#include <stdio.h>


void * xcalloc(size_t nmemb, size_t size) {
    void *mem = calloc(nmemb, size);
    if(!mem)
        abort();

    return mem;
}



typedef void (*fcallback)(void*);
typedef struct gdata {
    void *data;
    fcallback freer;
} gdata;

gdata * gdata_init(void *data, fcallback fcb) {
    gdata *gd = xcalloc(1, sizeof(*gd));
    gd->data = data;
    gd->freer = fcb;

    return gd;
}

void gdata_free(gdata *gd) {
    if(!gd)
        return;

    if(gd->freer != NULL)
        gd->freer(gd->data);
    free(gd);

    return;
}

void * gdata_getdata(gdata * const gd) {
    if(!gd) {
        errno = EINVAL;
        return NULL;
    }
    
    return gd->data;
}

void gdata_destruct(gdata *gd, void **storage) {
    if(!gd || !storage)
        return;

    *storage = gd->data;
    free(gd);
    return;
}



typedef struct stack {
    gdata **arr;
    int size;
    int used;
} stack;

stack * stack_init(int size) {
    if(size < 1)
        return NULL;

    stack *st = xcalloc(1, sizeof(*st));
    st->size = size;
    st->used = 0;
    st->arr = xcalloc(st->size, sizeof(gdata*));

    return st;
}

void stack_free(stack *st) {
    if(!st)
        return;

    for(int i = 0; i < st->used; i++)
        gdata_free(st->arr[i]);
    free(st->arr);
    free(st);
    
    return;
}

int stack_push(stack *st, gdata *data) {
    if(!st || !data)
        return -1;
    if(st->used == st->size)
        return 0;

    st->arr[st->used++] = data;

    return st->used;
}

int stack_pushd(stack *st, void *data, fcallback fcb) {
    return stack_push(st, gdata_init(data, fcb));
}

gdata * stack_pop(stack *st) {
    if(!st)
        return NULL;
    if(st->used <= 0)
        return NULL;

    gdata *gd = st->arr[--st->used];
    return gd;
}

void * stack_popd(stack *st) {
    gdata *gd = stack_pop(st);
    void *data = NULL;
    
    gdata_destruct(gd, &data);
    return data;
}



int main() {
    // stack *st = stack_init(10);
    // stack_pushd(st, (void*)10, NULL);
    // stack_pushd(st, (void*)11, NULL);
    // stack_pushd(st, (void*)12, NULL);
    // stack_pushd(st, strdup("This is some data"), free);

    // char *data = stack_popd(st);
    // printf("%s\n", (data) ? data : "null");
    // free(data);

    // stack_free(st);


    return 0;
}