#include "gc_sweep.h"
#include "gc_heap.h"
#include "../runtime.h"
#include <stdlib.h>
#include <unistd.h>

static void _rava_gc_finalize_object_data(RavaObject_t *o) {
    free(o->class_name);
    for (size_t i = 0; i < o->field_count; i++) {
        free(o->field_names[i]);
    }
    free(o->field_names);
    free(o->field_values);
}

static void _rava_gc_finalize_array_data(RavaArray_t *a) {
    free(a->data);
}

static void _rava_gc_finalize_arraylist_data(RavaArrayList_t *l) {
    free(l->data);
}

static void _rava_gc_finalize_hashmap_data(RavaHashMap_t *m) {
    for (size_t i = 0; i < m->bucket_count; i++) {
        if (m->buckets[i].occupied) {
            free(m->buckets[i].key);
        }
    }
    free(m->buckets);
}

static void _rava_gc_finalize_socket_data(RavaSocket_t *s) {
    if (!s->closed && s->fd >= 0) {
        close(s->fd);
    }
}

static void _rava_gc_finalize_methodref_data(RavaMethodRef_t *r) {
    free(r->class_name);
    free(r->method_name);
}

void rava_gc_finalize_object(RavaGCHeader_t *obj) {
    switch (obj->gc_type) {
        case RAVA_GC_TYPE_OBJECT: {
            RavaObject_t *o = (RavaObject_t*)obj;
            _rava_gc_finalize_object_data(o);
            break;
        }
        case RAVA_GC_TYPE_ARRAY: {
            RavaArray_t *a = (RavaArray_t*)obj;
            _rava_gc_finalize_array_data(a);
            break;
        }
        case RAVA_GC_TYPE_ARRAYLIST: {
            RavaArrayList_t *l = (RavaArrayList_t*)obj;
            _rava_gc_finalize_arraylist_data(l);
            break;
        }
        case RAVA_GC_TYPE_HASHMAP: {
            RavaHashMap_t *m = (RavaHashMap_t*)obj;
            _rava_gc_finalize_hashmap_data(m);
            break;
        }
        case RAVA_GC_TYPE_SOCKET: {
            RavaSocket_t *s = (RavaSocket_t*)obj;
            _rava_gc_finalize_socket_data(s);
            break;
        }
        case RAVA_GC_TYPE_METHODREF: {
            RavaMethodRef_t *r = (RavaMethodRef_t*)obj;
            _rava_gc_finalize_methodref_data(r);
            break;
        }
        default:
            break;
    }

    if (obj->gc_flags & RAVA_GC_FLAG_PINNED) {
        free(obj);
    }
}

void rava_gc_sweep(void) {
    RavaGCHeap_t *heap = rava_gc_get_heap();
    RavaGCHeader_t **ptr = &heap->all_objects;
    size_t freed_count = 0;
    size_t freed_bytes = 0;

    while (*ptr) {
        RavaGCHeader_t *obj = *ptr;

        if (obj->gc_mark == RAVA_GC_WHITE) {
            *ptr = obj->gc_next;
            freed_bytes += obj->gc_size;
            freed_count++;
            rava_gc_finalize_object(obj);
        } else {
            obj->gc_mark = RAVA_GC_WHITE;
            obj->gc_age++;
            ptr = &obj->gc_next;
        }
    }

    heap->live_bytes = heap->total_allocated - freed_bytes;
    heap->total_allocated = heap->live_bytes;

    if (heap->live_bytes > 0) {
        heap->gc_threshold = heap->live_bytes * 2;
    } else {
        heap->gc_threshold = RAVA_GC_INITIAL_THRESHOLD;
    }
}