#define SET_MSG(result, msg) \
    do { \
        snprintf((char *)(result).message, RESULT_MSG_SIZE, "%s", (const char *)msg); \
    } while (0)

#define COPY_MSG(result, msg) \
    do { \
        strncpy((char *)(result).message, (const char *)(msg), RESULT_MSG_SIZE - 1); \
        (result).message[RESULT_MSG_SIZE - 1] = '\0'; \
    } while (0)

#define REMOVE(ptr) \
    free(ptr); \
    ptr = NULL

#define IS_DIGIT(c) ((c) >= '0') && ((c) <= '9')

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

#include "bigint.h"
#include "vector.h"

/**
 * bigint_trim_zeros
 *  @number: a non-null big integer
 * 
 *  Helper function to remove leading zeros
 * 
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_trim_zeros(bigint_t *number) {
    bigint_result_t result = {0};

    size_t number_len = vector_size(number->digits);

    while (number_len > 1) {
        vector_result_t get_res = vector_get(number->digits, number_len - 1);
        if (get_res.status != VECTOR_OK) {
            vector_destroy(number->digits);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }

        int *last = (int*)get_res.value.element;
        if (*last != 0) {
            break;
        }

        vector_result_t pop_res = vector_pop(number->digits);
        if (pop_res.status != VECTOR_OK) {
            vector_destroy(number->digits);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }
        number_len--;
    }

    if (number_len == 1) {
        vector_result_t get_res = vector_get(number->digits, number_len - 1);
        if (get_res.status != VECTOR_OK) {
            vector_destroy(number->digits);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }

        int *first = (int*)get_res.value.element;
        if (*first == 0) {
            number->is_negative = false;
        }
    }

    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer successfully trimmed");

    return result;

}

/**
 * bigint_compare_abs
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 *
 *  Compares absolute value of two big integers
 *  if |x| <  |y| => -1
 *  if |x| == |y| => 0
 *  if |x| >  |y| => 1
 *
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_compare_abs(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    const size_t x_size = vector_size(x->digits);
    const size_t y_size = vector_size(y->digits);

    if (x_size != y_size) {
        result.value.compare_status = (x_size > y_size) ? 1 : -1;
        result.status = BIGINT_OK;
        SET_MSG(result, "Big integer comparison was successful");

        return result;
    }

    // Start to compare from the MSB
    for (int idx = (int)(x_size - 1); idx >= 0; idx--) {
        vector_result_t x_get = vector_get(x->digits, idx);
        if (x_get.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, x_get.message);

            return result;
        }

        vector_result_t y_get = vector_get(y->digits, idx);
        if (y_get.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, y_get.message);

            return result;
        }

        int *x_digit = (int*)x_get.value.element;
        int *y_digit = (int*)y_get.value.element;

        if (*x_digit != *y_digit) {
            result.value.compare_status = (*x_digit > *y_digit) ? 1 : -1;
            result.status = BIGINT_OK;
            SET_MSG(result, "Big integer comparison was successful");

            return result;
        }
    }

    result.value.compare_status = 0;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer comparison was successful");

    return result;
}

/**
 * bigint_add_abs
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Adds two absolute values together
 * 
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_add_abs(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    bigint_t *sum = malloc(sizeof(bigint_t));
    if (sum == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Cannot allocate memory for big integer");

        return result;
    }

    const size_t max_size = vector_size(x->digits) > vector_size(y->digits) ?
                            vector_size(x->digits) : vector_size(y->digits);

    vector_result_t vec_res = vector_new(max_size + 1, sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        free(sum);
        result.status = BIGINT_ERR_INVALID;
        COPY_MSG(result, vec_res.message);

        return result;
    }

    sum->digits = vec_res.value.vector;
    sum->is_negative = false;

    long long carry = 0;
    size_t idx = 0;

    const size_t x_size = vector_size(x->digits);
    const size_t y_size = vector_size(y->digits);
    while (idx < x_size || idx < y_size || carry) {
        long long partial_sum = carry;

        if (idx < x_size) {
            vector_result_t get_res = vector_get(x->digits, idx);
            if (get_res.status != VECTOR_OK) {
                vector_destroy(sum->digits);
                free(sum);
                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, get_res.message);

                return result;
            }

            int *x_digit = (int*)get_res.value.element;
            partial_sum += *x_digit;
        }

        if (idx < y_size) {
            vector_result_t get_res = vector_get(y->digits, idx);
            if (get_res.status != VECTOR_OK) {
                vector_destroy(sum->digits);
                free(sum);
                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, get_res.message);

                return result;
            }

            int *y_digit = (int*)get_res.value.element;
            partial_sum += *y_digit;
        }

        int digit = partial_sum % BIGINT_BASE;
        carry = partial_sum / BIGINT_BASE;

        vector_result_t push_res = vector_push(sum->digits, &digit);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(sum->digits);
            free(sum);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
        idx++;
    }

    bigint_result_t trim_res = bigint_trim_zeros(sum);
    if (trim_res.status != BIGINT_OK) {
        vector_destroy(sum->digits);
        free(sum);
        
        return trim_res;
    }

    result.value.number = sum;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integers successfully added");

    return result;
}

/**
 * bigint_sub_abs
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Subtracts two absolute values assuming that |x| >= |y|
 * 
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_sub_abs(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    bigint_t *difference = malloc(sizeof(bigint_t));
    if (difference == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Cannot allocate memory for big integer");

        return result;
    }

    vector_result_t vec_res = vector_new(vector_size(x->digits), sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        free(difference);
        result.status = BIGINT_ERR_INVALID;
        COPY_MSG(result, vec_res.message);

        return result;
    }

    difference->digits = vec_res.value.vector;
    difference->is_negative = false;

    long long borrow = 0;

    const size_t x_size = vector_size(x->digits);
    const size_t y_size = vector_size(y->digits);
    for (size_t idx = 0; idx < x_size; idx++) {
        vector_result_t x_get_res = vector_get(x->digits, idx);
        if (x_get_res.status != VECTOR_OK) {
            vector_destroy(difference->digits);
            free(difference);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, x_get_res.message);

            return result;
        }

        int *x_digit = (int*)x_get_res.value.element;
        long long partial_difference = *x_digit - borrow;

        if (idx < y_size) {
            vector_result_t y_get_res = vector_get(y->digits, idx);
            if (y_get_res.status != VECTOR_OK) {
                vector_destroy(difference->digits);
                free(difference);
                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, y_get_res.message);

                return result;
            }

            int *y_digit = (int*)y_get_res.value.element;
            partial_difference -= *y_digit;
        }

        if (partial_difference < 0) {
            partial_difference += BIGINT_BASE;
            borrow = 1;
        } else {
            borrow = 0;
        }

        int digit = partial_difference;
        vector_result_t push_res = vector_push(difference->digits, &digit);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(difference->digits);
            free(difference);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    bigint_result_t trim_res = bigint_trim_zeros(difference);
    if (trim_res.status != BIGINT_OK) {
        vector_destroy(difference->digits);
        free(difference);
        
        return trim_res;
    }

    result.value.number = difference;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integers successfully subtracted");

    return result;
}

/**
 * bigint_shift_left
 *  @num: a non-null big integer
 *  @n: number of digits to shift
 * 
 *  Shifts left by @n digits (i.e., multiply by BASE^n)
 * 
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_shift_left(const bigint_t *num, size_t n) {
    bigint_result_t result = {0};

    if (n == 0) {
        return bigint_clone(num);
    }

    bigint_t *shifted = malloc(sizeof(bigint_t));
    if (shifted == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for big integer");

        return result;
    }

    vector_result_t vec_res = vector_new(vector_size(num->digits) + n, sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        free(shifted);
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, vec_res.message);

        return result;
    }

    shifted->digits = vec_res.value.vector;
    shifted->is_negative = num->is_negative;

    // Add 'n' zeros by starting from the LSB
    int zero = 0;
    for (size_t idx = 0; idx < n; idx++) {
        vector_result_t push_res = vector_push(shifted->digits, &zero);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(shifted->digits);
            free(shifted);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    // Copy back original digits
    const size_t num_size = vector_size(num->digits);
    for (size_t idx = 0; idx < num_size; idx++) {
        vector_result_t get_res = vector_get(num->digits, idx);
        if (get_res.status != VECTOR_OK) {
            vector_destroy(shifted->digits);
            free(shifted);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }

        int *digit = (int*)get_res.value.element;
        vector_result_t push_res = vector_push(shifted->digits, digit);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(shifted->digits);
            free(shifted);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    result.value.number = shifted;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer shifted successfully");
    
    return result;
}

/**
 * bigint_split
 *  @num: a non-null big integers
 *  @m: the pivot/position where to split
 *  @high: digits \in [0, m)
 *  @low: digits \in [m, size)
 * 
 *  Splits number into @high and @low parts at position @m
 * 
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_split(const bigint_t *num, size_t m, bigint_t **high, bigint_t **low) {
    bigint_result_t result = {0};

    const size_t size = vector_size(num->digits);

    // Low part: digits \in [0, m)
    *low = malloc(sizeof(bigint_t));
    if (*low == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for big integer");

        return result;
    }

    vector_result_t low_res = vector_new(m ? m : 1, sizeof(int));
    if (low_res.status != VECTOR_OK) {
        free(*low);
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, low_res.message);

        return result;
    }

    (*low)->digits = low_res.value.vector;
    (*low)->is_negative = false;

    for (size_t idx = 0; idx < m && idx < size; idx++) {
        vector_result_t get_res = vector_get(num->digits, idx);
        if (get_res.status != VECTOR_OK) {
            vector_destroy((*low)->digits);
            free(*low);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }

        int *digit = (int*)get_res.value.element;
        vector_result_t push_res = vector_push((*low)->digits, digit);
        if (push_res.status != VECTOR_OK) {
            vector_destroy((*low)->digits);
            free(*low);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    if (vector_size((*low)->digits) == 0) {
        int zero = 0;
        vector_result_t push_res = vector_push((*low)->digits, &zero);
        if (push_res.status != VECTOR_OK) {
            vector_destroy((*low)->digits);
            free(*low);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    // First pass of zero trimming
    bigint_result_t first_trim_res = bigint_trim_zeros(*low);
    if (first_trim_res.status != BIGINT_OK) {
        vector_destroy((*low)->digits);
        free(*low);

        return first_trim_res;
    }

    // High part: digits \in [m, size)
    *high = malloc(sizeof(bigint_t));
    if (*high == NULL) {
        vector_destroy((*low)->digits);
        free(*low);
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for big integer");

        return result;
    }

    vector_result_t high_res = vector_new(size > m ? (size - m) : 1, sizeof(int));
    if (high_res.status != VECTOR_OK) {
        vector_destroy((*low)->digits);
        free(*low);
        free(*high);

        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, low_res.message);

        return result;
    }

    (*high)->digits = high_res.value.vector;
    (*high)->is_negative = false;

    if (size > m) {
        for (size_t idx = m; idx < size; idx++) {
            vector_result_t get_res = vector_get(num->digits, idx);
            if (get_res.status != VECTOR_OK) {
                vector_destroy((*low)->digits);
                vector_destroy((*high)->digits);
                free(*low);
                free(*high);

                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, get_res.message);

                return result;
            }

            int *digit = (int*)get_res.value.element;
            vector_result_t push_res = vector_push((*high)->digits, digit);
            if (push_res.status != VECTOR_OK) {
                vector_destroy((*low)->digits);
                vector_destroy((*high)->digits);
                free(*low);
                free(*high);

                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, push_res.message);

                return result;
            }
        }
    } else {
        int zero = 0;
        vector_result_t push_res = vector_push((*high)->digits, &zero);
        if (push_res.status != VECTOR_OK) {
            vector_destroy((*low)->digits);
            vector_destroy((*high)->digits);
            free(*low);
            free(*high);

            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    // Second pass of zero trimming
    bigint_result_t second_trim_res = bigint_trim_zeros(*high);
    if (second_trim_res.status != BIGINT_OK) {
        vector_destroy((*low)->digits);
        vector_destroy((*high)->digits);
        free(*low);
        free(*high);

        return second_trim_res;
    }

    result.status = BIGINT_OK;
    SET_MSG(result, "Big number successfully splitted");

    return result;
}

/**
 * bigint_karatsuba_base
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Base case of the Karatsuba recursive algorithm
 *  which uses a "grade school" multiplication.
 *  Its complexity is O(n^2)
 * 
 *  Returns a bigint_result_t data type
 */
