// RotateTo adjusts the yaw and pitch to face a point.
func (c *QuatCamera) RotateTo(center mgl.Vec3) {
	direction := center.Sub(c.position).Normalize()
	right := direction.Cross(AxisUp)
	up := right.Cross(direction)

	c.rotation = mgl.QuatLookAtV(c.position, center, up)
}

func safeNormalize(v mgl32.Vec3) mgl32.Vec3 {
	v = v.Normalize()
	if math.IsInf(float64(v[0]), 0) || math.IsNaN(float64(v[0])) {
		return mgl32.Vec3{}
	}
	return v
}

func (e *Editor) MoveSelectedNodeModel(x, y float32, axisLock mgl32.Vec3) {
	selectedModel, _ := e.overviewMenu.getSelectedNode(e.currentMap.Root)
	if selectedModel != nil {
		selectedModel.Translation = selectedModel.Translation.Add(axisLock.Mul(x * mouseSpeed))
	}
	updateMap(e.currentMap.Root)
}

//PointToLineDist distance from line (a,b) to point
func PointToLineDist(a, b, point mgl32.Vec3) float32 {
	ab := b.Sub(a)
	ap := point.Sub(a)
	prj := ap.Dot(ab)
	lenSq := ab.Dot(ab)
	t := prj / lenSq
	return ab.Mul(t).Add(a).Sub(point).Len()
}

func (f *fPlane) setPoints(v1, v2, v3 mgl32.Vec3) {
	aux1 := v1.Sub(v2)
	aux2 := v3.Sub(v2)

	f.N = aux2.Cross(aux1)
	f.N = safeNormalize(f.N)
	f.P = v2
	f.D = -(f.N.Dot(f.P))
}

// Lerp will interpolate between the desired position/center by amount.
func (c *QuatCamera) Lerp(position mgl.Vec3, center mgl.Vec3, amount float32) {
	direction := center.Sub(position).Normalize()
	right := direction.Cross(AxisUp)
	up := right.Cross(direction)

	targetRot := mgl.QuatLookAtV(position, center, up)
	c.rotation = mgl.QuatNlerp(c.rotation, targetRot, amount)
	c.position = c.position.Add(position.Sub(c.position).Mul(amount))
}

func (self *pane) pix2Vec(evnt *js.Object) mgl32.Vec2 {
	v := mgl32.Vec3{ // generate vector from current pixel coords
		float32(evnt.Get("clientX").Float()),
		float32(evnt.Get("clientY").Float()),
		1.0, // apply translations from transform matrix
	}
	v = self.untransform.Mul3x1(v) // apply pan & zoom untransform matrix

	return v.Vec2() // return vec2
}

func getIntersection(fDst1, fDst2 float32, P1, P2 mgl32.Vec3, Hit *mgl32.Vec3) bool {
	if (fDst1 * fDst2) >= 0.0 {
		return false
	}
	if fDst1 == fDst2 {
		return false
	}
	*Hit = P1.Add((P2.Sub(P1)).Mul(-fDst1 / (fDst2 - fDst1)))
	return true
}

// Rotate adjusts the direction vectors by a delta vector of {pitch, yaw, roll}.
// Roll is ignored for now.
func (c *EulerCamera) Rotate(delta mgl.Vec3) {
	c.yaw += float64(delta.Y())
	c.pitch += float64(delta.X())

	// Limit vertical rotation to avoid gimbal lock
	if c.pitch > halfPi {
		c.pitch = halfPi
	} else if c.pitch < -halfPi {
		c.pitch = -halfPi
	}

	c.updateVectors()
}

