package main

import rl "vendor:raylib"
import "core:fmt"
import "core:math"
import "core:os"
import "core:strconv"
import "core:reflect"

waveform_a : []f32 : {0.0, 0.1, 0.5, 0.3, 0.1, -0.1,  0.0, 0.0, 0.0, 0.0, 0.1, 0.3, 0.0}
waveform_b : []f32 : {0.0, 0.0, 0.0, 0.2, 0.4,  0.2, -0.1, 0.0, 0.0, 0.1, 0.3, 0.1, 0.0}

YELLOW : rl.Color = {254, 175, 1,  255}
ORANGE : rl.Color = {238, 123, 26, 255}
RED    : rl.Color = {222, 73,  50, 255}

LERP_SPEED :: 0.20

layout :: struct {
	wave_a_start : rl.Vector2,
	wave_a_end   : rl.Vector2,
	wave_a_amp : f32,
	
	wave_b_start : rl.Vector2,
	wave_b_end   : rl.Vector2,
	wave_b_amp : f32,
	
	grid_opacity : f32,
	grid_highlight_opacity : f32,
	grid_highlight_position : rl.Vector2,
}

slides : [dynamic]layout
state : layout
target : layout
delta : f32

init_slides :: proc() {
	// 0
	current_slide : layout = {
		wave_a_start = {-600, -250},
		wave_a_end   = {600,  -250},
		wave_a_amp = 250,
		
		wave_b_start = {-600, 250},
		wave_b_end   = {600,  250},
		wave_b_amp = 250,
		
		grid_opacity = 0,
		grid_highlight_opacity = 0,
		grid_highlight_position = 0,
	}
	append(&slides, current_slide)
}

lerp :: proc() {
	layout_info := type_info_of(layout)
	
	// Handle the named type wrapper
	actual_info := layout_info
	if named_info, ok := layout_info.variant.(reflect.Type_Info_Named); ok {
		actual_info = named_info.base
	}
	
	// Now cast to struct
	struct_info := actual_info.variant.(reflect.Type_Info_Struct)
	
	for i in 0..<struct_info.field_count {
		field_type := struct_info.types[i]
		field_offset := struct_info.offsets[i]
		
		// Get pointers to the field in both global structs
		state_ptr := rawptr(uintptr(&state) + field_offset)
		target_ptr := rawptr(uintptr(&target) + field_offset)
		
		// Type switch to lerp and write directly back to state
		switch field_type.id {
		case typeid_of(f32):
			from_val := (cast(^f32)state_ptr)^
			to_val := (cast(^f32)target_ptr)^
			(cast(^f32)state_ptr)^ = from_val + (to_val - from_val) * (1.0 - math.pow(LERP_SPEED, delta))
		
		case typeid_of(rl.Vector2):
			from_val := (cast(^rl.Vector2)state_ptr)^
			to_val := (cast(^rl.Vector2)target_ptr)^
			(cast(^rl.Vector2)state_ptr)^ = from_val + (to_val - from_val) * (1.0 - math.pow(LERP_SPEED, delta))
		}
	}
}

normalize :: proc(v : rl.Vector2) -> rl.Vector2 {
	return v / math.sqrt((v.x*v.x) + (v.y*v.y))
}

draw_waveform :: proc(wave : []f32, start : rl.Vector2, end : rl.Vector2, amp : f32) {
	samples := len(wave)
	
	lines := samples-1
	rl.DrawLineEx(start, end, 2, rl.DARKGRAY)
	total_direction := end - start
	step := total_direction / f32(lines)
	perpendicular : rl.Vector2 = normalize({total_direction.y, -total_direction.x})
	
	end_pos : rl.Vector2
	for value, i in wave[:lines] {
		start_base := start + (step*f32(i))
		  end_base := start + (step*f32(i+1))
		start_pos : rl.Vector2 = start_base + (perpendicular*wave[i]*amp)
		  end_pos              =   end_base + (perpendicular*wave[i+1]*amp)
		rl.DrawLineEx(start_pos, end_pos, 4, rl.PURPLE)
		rl.DrawCircleV(start_pos, 5, rl.RED)
	}
	rl.DrawCircleV(end_pos, 5, rl.RED)
}

draw_grid :: proc(first : rl.Vector2, last : rl.Vector2) {
	
}

main :: proc() {
	fast_forward := -1
	if len(os.args) > 1 {
		fast_forward, _ = strconv.parse_int(os.args[1])
	}
	fmt.println("Hello")
	
	// Initialization
	//--------------------------------------------------------------------------------------
	
	slide : int = 0

	rotation : f32 = 0.0

	cameraX : f32 = 0.0
	cameraY : f32 = 0.0
	camera : rl.Camera2D = {
		zoom=1
	}
	
	init_slides()
	
	rl.SetConfigFlags({.WINDOW_RESIZABLE})
	rl.InitWindow(1920, 1080, "BSC 2025 Presentation")
	rl.SetTargetFPS(60)
	rl.SetExitKey(nil)
	
	camera.offset = {f32(rl.GetScreenWidth()) / 2, f32(rl.GetScreenHeight()) / 2}
	camera.zoom = f32(rl.GetScreenHeight())/1080
	
	for !rl.WindowShouldClose() {
		delta = rl.GetFrameTime()
		if rl.IsWindowResized() {
			height := f32(rl.GetScreenHeight())
			width  := f32(rl.GetScreenWidth())
			camera.offset = {width / 2, height / 2}
			camera.zoom = height/1080
		}
		// Input
		//----------------------------------------------------------------------------------
		go_forward := false
		go_back := false
		mousePosition := rl.GetMousePosition()
		left_clicked := rl.IsMouseButtonReleased(rl.MouseButton(0))
		right_clicked := rl.IsMouseButtonReleased(rl.MouseButton(1))
		right_arrow := rl.IsKeyReleased(.RIGHT)
		left_arrow := rl.IsKeyReleased(.LEFT)
		
		go_forward = left_clicked || right_arrow
		go_back = right_clicked || left_arrow
		
		if slide < fast_forward {
			go_forward = true
		} else {
			fast_forward = -1
		}
		
		// Process
		//----------------------------------------------------------------------------------
		
		if go_forward {
			slide += 1
			fmt.printfln("Forward! To slide #{}", slide)
		} else if go_back {
			slide -= 1
			fmt.printfln("Back up! To slide #{}", slide)
		}
		
		target = slides[slide]
		lerp()
		
		// Draw
		//----------------------------------------------------------------------------------
		rl.BeginDrawing()
			rl.ClearBackground(rl.Color{16, 16, 16, 255})
			
			
			rl.BeginMode2D(camera)
			// World-space drawing
			
			
			draw_waveform(waveform_a, state.wave_a_start, state.wave_a_end, state.wave_a_amp)
			draw_waveform(waveform_b, state.wave_b_start, state.wave_b_end, state.wave_b_amp)
			
			
			
			rl.EndMode2D()
			// Screen-space drawing
			
			rl.DrawFPS(rl.GetScreenWidth() - 95, 10)
			
		rl.EndDrawing()
		//----------------------------------------------------------------------------------
		free_all(context.temp_allocator)
	}

	rl.CloseWindow()
}