#include "c_Array.h"
#include <stdlib.h>
#include <stdio.h>
#include "c_Test.h"


/* ========================================================================== */
/* TEST CASES                                                                 */
/* ========================================================================== */


// 1. Stack Initialization and Destruction Loop
static
void test_array_stack_init_destroy(void) {
    c_Array_t arr;
    c_err_t err = c_Array_Init(&arr, 5, sizeof(int));

    ASSERT_LL_EQ(C_SUCCESS, err);
    ASSERT_LL_EQ(5, c_Array_Length(&arr));
    ASSERT_LL_EQ(sizeof(int), c_Array_Size(&arr));
    ASSERT_PTR_NOT_NULL(arr.array);

    c_Array_Destroy(&arr);
}

// 2. Heap Dynamic Allocation Lifecycles
static void test_array_heap_new_delete(void) {
    c_Array_t* arr = c_Array_New(10, sizeof(double));

    ASSERT_PTR_NOT_NULL(arr);
    ASSERT_LL_EQ(10, c_Array_Length(arr));
    ASSERT_LL_EQ(sizeof(double), c_Array_Size(arr));

    c_Array_Delete(&arr);
    ASSERT_TRUE(arr==NULL); // Ensure pointer is zeroed out by reference parameter modification
}

// 3. Put and Get Data Element Scenarios
static void test_array_put_and_get(void) {
    c_Array_t* arr = c_Array_New(3, sizeof(int));
    ASSERT_PTR_NOT_NULL(arr);
    ASSERT_INT_EQ(3, arr->length);

    int val1 = 100, val2 = 200, val3 = 300;

    // Put elements inside length limits
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Put(arr, 0, &val1));
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Put(arr, 1, &val2));
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Put(arr, 2, &val3));

    // Out of bounds checks
    int val_bad = 999;
    ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Put(arr, 3, &val_bad));

    // Get verification
    void* fetch_ptr = NULL;
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Get(arr, 1, &fetch_ptr));
    ASSERT_PTR_NOT_NULL(fetch_ptr);
    ASSERT_INT_EQ(200, *(int*)fetch_ptr);

    // Out of bounds get verification
    ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Get(arr, 5, &fetch_ptr));

    c_Array_Delete(&arr);
}

// 4. Memory Resizing Limits Verification
static void test_array_resize(void) {
    c_Array_t* arr = c_Array_New(2, sizeof(int));
    int val0 = 42, val1 = 84;
    c_Array_Put(arr, 0, &val0);
    c_Array_Put(arr, 1, &val1);

    // Resize up to 4 elements
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Resize(arr, 4));
    ASSERT_INT_EQ(4, c_Array_Length(arr));

    // Verify older elements remain structurally untouched
    void* res_ptr = NULL;
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Get(arr, 1, &res_ptr));
    ASSERT_INT_EQ(84, *(int*)res_ptr);

    // Resize down to 1 element
    ASSERT_INT_EQ(C_SUCCESS, c_Array_Resize(arr, 1));
    ASSERT_INT_EQ(1, c_Array_Length(arr));

    // Index 1 should now be unreachable / out of bounds
    ASSERT_INT_EQ(C_ERR_PARAM, c_Array_Get(arr, 1, &res_ptr));

    c_Array_Delete(&arr);
}

// 5. Deep Copy Execution Verification
static void test_array_copy_and_copy_to(void) {
    c_Array_t* source = c_Array_New(3, sizeof(int));
    int a = 11, b = 22, c = 33;
    c_Array_Put(source, 0, &a);
    c_Array_Put(source, 1, &b);
    c_Array_Put(source, 2, &c);

    // Test c_Array_Copy (creates a new array object on the heap)
    c_Array_t* copied_arr = c_Array_Copy(source, 2); // copy only first 2 items
    ASSERT_PTR_NOT_NULL(copied_arr);
    ASSERT_INT_EQ(2, c_Array_Length(copied_arr));

    void* data_ptr = NULL;
    c_Array_Get(copied_arr, 1, &data_ptr);
    ASSERT_INT_EQ(22, *(int*)data_ptr);

    // Test c_Array_CopyTo (copies into an already initialized destination)
    c_Array_t dest;
    c_Array_Init(&dest, 3, sizeof(int));

    ASSERT_INT_EQ(C_SUCCESS, c_Array_CopyTo(source, &dest));

    c_Array_Get(&dest, 2, &data_ptr);
    ASSERT_INT_EQ(33, *(int*)data_ptr);

    // Clean up all resources
    c_Array_Delete(&copied_arr);
    c_Array_Destroy(&dest);
    c_Array_Delete(&source);
}


int main(void) {
    TEST_START(array_data_structure_suite);

    RUN_TEST(test_array_stack_init_destroy);
    RUN_TEST(test_array_heap_new_delete);
    RUN_TEST(test_array_put_and_get);
    RUN_TEST(test_array_resize);
    RUN_TEST(test_array_copy_and_copy_to);

    TEST_REPORT();
    RETURN_TEST_STATUS;
}