package net.shadowfacts.phycon.block.terminal

import com.mojang.blaze3d.systems.RenderSystem
import net.minecraft.client.MinecraftClient
import net.minecraft.client.gui.DrawableHelper
import net.minecraft.client.gui.screen.ingame.HandledScreen
import net.minecraft.client.gui.widget.AbstractButtonWidget
import net.minecraft.client.gui.widget.AbstractPressableButtonWidget
import net.minecraft.client.gui.widget.ButtonWidget
import net.minecraft.client.gui.widget.TextFieldWidget
import net.minecraft.client.render.Tessellator
import net.minecraft.client.render.VertexConsumerProvider
import net.minecraft.client.util.math.MatrixStack
import net.minecraft.entity.player.PlayerInventory
import net.minecraft.item.ItemStack
import net.minecraft.screen.slot.Slot
import net.minecraft.screen.slot.SlotActionType
import net.minecraft.text.LiteralText
import net.minecraft.text.Text
import net.minecraft.text.TranslatableText
import net.minecraft.util.Identifier
import net.minecraft.util.math.MathHelper
import net.shadowfacts.phycon.PhysicalConnectivity
import net.shadowfacts.phycon.networking.C2STerminalRequestItem
import net.shadowfacts.phycon.networking.C2STerminalUpdateDisplayedItems
import net.shadowfacts.phycon.util.SortMode
import net.shadowfacts.phycon.util.next
import net.shadowfacts.phycon.util.prev
import org.lwjgl.glfw.GLFW
import java.lang.NumberFormatException
import java.math.RoundingMode
import java.text.DecimalFormat
import kotlin.math.ceil
import kotlin.math.floor
import kotlin.math.min
import kotlin.math.roundToInt

/**
 * @author shadowfacts
 */
// todo: translate title
class TerminalScreen(handler: TerminalScreenHandler, playerInv: PlayerInventory, title: Text): HandledScreen<TerminalScreenHandler>(handler, playerInv, title) {
	companion object {
		private val BACKGROUND = Identifier(PhysicalConnectivity.MODID, "textures/gui/terminal.png")
		private val DIALOG = Identifier(PhysicalConnectivity.MODID, "textures/gui/terminal_amount.png")
	}

	private lateinit var searchBox: TextFieldWidget
	private lateinit var sortButton: SortButton
	var sortButtonX: Int = 0
		private set
	var sortButtonY = 0
		private set
	private lateinit var amountBox: TextFieldWidget
	private var dialogStack = ItemStack.EMPTY
	private var showingAmountDialog = false
		set(value) {
			val oldValue = field
			field = value
			for (e in dialogChildren) {
				e.visible = value
			}
			amountBox.isVisible
			searchBox.setSelected(!value)
			amountBox.setSelected(value)
			if (value && !oldValue) {
				amountBox.text = "1"
			}
			updateFocusedElement()
		}
	private var dialogChildren = mutableListOf<AbstractButtonWidget>()

	private var scrollPosition = 0f
	private var isDraggingScrollThumb = false
	private val trackMinY = 18
	private val trackHeight = 106
	private val thumbHeight = 15
	private val thumbWidth = 12
	private val scrollThumbTop: Int
		get() = trackMinY + (scrollPosition * (trackHeight - thumbHeight)).roundToInt()

	private val dialogWidth = 158
	private val dialogHeight = 62

	init {
		backgroundWidth = 252
		backgroundHeight = 222
	}

