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

// draw_header renders the top stats bar
fn draw_header(mut app App) {
	ctx := app.gg
	w := f32(ctx.width)

	// Background
	ctx.draw_rect_filled(0, 0, w, f32(app.header_height), header_bg)

	// Get stats
	stats := app.cached_stats

	// Format and draw stats
	heap_str := 'HEAP: ${profiler.format_bytes(stats.live_bytes)}'
	peak_str := 'Peak: ${profiler.format_bytes(stats.peak_bytes)}'
	allocs_str := '${stats.total_allocs} allocs'
	frees_str := '${stats.total_frees} frees'
	leaks_str := '${stats.leak_count} leaks'

	// Draw stats with spacing
	mut x := f32(20)
	y := f32(22)

	ctx.draw_text(int(x), int(y), heap_str, color: text_color, size: 20)
	x += 180

	ctx.draw_text(int(x), int(y), peak_str, color: text_color, size: 20)
	x += 160

	ctx.draw_text(int(x), int(y), allocs_str, color: new_alloc_color, size: 20)
	x += 140

	ctx.draw_text(int(x), int(y), frees_str, color: freed_color, size: 20)
	x += 120

	// Show leaks in red if there are any
	leak_clr := if stats.leak_count > 0 { leak_color } else { text_color }
	ctx.draw_text(int(x), int(y), leaks_str, color: leak_clr, size: 20)

	// Mode and frame counter on right
	mode_str := if app.demo_mode {
		'DEMO'
	} else if app.live_mode {
		'LIVE'
	} else {
		'LOCAL'
	}
	ctx.draw_text(int(w) - 250, int(y), mode_str, color: gg.Color{100, 255, 100, 255}, size: 20)

	frame_str := 'Frame: ${stats.frame_count}'
	ctx.draw_text(int(w) - 150, int(y), frame_str, color: text_color, size: 20)

	// Separator line
	ctx.draw_line(0, f32(app.header_height), w, f32(app.header_height), grid_color)
}

// draw_histogram renders the allocation histogram
fn draw_histogram(mut app App) {
	ctx := app.gg
	w := f32(ctx.width)

	// Histogram area
	hist_y := f32(app.header_height)
	hist_h := f32(app.histogram_height)
	center_y := hist_y + hist_h / 2

	// Background
	ctx.draw_rect_filled(0, hist_y, w, hist_h, bg_color)

	// Center line
	ctx.draw_line(0, center_y, w, center_y, grid_color)

	// Get frame data (always use cached data - it's populated by update_cache from snapshot or demo)
	frames := app.cached_frames
	if frames.len == 0 {
		ctx.draw_text(int(w / 2) - 80, int(center_y) - 10, 'No frame data',
			color: text_color
			size:  18
		)
		return
	}

	// Calculate max values for scaling
	mut max_new := u64(1)
	mut max_freed := u64(1)
	for frame in frames {
		if frame.new_bytes > max_new {
			max_new = frame.new_bytes
		}
		if frame.freed_bytes > max_freed {
			max_freed = frame.freed_bytes
		}
	}

	// Bar dimensions
	margin := f32(40)
	bar_area_width := w - margin * 2
	bar_width := bar_area_width / f32(frames.len)
	if bar_width < 1 {
		return
	}
	bar_gap := bar_width * 0.1
	actual_bar_w := bar_width - bar_gap

	max_bar_height := (hist_h / 2) - 10

	// Draw bars for each frame
	for i, frame in frames {
		x := margin + f32(i) * bar_width

		// New allocations (cyan, above center)
		if frame.new_bytes > 0 {
			new_height := f32(frame.new_bytes) / f32(max_new) * max_bar_height
			bar_color := if i == app.selected_frame { selected_color } else { new_alloc_color }
			ctx.draw_rect_filled(x, center_y - new_height, actual_bar_w, new_height, bar_color)
		}

		// Freed allocations (purple, below center)
		if frame.freed_bytes > 0 {
			freed_height := f32(frame.freed_bytes) / f32(max_freed) * max_bar_height
			bar_color := if i == app.selected_frame {
				gg.Color{150, 130, 255, 200}
			} else {
				freed_color
			}
			ctx.draw_rect_filled(x, center_y, actual_bar_w, freed_height, bar_color)
		}

		// Hover highlight
		if i == app.hover_frame && i != app.selected_frame {
			ctx.draw_rect_empty(x - 1, hist_y + 5, actual_bar_w + 2, hist_h - 10, timeline_cursor)
		}
	}

	// Legend
	ctx.draw_rect_filled(10, hist_y + 10, 12, 12, new_alloc_color)
	ctx.draw_text(26, int(hist_y) + 8, 'New', color: text_color, size: 14)

	ctx.draw_rect_filled(70, hist_y + 10, 12, 12, freed_color)
	ctx.draw_text(86, int(hist_y) + 8, 'Freed', color: text_color, size: 14)

	// Separator line
	ctx.draw_line(0, hist_y + hist_h, w, hist_y + hist_h, grid_color)
}

