module closure

$if !freestanding && !vinix {
	#include <sys/mman.h>
	#insert "@VEXEROOT/vlib/builtin/closure/closure_once_nix.h"

	fn C.v_closure_init_once(ClosureInitFn)
}

struct ClosureMutex {
	closure_mtx [128]u8
}

@[inline]
fn closure_mtx_ptr_platform() voidptr {
	return unsafe { voidptr(&g_closure.closure_mtx[0]) }
}

@[inline]
fn closure_alloc_platform() &u8 {
	mut p := &u8(unsafe { nil })
	$if freestanding {
		// Freestanding environments (no OS) use simple malloc
		p = unsafe { malloc(g_closure.v_page_size * 2) }
		if isnil(p) {
			return unsafe { nil }
		}
	} $else {
		// Main OS environments use mmap to get aligned pages
		p = unsafe {
			C.mmap(0, g_closure.v_page_size * 2, C.PROT_READ | C.PROT_WRITE,
				C.MAP_ANONYMOUS | C.MAP_PRIVATE, -1, 0)
		}
		if p == &u8(C.MAP_FAILED) {
			return unsafe { nil }
		}
	}
	return p
}

@[inline]
fn closure_memory_protect_platform(ptr voidptr, size isize, attr MemoryProtectAtrr) {
	$if freestanding {
		// No memory protection in freestanding mode
	} $else {
		match attr {
			.read_exec {
				unsafe { C.mprotect(ptr, size, C.PROT_READ | C.PROT_EXEC) }
			}
			.read_write {
				unsafe { C.mprotect(ptr, size, C.PROT_READ | C.PROT_WRITE) }
			}
		}
	}
}

@[inline]
fn get_page_size_platform() int {
	// Determine system page size
	mut page_size := 0x4000
	$if !freestanding {
		// Query actual page size in OS environments
		page_size = unsafe { int(C.sysconf(C._SC_PAGESIZE)) }
	}
	// Calculate required allocation size
	page_size = page_size * (((assumed_page_size - 1) / page_size) + 1)
	return page_size
}

@[inline]
fn closure_mtx_lock_init_platform() {
	$if !freestanding || vinix {
		C.pthread_mutex_init(closure_mtx_ptr_platform(), 0)
	}
}

@[inline]
fn closure_mtx_lock_platform() {
	$if !freestanding || vinix {
		C.pthread_mutex_lock(closure_mtx_ptr_platform())
	}
}

@[inline]
fn closure_mtx_unlock_platform() {
	$if !freestanding || vinix {
		C.pthread_mutex_unlock(closure_mtx_ptr_platform())
	}
}

@[inline]
fn closure_current_thread_id_platform() u64 {
	$if !freestanding {
		return u64(C.pthread_self())
	}
	return u64(0)
}

@[inline]
fn closure_init_once_platform() {
	$if freestanding || vinix {
		if isnil(g_closure.closure_ptr) {
			closure_init_body()
		}
	} $else {
		C.v_closure_init_once(closure_init_body)
	}
}