// 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 os
import time

// Default path for profiler data exchange
pub const profiler_data_path = '/tmp/v2_profiler.dat'

// Snapshot represents a point-in-time view of profiler state for IPC
pub struct Snapshot {
pub mut:
	timestamp    i64
	frame_count  u64
	live_bytes   u64
	peak_bytes   u64
	total_allocs u64
	total_frees  u64
	frames       []FrameData
	allocs       []AllocRecord
}

// write_snapshot writes the current profiler state to the shared file
// Call this at the end of each frame in the profiled application
pub fn write_snapshot() {
	write_snapshot_to(profiler_data_path)
}

// write_snapshot_to writes profiler state to a specific path
pub fn write_snapshot_to(path string) {
	if profiler_state.mu == unsafe { nil } {
		return
	}

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

	// Build snapshot data as simple text format (easy to parse)
	mut sb := []u8{cap: 4096}

	// Header with stats
	sb << 'V2PROF1\n'.bytes() // Version marker
	sb << 'T:${time.sys_mono_now()}\n'.bytes()
	sb << 'F:${profiler_state.current_frame}\n'.bytes()
	sb << 'L:${profiler_state.live_bytes}\n'.bytes()
	sb << 'P:${profiler_state.peak_bytes}\n'.bytes()
	sb << 'A:${profiler_state.total_allocs}\n'.bytes()
	sb << 'R:${profiler_state.total_frees}\n'.bytes()

	// Frame data (last 200 frames max)
	start_frame := if profiler_state.frames.len > 200 {
		profiler_state.frames.len - 200
	} else {
		0
	}
	sb << 'FRAMES:${profiler_state.frames.len - start_frame}\n'.bytes()
	for i := start_frame; i < profiler_state.frames.len; i++ {
		frame := profiler_state.frames[i]
		sb << '${frame.frame_num},${frame.new_bytes},${frame.freed_bytes},${frame.live_bytes}\n'.bytes()
	}

	// Allocation records (last 1000 max, for performance)
	start_alloc := if profiler_state.allocs.len > 1000 {
		profiler_state.allocs.len - 1000
	} else {
		0
	}
	sb << 'ALLOCS:${profiler_state.allocs.len - start_alloc}\n'.bytes()
	for i := start_alloc; i < profiler_state.allocs.len; i++ {
		alloc := profiler_state.allocs[i]
		freed_val := if alloc.freed { '1' } else { '0' }
		// ptr,size,frame,freed,free_frame,file,line
		sb << '${u64(alloc.ptr)},${alloc.size},${alloc.frame},${freed_val},${alloc.free_frame},${alloc.file},${alloc.line}\n'.bytes()
	}

	sb << 'END\n'.bytes()

	// Write atomically by writing to temp file then renaming
	tmp_path := path + '.tmp'
	os.write_file(tmp_path, sb.bytestr()) or { return }
	os.rename(tmp_path, path) or { return }
}

// read_snapshot reads profiler state from the shared file
// Returns none if file doesn't exist or is invalid
pub fn read_snapshot() ?Snapshot {
	return read_snapshot_from(profiler_data_path)
}

// read_snapshot_from reads profiler state from a specific path
pub fn read_snapshot_from(path string) ?Snapshot {
	content := os.read_file(path) or { return none }
	lines := content.split_into_lines()

	if lines.len < 7 || lines[0] != 'V2PROF1' {
		return none
	}

	mut snap := Snapshot{}

	// Parse header
	snap.timestamp = parse_value(lines[1], 'T:')
	snap.frame_count = u64(parse_value(lines[2], 'F:'))
	snap.live_bytes = u64(parse_value(lines[3], 'L:'))
	snap.peak_bytes = u64(parse_value(lines[4], 'P:'))
	snap.total_allocs = u64(parse_value(lines[5], 'A:'))
	snap.total_frees = u64(parse_value(lines[6], 'R:'))

	mut line_idx := 7

	// Parse frames
	if line_idx < lines.len && lines[line_idx].starts_with('FRAMES:') {
		num_frames := lines[line_idx].all_after('FRAMES:').int()
		line_idx++
		for _ in 0 .. num_frames {
			if line_idx >= lines.len {
				break
			}
			parts := lines[line_idx].split(',')
			if parts.len >= 4 {
				snap.frames << FrameData{
					frame_num:   u64(parts[0].i64())
					new_bytes:   u64(parts[1].i64())
					freed_bytes: u64(parts[2].i64())
					live_bytes:  u64(parts[3].i64())
				}
			}
			line_idx++
		}
	}

	// Parse allocs
	if line_idx < lines.len && lines[line_idx].starts_with('ALLOCS:') {
		num_allocs := lines[line_idx].all_after('ALLOCS:').int()
		line_idx++
		for _ in 0 .. num_allocs {
			if line_idx >= lines.len {
				break
			}
			parts := lines[line_idx].split(',')
			if parts.len >= 7 {
				snap.allocs << AllocRecord{
					ptr:        unsafe { voidptr(u64(parts[0].i64())) }
					size:       parts[1].int()
					frame:      u64(parts[2].i64())
					freed:      parts[3] == '1'
					free_frame: u64(parts[4].i64())
					file:       parts[5]
					line:       parts[6].int()
				}
			}
			line_idx++
		}
	}

	return snap
}

fn parse_value(line string, prefix string) i64 {
	if line.starts_with(prefix) {
		return line.all_after(prefix).i64()
	}
	return 0
}

// frame_end_with_snapshot ends the frame and writes a snapshot
// Use this instead of frame_end() when you want live monitoring
pub fn frame_end_with_snapshot() {
	frame_end()
	write_snapshot()
}