static bigint_result_t bigint_karatsuba_base(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    bigint_result_t prod_res = bigint_from_int(0);
    if (prod_res.status != BIGINT_OK) {
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, prod_res.message);

        return result;
    }

    bigint_t *product = prod_res.value.number;
    const size_t x_size = vector_size(x->digits);
    const size_t y_size = vector_size(y->digits);

    for (size_t i = 0; i < x_size; i++) {
        long long carry = 0;
        
        vector_result_t get_res = vector_get(x->digits, i);
        if (get_res.status != VECTOR_OK) {
            bigint_destroy(product);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }

        int *x_digit = (int*)get_res.value.element;
        for (size_t j = 0; j < y_size || carry; j++) {
            int *y_digit = NULL;
            int *curr = NULL;

            if (j < y_size) {
                vector_result_t y_res = vector_get(y->digits, j);
                if (y_res.status != VECTOR_OK) {
                    bigint_destroy(product);
                    result.status = BIGINT_ERR_INVALID;
                    COPY_MSG(result, y_res.message);

                    return result;
                }

                y_digit = (int*)y_res.value.element;
            }

            if ((i + j) < vector_size(product->digits)) {
                vector_result_t curr_res = vector_get(product->digits, i + j);
                if (curr_res.status != VECTOR_OK) {
                    bigint_destroy(product);
                    result.status = BIGINT_ERR_INVALID;
                    COPY_MSG(result, curr_res.message);

                    return result;
                }

                curr = (int*)curr_res.value.element;
            }

            long long partial_prod = carry;
            if (curr) { partial_prod += *curr; }
            if (y_digit) { partial_prod += (long long)(*x_digit) * (*y_digit); }

            int new_digit =(int)(partial_prod % BIGINT_BASE);
            carry = partial_prod / BIGINT_BASE;

            if (curr) {
                vector_result_t set_res = vector_set(product->digits, i + j, &new_digit);
                if (set_res.status != VECTOR_OK) {
                    bigint_destroy(product);
                    result.status = BIGINT_ERR_INVALID;
                    COPY_MSG(result, set_res.message);

                    return result;
                }
            } else {
                vector_result_t push_res = vector_push(product->digits, &new_digit);
                if (push_res.status != VECTOR_OK) {
                    bigint_destroy(product);
                    result.status = BIGINT_ERR_INVALID;
                    COPY_MSG(result, push_res.message);

                    return result;
                }
            }
        }
    }

    bigint_result_t trim_res = bigint_trim_zeros(product);
    if (trim_res.status != BIGINT_OK) {
        bigint_destroy(product);

        return trim_res;
    }

    result.value.number = product;
    result.status = BIGINT_OK;
    SET_MSG(result, "Product between big integers was successful");

    return result;
}