	override fun init() {
		super.init()

		children.clear()
		dialogChildren.clear()

		client!!.keyboard.setRepeatEvents(true)

		searchBox = TextFieldWidget(textRenderer, x + 138, y + 6, 80, 9, LiteralText("Search"))
		searchBox.setMaxLength(50)
		// setHasBorder is actually setDrawsBackground
		searchBox.setHasBorder(false)
		searchBox.isVisible = true
		searchBox.setSelected(true)
		searchBox.setEditableColor(0xffffff)
		addChild(searchBox)

		sortButtonX = x + 256
		sortButtonY = y
		sortButton = SortButton(sortButtonX, sortButtonY, handler.sortMode, {
			requestUpdatedItems()
		}, ::renderTooltip)
		addButton(sortButton)

		val dialogMinX = width / 2 - dialogWidth / 2
		val dialogMinY = height / 2 - dialogHeight / 2
		amountBox = TextFieldWidget(textRenderer, dialogMinX + 8, dialogMinY + 27, 80, 9, LiteralText("Amount"))
		amountBox.setHasBorder(false)
		amountBox.isVisible = false
		amountBox.setSelected(false)
		amountBox.setEditableColor(0xffffff)
		amountBox.setTextPredicate {
			if (it.isEmpty()) {
				true
			} else {
				try {
					Integer.parseInt(it) > 0
				} catch (e: NumberFormatException) {
					false
				}
			}
		}
		dialogChildren.add(amountBox)

		val plusOne = SmallButton(dialogMinX + 7, dialogMinY + 7, 28, LiteralText("+1")) {
			amountBox.intValue += 1
		}
		dialogChildren.add(plusOne)

		val plusTen = SmallButton(dialogMinX + 7 + 28 + 3, dialogMinY + 7, 28, LiteralText("+10")) {
			amountBox.intValue = ceil((amountBox.intValue + 1) / 10.0).toInt() * 10
		}
		dialogChildren.add(plusTen)

		val plusHundred = SmallButton(dialogMinX + 7 + (28 + 3) * 2, dialogMinY + 7, 28, LiteralText("+100")) {
			amountBox.intValue = ceil((amountBox.intValue + 1) / 100.0).toInt() * 100
		}
		dialogChildren.add(plusHundred)

		val minusOne = SmallButton(dialogMinX + 7, dialogMinY + 39, 28, LiteralText("-1")) {
			amountBox.intValue -= 1
		}
		dialogChildren.add(minusOne)

		val minusTen = SmallButton(dialogMinX + 7 + 28 + 3, dialogMinY + 39, 28, LiteralText("-10")) {
			amountBox.intValue = floor((amountBox.intValue - 1) / 10.0).toInt() * 10
		}
		dialogChildren.add(minusTen)

		val minusHundred = SmallButton(dialogMinX + 7 + (28 + 3) * 2, dialogMinY + 39, 28, LiteralText("-100")) {
			amountBox.intValue = floor((amountBox.intValue - 1) / 100.0).toInt() * 100
		}
		dialogChildren.add(minusHundred)

		// 101,25
		val request = ButtonWidget(dialogMinX + 101, dialogMinY + 21, 50, 20, LiteralText("Request")) {
			doDialogRequest()
		}
		dialogChildren.add(request)

		updateFocusedElement()
		requestUpdatedItems()
	}

	private fun updateFocusedElement() {
		focused = if (showingAmountDialog) {
			amountBox
		} else if (searchBox.isFocused) {
			searchBox
		} else {
			null
		}
	}

	private fun requestUpdatedItems() {
		val player = MinecraftClient.getInstance().player!!
		player.networkHandler.sendPacket(C2STerminalUpdateDisplayedItems(handler.terminal, searchBox.text, sortButton.mode, scrollPosition))
	}

	override fun tick() {
		super.tick()
		searchBox.tick()
		amountBox.tick()
	}

	override fun drawForeground(matrixStack: MatrixStack, mouseX: Int, mouseY: Int) {
		textRenderer.draw(matrixStack, title, 65f, 6f, 0x404040)
		textRenderer.draw(matrixStack, playerInventory.displayName, 65f, backgroundHeight - 94f, 0x404040)
		textRenderer.draw(matrixStack, TranslatableText("gui.phycon.terminal_buffer"), 7f, 6f, 0x404040)
	}

	override fun drawBackground(matrixStack: MatrixStack, delta: Float, mouseX: Int, mouseY: Int) {
		// if the dialog is open, the background gradient will be drawn in front of the main terminal gui
		if (!showingAmountDialog) {
			renderBackground(matrixStack)
		}

		RenderSystem.color4f(1f, 1f, 1f, 1f)
		client!!.textureManager.bindTexture(BACKGROUND)
		val x = (width - backgroundWidth) / 2
		val y = (height - backgroundHeight) / 2
		drawTexture(matrixStack, x, y, 0, 0, backgroundWidth, backgroundHeight)

		// scroll thumb
		drawTexture(matrixStack, x + 232, y + scrollThumbTop, 52, 230, thumbWidth, thumbHeight)
	}

