// 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

import time
import sync

// AllocRecord tracks a single allocation
pub struct AllocRecord {
pub:
	ptr       voidptr
	size      int
	frame     u64
	file      string // Source file
	line      int    // Source line
	timestamp i64    // Monotonic time in nanoseconds
pub mut:
	freed      bool
	free_frame u64
}

// FrameData aggregates allocation info for a single frame
pub struct FrameData {
pub:
	frame_num u64
pub mut:
	new_bytes   u64
	freed_bytes u64
	live_bytes  u64
	new_allocs  []int // Indices into allocs array
	freed_idxs  []int // Indices of allocations freed this frame
}

// ProfilerState holds all profiling data
@[heap]
pub struct ProfilerState {
pub mut:
	enabled       bool
	current_frame u64
	allocs        []AllocRecord
	alloc_map     map[voidptr]int // ptr -> index in allocs
	frames        []FrameData
	peak_bytes    u64
	live_bytes    u64
	total_allocs  u64
	total_frees   u64
	mu            &sync.Mutex = unsafe { nil }
}

// Global profiler state singleton
__global profiler_state = &ProfilerState{}

// init_profiler_state initializes the global profiler state
// Must be called before using the profiler
pub fn init_profiler_state() {
	profiler_state.mu = sync.new_mutex()
	profiler_state.enabled = false
	profiler_state.current_frame = 0
	profiler_state.allocs = []AllocRecord{cap: 10000}
	profiler_state.frames = []FrameData{cap: 1000}
	profiler_state.peak_bytes = 0
	profiler_state.live_bytes = 0
	profiler_state.total_allocs = 0
	profiler_state.total_frees = 0
}

// get_state returns the global profiler state
pub fn get_state() &ProfilerState {
	return profiler_state
}

// Statistics returns summary stats
pub struct Statistics {
pub:
	live_bytes   u64
	peak_bytes   u64
	total_allocs u64
	total_frees  u64
	leak_count   int
	frame_count  u64
}

// get_statistics returns current profiler statistics
pub fn get_statistics() Statistics {
	if profiler_state.mu == unsafe { nil } {
		return Statistics{}
	}
	profiler_state.mu.lock()
	defer {
		profiler_state.mu.unlock()
	}

	mut leak_count := 0
	for alloc in profiler_state.allocs {
		if !alloc.freed {
			leak_count++
		}
	}

	return Statistics{
		live_bytes:   profiler_state.live_bytes
		peak_bytes:   profiler_state.peak_bytes
		total_allocs: profiler_state.total_allocs
		total_frees:  profiler_state.total_frees
		leak_count:   leak_count
		frame_count:  profiler_state.current_frame
	}
}

// format_bytes converts bytes to a human-readable string
pub fn format_bytes(bytes u64) string {
	if bytes < 1024 {
		return '${bytes} B'
	} else if bytes < 1024 * 1024 {
		return '${f64(bytes) / 1024.0:.1} KB'
	} else if bytes < 1024 * 1024 * 1024 {
		return '${f64(bytes) / (1024.0 * 1024.0):.1} MB'
	} else {
		return '${f64(bytes) / (1024.0 * 1024.0 * 1024.0):.2} GB'
	}
}

// now_mono returns the current monotonic time in nanoseconds
fn now_mono() i64 {
	return time.sys_mono_now()
}