/**
 * bigint_karatusba
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Perform a multiplication using Karatsuba recursive algorithm
 *  in O(n^{\log_2 3}) \approx O(n^{1.585})
 */
static bigint_result_t bigint_karatsuba(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};
    bigint_result_t tmp_res = {0};

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integers");

        return result;
    }

    const size_t x_size = vector_size(x->digits);
    const size_t y_size = vector_size(y->digits);
    const size_t min_size = x_size < y_size ? x_size : y_size;
    const size_t max_size = x_size > y_size ? x_size : y_size;

    // Base case using "grade school" quadratic algorithm
    if (min_size <= 32 || max_size / min_size > 2) {
        return bigint_karatsuba_base(x, y);
    }

    // Split the big integer at approximately half the size of the larger number
    const size_t pivot = (x_size > y_size ? x_size : y_size) / 2;

    // Results of each step
    bigint_t *x1 = NULL, *x0 = NULL;
    bigint_t *y1 = NULL, *y0 = NULL;
    bigint_t *z0 = NULL, *z2 = NULL;
    bigint_t *x_sum = NULL, *y_sum = NULL;
    bigint_t *z1_temp = NULL, *z1_sub1 = NULL, *z1 = NULL;
    bigint_t *z2_shifted = NULL, *z1_shifted = NULL;
    bigint_t *temp = NULL, *product = NULL;

    // Split x = x1 * BASE^pivot + x0
    tmp_res = bigint_split(x, pivot, &x1, &x0);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }

    // Split y = y1 * BASE^pivot + y0
    tmp_res = bigint_split(y, pivot, &y1, &y0);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }

    // Perform karatsuba's trick
    tmp_res = bigint_karatsuba(x0, y0); // z0 = x0 * y0
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z0 = tmp_res.value.number;

    tmp_res = bigint_karatsuba(x1, y1); // z2 = x1 * y1
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z2 = tmp_res.value.number;

    // z1 = (x0 + x1) * (y0 + y1) - z0 - z2
    tmp_res = bigint_add(x0, x1); // x_sum = x0 + x1
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    x_sum = tmp_res.value.number;

    tmp_res = bigint_add(y0, y1); // y_sum = y0 + y1
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    y_sum = tmp_res.value.number;

    tmp_res = bigint_karatsuba(x_sum, y_sum); // z1_temp = (x0 + x1) * (y0 + y1)
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z1_temp = tmp_res.value.number;

    tmp_res = bigint_sub(z1_temp, z0); // z1_sub1 = z1_temp - z0
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z1_sub1 = tmp_res.value.number;

    tmp_res = bigint_sub(z1_sub1, z2); // z1 = z1_sub1 - z2
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z1 = tmp_res.value.number;

    tmp_res = bigint_shift_left(z2, 2 * pivot); // z2_shifted = z2 << (2 * pivot)
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z2_shifted = tmp_res.value.number;

    tmp_res = bigint_shift_left(z1, pivot); // z1_shifted = z1 << pivot
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    z1_shifted = tmp_res.value.number;

    tmp_res = bigint_add(z2_shifted, z1_shifted);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    temp = tmp_res.value.number;

    tmp_res = bigint_add(temp, z0);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    product = tmp_res.value.number;

    // Destroy intermediate allocations except for the product
    bigint_destroy(x1); bigint_destroy(x0);
    bigint_destroy(y1); bigint_destroy(y0);
    bigint_destroy(z0); bigint_destroy(z2);
    bigint_destroy(x_sum); bigint_destroy(y_sum);
    bigint_destroy(z1_temp); bigint_destroy(z1_sub1);
    bigint_destroy(z1); bigint_destroy(z2_shifted);
    bigint_destroy(z1_shifted); bigint_destroy(temp);

    result.value.number = product;
    result.status = BIGINT_OK;
    SET_MSG(result, "Product between big integers was successful");

    return result;

