package ru.dbotthepony.kstarbound.client

import com.github.benmanes.caffeine.cache.Cache
import com.github.benmanes.caffeine.cache.Caffeine
import org.apache.logging.log4j.LogManager
import org.lwjgl.BufferUtils
import org.lwjgl.glfw.Callbacks
import org.lwjgl.glfw.GLFW
import org.lwjgl.glfw.GLFWErrorCallback
import org.lwjgl.opengl.GL
import org.lwjgl.opengl.GL11
import org.lwjgl.opengl.GL45.*
import org.lwjgl.opengl.GLCapabilities
import org.lwjgl.system.MemoryStack
import org.lwjgl.system.MemoryUtil
import ru.dbotthepony.kstarbound.PIXELS_IN_STARBOUND_UNIT
import ru.dbotthepony.kstarbound.PIXELS_IN_STARBOUND_UNITf
import ru.dbotthepony.kstarbound.Starbound
import ru.dbotthepony.kstarbound.client.freetype.FreeType
import ru.dbotthepony.kstarbound.client.freetype.InvalidArgumentException
import ru.dbotthepony.kstarbound.client.gl.BlendFunc
import ru.dbotthepony.kstarbound.client.gl.GLFrameBuffer
import ru.dbotthepony.kstarbound.client.gl.GLTexture2D
import ru.dbotthepony.kstarbound.client.gl.ScissorRect
import ru.dbotthepony.kstarbound.client.gl.VertexArrayObject
import ru.dbotthepony.kstarbound.client.gl.BufferObject
import ru.dbotthepony.kstarbound.client.gl.checkForGLError
import ru.dbotthepony.kstarbound.client.gl.properties.GLStateFuncTracker
import ru.dbotthepony.kstarbound.client.gl.properties.GLGenericTracker
import ru.dbotthepony.kstarbound.client.gl.properties.GLObjectTracker
import ru.dbotthepony.kstarbound.client.gl.properties.GLStateIntTracker
import ru.dbotthepony.kstarbound.client.gl.properties.GLStateSwitchTracker
import ru.dbotthepony.kstarbound.client.gl.shader.GLPrograms
import ru.dbotthepony.kstarbound.client.gl.shader.GLShader
import ru.dbotthepony.kstarbound.client.gl.shader.GLShaderProgram
import ru.dbotthepony.kstarbound.client.gl.shader.UberShader
import ru.dbotthepony.kstarbound.client.gl.vertex.GeometryType
import ru.dbotthepony.kstarbound.client.gl.vertex.VertexBuilder
import ru.dbotthepony.kstarbound.client.input.UserInput
import ru.dbotthepony.kstarbound.client.render.Box2DRenderer
import ru.dbotthepony.kstarbound.client.render.Camera
import ru.dbotthepony.kstarbound.client.render.Font
import ru.dbotthepony.kstarbound.client.render.LayeredRenderer
import ru.dbotthepony.kstarbound.client.render.TextAlignY
import ru.dbotthepony.kstarbound.client.render.TileRenderers
import ru.dbotthepony.kstarbound.client.world.ClientWorld
import ru.dbotthepony.kstarbound.defs.image.Image
import ru.dbotthepony.kstarbound.math.roundTowardsNegativeInfinity
import ru.dbotthepony.kstarbound.math.roundTowardsPositiveInfinity
import ru.dbotthepony.kstarbound.util.forEachValid
import ru.dbotthepony.kstarbound.util.formatBytesShort
import ru.dbotthepony.kstarbound.world.LightCalculator
import ru.dbotthepony.kstarbound.world.api.ICellAccess
import ru.dbotthepony.kstarbound.world.api.IChunkCell
import ru.dbotthepony.kvector.api.IStruct4f
import ru.dbotthepony.kvector.arrays.Matrix3f
import ru.dbotthepony.kvector.arrays.Matrix3fStack
import ru.dbotthepony.kvector.util2d.AABB
import ru.dbotthepony.kvector.vector.RGBAColor
import ru.dbotthepony.kvector.vector.Vector2d
import ru.dbotthepony.kvector.vector.Vector2f
import ru.dbotthepony.kvector.vector.Vector2i
import ru.dbotthepony.kvector.vector.Vector4f
import java.io.Closeable
import java.io.File
import java.lang.ref.Cleaner
import java.lang.ref.WeakReference
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.time.Duration
import java.util.*
import java.util.concurrent.locks.LockSupport
import java.util.concurrent.locks.ReentrantLock
import kotlin.collections.ArrayList
import kotlin.math.roundToInt

