package main

import rl "libraries/raylib"
import ui "libraries/snths_ui"
import "core:fmt"

UiContainerType :: enum {
	Normal,
	Matrix,
	Scroll,
}

UiElementData_Container :: struct {
	type: UiContainerType,
	thickness: f32,
	scroll: f32,
}

UiElementData_Slider :: struct {
	min, max: f32,
	value:    ^f32,
}

UiElementData_FloatInput :: struct {
	value: ^f32,
	value_string: cstring,
}

FontStyle :: struct {
	font: rl.Font,
	size, spacing: f32
}

ProgramState :: enum {
	Normal,
	Message,
}

ProgramMessageType :: enum {
	ChangeMatrixTypeClearData,
}

@rodata program_messages := [ProgramMessageType]cstring {
	.ChangeMatrixTypeClearData = "Changing the matrix type will delete all current matrices.\nAre you sure you want to do this?",
}

program_set_message_state :: proc(program: ^Program, message: ProgramMessageType) {
	program.state = .Message
	program.message_type = message
}

program: Program

InputFloatField :: [32]byte
MATRIX_POOL_SIZE :: 4096

input_float_field_as_cstring :: proc(field: ^InputFloatField) -> cstring {
	return cstring(&field[0])
}

Program :: struct {
	ui_context: ui.Context,
	matrix_float_pool: []f32,
	matrix_value_string_pool: []InputFloatField,
	matrix_count: int,
	matrix_scroll: f32,
	matrix_scroll_speed: f32,
	grid: Grid,
	font_style: FontStyle,
	state: ProgramState,
	message_type: ProgramMessageType,
}

Grid :: struct {
	area:        rect2,
	inner_area:  rect2,
	zoom:        f32,
}

matrix_pool_max :: proc() -> int {
	return len(program.matrix_float_pool) / 9
}

matrix_pool_get_mat3 :: proc() -> ^mat3 {
	assert(program.matrix_count + 1 < matrix_pool_max(), "Max matrix count exceeded")
	mat := cast(^mat3)&program.matrix_float_pool[program.matrix_count * 9]
	program.matrix_count += 1
	return mat
}

program_init :: proc(allocator := context.allocator) {
	program.matrix_float_pool = make(type_of(program.matrix_float_pool), MATRIX_POOL_SIZE)
	program.matrix_value_string_pool = make(type_of(program.matrix_value_string_pool), MATRIX_POOL_SIZE)
	program.matrix_scroll_speed = 32.0
	program.font_style = {
		font = rl.GetFontDefault(),
		size = 16.0,
		spacing = 1.0
	}
	program.grid = {
		area = {0, 0, WINDOW_WIDTH, WINDOW_HEIGHT},
		inner_area = {-1, -1, 2, 2},
		zoom = 1.0,
	}
	ui.init(&program.ui_context, 4000, allocator)
}

program_update :: proc() {
	if rl.IsKeyPressed(.ENTER) {
		matrix_pool_get_mat3()
	}
	ui_elements := program_build_ui()
	if rl.IsKeyPressed(.TAB) {
		ui.focus_next_element(&program.ui_context)
	}
	program_render_ui(&program.ui_context, ui_elements)
}

program_build_ui :: proc() -> []ui.Element {
	ui.start(&program.ui_context, {0, 0}, {WINDOW_WIDTH, WINDOW_HEIGHT})
	top_bar_container_config := ui.ElementConfiguration {margin = V2_ONE * 4.0}
	top_bar_container := ui.container_begin({ui.Size_Percentage(1.0), ui.Size_Pixels(48.0)}, top_bar_container_config)
	top_bar_inner_height := ui.get_element_inner_area(top_bar_container^).height
	top_bar_button_dimensions := ui.Dimensions {ui.Size_Pixels(top_bar_inner_height), ui.Size_Pixels(top_bar_inner_height)}
	top_bar_button_config := ui.ElementConfiguration {margin = V2_ONE * 4}
	{
		config := top_bar_button_config
		config.label = "+"
		ui.button(top_bar_button_dimensions, config)
		config.label = "-"
		ui.same_line()
		ui.button(top_bar_button_dimensions, config)
	}
	ui.container_end()

	side_bar_container_config := ui.ElementConfiguration {margin = V2_ONE * 4.0}
	side_bar_container_data := new(UiElementData_Container, context.temp_allocator)
	side_bar_container_data^ = {type = .Scroll, scroll = program.matrix_scroll}
	matrix_container := ui.container_begin({ui.Size_Percentage(0.2), ui.Size_PercentageRemainder(1.0)}, side_bar_container_config, side_bar_container_data)
	for i in 0..<program.matrix_count {
		container_config := ui.ElementConfiguration{margin = V2_ONE * 8.0, label = fmt.ctprintf("Matrix %d", i)}
		container_dimensions := ui.Dimensions {ui.Size_Percentage(1.0), ui.Size_Pixels(112.0)}
		mat := program.matrix_float_pool[i * 9 : i * 9 + 9]
		value_strings := program.matrix_value_string_pool[i * 9 : i * 9 + 9]
		ui_mat3(mat, value_strings, container_dimensions, container_config)
	}
	ui.container_end()
	elements := ui.end()

	mouse := rl.GetMousePosition()
	if rect_has_point(rect2(matrix_container.area), mouse) {
		program.matrix_scroll = max(0, program.matrix_scroll - rl.GetMouseWheelMove() * program.matrix_scroll_speed)
	}

	return elements
}