cleanup: // Destroy intermediate allocations on error
    if (x1) { bigint_destroy(x1); }
    if (x0) { bigint_destroy(x0); }
    if (y1) { bigint_destroy(y1); }
    if (y0) { bigint_destroy(y0); }
    if (z0) { bigint_destroy(z0); }
    if (z2) { bigint_destroy(z2); }
    if (x_sum) { bigint_destroy(x_sum); }
    if (y_sum) { bigint_destroy(y_sum); }
    if (z1_temp) { bigint_destroy(z1_temp); }
    if (z1_sub1) { bigint_destroy(z1_sub1); }
    if (z1) { bigint_destroy(z1); }
    if (z2_shifted) { bigint_destroy(z2_shifted); }
    if (z1_shifted) { bigint_destroy(z1_shifted); }
    if (temp) { bigint_destroy(temp); }
    if (product) { bigint_destroy(product); }

    return result;
}

/**
 * bigint_div
 *  @x: a non-null big integer acting as a dividend
 *  @y: a non-null big integer acting as a divisor
 *
 *  Computers the quotient floor (i.e., |X| / |Y|) using Knuth's Algorithm D
 *  Adaoted from p. 273 of Don Knuth's TAoCP Vol. 2
 *  The complexity is O(n * m) where 'n' and 'm' are the number of base-10^9
 *  "parts" (the limbs in the code below) in the divisor and the quotient, respectively.
 *
 *  Returns a bigint_result_t containing the quotient.
 *  The called of this function will be responsible for applying the sign.
 */
