package main

import (
	"math"
)

func Bresenham2(fb *Framebuffer, color uint, x0 int, y0 int, x1 int, y1 int) {
	dx := int(math.Abs(float64(x1 - x0)))
	sx := -1
	if x0 < x1 {
		sx = 1
	}
	dy := -int(math.Abs(float64(y1 - y0)))
	sy := -1
	if y0 < y1 {
		sy = 1
	}
	err := dx + dy

	for {
		fb.SetSafe(uint(x0), uint(y0), color)
		if x0 == x1 && y0 == y1 {
			break
		}
		e2 := 2 * err
		if e2 >= dy {
			if x0 == x1 {
				break
			}
			err += dy
			x0 += sx
		}
		if e2 <= dx {
			if y0 == y1 {
				break
			}
			err += dx
			y0 += sy
		}
	}
}

func line(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i) {
	Bresenham2(fb, color, v0.X, v0.Y, v1.X, v1.Y)
}

/*func LineSweep(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i, v2 Vec2i) {

}*/

func Triangle1(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i, v2 Vec2i) {
	// Very silly manual sorting by Y
	if v2.Y < v0.Y {
		v0, v2 = v2, v0
	}
	if v1.Y < v0.Y {
		v0, v1 = v1, v0
	}
	if v2.Y < v1.Y {
		v1, v2 = v2, v1
	}

	// Don't worry about speed for now...
	dy := float32(v2.Y-v0.Y) - 0.5
	var v02step, v01step, v12step, xlong, xshort float32

	xlong = float32(v0.X) + 0.5
	xshort = xlong

	// We can check just for greater than because we sorted the vertices
	if dy > 0 {
		v02step = (float32(v2.X-v0.X) - 0.5) / dy // long side always
		v01step = (float32(v1.X-v0.X) - 0.5) / dy // first short side
		v12step = (float32(v2.X-v1.X) - 0.5) / dy // second short side
		xshort += v01step / 2
		xlong += v02step / 2
	} else {

	}

	for y := v0.Y; y <= v2.Y; y++ {
		xleft := int(math.Floor(float64(xshort)))
		xright := int(math.Floor(float64(xlong)))
		if xleft > xright {
			xleft, xright = xright, xleft
		}
		// Draw a horizontal line from elft to right
		for x := xleft; x <= xright; x++ {
			fb.SetSafe(uint(x), uint(y), color)
		}
		xlong += v02step
		if y < v1.Y {
			xshort += v01step
		} else {
			xshort += v12step
		}
	}

	// line(fb, color, v0, v1)
	// line(fb, color, v1, v2)
	// line(fb, color, v2, v0)
}