	@ExperimentalUnsignedTypes
	override fun render(matrixStack: MatrixStack, mouseX: Int, mouseY: Int, delta: Float) {
		if (showingAmountDialog) {
			RenderSystem.pushMatrix()
			// items are rendered at some stupidly high z offset. item amounts at an even higher one
			RenderSystem.translatef(0f, 0f, -350f)

			// fake the mouse x/y while showing a dialog so slot mouseover highlights aren't drawn
			super.render(matrixStack, -1, -1, delta)

			RenderSystem.popMatrix()
		} else {
			super.render(matrixStack, mouseX, mouseY, delta)
		}

		searchBox.render(matrixStack, mouseX, mouseY, delta)

		if (showingAmountDialog) {
			renderBackground(matrixStack)

			RenderSystem.color4f(1f, 1f, 1f, 1f)
			client!!.textureManager.bindTexture(DIALOG)
			val dialogMinX = width / 2 - dialogWidth / 2
			val dialogMinY = height / 2 - dialogHeight / 2
			drawTexture(matrixStack, dialogMinX, dialogMinY, 0, 0, dialogWidth, dialogHeight)

			for (e in dialogChildren) {
				e.render(matrixStack, mouseX, mouseY, delta)
			}
		} else {
			drawMouseoverTooltip(matrixStack, mouseX, mouseY)
		}
	}

	@ExperimentalUnsignedTypes
	fun drawSlotUnderlay(matrixStack: MatrixStack, slot: Slot) {
		if (!handler.isBufferSlot(slot.id)) {
			return
		}

		val mode = handler.terminal.internalBuffer.getMode(slot.id - handler.bufferSlotsStart)
		val color: UInt = when (mode) {
			TerminalBufferInventory.Mode.TO_NETWORK -> 0xFFFF0000u
			TerminalBufferInventory.Mode.FROM_NETWORK -> 0xFF00FF00u
			else -> return
		}
		DrawableHelper.fill(matrixStack, slot.x, slot.y, slot.x + 16, slot.y + 16, color.toInt())
	}

	private val DECIMAL_FORMAT = DecimalFormat("#.#").apply { roundingMode = RoundingMode.HALF_UP }
	private val FORMAT = DecimalFormat("##").apply { roundingMode = RoundingMode.HALF_UP }

	fun drawNetworkSlotAmount(stack: ItemStack, x: Int, y: Int, slot: Slot, matrixStack: MatrixStack) {
		val amount = stack.count
		val s = when {
			amount < 1_000 -> amount.toString()
			amount < 1_000_000 -> {
				val format = if (amount < 10_000) DECIMAL_FORMAT else FORMAT
				format.format(amount / 1_000.0) + "K"
			}
			amount < 1_000_000_000 -> {
				val format = if (amount < 10_000_000) DECIMAL_FORMAT else FORMAT
				format.format(amount / 1_000_000.0) + "M"
			}
			else -> {
				DECIMAL_FORMAT.format(amount / 1000000000.0).toString() + "B"
			}
		}

		// draw damage bar
		// empty string for label because vanilla renders the count behind the damage bar
		itemRenderer.renderGuiItemOverlay(textRenderer, stack, x, y, "")

		matrixStack.push()
		matrixStack.translate(x.toDouble(), y.toDouble(), itemRenderer.zOffset + 200.0)
		val scale = 2 / 3f
		matrixStack.scale(scale, scale, 1.0f)
		val immediate = VertexConsumerProvider.immediate(Tessellator.getInstance().buffer)
		val textX = (1 / scale * 18) - textRenderer.getWidth(s).toFloat() - 3
		val textY = (1 / scale * 18) - 11
		textRenderer.draw(s, textX, textY, 0xffffff, true, matrixStack.peek().model, immediate, false, 0, 0xF000F0)
		immediate.draw()
		matrixStack.pop()
	}