static bigint_result_t bigint_div(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};
    bigint_result_t tmp_res = {0};

    bigint_t *quotient = NULL;
    long long *u = NULL, *v = NULL, *q = NULL;

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integers");

        return result;
    }

    const size_t y_size = vector_size(y->digits);
    if (y_size == 0) {
        result.status = BIGINT_ERR_DIV_BY_ZERO;
        SET_MSG(result, "Cannot divide by zero");

        return result;
    }

    if (y_size == 1) {
        vector_result_t y0_res = vector_get(y->digits, 0);
        if (y0_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, y0_res.message);

            return result;
        }

        int *y0 = (int *)y0_res.value.element;
        if (*y0 == 0) {
            result.status = BIGINT_ERR_DIV_BY_ZERO;
            SET_MSG(result, "Cannot divide by zero");

            return result;
        }
    }

    tmp_res = bigint_compare_abs(x, y);
    if (tmp_res.status != BIGINT_OK) {
        return tmp_res;
    }

    if (tmp_res.value.compare_status < 0) {
        return bigint_from_int(0);
    }

    const size_t x_size = vector_size(x->digits);
    const size_t n = y_size;
    const long long BASE = (long long)BIGINT_BASE;

    quotient = malloc(sizeof(bigint_t));
    if (quotient == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Cannot allocate memory for big integer");

        goto cleanup;
    }

    quotient->digits = NULL;
    quotient->is_negative = false;

    // Single-limb divisor case. Here, we scan using 64-bit arithmetic in O(n)
    if (y_size == 1) {
        vector_result_t y0_res = vector_get(y->digits, 0);
        if (y0_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, y0_res.message);

            goto cleanup;
        }

        long long divisor = *(int *)y0_res.value.element;

        vector_result_t vec_res = vector_new(x_size, sizeof(int));
        if (vec_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_ALLOCATE;
            COPY_MSG(result, vec_res.message);

            goto cleanup;
        }

        quotient->digits = vec_res.value.vector;

        long long remainder = 0;
        for (int idx = (int)x_size - 1; idx >= 0; idx--) {
            vector_result_t xidx_res = vector_get(x->digits, idx);
            if (xidx_res.status != VECTOR_OK) {
                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, xidx_res.message);

                goto cleanup;
            }

            long long current = remainder * BASE + *(int *)xidx_res.value.element;
            int q_idx = (int)(current / divisor);
            remainder = current % divisor;

            vector_result_t push_res = vector_push(quotient->digits, &q_idx);
            if (push_res.status != VECTOR_OK) {
                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, push_res.message);

                goto cleanup;
            }
        }

        // Restore the LSB-first order
        const size_t q_size = vector_size(quotient->digits);
        for (size_t lo = 0, hi = q_size - 1; lo < hi; hi--) {
            vector_result_t lr = vector_get(quotient->digits, lo);
            vector_result_t hr = vector_get(quotient->digits, hi);

            if (lr.status != VECTOR_OK || hr.status != VECTOR_OK) {
                result.status = BIGINT_ERR_INVALID;
                SET_MSG(result, "Failed to reverse quotient digits");

                goto cleanup;
            }

            int lower_val = *(int *)lr.value.element;
            int higher_val = *(int *)hr.value.element;
            vector_set(quotient->digits, lo, &higher_val);
            vector_set(quotient->digits, hi, &lower_val);
        }

        bigint_result_t trim_res = bigint_trim_zeros(quotient);
        if (trim_res.status != BIGINT_OK) { result = trim_res; goto cleanup; }

        result.value.number = quotient;
        result.status = BIGINT_OK;
        SET_MSG(result, "Division between big integers was successful");

        return result;
    }

    /* General case using Knuth's Algorithm
     * First, some definitions:
     * index 0 -> least significant limb;
     * n -> limb count of divisor y
     * m -> limb count of quotient (x_size - n)
     * u[0 ... m + n] -> working copy of the (scaled) dividend +1 sentinel limb
     * v[0 ... n - 1] -> working copy of the (scaled) divisor
     * q[0 ... m] -> output quotient limbs
     */
    const size_t m = x_size - n;

    u = calloc(m + n + 1, sizeof(long long));
    v = calloc(n, sizeof(long long));
    q = calloc(m + 1, sizeof(long long));

    if (u == NULL || v == NULL || q == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Cannot allocate scratch arrays for division");

        goto cleanup;
    }

    for (size_t idx = 0; idx < x_size; idx++) {
        vector_result_t get_res = vector_get(x->digits, idx);
        if (get_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            goto cleanup;
        }

        u[idx] = *(int *)get_res.value.element;
    }

    for (size_t idx = 0; idx < n; idx++) {
        vector_result_t get_res = vector_get(y->digits, idx);
        if (get_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            goto cleanup;
        }

        v[idx] = *(int *)get_res.value.element;
    }

    // D1 (normalize): choose 'd' so that v[n - 1] >= BASE / 2 (after scaling)
    const long long d = BASE / (v[n - 1] + 1);

    long long carry = 0;
    for (size_t idx = 0; idx < x_size; idx++) {
        long long current = u[idx] * d + carry;
        u[idx] = current % BASE;
        carry = current / BASE;
    }
    u[x_size] = carry;

    carry = 0;
    for (size_t idx = 0; idx < n; idx++) {
        long long current = v[idx] * d + carry;
        v[idx] = current % BASE;
        carry = current / BASE;
    }

    // D2-D6: the main loop. One iteration produces one quotient limb
    for (long long j = (long long)m; j >= 0; j--) {
        size_t jj = (size_t)j;

        // D3: 2-by-1 trial quotient
        long long two_limb = u[jj + n] * BASE + u[jj + n - 1];
        long long q_hat = two_limb / v[n - 1];
        long long r_hat = two_limb % v[n - 1];

        while (q_hat >= BASE || ((n >= 2) && (q_hat * v[n - 2]) > (BASE * r_hat + u[jj + n - 2]))) {
            q_hat--;
            r_hat += v[n - 1];
            if (r_hat >= BASE) { break; }
        }

        // D4: multiply-subtract u[j ... j + n] -= q_hat * v[0 ... n - 1]
        long long borrow = 0;
        for (size_t idx = 0; idx < n; idx++) {
            long long product = q_hat * v[idx] + borrow;
            borrow = product / BASE;
            long long diff = u[jj + idx] - (product % BASE);
            if (diff < 0) {
                diff += BASE;
                borrow++;
            }
            u[jj + idx] = diff;
        }
        u[jj + n] -= borrow;

        // D5: store quotient digit
        q[jj] = q_hat;

        // D6: if 'u' went negative, add 'v' back once and decrement q[j]
        if (u[jj + n] < 0) {
            q[jj]--;
            carry = 0;
            for (size_t idx = 0; idx < n; idx++) {
                long long sum = u[jj + idx] + v[idx] + carry;
                u[jj + idx] = sum % BASE;
                carry = sum / BASE;
            }
            u[jj + n] += carry;
        }
    }

    // Delete working copy from memory
    REMOVE(u); REMOVE(v);

    // Build the bigint quotient from q[0 ... m] (index 0 = LSB)
    vector_result_t vec_res = vector_new(m + 1, sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, vec_res.message);

        goto cleanup;
    }

    quotient->digits = vec_res.value.vector;
    for (size_t idx = 0; idx <= m; idx++) {
        int q_idx = (int)q[idx];

        vector_result_t push_res = vector_push(quotient->digits, &q_idx);
        if (push_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            goto cleanup;
        }
    }

    REMOVE(q);

    bigint_result_t trim_res = bigint_trim_zeros(quotient);
    if (trim_res.status != BIGINT_OK) { result = trim_res; goto cleanup; }

    result.value.number = quotient;
    result.status = BIGINT_OK;
    SET_MSG(result, "Division between big integers was successful");

    return result;

cleanup:
    free(u); free(v); free(q);
    if (quotient) { bigint_destroy(quotient); }

    return result;
}


/**
 * bigint_from_int
 *  @value: an integer value
 * 
 *  Takes an integer and convert it to a big integer
 * 
 *  Returns a bigint_result_t data type containing a new big integer
 */
bigint_result_t bigint_from_int(long long value) {
    bigint_result_t result = {0};

    bigint_t *number = malloc(sizeof(bigint_t));
    if (number == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for big integer");

        return result;
    }

    vector_result_t vec_res = vector_new(4, sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        free(number);
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, vec_res.message);

        return result;
    }

    number->digits = vec_res.value.vector;
    number->is_negative = (value < 0);

    // Discard the sign since we don't need it anymore
    unsigned long long abs_val = value < 0 ? -(unsigned long long)value : (unsigned long long)value;

    if(abs_val == 0) {
        int zero = 0;
        vector_result_t push_res = vector_push(number->digits, &zero);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(number->digits);
            free(number);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    } else {
        while (abs_val != 0) {
            int digit = abs_val % BIGINT_BASE;
            vector_result_t push_res = vector_push(number->digits, &digit);
            if (push_res.status != VECTOR_OK) {
                vector_destroy(number->digits);
                free(number);
                result.status = BIGINT_ERR_INVALID;
                COPY_MSG(result, push_res.message);

                return result;
            }

            abs_val /= BIGINT_BASE;
        }
    }

    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer successfully created");
    result.value.number = number;

    return result;
}

