package synthas_ui

v2 :: [2]f32
rect2 :: struct {x, y, width, height: f32}
col :: [4]u8

rect_get_tl :: #force_inline proc(rect: rect2) -> v2 {return {rect.x, rect.y}}
rect_get_tr :: #force_inline proc(rect: rect2) -> v2 {return {rect.x + rect.width, rect.y}}
rect_get_br :: #force_inline proc(rect: rect2) -> v2 {return {rect.x + rect.width, rect.y + rect.height}}
rect_get_bl :: #force_inline proc(rect: rect2) -> v2 {return {rect.x, rect.y + rect.height}}

rect_grow :: proc(rect: rect2, amount: v2) -> rect2 {
	return {rect.x - amount.x / 2.0, rect.y - amount.y / 2.0, rect.width + amount.x, rect.height + amount.y}
}

ctx: ^Context

Context :: struct {
	origin: v2,
	containers: [dynamic]int,
	container_last_element: [dynamic]int,
	elements: [dynamic]Element,
	same_line: bool,
}

CONTAINER_STACK_SIZE :: 16

Element :: struct {
	area: rect2,
	using config: ElementConfiguration,
	data: ElementData,
	type: ElementType,
}

ElementConfiguration :: struct {
	label: cstring,
	color: col,
	margin, padding: v2,
}

ElementData :: struct {
	using float_input_data: ElementData_FloatInput,
}

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

ElementType :: enum {
	Container,
	Button,
	Slider,
}

Size_Pixels :: distinct f32
Size_Percentage :: distinct f32
Size_Flex :: distinct bool

Size :: union {
	Size_Pixels,
	Size_Percentage,
	Size_Flex,
}

Dimensions :: struct {
	width, height: Size,
}

Axis :: enum {X, Y}

init :: proc(state: ^Context, element_capacity: int, allocator := context.allocator) {
	state.containers = make(type_of(state.containers), 0, CONTAINER_STACK_SIZE, allocator)
	state.container_last_element = make(type_of(state.container_last_element), 0, CONTAINER_STACK_SIZE, allocator)
	state.elements = make(type_of(state.elements), 0, element_capacity, allocator)
}

start :: proc(ui_context: ^Context, origin: v2, size: v2) {
	ctx = ui_context
	ctx.origin = origin
	clear(&ctx.elements)
	clear(&ctx.containers)
	clear(&ctx.container_last_element)
	append(&ctx.elements, Element{
		area = {**origin, **size},
		label = "",
		color = {0, 0, 0, 0},
		margin = {},
		padding = {},
		type = .Container})
	append(&ctx.containers, 0)
	append(&ctx.container_last_element, -1)
}

end :: proc() -> []Element {
	assert(len(ctx.containers) < 2, "Didn't close all containers before ending UI layout mode")
	assert(len(ctx.containers) > 0, "Closed base container before ending UI layout mode")
	elements := ctx.elements[:]
	ctx = nil
	return elements[1:]
}

same_line :: proc() {
	ctx.same_line = true
}

container_begin :: proc(dimensions: Dimensions, config: ElementConfiguration) -> ^Element {
	area := _resolve_element_area(dimensions, config.margin)
	element := _append_element({area = area, config = config, type = .Container})
	container_index := len(ctx.elements) - 1
	append(&ctx.containers, container_index)
	append(&ctx.container_last_element, -1)
	return element
}

container_end :: proc() {
	container := ctx.elements[pop(&ctx.containers)]
	pop(&ctx.container_last_element)
	// TODO: Set flex
	ctx.same_line = false
	outer := get_element_outer_area(container)
}

button :: proc(dimensions: Dimensions, config: ElementConfiguration) -> ^Element {
	area := _resolve_element_area(dimensions, config.margin)
	return _append_element({area = area, config = config, type = .Button})
}

slider :: proc(dimensions: Dimensions, config: ElementConfiguration, data: ElementData_FloatInput) -> ^Element {
	area := _resolve_element_area(dimensions, config.margin)
	return _append_element({area = area, config = config, type = .Slider, data = {float_input_data = data}})
}

_append_element :: proc(element: Element) -> ^Element {
	append(&ctx.elements, element)
	ctx.container_last_element[len(ctx.containers) - 1] = len(ctx.elements) - 1
	return &ctx.elements[len(ctx.elements) - 1]
}

get_element_outer_area :: proc(element: Element) -> rect2 {
	return rect_grow(element.area, element.margin * 2.0)
}

get_element_inner_area :: proc(element: Element) -> rect2 {
	return rect_grow(element.area, -element.padding * 2.0)
}

_resolve_element_area :: proc(dimensions: Dimensions, margin: v2) -> rect2 {
	outer_position := _resolve_element_outer_position()
	outer_size := _resolve_element_outer_size(dimensions)
	return rect_grow(rect2{**outer_position, **outer_size}, -margin * 2.0)
}

_resolve_element_outer_position :: proc() -> v2 {
	if alignment_element := _element_container_previous(); alignment_element != nil {
		area: v2
		if ctx.same_line {
			area = rect_get_tr(get_element_outer_area(alignment_element^))
		} else {
			area = rect_get_bl(get_element_outer_area(alignment_element^))
		}
		ctx.same_line = false
		return area
	}
	return rect_get_tl(get_element_inner_area(_element_previous()^))
}

_resolve_element_outer_size :: proc(dimensions: Dimensions) -> v2 {
	return {_resolve_elemment_outer_size_axis(dimensions.width, .X), _resolve_elemment_outer_size_axis(dimensions.height, .Y)}
}

_resolve_elemment_outer_size_axis :: proc(size: Size, axis: Axis) -> f32 {
	switch value in size {
	case Size_Pixels:
		return cast(f32)value
	case Size_Percentage:
		if container := _container_current(); container != nil {
			inner := get_element_inner_area(container^)
			container_size := inner.width if axis == .X else inner.height
			return container_size * cast(f32)value
		} else {
			panic("Cannot use dimension Size_Percentage without an outer container")
		}
	case Size_Flex:
		return 0.0
	}
	unreachable()
}

_container_current :: proc() -> ^Element {
	return &ctx.elements[ctx.containers[len(ctx.containers) - 1]]
}

_element_previous :: proc() -> ^Element {
	return &ctx.elements[len(ctx.elements) - 1]
}

_element_container_previous :: proc() -> ^Element {
	if previous_index := ctx.container_last_element[len(ctx.containers) - 1]; previous_index != -1 {
		return &ctx.elements[previous_index]
	} else {
		return nil
	}
}