#include "include/lsort.h"
#include "include/types.h"
#include "include/radix.h"

static int _seperate_pos_neg(lsort_array* array, lsort_array* pos_array, lsort_array* neg_array) {
    for (int i = 0; i < array->count; i++) {
        if ((0x80000000 & array->items[i]->key) == 0x80000000) {
            lsort_array_append(neg_array, array->items[i]);
        } else {
            lsort_array_append(pos_array, array->items[i]);
        }
    }
    return 0;
}

static int _sort_items(lsort_array* numbers, lsort_array_array* buckets) {
    int byte_check = 0x0000000F;

    for (int i = 0; i < 8; i++) {
        // Loop through the list of numbers and append them to their respective buckets for this 4-byte chunk
        for (int item_index = 0; item_index < numbers->count; item_index++) {
            lsort_item* current_item = numbers->items[item_index];
            lsort_array* bucket = buckets->items[(current_item->key >> (i * 4)) & byte_check];

            
            lsort_array_append(bucket, current_item);
        }
        
        lsort_array_clear(numbers);
        
        // Add the bucketed numbers back to the original array after emptying it
        for (int bucket_number = 0; bucket_number < buckets->count; bucket_number++) {
            lsort_array* bucket = buckets->items[bucket_number];

            for (int bucket_item = 0; bucket_item < bucket->count; bucket_item++) {
                lsort_array_append(numbers, bucket->items[bucket_item]);
            }

            lsort_array_clear(bucket);
        }

        // Repeat for each 4-byte chunk...
    }

    return 0;
}

int lsort_radix(lsort_array* array, lsort_array* return_array) {
    if (array->count <= 0) return 1;

    // Seperate positive and negative numbers
    lsort_array* positive_numbers = lsort_array_create();
    lsort_array* negative_numbers = lsort_array_create();
    
    if (_seperate_pos_neg(array, positive_numbers, negative_numbers)) return 2;

    // Create buckets
    lsort_array_array* buckets = lsort_array_array_create();
    for (int i = 0; i < 16; i++) {
        lsort_array* bucket = lsort_array_create();
        lsort_array_array_append(buckets, bucket);
    }

    // Sort each set of numbers using those buckets
    _sort_items(negative_numbers, buckets);
    _sort_items(positive_numbers, buckets);
    

    // Add each array of numbers to the return array
    for (int i = 0; i < negative_numbers->count; i++) {
        lsort_array_append(return_array, negative_numbers->items[i]);
    }

    for (int i = 0; i < positive_numbers->count; i++) {
        lsort_array_append(return_array, positive_numbers->items[i]);
    }

    lsort_array_destroy(negative_numbers, 0);
    lsort_array_destroy(positive_numbers, 0);
    
    // Destroy the buckets
    lsort_array_array_destroy(buckets, 0);

    return check_sorted(return_array);
}