/**
 * bigint_from_string
 *  @string_num: an array of chars representing a number
 * 
 *  Takes a string containing a number and convert it to big integer
 * 
 *  Returns a bigint_result_t data type containing a new big integer
 */
bigint_result_t bigint_from_string(const char *string_num) {
    bigint_result_t result = {0};

    if (string_num == NULL || *string_num == 0) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid string");

        return result;
    }

    bigint_t *number = malloc(sizeof(bigint_t));
    if (number == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for big integer");

        return result;
    }

    vector_result_t vec_res = vector_new(4, sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        free(number);        
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, vec_res.message);

        return result;
    }

    number->digits = vec_res.value.vector;

    number->is_negative = false;
    if (*string_num == '-') {
        number->is_negative = true;
        string_num++;
    } else if (*string_num == '+') {
        string_num++;
    }

    // Check whether the integer is valid or not
    if (*string_num == '\0') {
        vector_destroy(number->digits);
        free(number);
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Invalid integer");

        return result;
    }

    // Check whether characters are digits
    for (const char *p = string_num; *p; ++p) {
        if (!IS_DIGIT((unsigned char)*p)) {
            vector_destroy(number->digits);
            free(number);
            result.status = BIGINT_ERR_INVALID;
            SET_MSG(result, "Invalid integer");

            return result;
        }
    }

    // Skip leading zeros
    while (*string_num == '0' && *(string_num + 1) != '\0') {
        string_num++;
    }

    const size_t number_len = strlen(string_num);

    // Process digits from right to left by chunks of the representation base
    for (int i = number_len; i > 0; i -= BIGINT_BASE_DIGITS) {
        const int start = (i - BIGINT_BASE_DIGITS > 0) ? i - BIGINT_BASE_DIGITS : 0;
        const int chunk_len = (i - start);

        int digit = 0;
        for (int j = 0; j < chunk_len; j++) {
            digit = digit * 10 + (string_num[start + j] - '0');
        }

        vector_result_t push_res = vector_push(number->digits, &digit);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(number->digits);
            free(number);
            result.status = BIGINT_ERR_ALLOCATE;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    bigint_result_t trim_res = bigint_trim_zeros(number);
    if (trim_res.status != BIGINT_OK) {
        vector_destroy(number->digits);
        free(number);

        return trim_res;
    }

    result.value.number = number;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer successfully created");

    return result;
}

/**
 * bigint_to_string
 *  @number: a valid non-null big number
 * 
 *  Converts a big integer to a C string
 *
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_to_string(const bigint_t *number) {
    bigint_result_t result = {0};

    if (number == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integer");

        return result;
    }

    const size_t size = vector_size(number->digits);
    const size_t max_len = (size * BIGINT_BASE_DIGITS) + 2; // +2 for sign and terminator
    
    char *str = malloc(max_len);
    if (str == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for string");

        return result;
    }

    char *ptr = str;
    if (number->is_negative) {
        *ptr++ = '-';
    }

    // Print MSB without leading zeros
    vector_result_t msb_res = vector_get(number->digits, size - 1);
    if (msb_res.status != VECTOR_OK) {
        result.status = BIGINT_ERR_INVALID;
        COPY_MSG(result, msb_res.message);

        return result;
    }

    int *msb = (int*)msb_res.value.element;
    ptr += sprintf(ptr, "%d", *msb);

    // Print remaining digits with leading zeros
    for (int idx = size - 2; idx >= 0; idx--) {
        vector_result_t digit_res = vector_get(number->digits, idx);
        if (digit_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, digit_res.message);

            return result;
        }

        int *digit = (int*)digit_res.value.element;
        ptr += sprintf(ptr, "%09d", *digit);
    }

    result.value.string_num = str;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer successfully converted");

    return result;
}

/**
 * bigint_clone
 *  @number: a valid non-null big integer
 *  
 *  Clones a big integer
 * 
 *  Returns a bigint_result_t data type containing the new big integer
 */
bigint_result_t bigint_clone(const bigint_t *number) {
    bigint_result_t result = {0};

    if (number == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integer");

        return result;
    }

    bigint_t *cloned = malloc(sizeof(bigint_t));
    if (cloned == NULL) {
        result.status = BIGINT_ERR_ALLOCATE;
        SET_MSG(result, "Failed to allocate memory for big integer");

        return result;
    }

    vector_result_t vec_res = vector_new(vector_size(number->digits), sizeof(int));
    if (vec_res.status != VECTOR_OK) {
        free(cloned);
        result.status = BIGINT_ERR_ALLOCATE;
        COPY_MSG(result, vec_res.message);

        return result;
    }

    cloned->digits = vec_res.value.vector;
    cloned->is_negative = number->is_negative;

    // Copy digits
    const size_t sz = vector_size(number->digits);
    for (size_t idx = 0; idx < sz; idx++) {
        vector_result_t get_res = vector_get(number->digits, idx);
        if (get_res.status != VECTOR_OK) {
            vector_destroy(cloned->digits);
            free(cloned);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, get_res.message);

            return result;
        }

        int *digit = (int*)get_res.value.element;
        
        vector_result_t push_res = vector_push(cloned->digits, digit);
        if (push_res.status != VECTOR_OK) {
            vector_destroy(cloned->digits);
            free(cloned);
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, push_res.message);

            return result;
        }
    }

    result.value.number = cloned;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer successfully cloned");

    return result;
}