// draw_timeline renders the frame timeline with scrubber
fn draw_timeline(mut app App) {
	ctx := app.gg
	w := f32(ctx.width)

	// Timeline area
	timeline_y := f32(app.header_height + app.histogram_height)
	timeline_h := f32(app.timeline_height)

	// Background
	ctx.draw_rect_filled(0, timeline_y, w, timeline_h, header_bg)

	frames := app.cached_frames
	if frames.len == 0 {
		return
	}

	// Draw frame ticks
	margin := f32(40)
	tick_area_width := w - margin * 2
	tick_spacing := tick_area_width / f32(frames.len)

	// Draw tick marks
	for i := 0; i < frames.len; i++ {
		x := margin + f32(i) * tick_spacing
		tick_height := if i % 10 == 0 { f32(15) } else { f32(8) }
		ctx.draw_line(x, timeline_y + 20, x, timeline_y + 20 + tick_height, grid_color)

		// Frame number labels every 10 frames
		if i % 10 == 0 && tick_spacing > 3 {
			ctx.draw_text(int(x) - 10, int(timeline_y) + 40, '${i}', color: text_color, size: 12)
		}
	}

	// Draw selected frame cursor
	if app.selected_frame >= 0 && app.selected_frame < frames.len {
		cursor_x := margin + f32(app.selected_frame) * tick_spacing
		// Triangle cursor
		draw_triangle_filled(ctx, cursor_x, timeline_y + 15, cursor_x - 8, timeline_y + 5,

			cursor_x + 8, timeline_y + 5, timeline_cursor)

		// Vertical line
		ctx.draw_line(cursor_x, timeline_y + 15, cursor_x, timeline_y + timeline_h - 5,
			timeline_cursor)

		// Frame info
		frame := frames[app.selected_frame]
		info := 'Frame ${app.selected_frame}: +${profiler.format_bytes(frame.new_bytes)} / -${profiler.format_bytes(frame.freed_bytes)}'
		ctx.draw_text(int(w / 2) - 100, int(timeline_y) + 55, info, color: timeline_cursor, size: 16)
	}

	// Separator line
	ctx.draw_line(0, timeline_y + timeline_h, w, timeline_y + timeline_h, grid_color)
}

