package main

import rl "libraries/raylib"
import "core:math/linalg"
import "core:fmt"

/*
	Maybe it is possible to have everything 3d be mathed the same way
	as in 2d. But I'm not sure if that's actually how it works.
*/

AnimationInterface :: struct {
	data: rawptr,
	reset: proc(animation: ^AnimationInterface),
	update_last: proc(animation: ^AnimationInterface, master_matrix: mat3),
	update: proc(animation: ^AnimationInterface, animation_progress: f32),
	next_matrix: proc(animation: ^AnimationInterface, next_matrix: mat3),
	draw_idle: proc(animation: AnimationInterface),
	draw_active: proc(animation: AnimationInterface),
}

animation_update_last :: proc(animation: ^AnimationInterface, master_matrix: mat3) {
	animation.update_last(animation, master_matrix)
}

animation_update :: proc(animation: ^AnimationInterface, animation_progress: f32) {
	animation.update(animation, animation_progress)
}

animation_next_matrix :: proc(animation: ^AnimationInterface, next_matrix: mat3) {
	animation.next_matrix(animation, next_matrix)
}

animation_draw_idle :: proc(animation: AnimationInterface) {
	animation.draw_idle(animation)
}

animation_draw_active :: proc(animation: AnimationInterface) {
	animation.draw_active(animation)
}

AnimationType :: enum {
	Rectangle,
}

RectangleCorners :: struct {
	tl, tr, br, bl: v2,
}

rectangle_corners_transform :: proc(m: mat3, corners: RectangleCorners) -> RectangleCorners {
	return {
		tl = (v3{**corners.tl, 1.0} * m).xy,
		tr = (v3{**corners.tr, 1.0} * m).xy,
		br = (v3{**corners.br, 1.0} * m).xy,
		bl = (v3{**corners.bl, 1.0} * m).xy,
	}
}

AnimationData_Rectangle :: struct {
	origin, middle, previous, next, last: RectangleCorners,
}

draw_transformation_rectangle :: proc(rectangle: RectangleCorners, color: rl.Color) {
	rect := rect_from_corners(rectangle.tl, rectangle.tr, rectangle.br, rectangle.bl)
	rl.DrawRectangleRec(rect, rl.Color{**color.rgb, color.a / 2})
	rl.DrawRectangleLinesEx(rect, 1.0, color)
}

draw_transformation_rectangle_with_handles :: proc(rectangle: RectangleCorners, color: rl.Color) {
	rect := rect_from_corners(rectangle.tl, rectangle.tr, rectangle.br, rectangle.bl)
	rl.DrawRectangleRec(rect, rl.Color{**color.rgb, color.a / 2})
	rl.DrawRectangleLinesEx(rect, 1.0, color)
	rl.DrawCircleV(rectangle.tl, 4.0, color)
	rl.DrawCircleV(rectangle.tr, 4.0, color)
	rl.DrawCircleV(rectangle.br, 4.0, color)
	rl.DrawCircleV(rectangle.bl, 4.0, color)
}

_animation_rectangle_draw_idle :: proc(animation: AnimationInterface) {
	data := cast(^AnimationData_Rectangle)animation.data
	draw_transformation_rectangle(data.last, TRANSFORMATION_RECTANGLE_COLOR_LAST)
	draw_transformation_rectangle_with_handles(data.origin, TRANSFORMATION_RECTANGLE_COLOR_ORIGIN)
}

_animation_rectangle_draw_active :: proc(animation: AnimationInterface) {
	data := cast(^AnimationData_Rectangle)animation.data
	draw_transformation_rectangle(data.last, TRANSFORMATION_RECTANGLE_COLOR_LAST)
	draw_transformation_rectangle(data.next, TRANSFORMATION_RECTANGLE_COLOR_NEXT)
	draw_transformation_rectangle(data.middle, TRANSFORMATION_RECTANGLE_COLOR_MIDDLE)
	draw_transformation_rectangle(data.origin, TRANSFORMATION_RECTANGLE_COLOR_ORIGIN)
}

_animation_rectangle_reset :: proc(animation: ^AnimationInterface) {
	data := cast(^AnimationData_Rectangle)animation.data
	data.middle = data.origin
	data.next = data.origin
	data.previous = data.origin
}

_animation_rectangle_next_matrix :: proc(animation: ^AnimationInterface, next_matrix: mat3) {
	data := cast(^AnimationData_Rectangle)animation.data
	data.previous = data.next
	data.middle = data.next
	data.next = rectangle_corners_transform(next_matrix, data.next)
}

_animation_rectangle_update_last :: proc(animation: ^AnimationInterface, master_matrix: mat3) {
	data := cast(^AnimationData_Rectangle)animation.data
	data.last = {
		tl = (master_matrix * v3{**data.origin.tl, 1.0}).xy,
		tr = (master_matrix * v3{**data.origin.tr, 1.0}).xy,
		br = (master_matrix * v3{**data.origin.br, 1.0}).xy,
		bl = (master_matrix * v3{**data.origin.bl, 1.0}).xy,
	}
}

_animation_rectangle_update :: proc(animation: ^AnimationInterface, animation_progress: f32) {
	data := cast(^AnimationData_Rectangle)animation.data
	data.middle = {
		tl = linalg.lerp(data.previous.tl, data.next.tl, animation_progress),
		tr = linalg.lerp(data.previous.tr, data.next.tr, animation_progress),
		br = linalg.lerp(data.previous.br, data.next.br, animation_progress),
		bl = linalg.lerp(data.previous.bl, data.next.bl, animation_progress),
	}
}

animation_reset :: proc(animation: ^AnimationInterface) {
	animation.reset(animation)
}

animation_create_rectangle :: proc(rectangle: ^AnimationData_Rectangle) -> AnimationInterface {
	return {
		data = rectangle,
		reset = _animation_rectangle_reset,
		update_last = _animation_rectangle_update_last,
		update = _animation_rectangle_update,
		next_matrix = _animation_rectangle_next_matrix,
		draw_idle = _animation_rectangle_draw_idle,
		draw_active = _animation_rectangle_draw_active,
	}
}