/**
 * bigint_compare
 *  @x: a valid non-null big integer
 *  @y: a valid non-null big integer
 * 
 *  Compares two big integers
 *  if x < y => -1
 *  if x == y => 0
 *  if x > y => 1
 * 
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_compare(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    if (x->is_negative != y->is_negative) {
        result.value.compare_status = x->is_negative ? -1 : 1;
        result.status = BIGINT_OK;
        SET_MSG(result, "Big integer comparison was successful");

        return result;
    }
    
    bigint_result_t cmp_res = bigint_compare_abs(x, y);
    if (cmp_res.status != BIGINT_OK) {
        return cmp_res;
    }
    
    const int8_t abs_cmp = cmp_res.value.compare_status;

    result.value.compare_status = x->is_negative ? -abs_cmp : abs_cmp;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer comparison was successful");

    return result;
}

/**
 * bigint_add
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Adds two big integers together
 * 
 *  Returns a bigint_result_t data type 
 */
bigint_result_t bigint_add(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integers");

        return result;
    }

    // Same sign: add absolute values
    if (x->is_negative == y->is_negative) {
        bigint_result_t sum_res = bigint_add_abs(x, y);
        if (sum_res.status != BIGINT_OK) {
            return sum_res;
        }

        bigint_t *sum = sum_res.value.number;
        if (sum) {
            sum->is_negative = x->is_negative;
        }

        result.value.number = sum;
        result.status = BIGINT_OK;
        SET_MSG(result, "Big integers successfully added");

        return result;
    }

    // Different signs: subtract smaller from larger
    bigint_result_t cmp_res = bigint_compare_abs(x, y);
    if (cmp_res.status != BIGINT_OK) {
        return cmp_res;
    }
    
    const int8_t cmp = cmp_res.value.compare_status;
    if (cmp == 0) {
        return bigint_from_int(0);
    } else if (cmp > 0) {
        bigint_result_t sub_res = bigint_sub_abs(x, y);
        if (sub_res.status != BIGINT_OK) {
            return sub_res;
        }

        bigint_t *sub = sub_res.value.number;
        if (sub) {
            sub->is_negative = x->is_negative;
        }

        result.value.number = sub;
        result.status = BIGINT_OK;
        SET_MSG(result, "Big integers successfully added");
    } else {
        bigint_result_t sub_res = bigint_sub_abs(y, x);
        if (sub_res.status != BIGINT_OK) {
            return sub_res;
        }
        
        bigint_t *sub = sub_res.value.number;
        if (sub) {
            sub->is_negative = y->is_negative;
        }

        result.value.number = sub;
        result.status = BIGINT_OK;
        SET_MSG(result, "Big integers successfully added");
    }

    return result;
}

/**
 * bigint_sub
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Subtracts two big integers together
 * 
 *  Returns a bigint_result_t data type 
 */
bigint_result_t bigint_sub(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integers");

        return result;
    }

    /* To subtract two big integers we can consider
     * the following equivalence:
     * x - y = x + (-y) 
     */
    bigint_result_t neg_y_res = bigint_clone(y);
    if (neg_y_res.status != BIGINT_OK) {
        return neg_y_res;
    }
    
    bigint_t *neg_y = neg_y_res.value.number;
    neg_y->is_negative = !neg_y->is_negative;

    bigint_result_t difference_res = bigint_add(x, neg_y);
    if (difference_res.status != BIGINT_OK) {
        bigint_destroy(neg_y);

        return difference_res;
    }
    
    bigint_destroy(neg_y);
    bigint_t *difference = difference_res.value.number;

    result.value.number = difference;
    result.status = BIGINT_OK;
    SET_MSG(result, "Big integers successfully subtracted");

    return result;
}

/**
 * bigint_prod
 *  @x: a non-null big integer
 *  @y: a non-null big integer
 * 
 *  Perform a multiplication between @a and @b
 *  using Karatsuba's algorithm
 * 
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_prod(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integers");

        return result;
    }

    bigint_result_t product_res = bigint_karatsuba(x, y);
    if (product_res.status != BIGINT_OK) {
        return product_res;
    }

    bigint_t *product = product_res.value.number;
    product->is_negative = (x->is_negative != y->is_negative);

    bigint_result_t trim_res = bigint_trim_zeros(product);
    if (trim_res.status != BIGINT_OK) {
        bigint_destroy(product);

        return trim_res;
    }

    result.value.number = product;
    result.status = BIGINT_OK;
    SET_MSG(result, "Product between big integers was successful");

    return result;
}

/**
 * bigint_divmod
 *  @x: a valid non-null big integer
 *  @y: a valid non-null big integer
 * 
 *  Computes truncated division with remainder. That is:
 *   quotient = trunc(x / y)       sign = sign(x) XOR sign(y)
 *   remainder = x - y * quotient  sign = sign(x)
 *  
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_divmod(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};
    bigint_result_t tmp_res = {0};

    bigint_t *quotient = NULL;
    bigint_t *y_times_q = NULL;
    bigint_t *remainder = NULL;

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big numbers");

        return result;
    }

    const size_t y_size = vector_size(y->digits);
    if (y_size == 0) {
        result.status = BIGINT_ERR_DIV_BY_ZERO;
        SET_MSG(result, "Cannot divide by zero");

        return result;
    }

    if (y_size == 1) {
        vector_result_t y_val_res = vector_get(y->digits, 0);
        if (y_val_res.status != VECTOR_OK) {
            result.status = BIGINT_ERR_INVALID;
            COPY_MSG(result, y_val_res.message);

            return result;
        }

        int *y_val = (int *)y_val_res.value.element;
        if (*y_val == 0) {
            result.status = BIGINT_ERR_DIV_BY_ZERO;
            SET_MSG(result, "Cannot divide by zero");

            return result;
        }
    }

    // |x| < |y|: quotient is 0, remainder is x
    tmp_res = bigint_compare_abs(x, y);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }

    if (tmp_res.value.compare_status < 0) {
        tmp_res = bigint_from_int(0);
        if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
        quotient = tmp_res.value.number;

        tmp_res = bigint_clone(x);
        if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
        remainder = tmp_res.value.number;

        result.value.division.quotient = quotient;
        result.value.division.remainder = remainder;

        result.status = BIGINT_OK;
        SET_MSG(result, "Division between big integers was successful");

        return result;
    }

    tmp_res = bigint_div(x, y);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    quotient = tmp_res.value.number;

    // Set quotient sign accordingly
    quotient->is_negative = (x->is_negative != y->is_negative);

    // Compute remainder using r = x - y * q
    tmp_res = bigint_prod(y, quotient);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    y_times_q = tmp_res.value.number;

    tmp_res = bigint_sub(x, y_times_q);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }
    remainder = tmp_res.value.number;

    tmp_res = bigint_trim_zeros(remainder);
    if (tmp_res.status != BIGINT_OK) { result = tmp_res; goto cleanup; }

    // Set remainder sign accordingly
    vector_result_t r0 = vector_get(remainder->digits, 0);
    if (r0.status != VECTOR_OK) {
        result.status = BIGINT_ERR_INVALID;
        COPY_MSG(result, r0.message);

        goto cleanup;
    }

    bool rem_is_zero = (vector_size(remainder->digits) == 1 && *(int *)r0.value.element == 0);

    if (!rem_is_zero) {
        remainder->is_negative = x->is_negative;
    }

    result.value.division.quotient = quotient;
    result.value.division.remainder = remainder;
    result.status = BIGINT_OK;
    SET_MSG(result, "Division between big integers was successful");

    bigint_destroy(y_times_q);

    return result;

cleanup:
    if (quotient) { bigint_destroy(quotient); }
    if (y_times_q) { bigint_destroy(y_times_q); }
    if (remainder) { bigint_destroy(remainder); }

    return result;
}

/**
 * bigint_mod
 *  @x: a valid non-null big integer
 *  @y: a valid non-null big integer
 * 
 *  Computes @x mod @y
 * 
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_mod(const bigint_t *x, const bigint_t *y) {
    bigint_result_t result = {0};

    if (x == NULL || y == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big numbers");

        return result;
    }

    bigint_result_t div_res = bigint_divmod(x, y);
    if (div_res.status != BIGINT_OK) { return div_res; }

    bigint_t* const quotient = div_res.value.division.quotient;
    bigint_t* const remainder = div_res.value.division.remainder;

    // Discard quotient
    bigint_destroy(quotient);

    result.value.number = remainder;
    result.status = BIGINT_OK;
    SET_MSG(result, "Division between big integers was successful");

    return result;
}

/**
 * bigint_destroy
 *  @number: a valid non-null big integer
 * 
 *  Deletes the big integer from the memory
 *  
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_destroy(bigint_t *number) {
    bigint_result_t result = {0};

    if (number == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid big integer");

        return result;
    }

    vector_destroy(number->digits);
    free(number);

    result.status = BIGINT_OK;
    SET_MSG(result, "Big integer successfully deleted");

    return result;
}

/**
 * bigint_printf
 *  @format: format string
 *  @...: variadic arguments
 * 
 *  Prints a bigint integer to stdout using the custom '%B' placeholder
 * 
 *  Returns a bigint_result_t data type
 */
