import "utils/vec" for Vec
import "luxe: math" for Math

var x_angle = 1 * Num.tau / 12
var y_angle = 5 * Num.tau / 12
var z_angle = 9 * Num.tau / 12
var X_Dir = [x_angle.cos, x_angle.sin, 0]
var Y_Dir = [y_angle.cos, y_angle.sin, 0]
var Z_Dir = [z_angle.cos, z_angle.sin, 0]

class Hex{

	//cheaper calculation might be possible?
	//but I dont understand it so it doesnt count :V
	static pos_to_coord(pos, scale){
		var coords = [0, 0, 0]
		
		scale = scale * 1.5
		coords.x = Math.dot(X_Dir, pos) / scale
		coords.y = Math.dot(Y_Dir, pos) / scale
		coords.z = Math.dot(Z_Dir, pos) / scale
		return coords
	}

	static pos_to_coord(pos){ pos_to_coord(pos, 1) }

	static coord_to_pos(coord, scale){
		var x_pos = Vec.mul(X_Dir, coord.x * scale)
		var y_pos = Vec.mul(Y_Dir, coord.y * scale)
		var z_pos = Vec.mul(Z_Dir, coord.z * scale)
		return Vec.add(x_pos, Vec.add(y_pos, z_pos))
	}

	static coord_to_pos(coord){ coord_to_pos(coord, 1) }

	static round(coords){
		var result = [
			coords.x.round,
			coords.y.round,
			coords.z.round
		]

		//if all is good, all is good
		if(result.x + result.y + result.z == 0) return result

		//otherwise calculate the difference rounding made
		var x_diff = result.x - coords.x
		var y_diff = result.y - coords.y
		var z_diff = result.z - coords.z

		//and recalculate the coordinate that made the biggest jump
		//so the 0 sum constraint is enforced again
		if(x_diff > y_diff && y_diff > z_diff) {
			result.x = -result.y - result.z
		} else if(y_diff > z_diff) {
			result.y = -result.z - result.x
		} else {
			result.z = -result.x-result.y
		}

		return result
	}
}