// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module profiler

// profiler_init initializes the profiler system
// Must be called before enabling profiling
pub fn profiler_init() {
	init_profiler_state()
}

// profiler_enable enables allocation tracking
pub fn profiler_enable() {
	if profiler_state.mu == unsafe { nil } {
		init_profiler_state()
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}
	profiler_state.enabled = true
	// Start first frame
	if profiler_state.frames.len == 0 {
		profiler_state.frames << FrameData{
			frame_num:   0
			new_bytes:   0
			freed_bytes: 0
			live_bytes:  profiler_state.live_bytes
		}
	}
}

// profiler_disable disables allocation tracking
pub fn profiler_disable() {
	if profiler_state.mu == unsafe { nil } {
		return
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}
	profiler_state.enabled = false
}

// profiler_is_enabled returns whether profiling is active
pub fn profiler_is_enabled() bool {
	if profiler_state.mu == unsafe { nil } {
		return false
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}
	return profiler_state.enabled
}

// frame_end signals the end of a frame and collects frame data
// Call this at the end of each game/application frame
pub fn frame_end() {
	if profiler_state.mu == unsafe { nil } || !profiler_state.enabled {
		return
	}

	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}

	// Finalize current frame's live bytes
	if profiler_state.frames.len > 0 {
		profiler_state.frames[profiler_state.frames.len - 1].live_bytes = profiler_state.live_bytes
	}

	// Increment frame counter
	profiler_state.current_frame++

	// Start new frame
	profiler_state.frames << FrameData{
		frame_num:   profiler_state.current_frame
		new_bytes:   0
		freed_bytes: 0
		live_bytes:  profiler_state.live_bytes
	}
}

// get_frame_count returns the current frame number
pub fn get_frame_count() u64 {
	if profiler_state.mu == unsafe { nil } {
		return 0
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}
	return profiler_state.current_frame
}

// get_frames returns a copy of all frame data
pub fn get_frames() []FrameData {
	if profiler_state.mu == unsafe { nil } {
		return []
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}
	return profiler_state.frames.clone()
}

// get_allocs returns a copy of all allocation records
pub fn get_allocs() []AllocRecord {
	if profiler_state.mu == unsafe { nil } {
		return []
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}
	return profiler_state.allocs.clone()
}

// get_leaks returns allocations that were never freed
pub fn get_leaks() []AllocRecord {
	if profiler_state.mu == unsafe { nil } {
		return []
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}

	mut leaks := []AllocRecord{}
	for alloc in profiler_state.allocs {
		if !alloc.freed {
			leaks << alloc
		}
	}
	return leaks
}

// get_allocs_for_frame returns allocations made in a specific frame
pub fn get_allocs_for_frame(frame_num u64) []AllocRecord {
	if profiler_state.mu == unsafe { nil } {
		return []
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}

	mut frame_allocs := []AllocRecord{}
	for alloc in profiler_state.allocs {
		if alloc.frame == frame_num {
			frame_allocs << alloc
		}
	}
	return frame_allocs
}

// get_live_allocs returns currently live (not freed) allocations
pub fn get_live_allocs() []AllocRecord {
	if profiler_state.mu == unsafe { nil } {
		return []
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}

	mut live := []AllocRecord{}
	for alloc in profiler_state.allocs {
		if !alloc.freed {
			live << alloc
		}
	}
	return live
}

// reset clears all profiler data
pub fn reset() {
	if profiler_state.mu == unsafe { nil } {
		return
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}

	profiler_state.allocs.clear()
	profiler_state.alloc_map.clear()
	profiler_state.frames.clear()
	profiler_state.current_frame = 0
	profiler_state.live_bytes = 0
	profiler_state.peak_bytes = 0
	profiler_state.total_allocs = 0
	profiler_state.total_frees = 0

	// Start fresh frame
	if profiler_state.enabled {
		profiler_state.frames << FrameData{
			frame_num: 0
		}
	}
}

// use_profiler_allocator enables the profiler allocator in the current context
// Returns the old allocator for restoration
pub fn use_profiler_allocator() Allocator {
	return push_allocator(profiler_allocator())
}

// restore_allocator restores the previous allocator
pub fn restore_allocator(old Allocator) {
	pop_allocator(old)
}