import "luxe: io" for IO
import "luxe: world" for World, Entity, Modifiers, ModifierSystem, Transform
import "luxe: draw" for Draw, PathStyle, LineCap
import "luxe: color" for Color
import "luxe: render" for Geometry, Primitive, IndexType, Render
import "luxe: assets" for Assets, Strings
import "luxe: bytes" for Uint16, Floats

import "queue" for Queue

import "modifiers/trail/trail.modifier" for ModifierData
import "luxe: math" for Math

//User facing API
//This is what the user of your modifier will interact with
class Trail {

	static create(entity) { Modifiers.create(This, entity) }
	static destroy(entity) { Modifiers.destroy(This, entity) }
	static has(entity) { Modifiers.has(This, entity) }

	static reset(entity){
		Modifiers.get_system(This, entity).reset(entity )
	}

} //Trail

#hidden
class Point {
	construct new(pos: Vec, up: Vec){
		_pos = pos
		_up = up
	}

	pos{_pos}
	up{_up}
}

#hidden
class TrailData {
	construct new(geometry, indices, positions, colors, uvs){
		_geometry = geometry
		_index_buf = indices
		_pos_buf = positions
		_col_buf = colors
		_uv_buf = uvs

		_progress = 0
		_progress_since_last_point = 0
		_points = Queue.new()
	}

	geometry{_geometry}
	index_buffer{_index_buf}
	position_buffer{_pos_buf}
	color_buffer{_col_buf}
	uv_buffer{_uv_buf}

	points: Queue {_points}

	progress: Num {_progress}
	progress=(v){_progress=v}

	progress_since_last_point: Num {_progress_since_last_point}
	progress_since_last_point=(v){_progress_since_last_point = v}
	
	previous_pos: Vec {_previous_pos}
	previous_pos=(v){_previous_pos=v}

	previous_up: Vec {_previous_up}
	previous_up=(v){_previous_up}
}

//Your modifier system implementation.
//This speaks to the engine and your user facing API
//to do the actual work. You'll get notified when things change
//in the world and respond to them here.
class TrailSystem is ModifierSystem {

	construct new() {
		//called when your system is first created.
		_instance_data = {}
	}

	init(world) {
		_world = world
		_draw = Draw.create(World.render_set(world))
		var edge_debug = PathStyle.new()
		edge_debug.color = [1,1,1,1]
		edge_debug.thickness = 2
		edge_debug.cap = LineCap.round
		_debug_edge_style = edge_debug

		var path_debug = PathStyle.new()
		path_debug.color = [1, 0, 0, 1]
		path_debug.thickness = 1
		_debug_path_style = path_debug

		var mesh_debug = PathStyle.new()
		mesh_debug.color = [0, 0, 1, 1]
		mesh_debug.thickness = 0.5
		_debug_mesh_style = mesh_debug
	}

	reset(entity: Entity){
		_instance_data[entity].points.clear()
	}

	destroy() {
		Draw.destroy(_draw)
	}

	attach(entity, data: ModifierData) {
		var material_id = Strings.get(data.material)
		var material = Assets.material(material_id)

		var index_buffer = create_index_buffer(data.subdivisions_length, data.subdivisions_width)
		var geo = Geometry.create(Primitive.triangle, material, (data.subdivisions_length - 1) * 6, IndexType.u16, index_buffer)

		var pos_buffer = create_position_buffer(data.edge_length, data.length, data.subdivisions_length, data.subdivisions_width)
		Geometry.set_vertex_buffer(geo, 0, pos_buffer)

		var color_buffer = create_color_buffer(data.subdivisions_length, data.subdivisions_width)
		Geometry.set_vertex_buffer(geo, 1, color_buffer)

		var uv_buffer = create_uv_buffer(data.subdivisions_length, data.subdivisions_width)
		Geometry.set_vertex_buffer(geo, 2, uv_buffer)

		World.render_set_add(_world, geo, entity)

		_instance_data[entity] = TrailData.new(geo, index_buffer, pos_buffer, color_buffer, uv_buffer)
	}

	create_position_buffer(height: Num, length: Num, subdivs_len: Num, subdivs_width: Num): VertexBuffer{
		var raw = Floats.new(4 * subdivs_width * subdivs_len)
		return Render.create_vertex_buffer(raw, raw.length)
	}

	create_color_buffer(subdivs_len: Num, subdivs_width: Num): VertexBuffer{
		var raw = Floats.new(4 * subdivs_width * subdivs_len)
		for(i in 0...subdivs_len){
			for(ii in 0...subdivs_width){
				raw[i*subdivs_width*4 + ii*4 + 0] = 1
				raw[i*subdivs_width*4 + ii*4 + 1] = 1
				raw[i*subdivs_width*4 + ii*4 + 2] = 1
				raw[i*subdivs_width*4 + ii*4 + 3] = 1
			}
		}
		//var arr = (0...(raw.size/4)).map{|i|"[%(raw[i*4]), %(raw[i*4+1]), %(raw[i*4+2])]"}.join("\n")
		//System.print(arr)
		return Render.create_vertex_buffer(raw, raw.length)
	}