// draw_controls renders the filter controls
fn draw_controls(mut app App) {
	ctx := app.gg
	w := f32(ctx.width)

	// Controls area
	ctrl_y := f32(app.header_height + app.histogram_height + app.timeline_height)
	ctrl_h := f32(app.controls_height)

	// Background
	ctx.draw_rect_filled(0, ctrl_y, w, ctrl_h, bg_color)

	// Filter buttons
	mut x := f32(20)
	y := ctrl_y + 10

	// Filter label
	ctx.draw_text(int(x), int(y), 'Filter:', color: text_color, size: 16)
	x += 60

	// Filter mode buttons
	filters := ['All', 'Leaks', 'Large', 'Frame']
	modes := [FilterMode.all, FilterMode.new_not_freed, FilterMode.large, FilterMode.current_frame]

	for i, label in filters {
		btn_w := f32(60)
		btn_h := f32(24)

		// Highlight active filter
		btn_color := if app.filter_mode == modes[i] { selected_color } else { header_bg }
		ctx.draw_rect_filled(x, y - 2, btn_w, btn_h, btn_color)
		ctx.draw_rect_empty(x, y - 2, btn_w, btn_h, grid_color)

		ctx.draw_text(int(x) + 8, int(y), label, color: text_color, size: 14)
		x += btn_w + 10
	}

	// Separator line
	ctx.draw_line(0, ctrl_y + ctrl_h, w, ctrl_y + ctrl_h, grid_color)
}

// draw_details renders the selection details panel
fn draw_details(mut app App) {
	ctx := app.gg
	w := f32(ctx.width)
	h := f32(ctx.height)

	// Details area
	details_y := f32(app.header_height + app.histogram_height + app.timeline_height +
		app.controls_height)
	details_h := h - details_y

	// Background
	ctx.draw_rect_filled(0, details_y, w, details_h, header_bg)

	// Show selected allocation info or instructions
	if app.selected_alloc >= 0 {
		allocs := app.cached_allocs
		if app.selected_alloc < allocs.len {
			alloc := allocs[app.selected_alloc]

			// Format allocation info
			ptr_str := 'Address: 0x${voidptr(alloc.ptr):p}'
			size_str := 'Size: ${profiler.format_bytes(u64(alloc.size))} (${alloc.size} bytes)'
			frame_str := 'Allocated: frame ${alloc.frame}'
			status_str := if alloc.freed {
				'Status: FREED (frame ${alloc.free_frame})'
			} else {
				'Status: LIVE (potential leak)'
			}

			status_color := if alloc.freed { freed_color } else { leak_color }

			mut y := details_y + 15
			ctx.draw_text(20, int(y), ptr_str, color: text_color, size: 16)

			ctx.draw_text(250, int(y), size_str, color: text_color, size: 16)

			ctx.draw_text(500, int(y), frame_str, color: text_color, size: 16)

			ctx.draw_text(700, int(y), status_str, color: status_color, size: 16)

			// Source location if available
			if alloc.file.len > 0 {
				y += 25
				loc_str := 'Source: ${alloc.file}:${alloc.line}'
				ctx.draw_text(20, int(y), loc_str, color: new_alloc_color, size: 16)
			}
		}
	} else {
		// Instructions
		ctx.draw_text(20, int(details_y) + 20,
			'Click on a histogram bar to select a frame, or use keyboard arrows to navigate',
			color: text_color
			size:  16
		)
	}
}

// draw_frame is the main frame callback
pub fn draw_frame(mut app App) {
	if app.gg == unsafe { nil } {
		return
	}
	app.gg.begin()

	// Update data
	if app.demo_mode {
		update_demo_data(mut app)
	} else {
		app.update_cache()
	}

	// Draw all sections
	draw_header(mut app)
	draw_histogram(mut app)
	draw_timeline(mut app)
	draw_controls(mut app)
	draw_details(mut app)

	// Draw status message if in live mode with no data
	if app.live_mode && app.cached_frames.len == 0 {
		ctx := app.gg
		w := f32(ctx.width)
		h := f32(ctx.height)
		ctx.draw_text(int(w / 2) - 200, int(h / 2), app.status_msg,
			color: text_color
			size:  20
		)
	}

	app.gg.end()
}

// Helper: draw a filled triangle
fn draw_triangle_filled(ctx &gg.Context, x1 f32, y1 f32, x2 f32, y2 f32, x3 f32, y3 f32, c gg.Color) {
	ctx.draw_convex_poly([x1, y1, x2, y2, x3, y3], c)
}