class StarboundClient : Closeable {
	val window: Long
	val camera = Camera(this)
	val input = UserInput()
	val thread: Thread = Thread.currentThread()
	val capabilities: GLCapabilities

	var viewportX: Int = 0
		private set
	var viewportY: Int = 0
		private set
	var viewportWidth: Int = 0
		private set
	var viewportHeight: Int = 0
		private set

	// potentially visible cells
	var viewportCellX = 0
		private set
	var viewportCellY = 0
		private set
	var viewportCellWidth = 0
		private set
	var viewportCellHeight = 0
		private set
	var viewportRectangle = AABB.rectangle(Vector2d.ZERO, 0.0, 0.0)
		private set

	var viewportBottomLeft = Vector2d()
		private set
	var viewportTopRight = Vector2d()
		private set

	var fullbright = true

	var clientTerminated = false
		private set

	var viewportMatrixScreen: Matrix3f
		private set
		get() = Matrix3f.unmodifiable(field)

	var viewportMatrixWorld: Matrix3f
		private set
		get() = Matrix3f.unmodifiable(field)

	var isRenderingGame = true
		private set

	private val scissorStack = LinkedList<ScissorRect>()
	private val cleanerBacklog = ArrayList<() -> Unit>()
	private val onDrawGUI = ArrayList<() -> Unit>()
	private val onPreDrawWorld = ArrayList<(LayeredRenderer) -> Unit>()
	private val onPostDrawWorld = ArrayList<() -> Unit>()
	private val onPostDrawWorldOnce = ArrayList<(LayeredRenderer) -> Unit>()
	private val onViewportChanged = ArrayList<(width: Int, height: Int) -> Unit>()
	private val terminateCallbacks = ArrayList<() -> Unit>()
	private val startupTextList = ArrayList<String>()
	private var finishStartupRendering = System.currentTimeMillis() + 4000L

	private val cleaner = Cleaner.create { r ->
		val thread = Thread(r, "OpenGL Cleaner for '${thread.name}'")
		thread.priority = 2
		thread
	}

	var objectsCreated = 0L
		private set

	var objectsCleaned = 0L
		private set

