package ru.dbotthepony.kstarbound.lua

import ru.dbotthepony.kommons.math.RGBAColor
import ru.dbotthepony.kommons.util.Either
import ru.dbotthepony.kommons.util.IStruct2d
import ru.dbotthepony.kommons.util.IStruct2f
import ru.dbotthepony.kommons.util.IStruct2i
import ru.dbotthepony.kommons.util.IStruct3d
import ru.dbotthepony.kommons.util.IStruct3f
import ru.dbotthepony.kommons.util.IStruct3i
import ru.dbotthepony.kommons.util.IStruct4d
import ru.dbotthepony.kommons.util.IStruct4f
import ru.dbotthepony.kommons.util.IStruct4i
import ru.dbotthepony.kstarbound.Registry
import ru.dbotthepony.kstarbound.math.AABB
import ru.dbotthepony.kstarbound.math.AABBi
import ru.dbotthepony.kstarbound.math.Line2d
import ru.dbotthepony.kstarbound.math.vector.Vector2d
import ru.dbotthepony.kstarbound.math.vector.Vector2f
import ru.dbotthepony.kstarbound.math.vector.Vector2i
import ru.dbotthepony.kstarbound.world.physics.Poly

// TODO: error reporting when argument was provided, but it is malformed
//  currently, invalid data gets silently discarded, and treated as "no value" aka null
fun LuaThread.getPoly(stackIndex: Int = -1): Poly? {
	return readTableValues(stackIndex) {
		getVector2d(it) ?: throw IllegalArgumentException("Provided poly table contains invalid points")
	}?.let { Poly(it) }
}

fun LuaThread.ArgStack.nextPoly(position: Int = this.position++): Poly {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Poly expected, got nil")

	return lua.getPoly(position)
		?: throw IllegalArgumentException("bad argument #$position: Poly expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalPoly(position: Int = this.position++): Poly? {
	if (position !in 1 ..this.top)
		return null

	return lua.getPoly(position)
}

fun LuaThread.getLine2d(stackIndex: Int = -1): Line2d? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getVector2d()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getVector2d()
	pop()
	y ?: return null

	return Line2d(x, y)
}

fun LuaThread.ArgStack.nextLine2d(position: Int = this.position++): Line2d {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Line2d expected, got nil")

	return lua.getLine2d(position)
		?: throw IllegalArgumentException("bad argument #$position: Line2d expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalLine2d(position: Int = this.position++): Line2d? {
	if (position !in 1 ..this.top)
		return null

	return lua.getLine2d(position)
}

fun LuaThread.getVector2d(stackIndex: Int = -1): Vector2d? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getDouble()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getDouble()
	pop()
	y ?: return null

	return Vector2d(x, y)
}

fun LuaThread.ArgStack.nextVector2d(position: Int = this.position++): Vector2d {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Vector2d expected, got nil")

	return lua.getVector2d(position)
		?: throw IllegalArgumentException("bad argument #$position: Vector2d expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalVector2d(position: Int = this.position++): Vector2d? {
	if (position !in 1 ..this.top)
		return null

	return lua.getVector2d(position)
}

fun LuaThread.getVector2f(stackIndex: Int = -1): Vector2f? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getFloat()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getFloat()
	pop()
	y ?: return null

	return Vector2f(x, y)
}

fun LuaThread.ArgStack.nextVector2f(position: Int = this.position++): Vector2f {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Vector2f expected, got nil")

	return lua.getVector2f(position)
		?: throw IllegalArgumentException("bad argument #$position: Vector2f expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalVector2f(position: Int = this.position++): Vector2f? {
	if (position !in 1 ..this.top)
		return null

	return lua.getVector2f(position)
}

fun LuaThread.getVector2iOrAABB(stackIndex: Int = -1): Either<Vector2i, AABB>? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(3)
	val type = loadTableValue(abs)
	pop()

	if (type == LuaType.NUMBER) {
		return Either.right(getAABB() ?: return null)
	} else {
		return Either.left(getVector2i() ?: return null)
	}
}