ui_mat3 :: proc(mat: []f32, value_strings: []InputFloatField, dimensions: ui.Dimensions, config: ui.ElementConfiguration, allocator := context.temp_allocator) {
	container_data := new(UiElementData_Container, allocator)
	container_data^ = {type = .Matrix, thickness = 2.0}
	ui.container_begin(dimensions, config, container_data)
		matrix_input_config := ui.ElementConfiguration {margin = V2_ONE * 4.0}
		matrix_input_dimensions := ui.Dimensions {ui.Size_Percentage(1.0 / 3.0), ui.Size_Percentage(1.0 / 3.0)}
		#unroll for i in 0..<3 {
			#unroll for j in 0..<3 {
				data := new(UiElementData_FloatInput, allocator)
				index := i * 3 + j
				data^ = {value = &mat[index], value_string = input_float_field_as_cstring(&value_strings[index])}
				ui.input_float(matrix_input_dimensions, matrix_input_config, data)
				ui.same_line()
			}
			program.ui_context.same_line = false
		}
	ui.container_end()
}

program_render_ui :: proc(ctx: ^ui.Context, elements: []ui.Element) {
	scissor_container: ^ui.Element

	defer {
		if scissor_container != nil {
			rl.EndScissorMode()
			scissor_container = nil
		}
	}

	for &element in elements {
		offset: v2
		if scissor_container != nil {
			if element.id.container_index < scissor_container.id.container_index {
				rl.EndScissorMode()
				scissor_container = nil
			} else {
				offset.y = -(cast(^UiElementData_Container)scissor_container.data).scroll
			}
		}

		area := rect_translate(rl.Rectangle(element.area), offset)
		switch element.type {
		case .Container:
			dim := rl.Color {0, 0, 0, 192}
			if element.data != nil {
				data := cast(^UiElementData_Container)element.data
				switch data.type {
				case .Normal:
					rl.DrawRectangleRounded(area, 0.1, 4.0, dim)
					rl.GuiGroupBox(area, element.label)
				case .Matrix:
					matrix_area := ui.rect_grow(ui.rect2(area), element.margin / 2.0)
					tl, tr, br, bl := ui.rect_get_corners(matrix_area)
					col := rl.WHITE
					hook_length: f32 = 4.0
					rl.DrawLineEx(tl, bl, data.thickness, col)
					rl.DrawLineEx(tl, tl + V2_RIGHT * hook_length, data.thickness, col)
					rl.DrawLineEx(bl, bl + V2_RIGHT * hook_length, data.thickness, col)
					rl.DrawLineEx(tr, br, data.thickness, col)
					rl.DrawLineEx(tr, tr + V2_LEFT * hook_length, data.thickness, col)
					rl.DrawLineEx(br, br + V2_LEFT * hook_length, data.thickness, col)
				case .Scroll:
					rl.DrawRectangleRounded(area, 0.1, 4.0, dim)
					rl.GuiGroupBox(area, element.label)
					scissor_container = &element
					rl.BeginScissorMode(**rect2_to_irect2(area))
				}
			} else {
				rl.DrawRectangleRounded(area, 0.1, 4.0, dim)
				rl.GuiGroupBox(area, element.label)
			}
		case .Button:
			rl.GuiButton(area, element.label)
		case .Slider:
			data := cast(^UiElementData_Slider)element.data
			rl.GuiSlider(area, element.label, "", data.value, data.min, data.max)
		case .InputFloat:
			data := cast(^UiElementData_FloatInput)element.data
			if rl.GuiValueBoxFloat(area, element.label, data.value_string, data.value, ui.is_element_focused(ctx, element)) == 1 {
				ui.focus_element(ctx, element)
			}
		}
	}
}