// CreateBeam - creates a square prism oriented along the vector
func CreateBeam(width float32, vector mgl32.Vec3) *Geometry {
	direction := vector.Normalize()
	geo := CreateBoxWithOffset(width, width, -width*0.5, -width*0.5)
	geo2 := CreateBoxWithOffset(width, width, -width*0.5, -width*0.5)
	facingTx := util.Mat4From(mgl32.Vec3{1, 1, 1}, mgl32.Vec3{}, util.FacingOrientation(0, direction, mgl32.Vec3{0, 0, 1}, mgl32.Vec3{1, 0, 0}))
	geo.Transform(facingTx)
	facingTx = util.Mat4From(mgl32.Vec3{1, 1, 1}, vector, util.FacingOrientation(0, direction, mgl32.Vec3{0, 0, -1}, mgl32.Vec3{1, 0, 0}))
	geo2.Optimize(geo, facingTx)
	geo.Indicies = append(geo.Indicies, 0, 1, 4, 4, 5, 0) //top
	geo.Indicies = append(geo.Indicies, 1, 2, 7, 7, 4, 1) //side
	geo.Indicies = append(geo.Indicies, 2, 3, 6, 6, 7, 2) //bottom
	geo.Indicies = append(geo.Indicies, 3, 0, 5, 5, 6, 3) //side
	return geo
}

func Upvote(tip mgl.Vec3, size float32) []float32 {
	a := tip.Add(mgl.Vec3{-size / 2, -size * 2, 0})
	b := tip.Add(mgl.Vec3{size / 2, -size, 0})
	return []float32{
		tip[0], tip[1], tip[2], // Top
		tip[0] - size, tip[1] - size, tip[2], // Bottom left
		tip[0] + size, tip[1] - size, tip[2], // Bottom right

		// Arrow handle
		b[0], b[1], b[2], // Top Right
		a[0], b[1], a[2], // Top Left
		a[0], a[1], a[2], // Bottom Left
		a[0], a[1], a[2], // Bottom Left
		b[0], b[1], b[2], // Top Right
		b[0], a[1], b[2], // Bottom Right
	}
}

func (p *fullPiano) GetKeyFromRay(rayStart, rayEnd mgl32.Vec3) *PianoKey {
	minDist := float32(10000)
	minDistIdx := -1

	for i, k := range p.Keys {
		hit, pos := k.Hit(rayStart, rayEnd)
		if hit {
			dist := rayStart.Sub(pos).Len()
			if dist < minDist {
				minDistIdx = i
				minDist = dist
			}
		}
	}

	if minDistIdx != -1 {
		return &p.Keys[minDistIdx]
	}

	return nil
}

//PointToPlaneDist distance from plane (a,b,c) to point
func PointToPlaneDist(a, b, c, point mgl32.Vec3) float32 {
	ab := b.Sub(a)
	ac := c.Sub(a)
	ap := point.Sub(a)
	normal := ac.Cross(ab).Normalize()
	return float32(math.Abs(float64(ap.Dot(normal))))
}

// NewPianoKey returns a key for our piano.
func NewPianoKey(pos mgl32.Vec3, lightColor mgl32.Vec3, white bool, freq float32) PianoKey {
	var color mgl32.Vec4
	var keySize float32
	if white {
		color = mgl32.Vec4{0.98, 0.97, 0.94}
		keySize = 2
	} else {
		color = mgl32.Vec4{0.1, 0.1, 0.1, 1.0}
		keySize = 1

	}
	pk := PianoKey{Pos: pos, Angle: 0, Color: color, Frequency: freq, Finger: -1, white: white, LightColor: lightColor}
	pk.BBox[0] = pos.Sub(mgl32.Vec3{0.5, 0.6, keySize})
	pk.BBox[1] = pos.Add(mgl32.Vec3{0.5, 0.6, keySize})
	pk.source = al.GenSources(1)[0]
	pk.source.SetGain(1.0)
	pk.source.SetPosition(al.Vector{pos.X(), pos.Y(), pos.Z()})
	pk.source.SetVelocity(al.Vector{})
	pk.buffers = al.GenBuffers(3)

	var samples [1024 * 16]int16

	sampleRate := 44100
	amplitude := float32(0.8 * 0x7FFF)

	for i := 0; i < len(samples); i++ {
		val := f32.Sin((2.0 * math.Pi * freq) / float32(sampleRate) * float32(i))
		samples[i] = int16(amplitude * val)
	}

	buf := &bytes.Buffer{}
	binary.Write(buf, binary.LittleEndian, &samples)
	pk.buffers[0].BufferData(al.FormatMono16, buf.Bytes(), 44100)

	f, _ := os.Create("audio.raw")
	binary.Write(f, binary.LittleEndian, &samples)
	f.Close()

	return pk
}