fun LuaThread.ArgStack.nextVector2iOrAABB(position: Int = this.position++): Either<Vector2i, AABB> {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Vector2d expected, got nil")

	return lua.getVector2iOrAABB(position)
		?: throw IllegalArgumentException("bad argument #$position: Vector2d or AABB expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalVector2iOrAABB(position: Int = this.position++): Either<Vector2i, AABB>? {
	if (position !in 1 ..this.top)
		return null

	return lua.getVector2iOrAABB(position)
}

fun LuaThread.getRegistryID(stackIndex: Int = -1): Either<String, Int>? {
	val abs = absStackIndex(stackIndex)

	when (typeAt(abs)) {
		LuaType.NUMBER -> return Either.right(getLong(stackIndex)!!.toInt())
		LuaType.STRING -> return Either.left(getString(stackIndex)!!)
		else -> return null
	}
}

fun LuaThread.ArgStack.nextRegistryID(position: Int = this.position++): Either<String, Int> {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Vector2d expected, got nil")

	return lua.getRegistryID(position)
		?: throw IllegalArgumentException("bad argument #$position: Vector2d or AABB expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalRegistryID(position: Int = this.position++): Either<String, Int>? {
	if (position !in 1 ..this.top)
		return null

	return lua.getRegistryID(position)
}

fun LuaThread.getVector2i(stackIndex: Int = -1): Vector2i? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getLong()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getLong()
	pop()
	y ?: return null

	return Vector2i(x.toInt(), y.toInt())
}

fun LuaThread.ArgStack.nextVector2i(position: Int = this.position++): Vector2i {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: Vector2i expected, got nil")

	return lua.getVector2i(position)
		?: throw IllegalArgumentException("bad argument #$position: Vector2i expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalVector2i(position: Int = this.position++): Vector2i? {
	if (position !in 1 ..this.top)
		return null

	lua.typeAt(position).isTableOrNothing { "bad argument #$position: optional Vector2i expected, got $this" }
	return lua.getVector2i(position)
}

fun LuaThread.getColor(stackIndex: Int = -1): RGBAColor? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getLong()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getLong()
	pop()
	y ?: return null

	push(3)
	loadTableValue(abs)

	val z = getLong()
	pop()
	z ?: return null

	push(4)
	loadTableValue(abs)

	val w = getLong() ?: 255L
	pop()

	return RGBAColor(x.toInt(), y.toInt(), z.toInt(), w.toInt())
}

fun LuaThread.ArgStack.nextColor(position: Int = this.position++): RGBAColor {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: RGBAColor expected, got nil")

	return lua.getColor(position)
		?: throw IllegalArgumentException("bad argument #$position: RGBAColor expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalColor(position: Int = this.position++): RGBAColor? {
	if (position !in 1 ..this.top)
		return null

	return lua.getColor(position)
}

fun LuaThread.getAABB(stackIndex: Int = -1): AABB? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getDouble()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getDouble()
	pop()
	y ?: return null

	push(3)
	loadTableValue(abs)

	val z = getDouble()
	pop()
	z ?: return null

	push(4)
	loadTableValue(abs)

	val w = getDouble()
	pop()
	w ?: return null

	return AABB(Vector2d(x, y), Vector2d(z, w))
}

fun LuaThread.ArgStack.nextAABB(position: Int = this.position++): AABB {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: AABB expected, got nil")

	return lua.getAABB(position)
		?: throw IllegalArgumentException("bad argument #$position: AABB expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalAABB(position: Int = this.position++): AABB? {
	if (position !in 1 ..this.top)
		return null

	return lua.getAABB(position)
}

fun LuaThread.getAABBi(stackIndex: Int = -1): AABBi? {
	val abs = this.absStackIndex(stackIndex)

	if (!this.isTable(abs))
		return null

	push(1)
	loadTableValue(abs)

	val x = getLong()
	pop()
	x ?: return null

	push(2)
	loadTableValue(abs)

	val y = getLong()
	pop()
	y ?: return null

	push(3)
	loadTableValue(abs)

	val z = getLong()
	pop()
	z ?: return null

	push(4)
	loadTableValue(abs)

	val w = getLong()
	pop()
	w ?: return null

	return AABBi(Vector2i(x.toInt(), y.toInt()), Vector2i(z.toInt(), w.toInt()))
}

fun LuaThread.ArgStack.nextAABBi(position: Int = this.position++): AABBi {
	if (position !in 1 ..this.top)
		throw IllegalArgumentException("bad argument #$position: RGBAColor expected, got nil")

	return lua.getAABBi(position)
		?: throw IllegalArgumentException("bad argument #$position: RGBAColor expected, got ${lua.typeAt(position)}")
}

fun LuaThread.ArgStack.nextOptionalAABBi(position: Int = this.position++): AABBi? {
	if (position !in 1 ..this.top)
		return null

	return lua.getAABBi(position)
}

fun LuaThread.push(value: IStruct4i?) {
	value ?: return push()
	pushTable(arraySize = 4)
	val table = stackTop
	val (x, y, z, w) = value

	push(1)
	push(x.toLong())
	setTableValue(table)

	push(2)
	push(y.toLong())
	setTableValue(table)

	push(3)
	push(z.toLong())
	setTableValue(table)

	push(4)
	push(w.toLong())
	setTableValue(table)
}

fun LuaThread.push(value: IStruct3i?) {
	value ?: return push()
	pushTable(arraySize = 3)
	val table = stackTop
	val (x, y, z) = value

	push(1)
	push(x.toLong())
	setTableValue(table)

	push(2)
	push(y.toLong())
	setTableValue(table)

	push(3)
	push(z.toLong())
	setTableValue(table)
}

fun LuaThread.push(value: IStruct2i?) {
	value ?: return push()
	pushTable(arraySize = 2)
	val table = stackTop
	val (x, y) = value

	push(1)
	push(x.toLong())
	setTableValue(table)

	push(2)
	push(y.toLong())
	setTableValue(table)
}

fun LuaThread.push(value: IStruct4f?) {
	value ?: return push()
	pushTable(arraySize = 4)
	val table = stackTop
	val (x, y, z, w) = value

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)

	push(3)
	push(z)
	setTableValue(table)

	push(4)
	push(w)
	setTableValue(table)
}

fun LuaThread.push(value: IStruct3f?) {
	value ?: return push()
	pushTable(arraySize = 3)
	val table = stackTop
	val (x, y, z) = value

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)

	push(3)
	push(z)
	setTableValue(table)
}

