package main
import "../lib/oui"

import "core:fmt"
import "core:math"
import "core:slice"
import "core:runtime"
import "core:strings"
import rl "vendor:raylib"

UBUNTU_MONO := #load("../res/UbuntuMono-Regular.ttf")

font : rl.Font
big_font : rl.Font
small_font : rl.Font

c0 : ^oui.Context

main :: proc() {

	// TODO: Replace the dynamic array of Workday-pointers with
	//       an actual array of Workdays, plus a length variable
	//       for cache reasons, and to simplify the process of
	//       adding new Workdays to the array.

	workdays: [dynamic]^Workday
	resize(&workdays, 3)

	workday0: = new_workday({10, 22, 3, 5, 2023},
	                        {00, 08, 4, 5, 2023},
	                        {00, 22, 4, 5, 2023},
	                        {30, 21, 4, 5, 2023})
	workdays[0] = &workday0

	workday1: = new_workday(workday0.wrap,
	                        {00, 08, 5, 5, 2023},
	                        {30, 15, 5, 5, 2023},
	                        {30, 16, 5, 5, 2023})
	workdays[1] = &workday1

	workday2: = new_workday(workday1.wrap,
	                        {00, 12, 6, 5, 2023},
	                        {15, 17, 6, 5, 2023},
	                        {00, 17, 6, 5, 2023})
	workdays[2] = &workday2

	slice.sort_by(workdays[:], lessWorkdayPtr)

	//call_text: cstring = "00:00"
	call_text: = make([]byte, 6)
	defer delete(call_text)
	call_text[len(call_text)-1] = 0
	//wrap_text: cstring = "00:00"
	wrap_text: = make([]byte, 6)
	defer delete(wrap_text)
	wrap_text[len(wrap_text)-1] = 0
	
	date_text: = make([]byte, len(toString(workday0.call))+1 )
	defer delete(date_text)
	wrap_text[len(wrap_text)-1] = 0

	total_sum: cstring = "3500 NOK + 26%"
	inc_soc: cstring = "4276 NOK"
	text_height: f32


	using rl
	width: i32 = 700
	height: i32 = 400

	InitWindow(width, height, "satscalc")
	defer CloseWindow()

	SetTargetFPS(60)
	SetWindowState({.WINDOW_RESIZABLE})
	SetWindowMinSize(width, height)

	// Loading fonts - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	font_size :: 18
	font = LoadFontFromMemory(".ttf", raw_data(UBUNTU_MONO), i32(len(UBUNTU_MONO)), font_size, nil, 0)
	defer UnloadFont(font)

	small_font_size :: 14
	small_font = LoadFontFromMemory(".ttf", raw_data(UBUNTU_MONO), i32(len(UBUNTU_MONO)), small_font_size, nil, 0)
	defer UnloadFont(small_font)

	big_font_size :: 24
	big_font = LoadFontFromMemory(".ttf", raw_data(UBUNTU_MONO), i32(len(UBUNTU_MONO)), big_font_size, nil, 0)
	defer UnloadFont(big_font)
	
	// oui stuff
	
	c0 = new(oui.Context)
	defer free(c0)
	oui.context_init(c0, 1028, 1028 * 8)
	defer oui.context_destroy(c0)
	
	// Setting up the timelines

	for day in workdays {
		beginning: Moment = {0, 0, day.call.day, day.call.month, day.call.year}
		
		fmt.println("\nNew day!")
		
		for each_block, i in day.blocks {
			if i == day.total_timeblocks do break
			day.fractions[i].start = daycount(diff(beginning, each_block.start))
			day.fractions[i].end = daycount(diff(beginning, each_block.end))
			fmt.println(day.fractions[i])
		}
	}

	for !WindowShouldClose() { // MAIN LOOP ---- MAIN LOOP ---- MAIN LOOP ---- MAIN LOOP

		free_all(context.temp_allocator)

		if IsWindowResized() {
			height = GetScreenHeight()
			width = GetScreenWidth()
			fmt.println("Resized to:", width, 'x', height)
		}
		
		
		// TODO: Find a good way to calculate the size and location
		//       of all the timeblocks in every day.
		//       
		//       I know I want them to scale with the window, and
		//       that the width of them should be normalized.
		//       If you add a day that lasts until 4 AM the morning
		//       after, all the other days should scale down to keep
		//       the vertical alignment of time accurate
		//       
		// TODO: Hovering over a timeblock should make it pulse softly
		//       clicking will put a white border around the timeblock,
		//       and display information about the block in the
		//       bottom left of the screen.
			
		mousePosition: = rl.GetMousePosition()
		oui.set_cursor(c0, int(mousePosition.x), int(mousePosition.y))
		if rl.IsMouseButtonPressed(rl.MouseButton(0))  do oui.set_button(c0, .Left, true)
		if rl.IsMouseButtonReleased(rl.MouseButton(0)) do oui.set_button(c0, .Left, false)
		
		// DRAW
		// ------------------------------------------
		BeginDrawing()
			
			ClearBackground(rl.RED)
			
when true {
			// hotloop
			oui.begin_layout(c0)
				
				
				master_container := panel()
					master_container.id = oui.push_id(c0, "big_mr_boss_man") // Make ID for master thing just because.
					                                                         // Does not need to be freed because master.
					master_container.layout = .Absolute
					master_container.layout_size = {int(GetScreenWidth()), int(GetScreenHeight())}
				
				{
				top_bar := panel_line(master_container, theme.background_bar, 30)
					top_bar.id = oui.push_id(c0, "small_boie") // Make ID for anything that will have children.
					defer oui.pop_id(c0)                       // These need to be pop'ed before the next item at the same level in the hierachy.
					top_bar.layout_margin = 6
					
				oui.item_insert(top_bar, label("Date", font, .Left))
				oui.item_insert(top_bar, label("Calltime", font, .Left))
				oui.item_insert(top_bar, label("Lunch", font, .Left))
				}
				
				{
				bottom_bar := panel(theme.background_bar)
					bottom_bar.id = oui.push_id(c0, "not_small_boie")
					defer oui.pop_id(c0)
				    bottom_bar.layout_cut_children = .Left
					master_container.layout_cut_children = .Bottom
					bottom_bar.layout_size.y = 50
					oui.item_insert(master_container, bottom_bar)
				}
				
				{
				middle_section := panel(theme.background)
					middle_section.id = oui.push_id(c0, "middle_section")
					defer oui.pop_id(c0)
					middle_section.layout_margin = 10 // Spacing from edges
					middle_section.layout_cut_gap = 5 // Spacing between children
					master_container.layout_cut_children = .Fill
					oui.item_insert(master_container, middle_section)
					
					// To loop over the members of a struct you need to do this goofy shit:
					info := runtime.type_info_base(type_info_of(Theme))
					st := info.variant.(runtime.Type_Info_Struct)
					root := uintptr(&theme)
					for offset, i in st.offsets {
						
						line := panel_line(middle_section, theme.background, 25)
							line.layout_cut_gap = 10
							line.id = oui.push_id(c0, fmt.tprintf("line_%d", i))
							defer oui.pop_id(c0)
							
							oui.item_insert(line, label(st.names[i], font, ))
							
							// To then access the member of the struct you're looping over
							// you need to do this shit:
							//                  v------------------------v
							color_sliders(line, cast(^Color) (root+offset))
					}
					
					output_theme_button := button("output theme", 100)
					oui.item_insert(middle_section, output_theme_button)
					if oui.is_clicked(c0, output_theme_button) do fmt.printf("%#v", theme)
				}
					
				
			oui.end_layout(c0)
			
				ui_draw(master_container)
			// DRAW HERE OR BELOW
			oui.process(c0)
			
} else {
			DrawTextEx(font, "Date", {20, 8}, font_size, 0, RAYWHITE);
			DrawTextEx(font, "Calltime", {105, 8}, font_size, 0, RAYWHITE);
			DrawTextEx(font, "Wraptime", {f32(width)-83, 8}, font_size, 0, RAYWHITE);
			
			for day, i in workdays {
				
				// TODO: The fractions held inside Workday-s needs to come in pairs,
				//       just like moments come as pairs in timeblocks.
				//       Because that will let us store both the beginning and ending
				//       of timeblocks, which is a simple way to take care of reading
				//       out-of-bounds and will make it possible to render lunch breaks
				//       
				//      (At least, given how lunch breaks are currently implemented,
				//       as holes in the workday)

				DrawRectangle(10, DAY_HEIGHT*i32(i+1)-4, width-20, DAY_HEIGHT-1, theme.background_top)
				for block, j in day.blocks {
					if j == day.total_timeblocks do break
					block_color: = GREEN
					switch {
						case block.value > 2.1:
							block_color = PURPLE
						case block.value > 1.6:
							block_color = RED
						case block.value > 1.1:
							block_color = ORANGE
					}
					
					DrawRectangle(TIMELINE_START+i32(math.round(day.fractions[j].start*f32(width+TIMELINE_END-TIMELINE_START))),
					              DAY_HEIGHT*i32(i+1)-4,
					              i32(math.round(f32(width+TIMELINE_END-TIMELINE_START)*(day.fractions[j].end-day.fractions[j].start)+0.5)),
					              DAY_HEIGHT-1,
					              block_color)
				}
				
				copy(call_text, clockprint(day.call))
				copy(wrap_text, clockprint(day.wrap))
				copy(date_text, toString(day.call))
				
				text_height = math.round(f32(i+1)*DAY_HEIGHT+(DAY_HEIGHT-font_size)*0.25)
				
				DrawTextEx(font, cstring(&date_text[0]), {20, text_height}, font_size, 0, RAYWHITE);
				DrawTextEx(font, cstring(&wrap_text[0]), {f32(width)-70, text_height}, font_size, 0, RAYWHITE);
				
				if i == len(workdays)-1 {
					DrawTextEx(big_font, "+", {20, DAY_HEIGHT*f32(i+2)}, big_font_size, 0, RAYWHITE)
				}
			}
			
			DrawRectangle(0, height-50, width+10, 60, theme.background_top)
			
			DrawTextEx(small_font,	total_sum,	{f32(width)-120, f32(height)-43}, small_font_size, 0, RAYWHITE);
			DrawTextEx(big_font,	inc_soc,	{f32(width)-120, f32(height)-29}, big_font_size, 0, RAYWHITE);
}
		EndDrawing()
	}
}