bigint_result_t bigint_printf(const char *format, ...) {
    bigint_result_t result = {0};

    if (format == NULL) {
        result.status = BIGINT_ERR_INVALID;
        SET_MSG(result, "Invalid format string");

        return result;
    }

    va_list args;
    va_start(args, format);

    // Process string char by char
    for (const char *p = format; *p != '\0'; p++) {
        if (*p == '%' && *(p + 1) != '%') {
            p++;
            const char placeholder = *p;

            switch (placeholder) {
                case 'B': {
                    bigint_t *num = va_arg(args, bigint_t*);
                    if (num == NULL) {
                        for (const char *s = "<invalid big integer>"; *s != '\0'; s++) { putchar(*s); }
                    } else {
                        bigint_result_t num_str_res = bigint_to_string(num);
                        if (num_str_res.status != BIGINT_OK) {
                            va_end(args);
                            return num_str_res;
                        }

                        char *number_str = num_str_res.value.string_num;
                        for (const char *s = number_str; *s != '\0'; s++) { putchar(*s); }
                        free(number_str);
                    }
                    break;
                }
                case 'd':
                case 'i': {
                    int val = va_arg(args, int);
                    printf("%d", val);
                    break;
                }
                case 'u': {
                    unsigned int val = va_arg(args, unsigned int);
                    printf("%u", val);
                    break;
                }
                case 'l': {
                    if (*(p + 1) == 'd' || *(p + 1) == 'i') {
                        long val = va_arg(args, long);
                        printf("%ld", val);
                        p++;
                    } else if (*(p + 1) == 'l' && (*(p + 2) == 'd' || *(p + 2) == 'i')) {
                        long long val = va_arg(args, long long);
                        printf("%lld", val);
                        p += 2;
                    } else if (*(p + 1) == 'u') {
                        unsigned long val = va_arg(args, unsigned long);
                        printf("%lu", val);
                        p++;
                    }
                    break;
                }
                case 's': {
                    char* val = va_arg(args, char*);
                    if (val) {
                        for (const char *s = val; *s != '\0'; s++) { putchar(*s); }
                    } else {
                        for (const char *s = "<invalid string>"; *s != '\0'; s++) { putchar(*s); }
                    }
                    break;
                }
                case 'c': {
                    int val = va_arg(args, int);
                    putchar(val);
                    break;
                }
                case 'f': {
                    double val = va_arg(args, double);
                    printf("%f", val);
                    break;
                }
                case 'p': {
                    void* const val = va_arg(args, void*);
                    printf("%p", val);
                    break;
                }
                case 'x': {
                    unsigned int val = va_arg(args, unsigned int);
                    printf("%x", val);
                    break;
                }
                case 'X': {
                    unsigned int val = va_arg(args, unsigned int);
                    printf("%X", val);
                    break;
                }
                default: // Unsupported placeholder so we just print it
                    printf("%%%c", placeholder);
                    break;
            }
        } else if (*p == '%' && *(p + 1) == '%') {
            // print the percent character as is
            putchar('%');
            p++;
        } else { // Print ASCII character
            putchar(*p);
        }
    }
    
    va_end(args);

    result.status = BIGINT_OK;
    SET_MSG(result, "Printf completed successfully");

    return result;
}