// updates the Colors of the model to fake lighting
func esLightModel(p PositionComponent, s SizeComponent, m interface {
	Model() *render.StaticModel
}) {
	if m.Model() == nil {
		return
	}
	xx, yy, zz := p.Position()
	bounds := s.Bounds()
	bounds = bounds.Shift(float32(xx), float32(yy), float32(zz))

	c := mgl32.Vec3{float32(xx), float32(yy), float32(zz)}
	c[1] += bounds.Max.Sub(bounds.Min).Mul(0.5).Y()

	var light, skyLight float32
	var count float32
	for y := bounds.Min.Y(); y <= bounds.Max.Y(); y++ {
		for z := bounds.Min.Z() - 1; z <= bounds.Max.Z()+1; z++ {
			for x := bounds.Min.X() - 1; x <= bounds.Max.X()+1; x++ {
				bx, by, bz := int(math.Floor(float64(x))), int(math.Floor(float64(y))), int(math.Floor(float64(z)))
				bl := float32(chunkMap.BlockLight(bx, by, bz))
				sl := float32(chunkMap.SkyLight(bx, by, bz))

				dist := 1.0 - c.Sub(mgl32.Vec3{float32(bx) + 0.5, float32(by) + 0.5, float32(bz) + 0.5}).Len()
				if dist < 0 {
					continue
				}

				light += bl * dist
				skyLight += sl * dist
				count += dist
			}
		}
	}
	light /= count
	skyLight /= count
	model := m.Model()
	model.BlockLight, model.SkyLight = light, skyLight
}

//	Calculate normals by using cross products along the triangle strips
//	and averaging the normals for each vertex
func (terrain *Terrain) CalculateNormals() {
	var element_pos uint32 = 0
	var AB, AC, cross_product mgl32.Vec3

	// Loop through each triangle strip
	for x := uint32(0); x < terrain.XSize-1; x++ {
		// Loop along the strip
		for tri := uint32(0); tri < terrain.ZSize*2-2; tri++ {
			// Extract the vertex indices from the element array
			v1 := terrain.Indices[element_pos]
			v2 := terrain.Indices[element_pos+1]
			v3 := terrain.Indices[element_pos+2]

			// Define the two vectors for the triangle
			AB = terrain.Vertices[v2].Sub(terrain.Vertices[v1])
			AC = terrain.Vertices[v3].Sub(terrain.Vertices[v1])

			// Calculate the cross product
			cross_product = AB.Cross(AC)

			// Add this normal to the vertex normal for all three vertices in the triangle
			terrain.Normals[v1] = terrain.Normals[v1].Add(cross_product)
			terrain.Normals[v2] = terrain.Normals[v2].Add(cross_product)
			terrain.Normals[v3] = terrain.Normals[v3].Add(cross_product)

			// Move on to the next vertex along the strip
			element_pos++
		}

		// Jump past the lat two element positions to reach the start of the strip
		element_pos += 2
	}

	// Normalise the normals
	for v := uint32(0); v < terrain.XSize*terrain.ZSize; v++ {
		terrain.Normals[v] = terrain.Normals[v].Normalize()
	}
}