	private fun isPointInsScrollThumb(mouseX: Double, mouseY: Double): Boolean {
		val x = (width - backgroundWidth) / 2
		val y = (height - backgroundHeight) / 2
		val thumbMinX = x + 232
		val thumbMaxX = thumbMinX + thumbWidth
		val thumbMinY = y + scrollThumbTop
		val thumbMaxY = thumbMinY + thumbHeight
		return mouseX >= thumbMinX && mouseX < thumbMaxX && mouseY >= thumbMinY && mouseY < thumbMaxY
	}

	override fun onMouseClick(slot: Slot?, invSlot: Int, clickData: Int, type: SlotActionType?) {
		super.onMouseClick(slot, invSlot, clickData, type)

		updateFocusedElement()

		if (slot != null && !slot.stack.isEmpty && handler.isNetworkSlot(slot.id)) {
			val stack = slot.stack

			if (type == SlotActionType.QUICK_MOVE) {
				// shift click, request full stack
				requestItem(stack, min(stack.count, stack.maxCount))
			} else if (type == SlotActionType.PICKUP) {
				if (clickData == 1) {
					// right click, request half stack
					requestItem(stack, ceil(min(stack.count, stack.maxCount) / 2f).toInt())
				} else {
					dialogStack = stack
					showingAmountDialog = true
					searchBox.setSelected(false)
				}
			}
		}
	}

