package main

import rl "vendor:raylib"

import "common"
import "core:fmt"
import inf "infrastructure"

// PLAN AREA
// TODO implement deleting of roads

Simulator :: struct {
	// Stores all nodes
	nodes: [dynamic]inf.Node,
	// Stores all roads
	roads: [dynamic]inf.Road,
	// Tracks the temporary node location
	temp_node_index: Maybe(u32),
	// Tracks the selected road
	highlighted_road: Maybe(u32),
	// Tracks whether the user wishes to see node's snapping radius
	show_details: bool,
	// Tracks whether after placing a road new one will start being placed
	auto_continue: bool,
	// Tracks whether the delete mode is activated
	delete_mode: bool,
}

// Destructor
deinit :: proc(self: ^Simulator) {
	self.temp_node_index = nil
	
	delete(self.roads)
	
	for &node in self.nodes {
		inf.node_deinit(&node)
	}
	delete(self.nodes)
}

// Functionality that runs every tick regardless of input
update :: proc(self: ^Simulator, pos: rl.Vector2) {
	update_highlighted_road(self, pos)
}

// Public input function that gets called in graphics library loop
handle_input :: proc(self: ^Simulator, pos: rl.Vector2) {
	handle_keyboard_input(self)
	handle_mouse_input(self, pos)
}

// General keyboard input event handler
@(private="file")
handle_keyboard_input :: proc(self: ^Simulator) {
	self.show_details = rl.IsKeyDown(.LEFT_ALT)
	self.auto_continue = rl.IsKeyDown(.LEFT_CONTROL)
	self.delete_mode = rl.IsKeyDown(.LEFT_SHIFT)
	
	if (rl.IsKeyReleased(.C)) {
		self.temp_node_index = nil
		clear(&self.roads)
		clear(&self.nodes)
	}
}

// Generally mouse event handler
@(private="file")
handle_mouse_input :: proc(self: ^Simulator, pos: rl.Vector2) {
	if (rl.IsMouseButtonReleased(.LEFT)) {
		left_click_event(self, pos)
	} else if (rl.IsMouseButtonReleased(.RIGHT)) {
		right_click_event(self)
	}
}

// Handles left click functionality
@(private="file")
left_click_event :: proc(self: ^Simulator, pos: rl.Vector2) {
	// DELETE
	if road, ok := self.highlighted_road.?; ok && self.delete_mode {
		delete_road(self, road)
		return
	}
	
	// BUILD
	cur_node_index := get_node_or_new(self, pos)
	
	if temp, ok := self.temp_node_index.?; ok {
		// If both values are identical this means the user has to create a new road using the same nodes
		if cur_node_index == temp do return
		data := get_intersecting_roads(self, temp, cur_node_index)
		split_roads_by_points(self, data, temp, cur_node_index)
		
		self.temp_node_index = self.auto_continue ? cur_node_index : nil
		return
	}
	
	self.temp_node_index = cur_node_index
}

// Handles right click functionality
@(private="file")
right_click_event :: proc(self: ^Simulator) {
	if self.temp_node_index == nil do return
	index := self.temp_node_index.?
	
	temp_node := &self.nodes[index]
	self.temp_node_index = nil
	if len(temp_node.roads) > 0 do return	
	
	inf.node_deinit(temp_node)
	// We can safely call the remove here as the only way it will get deleted is if it's the only node aka it was created during our creation process
	// Consequently this means that it will always be on last place and never swapped with anything
	unordered_remove(&self.nodes, index)
}

// Main drawing function
draw :: proc(self: ^Simulator, pos: rl.Vector2) {
	rl.ClearBackground(common.BACKGROUND_COLOUR)
	
	// draw roads
	for &road, index in self.roads {
		start := road.nodes[0]
		end := road.nodes[1]
		
		road_colour: rl.Color
		if road, ok := self.highlighted_road.?; ok && road == u32(index) && self.delete_mode {
			road_colour = common.ROAD_HIGHLIGHT_COLOUR
		} else do road_colour = common.ROAD_COLOUR
		
		rl.DrawLineEx(self.nodes[start].pos, self.nodes[end].pos, common.ROAD_SIZE, road_colour)
	}
	
	// draw nodes
	for &node in self.nodes {
		// draws the snapping radius if key is held down
		if self.show_details do rl.DrawCircleV(node.pos, common.NODE_SNAP_RADIUS * common.NODE_RADIUS, common.NODE_SNAP_COLOUR)
		// draws the node
		rl.DrawCircleV(node.pos, common.NODE_RADIUS, common.NODE_DONE_COLOUR)
	}
	
	// draw temp road if exists
	if val, ok := self.temp_node_index.?; ok {
		rl.DrawLineEx(self.nodes[val].pos, pos, common.ROAD_SIZE, common.ROAD_COLOUR)
		rl.DrawCircleV(pos, common.NODE_RADIUS, common.NODE_BUILD_COLOUR)
	}
	
	draw_ui(self)
}

