// Copyright (c) 2020-2024 Joe Conigliaro. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module main

import gg
import os
import v2.profiler

fn main() {
	// Initialize profiler system
	profiler.profiler_init()

	// Create application state (on stack, like the working example)
	mut app := App{}

	// Check command line args for mode
	args := os.args
	if '--demo' in args {
		app.demo_mode = true
		app.live_mode = false
		init_demo_data(mut app)
	} else {
		// Default to live mode - read from snapshot file
		app.demo_mode = false
		app.live_mode = true
	}

	// Create gg context
	app.gg = gg.new_context(
		width:         window_width
		height:        window_height
		create_window: true
		window_title:  'V2 Allocation Profiler'
		bg_color:      bg_color
		frame_fn:      frame
		event_fn:      event_handler
		user_data:     &app
	)

	// Run the application
	app.gg.run()
}

// frame is the frame callback for gg
fn frame(mut app App) {
	draw_frame(mut app)
}

// event_handler handles gg events
fn event_handler(e &gg.Event, mut app App) {
	handle_event(e, mut app)
}

// init_demo_data populates the profiler with simulated data for demonstration
fn init_demo_data(mut app App) {
	app.demo_mode = true
	app.demo_frame = 0

	// Create simulated frame and allocation data
	app.cached_frames = []profiler.FrameData{cap: 100}
	app.cached_allocs = []profiler.AllocRecord{cap: 500}

	// Simulate 100 frames of allocation activity
	mut total_live := u64(0)
	mut peak := u64(0)
	mut alloc_idx := 0
	mut total_allocs := u64(0)
	mut total_frees := u64(0)

	for frame_num := 0; frame_num < 100; frame_num++ {
		mut frame_data := profiler.FrameData{
			frame_num: u64(frame_num)
		}

		// Simulate some allocations each frame
		// More allocations early, fewer later (typical startup pattern)
		num_allocs := if frame_num < 20 { 10 - frame_num / 4 } else { 2 + (frame_num % 3) }

		for _ in 0 .. num_allocs {
			// Random-ish allocation sizes
			size := 64 + ((frame_num * 17 + alloc_idx * 31) % 4096)

			app.cached_allocs << profiler.AllocRecord{
				ptr:       unsafe { voidptr(u64(0x1000) + u64(alloc_idx) * 0x100) }
				size:      size
				frame:     u64(frame_num)
				file:      ['main.v', 'parser.v', 'scanner.v', 'types.v', 'gen.v'][alloc_idx % 5]
				line:      100 + (alloc_idx % 500)
				timestamp: i64(frame_num) * 16_666_667 + i64(alloc_idx) * 1000
				freed:     false
			}

			frame_data.new_allocs << alloc_idx
			frame_data.new_bytes += u64(size)
			total_live += u64(size)
			total_allocs++
			alloc_idx++
		}

		// Simulate some frees (but not all - create some "leaks")
		// Free some allocations from previous frames
		if frame_num > 5 {
			num_frees := num_allocs - 1 // Always free slightly fewer than we allocate
			mut freed_count := 0
			for i := 0; i < app.cached_allocs.len && freed_count < num_frees; i++ {
				if !app.cached_allocs[i].freed && app.cached_allocs[i].frame < u64(frame_num - 3) {
					// 80% chance to free
					if (i * 7 + frame_num * 13) % 10 < 8 {
						app.cached_allocs[i].freed = true
						app.cached_allocs[i].free_frame = u64(frame_num)
						frame_data.freed_idxs << i
						frame_data.freed_bytes += u64(app.cached_allocs[i].size)
						total_live -= u64(app.cached_allocs[i].size)
						total_frees++
						freed_count++
					}
				}
			}
		}

		frame_data.live_bytes = total_live
		if total_live > peak {
			peak = total_live
		}

		app.cached_frames << frame_data
	}

	// Count leaks
	mut leak_count := 0
	for alloc in app.cached_allocs {
		if !alloc.freed {
			leak_count++
		}
	}

	// Update stats
	app.cached_stats = profiler.Statistics{
		live_bytes:   total_live
		peak_bytes:   peak
		total_allocs: total_allocs
		total_frees:  total_frees
		leak_count:   leak_count
		frame_count:  100
	}
}

// update_demo_data simulates ongoing activity in demo mode
fn update_demo_data(mut app App) {
	// In demo mode, we just use the static simulated data
	// For a more dynamic demo, we could add new frames here
	app.demo_frame++
}