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

typedef struct {
    char* arr;
    size_t size;
} Vec8_t;

Vec8_t create(size_t init_size) {
    Vec8_t vec = { .arr = nullptr, .size = 0 };
    if (init_size > 0) {
        vec.arr = malloc(init_size * sizeof(char));
        vec.size = init_size;
    }
    return vec;
}

void delete(Vec8_t* vec) {
    if (vec->arr != nullptr) free(vec->arr);
    vec->arr = nullptr;
}

int main(int argc, char* argv[]) {
    size_t count = 100000000;  // 100M
    int vec_count = 1;
    
    if (argc > 1) count = atoll(argv[1]);
    if (argc > 2) vec_count = atoi(argv[2]);
    
    size_t total = count * (size_t)vec_count;
    printf("=== Direct Allocation Memory Test ===\n");
    printf("Elements per vector: %zu\n", count);
    printf("Number of vectors: %d\n", vec_count);
    printf("Total elements: %zu\n", total);
    printf("Total memory: %.1f GB\n", (total * sizeof(char)) / (1024.0 * 1024.0 * 1024.0));
    printf("\n");
    
    struct timespec start, end;
    Vec8_t* vecs = malloc(vec_count * sizeof(Vec8_t));
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    printf("Allocating %d vectors of %zu elements each...\n", vec_count, count);
    for (int v = 0; v < vec_count; v++) {
        vecs[v] = create(count);
        if (vecs[v].arr == nullptr) {
            printf("  ERROR: Failed to allocate vector %d!\n", v);
            return 1;
        }
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    double alloc_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    printf("Allocation time: %.2f seconds\n", alloc_time);
    
    printf("\nFilling vectors...\n");
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (int v = 0; v < vec_count; v++) {
        for (size_t i = 0; i < count; i++) {
            vecs[v].arr[i] = (char)(i % 256);
        }
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    double fill_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    printf("Fill time: %.2f seconds\n", fill_time);
    
    printf("\nVerifying...\n");
    int errors = 0;
    for (int v = 0; v < vec_count; v++) {
        if (vecs[v].size != count) errors++;
        if (vecs[v].arr[0] != 0) errors++;
        if (vecs[v].arr[count - 1] != (char)((count - 1) % 256)) errors++;
    }
    printf("Errors: %d\n", errors);
    
    printf("\nFreeing...\n");
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int v = 0; v < vec_count; v++) {
        delete(&vecs[v]);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    double free_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    printf("Free time: %.2f seconds\n", free_time);
    
    free(vecs);
    
    printf("\n=== Complete ===\n");
    printf("Total time: %.2f seconds\n", alloc_time + fill_time + free_time);
    
    return errors > 0 ? 1 : 0;
}