// 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 v2.profiler

// Filter modes for allocation view
pub enum FilterMode {
	all           // Show all allocations
	new_not_freed // Show allocations that haven't been freed (potential leaks)
	large         // Show allocations larger than threshold
	current_frame // Show allocations from selected frame only
}

// App holds the GUI application state
pub struct App {
pub mut:
	gg &gg.Context = unsafe { nil }
	// View state
	selected_frame  int        = -1 // -1 means no selection
	selected_alloc  int        = -1 // Index of selected allocation
	filter_mode     FilterMode = .all
	large_threshold int        = 1024 // Threshold for "large" filter (bytes)
	search_text     string
	// Scroll/pan state
	timeline_scroll  int // Horizontal scroll for timeline
	histogram_scroll int // Scroll for histogram if needed
	// Cached data (updated each frame)
	cached_frames []profiler.FrameData
	cached_allocs []profiler.AllocRecord
	cached_stats  profiler.Statistics
	// Layout dimensions
	header_height    int = 60
	histogram_height int = 200
	timeline_height  int = 80
	controls_height  int = 40
	details_height   int = 60
	// Hover state
	hover_frame int = -1
	hover_alloc int = -1
	// Mode
	demo_mode  bool // Use simulated data for demo (false = live mode)
	demo_frame int  // Current demo frame counter
	live_mode  bool = true // Read from profiler snapshot file
	// Status
	status_msg string = 'Waiting for profiler data...'
}

// Colors for the profiler visualization
pub const bg_color = gg.Color{30, 30, 30, 255} // Dark gray background
pub const new_alloc_color = gg.Color{0, 200, 255, 200} // Cyan for new allocations
pub const freed_color = gg.Color{180, 100, 255, 200} // Purple for freed allocations
pub const leak_color = gg.Color{255, 100, 100, 255} // Red for leaks/live
pub const timeline_cursor = gg.Color{255, 255, 0, 255} // Yellow for timeline cursor
pub const text_color = gg.Color{220, 220, 220, 255} // Light gray text
pub const header_bg = gg.Color{40, 40, 45, 255} // Slightly lighter header
pub const grid_color = gg.Color{60, 60, 60, 255} // Grid lines
pub const selected_color = gg.Color{100, 150, 255, 255} // Selection highlight

// Window dimensions
pub const window_width = 1200
pub const window_height = 700

// init_app creates a new App instance (unused, kept for reference)
fn init_app_heap() &App {
	return &App{}
}

// update_cache refreshes cached profiler data
pub fn (mut app App) update_cache() {
	if app.demo_mode {
		return
	}

	if app.live_mode {
		// Read from snapshot file
		if snap := profiler.read_snapshot() {
			app.cached_frames = snap.frames
			app.cached_allocs = snap.allocs
			app.cached_stats = profiler.Statistics{
				live_bytes:   snap.live_bytes
				peak_bytes:   snap.peak_bytes
				total_allocs: snap.total_allocs
				total_frees:  snap.total_frees
				leak_count:   count_leaks(snap.allocs)
				frame_count:  snap.frame_count
			}
			app.status_msg = 'Live: Frame ${snap.frame_count}'
		} else {
			app.status_msg = 'Waiting for profiler data at ${profiler.profiler_data_path}...'
		}
		return
	}

	// In-process mode (same process)
	app.cached_frames = profiler.get_frames()
	app.cached_allocs = profiler.get_allocs()
	app.cached_stats = profiler.get_statistics()
}

fn count_leaks(allocs []profiler.AllocRecord) int {
	mut count := 0
	for alloc in allocs {
		if !alloc.freed {
			count++
		}
	}
	return count
}

// get_filtered_allocs returns allocations matching current filter
pub fn (app &App) get_filtered_allocs() []profiler.AllocRecord {
	mut result := []profiler.AllocRecord{}

	allocs := app.cached_allocs

	for alloc in allocs {
		match app.filter_mode {
			.all {
				result << alloc
			}
			.new_not_freed {
				if !alloc.freed {
					result << alloc
				}
			}
			.large {
				if alloc.size >= app.large_threshold {
					result << alloc
				}
			}
			.current_frame {
				if app.selected_frame >= 0 && alloc.frame == u64(app.selected_frame) {
					result << alloc
				}
			}
		}
	}

	// Apply search filter if text is present
	if app.search_text.len > 0 {
		mut filtered := []profiler.AllocRecord{}
		for alloc in result {
			if alloc.file.contains(app.search_text) {
				filtered << alloc
			}
		}
		return filtered
	}

	return result
}

// get_frame_at_x returns the frame index at the given x coordinate in timeline
pub fn (app &App) get_frame_at_x(x f32, timeline_x f32, timeline_width f32) int {
	frames := app.cached_frames
	if frames.len == 0 {
		return -1
	}

	// Calculate which frame this x position corresponds to
	relative_x := x - timeline_x
	if relative_x < 0 || relative_x > timeline_width {
		return -1
	}

	frame_width := timeline_width / f32(frames.len)
	frame_idx := int(relative_x / frame_width)

	if frame_idx >= 0 && frame_idx < frames.len {
		return frame_idx
	}
	return -1
}