@(private="file")
draw_ui :: proc(self: ^Simulator) {
	entity_count := fmt.ctprintf("Nodes: %d\nRoads: %d", len(self.nodes), len(self.roads))
	rl.DrawText(entity_count, i32(common.WIDTH - 13 * len(entity_count)), common.HEIGHT - 2 * common.TEXT_SIZE, common.TEXT_SIZE, common.TEXT_COLOUR)
}

// This function only returns the index to the node or if it doesn't exist bool in the tuple is false
@(private="file")
get_node_index_if_exists :: proc(self: ^Simulator, pos: rl.Vector2) -> (u32, bool) {
	for &node, index in self.nodes {
		if inf.node_within_snapping_radius(&node, pos) do return u32(index), true
	}
	
	return 0, false
}

// Given position, the function will attempt the return the pointer to the node in near vicinity, 
// or if unsuccesful manually creating the node based on the position in the list and then returning the pointer to it
@(private="file")
get_node_or_new :: proc(self: ^Simulator, pos: rl.Vector2) -> u32 {
	if node, ok := get_node_index_if_exists(self, pos); ok do return node
	
	node := inf.node_init(pos)
	append(&self.nodes, node)
	
	return u32(len(self.nodes) - 1)
}

// Returns data about roads that intersect the given 2 nodes (points)
@(private="file")
get_intersecting_roads :: proc(self: ^Simulator, start: u32, end: u32) -> []common.Intersection_Data {
	intersections: [dynamic]common.Intersection_Data
	collision_point: rl.Vector2
	
	outer: for road, index in self.roads {
		road_start_node := road.nodes[0]
		road_end_node := road.nodes[1]
		
		if !rl.CheckCollisionLines(self.nodes[start].pos, self.nodes[end].pos, self.nodes[road_start_node].pos, self.nodes[road_end_node].pos, &collision_point) do continue
		
		// Save the collision info
		data := common.Intersection_Data {
			road = u32(index),
			point = collision_point
		}
		
		node := inf.node_init(data.point)
		// Here we check if the intersection points that were recorded before, are already within snapping radius of our current intersected point
		for collision in intersections {
			if (inf.node_within_snapping_radius(&node, collision.point)) do continue outer
		}
		
		// Here we check if our new intersected point node is too close to already established nodes
		if _, ok := get_node_index_if_exists(self, data.point); ok do continue
		
		append(&intersections, data)
	}
	
	return intersections[:]
}

// Given intersection data, the function splits all existing roads and adds new nodes on intersections
@(private="file")
split_roads_by_points :: proc(self: ^Simulator, intersections: []common.Intersection_Data, start: u32, end: u32) {
	if len(intersections) == 0 {
		add_road(self, start, end)
		return
	}
	
	first_intersection_node := get_node_or_new(self, intersections[0].point)
	add_road(self, start, first_intersection_node)
	
	for i in 0..<len(intersections) {
		intersection := intersections[i]
		// The node created at the point of intersection
		new_node := get_node_or_new(self, intersection.point)
		
		// Pointer to the node that borders the road that was intersected
		// This node and the new node will become nodes for the new road being created
		road_old_node := self.roads[intersection.road].nodes[1]
		
		// The old road that was intersected now borders the new node
		// and the old node is removed from the road's end node reference,
		// as is the end node's road reference
		ok := update_node_reference(self, intersection.road, road_old_node, new_node)
		if !ok do fmt.panicf("Failed to update the node reference to the Road ID=%d, because I couldn't find old reference ID=%d\n", 
			intersection.road, road_old_node)
		
		// This adds the road (to the road manager) and also references the road at both nodes (pointers)
		add_road(self, new_node, road_old_node)
		
		if (i == len(intersections) - 1) do continue
		
		node_start := get_node_or_new(self, intersection.point)
		node_end := get_node_or_new(self, intersections[i + 1].point)
		
		add_road(self, node_start, node_end)
	}
	
	last_intersection_road := intersections[len(intersections) - 1]
	last_intersection_node := get_node_or_new(self, last_intersection_road.point)
	add_road(self, last_intersection_node, end)
}