	init {
		check(CLIENTS.get() == null) { "Already has OpenGL context existing at ${Thread.currentThread()}!" }
		CLIENTS.set(this)

		lock.lock()

		try {
			clients++

			if (!glfwInitialized) {
				check(GLFW.glfwInit()) { "Unable to initialize GLFW" }
				glfwInitialized = true

				GLFWErrorCallback.create { error, description ->
					LOGGER.error("LWJGL error {}: {}", error, description)
				}.set()
			}
		} finally {
			lock.unlock()
		}

		GLFW.glfwDefaultWindowHints()

		GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE)
		GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, GLFW.GLFW_TRUE)
		GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MAJOR, 4)
		GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 5)
		GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_PROFILE, GLFW.GLFW_OPENGL_CORE_PROFILE)
		GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_FORWARD_COMPAT, GLFW.GLFW_TRUE)

		window = GLFW.glfwCreateWindow(800, 600, "KStarbound", MemoryUtil.NULL, MemoryUtil.NULL)
		require(window != MemoryUtil.NULL) { "Unable to create GLFW window" }
		startupTextList.add("Created GLFW window")

		input.installCallback(window)

		GLFW.glfwMakeContextCurrent(window)

		// This line is critical for LWJGL's interoperation with GLFW's
		// OpenGL context, or any context that is managed externally.
		// LWJGL detects the context that is current in the current thread,
		// creates the GLCapabilities instance and makes the OpenGL
		// bindings available for use.
		capabilities = GL.createCapabilities()

		GLFW.glfwSetFramebufferSizeCallback(window) { _, w, h ->
			if (w == 0 || h == 0) {
				isRenderingGame = false
			} else {
				isRenderingGame = true
				setViewport(0, 0, w, h)
				viewportMatrixScreen = updateViewportMatrixScreen()
				viewportMatrixWorld = updateViewportMatrixWorld()

				for (callback in onViewportChanged) {
					callback.invoke(w, h)
				}
			}
		}

		val stack = MemoryStack.stackPush()

		try {
			val pWidth = stack.mallocInt(1)
			val pHeight = stack.mallocInt(1)

			GLFW.glfwGetWindowSize(window, pWidth, pHeight)

			val vidmode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor())!!

			GLFW.glfwSetWindowPos(
				window,
				(vidmode.width() - pWidth[0]) / 2,
				(vidmode.height() - pHeight[0]) / 2
			)

			setViewport(0, 0, pWidth[0], pHeight[0])
			viewportMatrixScreen = updateViewportMatrixScreen()
			viewportMatrixWorld = updateViewportMatrixWorld()
		} finally {
			stack.close()
		}

		// vsync
		GLFW.glfwSwapInterval(0)

		GLFW.glfwShowWindow(window)
		putDebugLog("Initialized GLFW window")
	}

	val maxTextureBlocks = glGetInteger(GL_MAX_TEXTURE_IMAGE_UNITS)
	val maxUserTextureBlocks = maxTextureBlocks - 1 // available textures blocks for generic use
	val maxVertexAttribBindPoints = glGetInteger(GL_MAX_VERTEX_ATTRIB_BINDINGS)

	init {
		LOGGER.info("OpenGL Version: ${glGetString(GL_VERSION)}")
		LOGGER.info("OpenGL Vendor: ${glGetString(GL_VENDOR)}")
		LOGGER.info("OpenGL Renderer: ${glGetString(GL_RENDERER)}")
		LOGGER.debug("Max supported texture image units: $maxTextureBlocks")
		LOGGER.debug("Max supported vertex attribute bind points: $maxVertexAttribBindPoints")
	}

	val stack = Matrix3fStack()

	// минимальное время хранения 5 минут и...
	private val named2DTextures0: Cache<String, GLTexture2D> = Caffeine.newBuilder()
		.expireAfterAccess(Duration.ofMinutes(5))
		.build()

	// ...бесконечное хранение пока кто-то все ещё использует текстуру
	private val named2DTextures1: Cache<String, GLTexture2D> = Caffeine.newBuilder()
		.weakValues()
		.build()

	private val missingTexture: GLTexture2D by lazy {
		newTexture(missingTexturePath).upload(Starbound.readDirect(missingTexturePath), GL_RGBA, GL_RGBA).generateMips().also {
			it.textureMinFilter = GL_NEAREST
			it.textureMagFilter = GL_NEAREST
		}
	}

	private val missingTexturePath = "/assetmissing.png"
	private val regularShaderPrograms = ArrayList<WeakReference<GLShaderProgram.Regular>>()
	private val uberShaderPrograms = ArrayList<WeakReference<UberShader>>()

	val lightMapLocation = maxTextureBlocks - 1

	fun addShaderProgram(program: GLShaderProgram) {
		if (program is UberShader) {
			uberShaderPrograms.add(WeakReference(program))
		}

		if (program is GLShaderProgram.Regular) {
			regularShaderPrograms.add(WeakReference(program))
		}
	}

	fun registerCleanable(ref: Any, fn: (Int) -> Unit, nativeRef: Int): Cleaner.Cleanable {
		objectsCreated++

		val cleanable = cleaner.register(ref) {
			if (isSameThread()) {
				objectsCleaned++
				fn(nativeRef)
				checkForGLError()
			} else {
				synchronized(cleanerBacklog) {
					cleanerBacklog.add {
						objectsCleaned++
						fn(nativeRef)
						checkForGLError()
					}
				}
			}
		}

		return cleanable
	}

	fun cleanup() {
		synchronized(cleanerBacklog) {
			for (lambda in cleanerBacklog) {
				lambda.invoke()
			}

			cleanerBacklog.clear()
		}
	}

	var blend by GLStateSwitchTracker(GL_BLEND)
	var scissor by GLStateSwitchTracker(GL_SCISSOR_TEST)

	var cull by GLStateSwitchTracker(GL_CULL_FACE)
	var cullMode by GLStateFuncTracker(::glCullFace, GL_BACK)

	var textureUnpackAlignment by GLStateIntTracker(::glPixelStorei, GL_UNPACK_ALIGNMENT, 4)

	var scissorRect by GLGenericTracker(ScissorRect(0, 0, 0, 0)) {
		// require(it.x >= 0) { "Invalid X ${it.x}"}
		// require(it.y >= 0) { "Invalid Y ${it.y}"}

		require(it.width >= 0) { "Invalid width ${it.width}"}
		require(it.height >= 0) { "Invalid height ${it.height}"}

		glScissor(it.x, it.y, it.width, it.height)
	}

	var depthTest by GLStateSwitchTracker(GL_DEPTH_TEST)

	var vao by GLObjectTracker<VertexArrayObject>(::glBindVertexArray)
	var framebuffer by GLObjectTracker<GLFrameBuffer>(::glBindFramebuffer, GL_FRAMEBUFFER)
	var program by GLObjectTracker<GLShaderProgram>(::glUseProgram)

	private val textures = Array(maxTextureBlocks) { GLObjectTracker<GLTexture2D>(GL11::glBindTexture, GL_TEXTURE_2D) }

	var activeTexture = 0
		set(value) {
			ensureSameThread()

			if (field != value) {
				require(value in 0 until maxTextureBlocks) { "Texture block out of bounds: $value (max texture blocks is $maxTextureBlocks)" }
				glActiveTexture(GL_TEXTURE0 + value)
				checkForGLError()
				field = value
			}
		}

	var texture2D: GLTexture2D?
		get() = textures[activeTexture].get()
		set(value) { textures[activeTexture].accept(value) }

	var clearColor by GLGenericTracker<IStruct4f>(RGBAColor.WHITE) {
		val (r, g, b, a) = it
		glClearColor(r, g, b, a)
	}

	var blendFunc by GLGenericTracker(BlendFunc()) {
		glBlendFuncSeparate(it.sourceColor.enum, it.destinationColor.enum, it.sourceAlpha.enum, it.destinationAlpha.enum)
	}

	val freeType = FreeType()
	val font = Font()
	val box2dRenderer = Box2DRenderer()
	val programs = GLPrograms()

	init {
		glActiveTexture(GL_TEXTURE0)
		checkForGLError()
	}

	val whiteTexture = GLTexture2D("white")

	init {
		val buffer = ByteBuffer.allocateDirect(3)
		buffer.put(0xFF.toByte())
		buffer.put(0xFF.toByte())
		buffer.put(0xFF.toByte())
		buffer.position(0)
		whiteTexture.upload(GL_RGB, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, buffer)
	}

	fun setViewport(x: Int, y: Int, width: Int, height: Int) {
		ensureSameThread()

		if (viewportX != x || viewportY != y || viewportWidth != width || viewportHeight != height) {
			glViewport(x, y, width, height)
			checkForGLError("Setting viewport")
			viewportX = x
			viewportY = y
			viewportWidth = width
			viewportHeight = height
		}
	}

	fun pushScissorRect(x: Float, y: Float, width: Float, height: Float) {
		return pushScissorRect(x.roundToInt(), y.roundToInt(), width.roundToInt(), height.roundToInt())
	}

	@Suppress("NAME_SHADOWING")
	fun pushScissorRect(x: Int, y: Int, width: Int, height: Int) {
		var x = x
		var y = y
		var width = width
		var height = height

		val peek = scissorStack.lastOrNull()

		if (peek != null) {
			x = x.coerceAtLeast(peek.x)
			y = y.coerceAtLeast(peek.y)
			width = width.coerceAtMost(peek.width)
			height = height.coerceAtMost(peek.height)

			if (peek.x == x && peek.y == y && peek.width == width && peek.height == height) {
				scissorStack.add(peek)
				return
			}
		}

		val rect = ScissorRect(x, y, width, height)
		scissorStack.add(rect)
		scissorRect = rect
		scissor = true
	}

	fun popScissorRect() {
		scissorStack.removeLast()

		val peek = scissorStack.lastOrNull()

		if (peek == null) {
			scissor = false
			return
		}

		val y = viewportHeight - peek.y - peek.height
		scissorRect = ScissorRect(peek.x, y, peek.width, peek.height)
	}

	val currentScissorRect get() = scissorStack.lastOrNull()

	fun ensureSameThread() {
		if (thread !== Thread.currentThread()) {
			throw IllegalAccessException("Trying to access $this outside of $thread!")
		}
	}

	fun isSameThread() = thread === Thread.currentThread()
	fun newTexture(name: String = "<unknown>") = GLTexture2D(name)

	fun loadTexture(path: String): GLTexture2D {
		ensureSameThread()

		return named2DTextures0.get(path) {
			named2DTextures1.get(it) {
				val data = Image.get(it)

				if (data == null) {
					LOGGER.error("Texture {} is missing! Falling back to {}", it, missingTexturePath)
					missingTexture
				} else {
					newTexture(it).upload(data).also {
						it.textureMinFilter = GL_NEAREST
						it.textureMagFilter = GL_NEAREST
					}
				}
			}
		}
	}

	fun newEBO() = BufferObject.EBO()
	fun newVBO() = BufferObject.VBO()
	fun newVAO() = VertexArrayObject()

	inline fun quadWireframe(color: RGBAColor = RGBAColor.WHITE, lambda: (VertexBuilder) -> Unit) {
		val builder = programs.position.builder

		builder.builder.begin(GeometryType.QUADS_AS_LINES_WIREFRAME)
		lambda.invoke(builder.builder)
		builder.upload()

		programs.position.use()
		programs.position.colorMultiplier = color
		programs.position.worldMatrix = stack.last()

		builder.draw(GL_LINES)
	}

	fun vertex(file: File) = GLShader(file, GL_VERTEX_SHADER)
	fun fragment(file: File) = GLShader(file, GL_FRAGMENT_SHADER)

	fun vertex(contents: String) = GLShader(contents, GL_VERTEX_SHADER)
	fun fragment(contents: String) = GLShader(contents, GL_FRAGMENT_SHADER)

	fun internalVertex(file: String) = GLShader(readInternal(file), GL_VERTEX_SHADER)
	fun internalFragment(file: String) = GLShader(readInternal(file), GL_FRAGMENT_SHADER)
	fun internalGeometry(file: String) = GLShader(readInternal(file), GL_GEOMETRY_SHADER)

	fun putDebugLog(text: String, replace: Boolean = false) {
		if (replace) {
			if (startupTextList.isEmpty()) {
				startupTextList.add(text)
			} else {
				startupTextList[startupTextList.size - 1] = text
			}
		} else {
			startupTextList.add(text)
		}

		finishStartupRendering = System.currentTimeMillis() + 4000L
	}

	private fun isMe(state: StarboundClient?) {
		if (state != null && state != this) {
			throw InvalidArgumentException("Provided object does not belong to $this state tracker (belongs to $state)")
		}
	}

	private fun updateViewportMatrixScreen(): Matrix3f {
		return Matrix3f.ortho(0f, viewportWidth.toFloat(), 0f, viewportHeight.toFloat())
	}

	private fun updateViewportMatrixWorld(): Matrix3f {
		return Matrix3f.orthoDirect(0f, viewportWidth.toFloat(), 0f, viewportHeight.toFloat())
	}

	private val xMousePos = ByteBuffer.allocateDirect(8).also { it.order(ByteOrder.LITTLE_ENDIAN) }.asDoubleBuffer()
	private val yMousePos = ByteBuffer.allocateDirect(8).also { it.order(ByteOrder.LITTLE_ENDIAN) }.asDoubleBuffer()

	val mouseCoordinates: Vector2d get() {
		xMousePos.position(0)
		yMousePos.position(0)
		GLFW.glfwGetCursorPos(window, xMousePos, yMousePos)
		xMousePos.position(0)
		yMousePos.position(0)

		return Vector2d(xMousePos.get(), yMousePos.get())
	}

	val mouseCoordinatesF: Vector2f get() {
		xMousePos.position(0)
		yMousePos.position(0)
		GLFW.glfwGetCursorPos(window, xMousePos, yMousePos)
		xMousePos.position(0)
		yMousePos.position(0)

		return Vector2f(xMousePos.get().toFloat(), yMousePos.get().toFloat())
	}

	fun screenToWorld(x: Double, y: Double): Vector2d {
		val relativeX = (-viewportWidth / 2.0 + x) / settings.zoom / PIXELS_IN_STARBOUND_UNIT + camera.pos.x
		val relativeY = (-viewportHeight / 2.0 + y) / settings.zoom / PIXELS_IN_STARBOUND_UNIT + camera.pos.y
		return Vector2d(relativeX, relativeY)
	}

	fun screenToWorld(x: Int, y: Int): Vector2d {
		return screenToWorld(x.toDouble(), y.toDouble())
	}

	fun screenToWorld(value: Vector2d): Vector2d {
		return screenToWorld(value.x, value.y)
	}

	val tileRenderers = TileRenderers(this)
	var world: ClientWorld? = ClientWorld(this, 0L, Vector2i(3000, 2000), true)

	init {
		putDebugLog("Initialized OpenGL context")
		clearColor = RGBAColor.SLATE_GRAY

		blend = true
		blendFunc = BlendFunc.MULTIPLY_WITH_ALPHA
	}

	// nanoseconds
	var frameRenderTime = 0L
		private set

	private var nextRender = System.nanoTime()
	private val frameRenderTimes = LongArray(60) { 1L }
	private var frameRenderIndex = 0
	private val renderWaitTimes = LongArray(60) { 1L }
	private var renderWaitIndex = 0
	private var lastRender = System.nanoTime()

	val averageRenderWait: Double get() {
		var sum = 0.0

		for (value in renderWaitTimes)
			sum += value

		if (sum == 0.0)
			return 0.0

		sum /= 1_000_000_000.0
		return sum / renderWaitTimes.size
	}

	val averageRenderTime: Double get() {
		var sum = 0.0

		for (value in frameRenderTimes)
			sum += value

		if (sum == 0.0)
			return 0.0

		sum /= 1_000_000_000.0
		return sum / frameRenderTimes.size
	}

	val settings = ClientSettings()

	val viewportCells: ICellAccess = object : ICellAccess {
		override fun getCell(x: Int, y: Int): IChunkCell? {
			return world?.getCell(x + viewportCellX, y + viewportCellY)
		}

		override fun getCellDirect(x: Int, y: Int): IChunkCell? {
			return world?.getCellDirect(x + viewportCellX, y + viewportCellY)
		}
	}

	var viewportLighting = LightCalculator(viewportCells, viewportCellWidth, viewportCellHeight)
		private set

	val viewportLightingTexture = newTexture("Viewport Lighting")
	private var viewportLightingMem: ByteBuffer? = null

	fun updateViewportParams() {
		viewportRectangle = AABB.rectangle(
			camera.pos,
			viewportWidth / settings.zoom / PIXELS_IN_STARBOUND_UNIT,
			viewportHeight / settings.zoom / PIXELS_IN_STARBOUND_UNIT)

		viewportCellX = roundTowardsNegativeInfinity(viewportRectangle.mins.x) - 16
		viewportCellY = roundTowardsNegativeInfinity(viewportRectangle.mins.y) - 16
		viewportCellWidth = roundTowardsPositiveInfinity(viewportRectangle.width) + 32
		viewportCellHeight = roundTowardsPositiveInfinity(viewportRectangle.height) + 32

		viewportTopRight = screenToWorld(viewportWidth, viewportHeight)
		viewportBottomLeft = screenToWorld(0, 0)

		if (viewportLighting.width != viewportCellWidth || viewportLighting.height != viewportCellHeight) {
			viewportLighting = LightCalculator(viewportCells, viewportCellWidth, viewportCellHeight)
			viewportLighting.multithreaded = true

			if (viewportCellWidth > 0 && viewportCellHeight > 0) {
				viewportLightingMem = ByteBuffer.allocateDirect(viewportCellWidth.coerceAtMost(4096) * viewportCellHeight.coerceAtMost(4096) * 3)
			} else {
				viewportLightingMem = null
			}
		}
	}

	fun onViewportChanged(callback: (width: Int, height: Int) -> Unit) {
		onViewportChanged.add(callback)
	}

	fun onDrawGUI(lambda: () -> Unit) {
		onDrawGUI.add(lambda)
	}

	fun onPreDrawWorld(lambda: (LayeredRenderer) -> Unit) {
		onPreDrawWorld.add(lambda)
	}

	fun onPostDrawWorld(lambda: () -> Unit) {
		onPostDrawWorld.add(lambda)
	}

	fun onPostDrawWorldOnce(lambda: (LayeredRenderer) -> Unit) {
		onPostDrawWorldOnce.add(lambda)
	}

	fun renderFrame(): Boolean {
		ensureSameThread()

		var diff = nextRender - System.nanoTime()

		// try to sleep until next frame as precise as possible
		while (diff > 0L) {
			if (diff >= 1_500_000L) {
				LockSupport.parkNanos(1_000_000L)
			} else {
				Thread.yield()
			}

			diff = nextRender - System.nanoTime()
		}

		val mark = System.nanoTime()

		try {
			if (GLFW.glfwWindowShouldClose(window)) {
				close()
				return false
			}

			val world = world

			if (!isRenderingGame) {
				cleanup()
				GLFW.glfwPollEvents()

				if (world != null) {
					if (Starbound.initialized)
						world.think()
				}

				return true
			}

			uberShaderPrograms.forEachValid {
				if (it.flags.contains(UberShader.Flag.NEEDS_SCREEN_SIZE)) {
					it.screenSize = Vector2f(viewportWidth.toFloat(), viewportHeight.toFloat())
				}
			}

			if (world != null) {
				updateViewportParams()
				val layers = LayeredRenderer()

				if (Starbound.initialized)
					world.think()

				clearColor = RGBAColor.SLATE_GRAY
				glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)
				stack.clear(Matrix3f.identity())

				val viewMatrix = viewportMatrixWorld.copy()
					.translate(viewportWidth / 2f, viewportHeight / 2f) // центр экрана + координаты отрисовки мира
					.scale(x = settings.zoom * PIXELS_IN_STARBOUND_UNITf, y = settings.zoom * PIXELS_IN_STARBOUND_UNITf) // масштабируем до нужного размера
					.translate(-camera.pos.x.toFloat(), -camera.pos.y.toFloat()) // перемещаем вид к камере

				regularShaderPrograms.forEachValid { it.viewMatrix = viewMatrix }

				for (lambda in onPreDrawWorld) {
					lambda.invoke(layers)
				}

				for (i in onPostDrawWorldOnce.size - 1 downTo 0) {
					onPostDrawWorldOnce[i].invoke(layers)
					onPostDrawWorldOnce.removeAt(i)
				}

				viewportLighting.clear()
				val viewportLightingMem = viewportLightingMem

				world.addLayers(
					layers = layers,
					size = viewportRectangle)

				if (viewportLightingMem != null && !fullbright) {
					viewportLightingMem.position(0)
					BufferUtils.zeroBuffer(viewportLightingMem)
					viewportLightingMem.position(0)
					viewportLighting.calculate(viewportLightingMem, viewportLighting.width.coerceAtMost(4096), viewportLighting.height.coerceAtMost(4096))
					viewportLightingMem.position(0)

					val old = textureUnpackAlignment
					textureUnpackAlignment = if (viewportLighting.width.coerceAtMost(4096) % 4 == 0) 4 else 1

					viewportLightingTexture.upload(
						GL_RGB,
						viewportLighting.width.coerceAtMost(4096),
						viewportLighting.height.coerceAtMost(4096),
						GL_RGB,
						GL_UNSIGNED_BYTE,
						viewportLightingMem
					)

					textureUnpackAlignment = old
				} else {
					viewportLightingTexture.upload(GL_RGBA, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, WHITE)
				}

				viewportLightingTexture.textureMinFilter = GL_LINEAR

				activeTexture = lightMapLocation
				texture2D = viewportLightingTexture
				activeTexture = 0

				val lightmapUV = if (fullbright) Vector4f.ZERO else Vector4f(
					((viewportBottomLeft.x - viewportCellX) / viewportLighting.width).toFloat(),
					((viewportBottomLeft.y - viewportCellY) / viewportLighting.height).toFloat(),
					(1f - (viewportCellX + viewportCellWidth - viewportTopRight.x) / viewportLighting.width).toFloat(),
					(1f - (viewportCellY + viewportCellHeight - viewportTopRight.y) / viewportLighting.height).toFloat())

				uberShaderPrograms.forEachValid {
					it.lightmapTexture = lightMapLocation
					it.lightmapUV = lightmapUV
				}

				layers.render()

				world.physics.debugDraw()

				for (lambda in onPostDrawWorld) {
					lambda.invoke()
				}
			}

			regularShaderPrograms.forEachValid { it.viewMatrix = viewportMatrixScreen }

			val thisTime = System.currentTimeMillis()

			if (startupTextList.isNotEmpty() && thisTime <= finishStartupRendering) {
				var alpha = 1f

				if (finishStartupRendering - thisTime < 1000L) {
					alpha = (finishStartupRendering - thisTime) / 1000f
				}

				stack.push()
				stack.last().translate(y = viewportHeight.toFloat())
				var shade = 255

				for (i in startupTextList.size - 1 downTo 0) {
					val size = font.render(startupTextList[i], alignY = TextAlignY.BOTTOM, scale = 0.4f, color = RGBAColor(shade / 255f, shade / 255f, shade / 255f, alpha))
					stack.last().translate(y = -size.height * 1.2f)

					if (shade > 120) {
						shade -= 10
					}
				}

				stack.pop()
			}

			stack.clear(Matrix3f.identity())

			for (fn in onDrawGUI) {
				fn.invoke()
			}

			val runtime = Runtime.getRuntime()

			font.render("Latency: ${(averageRenderWait * 1_00000.0).toInt() / 100f}ms", scale = 0.4f)
			font.render("Frame: ${(averageRenderTime * 1_00000.0).toInt() / 100f}ms", y = font.lineHeight * 0.6f, scale = 0.4f)
			font.render("JVM Heap: ${formatBytesShort(runtime.totalMemory() - runtime.freeMemory())}", y = font.lineHeight * 1.2f, scale = 0.4f)
			font.render("OGL A: ${objectsCreated - objectsCleaned} D: $objectsCleaned", y = font.lineHeight * 1.8f, scale = 0.4f)

			GLFW.glfwSwapBuffers(window)
			GLFW.glfwPollEvents()
			input.think()

			camera.think(Starbound.TICK_TIME_ADVANCE)

			cleanup()

			return true
		} finally {
			frameRenderTime = System.nanoTime() - mark
			frameRenderTimes[++frameRenderIndex % frameRenderTimes.size] = frameRenderTime
			renderWaitTimes[++renderWaitIndex % renderWaitTimes.size] = System.nanoTime() - lastRender
			lastRender = System.nanoTime()
			nextRender = mark + Starbound.TICK_TIME_ADVANCE_NANOS
		}
	}

	fun onTermination(lambda: () -> Unit) {
		terminateCallbacks.add(lambda)
	}

	override fun close() {
		if (clientTerminated)
			return

		lock.lock()

		try {
			if (window != MemoryUtil.NULL) {
				Callbacks.glfwFreeCallbacks(window)
				GLFW.glfwDestroyWindow(window)
			}

			if (--clients == 0) {
				GLFW.glfwTerminate()
				GLFW.glfwSetErrorCallback(null)?.free()
				glfwInitialized = false
			}

			clientTerminated = true

			for (callback in terminateCallbacks) {
				callback.invoke()
			}
		} finally {
			lock.unlock()
		}
	}

	companion object {
		private val LOGGER = LogManager.getLogger(StarboundClient::class.java)
		private val CLIENTS = ThreadLocal<StarboundClient>()
		private val WHITE = ByteBuffer.allocateDirect(4).also {
			it.put(0xFF.toByte())
			it.put(0xFF.toByte())
			it.put(0xFF.toByte())
			it.put(0xFF.toByte())
			it.position(0)
		}

		@JvmStatic
		fun current() = checkNotNull(CLIENTS.get()) { "No client registered to current thread (${Thread.currentThread()})" }
		@JvmStatic
		fun currentOrNull(): StarboundClient? = CLIENTS.get()

		private val lock = ReentrantLock()
		@Volatile
		private var glfwInitialized = false
		@Volatile
		private var clients = 0

		@JvmStatic
		fun readInternal(file: String): String {
			return ClassLoader.getSystemClassLoader().getResourceAsStream(file)!!.bufferedReader()
				.let {
					val read = it.readText()
					it.close()
					read
				}
		}
	}
}