package tafl

import "core:fmt"
//import "core:math"
import rl "vendor:raylib"

tafl_elements : [4096]Tafl
tafl_elements_count : int

tafl_stack    : [4096]int
tafl_stack_depth : int

child_buffer : [4096]int
child_buffer_len : int

temp_child_buffer : [4096]int
temp_child_buffer_len : int // May be inferred by child count, and not be needed

main :: proc() {
	
	{
		tafl(color={.1,.1,.1,1})
		
		{
			tafl(color={.1,.1,.1,1})
			
			{
				tafl(color={.1,.1,.1,1})
				
				{
					tafl(color={.1,.1,.1,1})
				}
				{
					tafl(color={.1,.1,.1,1})
				}
				{
					tafl(color={.1,.1,.1,1})
				}
			}
			
			{
				tafl(color={.1,.1,.1,1})
			}
		}
		
		{
			tafl(color={.1,.1,.1,1})
		}
		{
			tafl(color={.1,.1,.1,1})
			{
				tafl(color={.1,.1,.1,1})
			}
			{
				tafl(color={.1,.1,.1,1})
			}
		}
		{
			tafl(color={.1,.1,.1,1})
		}
	}
}



@(deferred_out=__tafl_close)
tafl :: proc(
	/*width  : int = 0,
	height : int = 0,
	x : int = 0,
	y : int = 0,*/
	sizing_width  : Sizing_Dimension = {.FIT, 0, 0},
	sizing_height : Sizing_Dimension = {.FIT, 0, 0},
	layout : Layout = .LEFT_TO_RIGHT,
	padding : Sides = {0,0,0,0},
	child_gap : int = 0,
	color : Color =  {1,1,0,1},
	) -> ^Tafl{
	
	parent_ptr : ^Tafl = nil
	if tafl_stack_depth > 0 {
		parent_ptr = &tafl_elements[tafl_stack[tafl_stack_depth-1]]
	}
	
	tafl_elements[tafl_elements_count] = {
		/*width = width,
		height = height,
		x = x,
		y = y,*/
		sizing = {sizing_width, sizing_height},
		layout = layout,
		padding = padding,
		child_gap = child_gap,
		
		parent = parent_ptr,
	}
	this_tafl : ^Tafl = &tafl_elements[tafl_elements_count]
	
	tafl_stack[tafl_stack_depth] = tafl_elements_count
	this_tafl.own_index = tafl_elements_count
	this_tafl.own_depth = tafl_stack_depth
	this_tafl.children.index = temp_child_buffer_len
	
	indent(this_tafl.own_depth)
	fmt.printfln("+ Opened tafl {}", this_tafl.own_index)

	tafl_elements_count += 1
	tafl_stack_depth += 1
	
	return this_tafl
}


__tafl_close :: proc(tafl : ^Tafl) {
	
	parent := tafl.parent
	if parent != nil {
		
		tafl.width  += tafl.padding.left + tafl.padding.right
		tafl.height += tafl.padding.top  + tafl.padding.bottom
		
		// Not entirely sure yet, because Nic's video doesn't say you need this
		// max(), but I have a feeling that childless tafls will cause negative
		// total_child_gaps, which would be bad.
		// 
		// ALSO: Wtf? Why are we basing this off of the tafls number of siblings?
		//       I do not understand this.
		total_child_gap := max(parent.children.len - 1, 0) * parent.child_gap
		
		switch parent.layout {
			case .LEFT_TO_RIGHT:
				tafl.width += total_child_gap
				parent.width += tafl.width
				parent.height = max(tafl.height, parent.height)
			case .TOP_TO_BOTTOM:
				tafl.height += total_child_gap
				parent.height += tafl.height
				parent.width   = max(tafl.width, parent.width)
		}
		
	}
	
	for i in 0..<tafl.children.len {
		child_buffer[child_buffer_len+i] = temp_child_buffer[tafl.children.index+i]
		temp_child_buffer_len -= 1
	}
	tafl.children.index = child_buffer_len
	child_buffer_len += tafl.children.len
	
	temp_child_buffer[temp_child_buffer_len] = tafl.own_index
	temp_child_buffer_len += 1
	
	if parent != nil {
		parent.children.len += 1
	} else {
		child_buffer[child_buffer_len] = 0
		child_buffer_len += 1
	}
	
	tafl_stack_depth -= 1
	
	indent(tafl.own_depth)
	fmt.printfln("+ Closed tafl {}\t\tchild_buffer:{}\t\ttemp_child_buffer:{}\tchild_index:{} {}", tafl.own_index, child_buffer[0:child_buffer_len], temp_child_buffer[0:temp_child_buffer_len], tafl.children.index, tafl.children.len)
}



grow_children :: proc(parent : ^Tafl) {
	remainingWidth := parent.width
	remainingHeight := parent.height
	remainingWidth  -= parent.padding.left + parent.padding.right
	remainingHeight -= parent.padding.top  + parent.padding.bottom
	
	for i in 0..<parent.children.len {
		child : ^Tafl = &tafl_elements[child_buffer[parent.children.index+i]]
		remainingWidth -= child.width
	}
	// Do we need to make sure this isn't negative???
	remainingWidth -= (parent.children.len - 1) * parent.child_gap
	
	for i in 0..<parent.children.len {
		child : ^Tafl = &tafl_elements[child_buffer[parent.children.index+i]]
		if child.sizing.width.type == .GROW {
			child.width += remainingWidth
		} else if (child.sizing.height.type == .GROW) {
			child.height += remainingHeight
		}
	}
}





Sizing_Dimension :: struct {
	type : enum{
		FIT,
		GROW,
		FIXED
	},
	min, max : int
}

Layout :: enum {
	LEFT_TO_RIGHT,
	TOP_TO_BOTTOM,
}

Sides :: struct {
	top, bottom, left, right : int
}

Color :: struct {
	r,g,b,a : f32
}

Tafl :: struct {
	width, height : int,
	x, y : int,
	
	own_index : int, // Delete me
	own_depth : int, // Delete me
	
	parent : ^Tafl,
	
	
	
	// style
	
	children : struct {
		index, len : int
	},
	sizing : struct {
		width  : Sizing_Dimension,
		height : Sizing_Dimension,
	},
	layout : Layout,
	padding : Sides,
	child_gap : int,
	color : Color,
}

Tafl_Style :: struct {
	sizing : struct {
		width  : Sizing_Dimension,
		height : Sizing_Dimension,
	},
	layout : Layout,
	padding : Sides,
	child_gap : int,
	color : Color,
}

indent :: proc(x : int) {
	for _ in 0..<x {
		fmt.print("|   ")
	}
}

GROW : Sizing_Dimension : {.GROW, 0, max(type_of(Sizing_Dimension{}.max))}

FIT : Sizing_Dimension : {.FIT, 0, max(type_of(Sizing_Dimension{}.max))}