// Adds a new road into roads array, start and end are indexes of existing nodes
@(private="file")
add_road :: proc(self: ^Simulator, start: u32, end: u32) {
	road := inf.road_init(start, end)
	append(&self.roads, road)
	
	road_index := u32(len(self.roads) - 1)
	append(&self.nodes[start].roads, road_index)
	append(&self.nodes[end].roads, road_index)
}

// Attempts to update node reference to the road;
// Returns false if the old reference doesn't exist
@(private="file")
update_node_reference :: proc(self: ^Simulator, road_to_update: u32, old_ref: u32, new_ref: u32) -> bool {
	road := &self.roads[road_to_update]
	
	for i in 0..<len(road.nodes) {
		if road.nodes[i] != old_ref do continue
		
		road.nodes[i] = new_ref
		inf.node_unreference_road(&self.nodes[old_ref], road_to_update)
		append(&self.nodes[new_ref].roads, road_to_update)
		
		return true
	}
	
	return false
}

// Keeps track of the selected/highlighted road
@(private="file")
update_highlighted_road :: proc(self: ^Simulator, pos: rl.Vector2) {
	for road, index in self.roads {
		start_node := self.nodes[road.nodes[0]]
		end_node := self.nodes[road.nodes[1]]
		
		if !rl.CheckCollisionPointLine(pos, start_node.pos, end_node.pos, common.ROAD_SIZE) do continue
		
		self.highlighted_road = u32(index)
		return
	}
	
	self.highlighted_road = nil
}

@(private="file")
delete_road :: proc(self: ^Simulator, road_to_delete: u32) {
	// First we need to unreference this road from surrounding nodes and then delete those nodes IF this was the last road connection
	road := self.roads[road_to_delete]
	// Pointers to the nodes bordering the road we wish to delete
	start_node := &self.nodes[road.nodes[0]]
	end_node := &self.nodes[road.nodes[1]]
	
	// We unreference the road from the nodes bordering the road
	start_unref := inf.node_unreference_road(start_node, road_to_delete)
	end_unref := inf.node_unreference_road(end_node, road_to_delete)
	if !start_unref || !end_unref do fmt.panicf("Failed to unreference one (or both) of the nodes of the Road ID=%d\n", road_to_delete)
	
	// Now we delete the road
	delete_entity(self, road_to_delete, .Road)
	
	// After the remove we have to replace references
	if len(start_node.roads) == 0 {
		if result, ok := delete_entity(self, road.nodes[0], .Node); ok && result[0] == road.nodes[1] {
			road.nodes[1] = result[1]
		}
	}
	
	if len(end_node.roads) == 0 do delete_entity(self, road.nodes[1], .Node)
}

// Function that allows deleting of any entity within the entity list (nodes, roads, etc.) while ensuring valid references
// Returns swapped entities if they exist
delete_entity :: proc(self: ^Simulator, entity_index: u32, type: common.Entity) -> ([2]u32, bool) {
	mlen: u32
	// Stores data about old and new index in case the deleted index is not last, meaning the swap occurs
	index_change: [2]u32
	// Tracks whether the removal of node/road will cause a swap in the (dynamic) array 
	// and thus forcing the pre-swapped reference to be updated
	swap_made: bool
	
	switch type {
	case .Node:
		mlen = u32(len(self.nodes))
	case .Road:
		mlen = u32(len(self.roads))
	}
	
	last := mlen - 1
	if entity_index != last {
		index_change = {last, entity_index}
		swap_made = true
	}
	
	switch type {
	case .Node:
		unordered_remove(&self.nodes, entity_index)
		
		if !swap_made do return {}, false
		for &road in self.roads do inf.road_update_node_reference(&road, index_change[0], index_change[1])
		
		return index_change, true
		
	case .Road:
		unordered_remove(&self.roads, entity_index)
		
		if !swap_made do return {}, false
		
		for &node in self.nodes do inf.node_update_road_reference(&node, index_change[0], index_change[1])
		
		return index_change, true
	}
	
	return {}, false
}