// Draw draws this to the target region.
func (m *Model) Draw(r Region, delta float64) {
	if m.isNew || m.isDirty() || forceDirty {
		m.isNew = false
		data := m.data[:0]

		for _, v := range m.verts {
			vec := mgl32.Vec3{v.X - 0.5, v.Y - 0.5, v.Z - 0.5}
			vec = m.mat.Mul4x1(vec.Vec4(1)).Vec3().
				Add(mgl32.Vec3{0.5, 0.5, 0.5})
			vX, vY, vZ := vec[0], 1.0-vec[1], vec[2]

			dx := r.X + r.W*float64(vX)
			dy := r.Y + r.H*float64(vY)
			dx /= scaledWidth
			dy /= scaledHeight
			data = appendShort(data, int16(math.Floor((dx*float64(lastWidth))+0.5)))
			data = appendShort(data, int16(math.Floor((dy*float64(lastHeight))+0.5)))
			data = appendShort(data, 256*int16(m.Layer())+int16(256*vZ))
			data = appendShort(data, 0)
			data = appendUnsignedShort(data, v.TX)
			data = appendUnsignedShort(data, v.TY)
			data = appendUnsignedShort(data, v.TW)
			data = appendUnsignedShort(data, v.TH)
			data = appendShort(data, v.TOffsetX)
			data = appendShort(data, v.TOffsetY)
			data = appendShort(data, v.TAtlas)
			data = appendShort(data, 0)
			data = appendUnsignedByte(data, v.R)
			data = appendUnsignedByte(data, v.G)
			data = appendUnsignedByte(data, v.B)
			data = appendUnsignedByte(data, v.A)
		}
		m.data = data
	}
	render.UIAddBytes(m.data)
}

func TestTransformTranslate(t *testing.T) {
	transform := NewTransform()
	transform.SetPosition(10, 10, 10)

	vector := mgl32.Vec3{-5, 6, 3}
	expected := mgl32.Vec3{5, 16, 13}
	transform.Translate(vector)

	if transform.position != expected {
		t.Errorf("Expected position to be %v got %v", expected, transform.position)
	}

	if transform.matrix[12] != expected.X() ||
		transform.matrix[13] != expected.Y() ||
		transform.matrix[14] != expected.Z() {
		t.Error("Matrix was not updated correctly after translation.")
	}
}

func (f *Frustum) SetCamera(p, l, u mgl32.Vec3) {
	Z := p.Sub(l)
	Z = safeNormalize(Z)

	X := u.Cross(Z)
	X = safeNormalize(X)

	Y := Z.Cross(X)

	nc := p.Sub(Z.Mul(f.near))
	fc := p.Sub(Z.Mul(f.far))

	ntl := nc.Add(Y.Mul(f.nh)).Sub(X.Mul(f.nw))
	ntr := nc.Add(Y.Mul(f.nh)).Add(X.Mul(f.nw))
	nbl := nc.Sub(Y.Mul(f.nh)).Sub(X.Mul(f.nw))
	nbr := nc.Sub(Y.Mul(f.nh)).Add(X.Mul(f.nw))

	ftl := fc.Add(Y.Mul(f.fh)).Sub(X.Mul(f.fw))
	ftr := fc.Add(Y.Mul(f.fh)).Add(X.Mul(f.fw))
	fbl := fc.Sub(Y.Mul(f.fh)).Sub(X.Mul(f.fw))
	fbr := fc.Sub(Y.Mul(f.fh)).Add(X.Mul(f.fw))

	const (
		top = iota
		bottom
		left
		right
		nearP
		farP
	)
	f.planes[top].setPoints(ntr, ntl, ftl)
	f.planes[bottom].setPoints(nbl, nbr, fbr)
	f.planes[left].setPoints(ntl, nbl, fbl)
	f.planes[right].setPoints(nbr, ntr, fbr)
	f.planes[nearP].setPoints(ntl, ntr, nbr)
	f.planes[farP].setPoints(ftr, ftl, fbl)
}

func (w *Window) SetTranslation(translation mgl32.Vec3) {
	w.node.SetTranslation(translation)
	w.position = translation.Vec2()
}