	create_uv_buffer(subdivs_len: Num, subdivs_width: Num): VertexBuffer{
		var raw = Floats.new(2 * subdivs_width * subdivs_len)
		for(i in 0...subdivs_len){
			var x = i / (subdivs_len - 1)
			for(ii in 0...subdivs_width){
				var y = ii / (subdivs_width - 1)
				raw[i*2*subdivs_width + ii*2 + 0] = x
				raw[i*2*subdivs_width + ii*2 + 1] = y
			}
		}
		//var arr = (0...(raw.size/2)).map{|i|"[%(raw[i*2]), %(raw[i*2+1])]"}.join("\n")
		//System.print(arr)
		return Render.create_vertex_buffer(raw, raw.length)
	}

	create_index_buffer(subdivs_len: Num, subdivs_width: Num): IndexBuffer{
		var rows = subdivs_len - 1
		var cols = subdivs_width-1
		var index_count = rows * cols * 6
		var raw = Uint16.new(index_count)
		for(i in 0...rows){
			for(ii in 0...cols){
				//System.print("x: %(i) | y:%(ii)")
				//first triangle
				raw[i*6*cols + ii*6 + 0] = i * (cols+1) + ii + 0
				raw[i*6*cols + ii*6 + 1] = i * (cols+1) + ii + cols+1
				raw[i*6*cols + ii*6 + 2] = i * (cols+1) + ii + 1
				//System.print("(%(i*6*cols + ii*6 + 0), %(i*6*cols + ii*6 + 1), %(i*6*cols + ii*6 + 2))")
				//System.print("[%(i * (cols+1) + ii + 0), %(i * (cols+1) + ii + cols+1), %(i * (cols+1) + ii + 1)]")

				//second triangle
				raw[i*6*cols + ii*6 + 3] = i * (cols+1) + ii + 1
				raw[i*6*cols + ii*6 + 4] = i * (cols+1) + ii + cols+1
				raw[i*6*cols + ii*6 + 5] = i * (cols+1) + ii + cols+2
				//System.print("(%(i*6*cols + ii*6 + 3), %(i*6*cols + ii*6 + 4), %(i*6*cols + ii*6 + 5))")
				//System.print("[%(i * (cols+1) + ii + 1), %(i * (cols+1) + ii + cols+1), %(i * (cols+1) + ii + cols+2)]")
			}
		}
		//var arr = (0...(raw.length/(3*4))).map{|i|"[%(raw[i*3]), %(raw[i*3+1]), %(raw[i*3+2])]"}.join("\n")
		//System.print(arr)
		return Render.create_index_buffer(raw, raw.length)
	}

	detach(entity, data: ModifierData) {
		//called when detached from an entity, like on destroy
		
	}

	tick(delta) {
		//System.print("positions")
		record_positions(delta)
		//System.print("buffers")
		update_buffers()
		//System.print("debug")
		//debug_draw()
		//System.print("end") 
	} //tick

	record_positions(delta: Num){
		each{|entity, data: ModifierData|
			if(!Transform.has(entity)) return
			
			var instance_data: TrailData = _instance_data[entity]

			var pos = Transform.get_pos_world(entity)
			var up = Transform.local_dir_to_world(entity, 0, data.edge_length * 0.5, 0)
			var prev_pos = instance_data.previous_pos || pos
			var prev_up = instance_data.previous_up || up

			var dist = instance_data.progress_since_last_point
			var diff:Num
			if(data.time_based){
				diff = delta
			} else {
				diff = Math.dist(pos, prev_pos)
			}
			if(diff > data.length){
				if(data.time_based){
					var t = data.length / diff
					prev_pos.x = Math.lerp(pos.x, prev_pos.x, t)
					prev_pos.y = Math.lerp(pos.y, prev_pos.y, t)
					prev_pos.z = Math.lerp(pos.z, prev_pos.z, t)
				} else {
					var dir = [prev_pos.x - pos.x, prev_pos.y - pos.y, prev_pos.z - pos.z]
					Math.normalize(dir)
					
					dir.x = dir.x * data.length
					dir.y = dir.y * data.length
					dir.z = dir.z * data.length
					
					prev_pos.x = pos.x + dir.x
					prev_pos.y = pos.y + dir.y
					prev_pos.z = pos.z + dir.z
				}
				diff = data.length
			}
			dist = dist + diff
			var step = data.length / data.subdivisions_length
			while(dist > step){
				dist = dist - step
				var t = 1 - dist / diff
				var point = Point.new([
					Math.lerp(prev_pos.x, pos.x, t),
					Math.lerp(prev_pos.y, pos.y, t),
					Math.lerp(prev_pos.z, pos.z, t)
				], [
					Math.lerp(prev_up.x, up.x, t),
					Math.lerp(prev_up.y, up.y, t),
					Math.lerp(prev_up.z, up.z, t)
				])
				Math.normalize(point.up)
				if(instance_data.points.count >= data.subdivisions_length - 1) instance_data.points.dequeue()
				instance_data.points.enqueue(point)
			}
			instance_data.progress_since_last_point = dist

			instance_data.previous_pos = pos
			instance_data.previous_up = up
		}
	}