fun LuaThread.push(value: IStruct2f?) {
	value ?: return push()
	pushTable(arraySize = 2)
	val table = stackTop
	val (x, y) = value

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)
}

fun LuaThread.push(value: IStruct4d?) {
	value ?: return push()
	pushTable(arraySize = 4)
	val table = stackTop
	val (x, y, z, w) = value

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)

	push(3)
	push(z)
	setTableValue(table)

	push(4)
	push(w)
	setTableValue(table)
}

fun LuaThread.push(value: IStruct3d?) {
	value ?: return push()
	pushTable(arraySize = 3)
	val table = stackTop
	val (x, y, z) = value

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)

	push(3)
	push(z)
	setTableValue(table)
}

fun LuaThread.push(value: IStruct2d?) {
	value ?: return push()
	pushTable(arraySize = 2)
	val table = stackTop
	val (x, y) = value

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)
}

fun LuaThread.setTableValue(key: String, value: IStruct2i?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: String, value: IStruct3i?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: String, value: IStruct4i?) { push(key); push(value); setTableValue() }

fun LuaThread.setTableValue(key: String, value: IStruct2d?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: String, value: IStruct3d?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: String, value: IStruct4d?) { push(key); push(value); setTableValue() }

fun LuaThread.setTableValue(key: String, value: IStruct2f?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: String, value: IStruct3f?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: String, value: IStruct4f?) { push(key); push(value); setTableValue() }

fun LuaThread.setTableValue(key: Long, value: IStruct2i?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: IStruct3i?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: IStruct4i?) { push(key); push(value); setTableValue() }

fun LuaThread.setTableValue(key: Long, value: IStruct2d?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: IStruct3d?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: IStruct4d?) { push(key); push(value); setTableValue() }

fun LuaThread.setTableValue(key: Long, value: IStruct2f?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: IStruct3f?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: IStruct4f?) { push(key); push(value); setTableValue() }

fun LuaThread.setTableValue(key: Int, value: IStruct2i?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: IStruct3i?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: IStruct4i?) { push(key.toLong()); push(value); setTableValue() }

fun LuaThread.setTableValue(key: Int, value: IStruct2d?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: IStruct3d?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: IStruct4d?) { push(key.toLong()); push(value); setTableValue() }

fun LuaThread.setTableValue(key: Int, value: IStruct2f?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: IStruct3f?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: IStruct4f?) { push(key.toLong()); push(value); setTableValue() }

fun LuaThread.push(value: AABB?) {
	value ?: return push()
	pushTable(arraySize = 4)
	val table = stackTop
	val (x, y) = value.mins
	val (z, w) = value.maxs

	push(1)
	push(x)
	setTableValue(table)

	push(2)
	push(y)
	setTableValue(table)

	push(3)
	push(z)
	setTableValue(table)

	push(4)
	push(w)
	setTableValue(table)
}

fun LuaThread.push(value: AABBi?) {
	value ?: return push()
	pushTable(arraySize = 4)
	val table = stackTop
	val (x, y) = value.mins
	val (z, w) = value.maxs

	push(1)
	push(x.toLong())
	setTableValue(table)

	push(2)
	push(y.toLong())
	setTableValue(table)

	push(3)
	push(z.toLong())
	setTableValue(table)

	push(4)
	push(w.toLong())
	setTableValue(table)
}

fun LuaThread.push(value: Poly?) {
	value ?: return push()

	pushTable(value.vertices.size)

	for ((i, vertex) in value.vertices.withIndex())
		setTableValue(i + 1L, vertex)
}

fun LuaThread.setTableValue(key: String, value: Poly?) { push(key); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Int, value: Poly?) { push(key.toLong()); push(value); setTableValue() }
fun LuaThread.setTableValue(key: Long, value: Poly?) { push(key); push(value); setTableValue() }

fun LuaThread.push(value: Registry.Ref<*>, preferStringsIDs: Boolean = true) {
	if (value.isPresent) {
		if (preferStringsIDs || value.entry!!.id == null) {
			push(value.entry!!.key)
		} else {
			push(value.entry!!.id!!.toLong())
		}
	} else {
		value.key.map({ push(it) }, { push(it.toLong()) })
	}
}