	override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
		if (showingAmountDialog) {
			for (e in dialogChildren) {
				if (e.mouseClicked(mouseX, mouseY, button)) {
					return true
				}
			}
			return false
		} else {
			if (isPointInsScrollThumb(mouseX, mouseY)) {
				isDraggingScrollThumb = true
				return true
			}

			return super.mouseClicked(mouseX, mouseY, button)
		}
	}

	override fun mouseDragged(mouseX: Double, mouseY: Double, button: Int, deltaX: Double, deltaY: Double): Boolean {
		if (showingAmountDialog) {
			return false
		} else if (isDraggingScrollThumb) {
			scrollPosition = (mouseY.toFloat() - (y + trackMinY) - 7.5f) / (trackHeight - 15)
			scrollPosition = MathHelper.clamp(scrollPosition, 0f, 1f)
			requestUpdatedItems()
			return true
		} else {
			return super.mouseDragged(mouseX, mouseY, button, deltaX, deltaY)
		}
	}

	override fun mouseMoved(d: Double, e: Double) {
		if (showingAmountDialog) {
		} else {
			super.mouseMoved(d, e)
		}
	}

	override fun mouseReleased(d: Double, e: Double, i: Int): Boolean {
		if (showingAmountDialog) {
			return false
		} else {
			isDraggingScrollThumb = false

			return super.mouseReleased(d, e, i)
		}
	}

	override fun mouseScrolled(mouseX: Double, mouseY: Double, amount: Double): Boolean {
		if (showingAmountDialog) {
			return false
		} else {
			var newOffsetInRows = handler.currentScrollOffsetInRows() - amount.toInt()
			newOffsetInRows = MathHelper.clamp(newOffsetInRows, 0, handler.maxScrollOffsetInRows())
			val newScrollPosition = newOffsetInRows / handler.maxScrollOffsetInRows().toFloat()
			scrollPosition = newScrollPosition
			requestUpdatedItems()

			return super.mouseScrolled(mouseX, mouseY, amount)
		}
	}

	override fun charTyped(c: Char, i: Int): Boolean {
		if (showingAmountDialog) {
			return amountBox.charTyped(c, i)
		} else {
			val oldText = searchBox.text
			if (searchBox.charTyped(c, i)) {
				if (searchBox.text != oldText) {
					scrollPosition = 0f
					requestUpdatedItems()
				}
				return true
			}

			return super.charTyped(c, i)
		}
	}

	override fun keyPressed(key: Int, j: Int, k: Int): Boolean {
		if (showingAmountDialog) {
			return when (key) {
				GLFW.GLFW_KEY_ESCAPE -> {
					showingAmountDialog = false
					true
				}
				GLFW.GLFW_KEY_ENTER -> {
					doDialogRequest()
					true
				}
				else -> {
					amountBox.keyPressed(key, j, k)
				}
			}
		} else {
			val oldText = searchBox.text
			if (searchBox.keyPressed(key, j, k)) {
				if (searchBox.text != oldText) {
					scrollPosition = 0f
					requestUpdatedItems()
				}
				return true
			}
			return if (searchBox.isFocused && searchBox.isVisible && key != GLFW.GLFW_KEY_ESCAPE) {
				true
			} else {
				super.keyPressed(key, j, k)
			}
		}
	}

	private fun doDialogRequest() {
		showingAmountDialog = false
		requestItem(dialogStack, amountBox.intValue)
	}

	private fun requestItem(stack: ItemStack, amount: Int) {
		val netHandler = MinecraftClient.getInstance().player!!.networkHandler
		val packet = C2STerminalRequestItem(handler.terminal, stack, amount)
		netHandler.sendPacket(packet)
	}

	private var TextFieldWidget.intValue: Int
		get() = if (text.isEmpty()) 0 else Integer.parseInt(text)
		set(value) {
			text = value.toString()
			setSelected(true)
		}

	class SmallButton(x: Int, y: Int, width: Int, title: Text, action: PressAction): ButtonWidget(x, y, width, 14, title, action) {
		@ExperimentalUnsignedTypes
		override fun renderButton(matrixStack: MatrixStack, mouseX: Int, mouseY: Int, delta: Float) {
			val client = MinecraftClient.getInstance()
			client.textureManager.bindTexture(DIALOG)
			RenderSystem.color4f(1f, 1f, 1f, 1f)
			val v = if (isHovered) 142 else 128
			RenderSystem.enableBlend()
			RenderSystem.defaultBlendFunc()
			RenderSystem.enableDepthTest()
			drawTexture(matrixStack, x, y, 0, v, width / 2, height)
			drawTexture(matrixStack, x + width / 2, y, 200 - width / 2, v, width / 2, height)
			drawCenteredText(matrixStack, client.textRenderer, message, x + width / 2, y + (height - 8) / 2, 0xffffffffu.toInt())
		}
	}

	class SortButton(
		x: Int,
		y: Int,
		var mode: SortMode,
		val onChange: (SortMode) -> Unit,
		val doRenderTooltip: (MatrixStack, Text, Int, Int) -> Unit
	): AbstractPressableButtonWidget(x, y, 20, 20, LiteralText("")) {
		override fun onPress() {}

		override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
			if ((button == 0 || button == 1) && clicked(mouseX, mouseY)) {
				val newVal = if (button == 0) mode.next else mode.prev
				mode = newVal
				onChange(mode)

				playDownSound(MinecraftClient.getInstance().soundManager)
				return true
			}
			return false
		}

		override fun renderButton(matrixStack: MatrixStack, mouseX: Int, mouseY: Int, delta: Float) {
			val client = MinecraftClient.getInstance()
			RenderSystem.color4f(1f, 1f, 1f, 1f)
			RenderSystem.enableBlend()
			RenderSystem.defaultBlendFunc()
			RenderSystem.enableDepthTest()

			client.textureManager.bindTexture(WIDGETS_LOCATION)
			val k = getYImage(isHovered)
			drawTexture(matrixStack, x, y, 0, 46 + k * 20, width / 2, height)
			drawTexture(matrixStack, x + width / 2, y, 200 - width / 2, 46 + k * 20, width / 2, height)

			client.textureManager.bindTexture(BACKGROUND)
			val u: Int = when (mode) {
				SortMode.COUNT_HIGH_FIRST -> 0
				SortMode.COUNT_LOW_FIRST -> 16
				SortMode.ALPHABETICAL -> 32
			}
			drawTexture(matrixStack, x + 2, y + 2, u, 230, 16, 16)

			if (isHovered) {
				renderToolTip(matrixStack, mouseX, mouseY)
			}
		}

		override fun renderToolTip(matrixStack: MatrixStack, mouseX: Int, mouseY: Int) {
			val text = LiteralText("")
			text.append("Sort by: ")
			text.append(mode.tooltip)
			doRenderTooltip(matrixStack, text, mouseX, mouseY)
		}
	}

}