	update_buffers(){
		each{|entity, data: ModifierData|
			var instance_data: TrailData = _instance_data[entity]
			var positions = Floats.new(Render.vertex_buffer_get_size(instance_data.position_buffer) / 4)
			Render.vertex_buffer_get_data(instance_data.position_buffer, positions, positions.size * 4, 0)
			//System.print("positions(%(Render.vertex_buffer_get_size(instance_data.position_buffer))):")
			//System.print((0...(positions.size/4)).map{|i|"[%(positions[i*4]), %(positions[i*4+1]), %(positions[i*4+2])]"}.join("\n"))
			var i = -1
			for(p in instance_data.points){
				i = i + 1
				for(ii in 0...data.subdivisions_width){
					var t = ii / (data.subdivisions_width-1)
					var offset_x = Math.lerp(-p.up.x, p.up.x, t)
					var offset_y = Math.lerp(-p.up.y, p.up.y, t)
					var offset_z = Math.lerp(-p.up.z, p.up.z, t)
					positions[i*4*data.subdivisions_width + ii*4 + 0] = p.pos.x + offset_x * data.edge_length * 0.5
					positions[i*4*data.subdivisions_width + ii*4 + 1] = p.pos.y + offset_y * data.edge_length * 0.5
					positions[i*4*data.subdivisions_width + ii*4 + 2] = p.pos.z + offset_z * data.edge_length * 0.5
				}
			}
			if(Transform.has(entity)){
				i = i + 1

				var start = Transform.local_point_to_world(entity, 0, data.edge_length * -0.5, 0)
				var end = Transform.local_point_to_world(entity, 0, data.edge_length * 0.5, 0)

				for(ii in 0...data.subdivisions_width){
					var t = ii / (data.subdivisions_width-1)
					var pos_x = Math.lerp(start.x, end.x, t)
					var pos_y = Math.lerp(start.y, end.y, t)
					var pos_z = Math.lerp(start.z, end.z, t)
					positions[i*4*data.subdivisions_width + ii*4 + 0] = pos_x
					positions[i*4*data.subdivisions_width + ii*4 + 1] = pos_y
					positions[i*4*data.subdivisions_width + ii*4 + 2] = pos_z
				}
			}
			Render.vertex_buffer_replace(instance_data.position_buffer, positions, positions.length)
			Geometry.set_vert_count(instance_data.geometry, i.max(0) * 6 * (data.subdivisions_width-1))
		}
	}

	debug_draw(){
		each {|entity, data: ModifierData|
			var start = [0, 0]
			var end = [0, data.edge_length]
			var depth = 0
			if(Transform.has(entity)){
				start = Transform.local_point_to_world(entity, 0, data.edge_length * -0.5, 0)
				end = Transform.local_point_to_world(entity, 0, data.edge_length * 0.5, 0)
				depth = Transform.get_depth2D_world(entity)
			}
			Draw.line(_draw, start.x, start.y, end.x, end.y, depth, _debug_edge_style)

			var instance_data: TrailData = _instance_data[entity]

			if(instance_data.points.count > 1){
				Draw.path3D(_draw, instance_data.points.map{|p:Point|p.pos}.toList, _debug_path_style, false)
			}

			instance_data.points.each{|point: Point|
				var from_x = point.pos.x + point.up.x * data.edge_length * 0.5
				var from_y = point.pos.y + point.up.y * data.edge_length * 0.5
				var from_z = point.pos.x + point.up.x * data.edge_length * 0.5

				var to_x = point.pos.x - point.up.x * data.edge_length * 0.5
				var to_y = point.pos.y - point.up.y * data.edge_length * 0.5
				var to_z = point.pos.z - point.up.z * data.edge_length * 0.5

				Draw.path3D(_draw, [[from_x, from_y, from_z], [to_x, to_y, to_z]], _debug_path_style, false)
			}

			var positions = Floats.new(Render.vertex_buffer_get_size(instance_data.position_buffer) / 4)
			Render.vertex_buffer_get_data(instance_data.position_buffer, positions, positions.size * 4, 0)
			var indices = Uint16.new(Render.index_buffer_get_size(instance_data.index_buffer) / 2)
			Render.index_buffer_get_data(instance_data.index_buffer, indices, indices.length, 0)
			for(i in 0...(Geometry.get_vert_count(instance_data.geometry) / 3)){
				var i1 = indices[i * 3 + 0]
				var i2 = indices[i * 3 + 1]
				var i3 = indices[i * 3 + 2]

				var v1 = [positions[i1 * 4 + 0], positions[i1 * 4 + 1], positions[i1 * 4 + 2]]
				var v2 = [positions[i2 * 4 + 0], positions[i2 * 4 + 1], positions[i2 * 4 + 2]]
				var v3 = [positions[i3 * 4 + 0], positions[i3 * 4 + 1], positions[i3 * 4 + 2]]

				Draw.path3D(_draw, [v1, v2, v3], _debug_mesh_style, true)
			}
		}
		Draw.commit(_draw)
	}

} //TrailSystem

var Modifier = TrailSystem //required