PhysicalConnectivity/src/main/kotlin/net/shadowfacts/phycon/network/block/extractor/ExtractorBlockEntity.kt

package net.shadowfacts.phycon.network.block.extractor

import alexiil.mc.lib.attributes.SearchOptions
import alexiil.mc.lib.attributes.Simulation
import alexiil.mc.lib.attributes.item.FixedItemInv
import alexiil.mc.lib.attributes.item.ItemAttributes
import alexiil.mc.lib.attributes.item.filter.ExactItemStackFilter
import net.minecraft.block.BlockState
import net.minecraft.item.ItemStack
import net.minecraft.nbt.CompoundTag
import net.minecraft.util.math.Direction
import net.shadowfacts.phycon.api.packet.Packet
import net.shadowfacts.phycon.init.PhyBlockEntities
import net.shadowfacts.phycon.network.DeviceBlockEntity
import net.shadowfacts.phycon.network.component.ActivationController
import net.shadowfacts.phycon.network.component.NetworkStackDispatcher
import net.shadowfacts.phycon.network.component.handleItemStack
import net.shadowfacts.phycon.network.packet.CapacityPacket
import net.shadowfacts.phycon.network.packet.ItemStackPacket
import net.shadowfacts.phycon.network.packet.RemoteActivationPacket
import net.shadowfacts.phycon.util.ActivationMode
import kotlin.properties.Delegates

/**
 * @author shadowfacts
 */
class ExtractorBlockEntity: DeviceBlockEntity(PhyBlockEntities.EXTRACTOR),
	NetworkStackDispatcher<ExtractorBlockEntity.PendingInsertion>,
	ActivationController.ActivatableDevice {

	companion object {
		val SLEEP_TIME = 40L
	}

	private val facing: Direction
		get() = cachedState[ExtractorBlock.FACING]

	private var inventory: FixedItemInv? = null
	override val pendingInsertions = mutableListOf<PendingInsertion>()
	override val dispatchStackTimeout = 40L
	override val controller = ActivationController(SLEEP_TIME, this)

	fun updateInventory() {
		val offsetPos = pos.offset(facing)
		val option = SearchOptions.inDirection(facing)
		inventory = ItemAttributes.FIXED_INV.getFirstOrNull(world, offsetPos, option)
	}

	private fun getInventory(): FixedItemInv? {
		if (inventory == null) updateInventory()
		return inventory
	}

	override fun handle(packet: Packet) {
		when (packet) {
			is CapacityPacket -> handleCapacity(packet)
			is ItemStackPacket -> handleItemStack(packet)
			is RemoteActivationPacket -> controller.handleRemoteActivation(packet)
		}
	}

	override fun doHandleItemStack(packet: ItemStackPacket): ItemStack {
		// we can't insert things back into the inventory, so just let them spawn
		return packet.stack
	}

	override fun createPendingInsertion(stack: ItemStack) = PendingInsertion(stack, counter)

	override fun finishInsertion(insertion: PendingInsertion): ItemStack {
		val inventory = getInventory() ?: return insertion.stack
		// if the inventory has changed, the old slot index is meaningless
		if (inventory !== insertion.inventory) return insertion.stack
		val extracted = inventory.extractStack(insertion.inventorySlot, ExactItemStackFilter(insertion.stack), ItemStack.EMPTY, insertion.totalCapacity, Simulation.ACTION)
		if (extracted.isEmpty) return insertion.stack
		// if we extracted less than expected, make sure super.finishInsertion doesn't send more than we actually have
		insertion.stack = extracted
		return super.finishInsertion(insertion)
	}

	override fun tick() {
		super.tick()

		if (!world!!.isClient) {
			controller.tick()
		}
	}

	override fun activate(): Boolean {
		val inventory = getInventory() ?: return false
		for (slot in 0 until inventory.slotCount) {
			val slotStack = inventory.getInvStack(slot)
			if (slotStack.isEmpty) continue
			dispatchItemStack(slotStack) { insertion ->
				insertion.inventory = inventory
				insertion.inventorySlot = slot
			}
			return true
		}
		return false
	}

	override fun toTag(tag: CompoundTag): CompoundTag {
		tag.putString("ActivationMode", controller.activationMode.name)
		return super.toTag(tag)
	}

	override fun fromTag(state: BlockState, tag: CompoundTag) {
		super.fromTag(state, tag)
		controller.activationMode = ActivationMode.valueOf(tag.getString("ActivationMode"))
	}

	override fun toClientTag(tag: CompoundTag): CompoundTag {
		tag.putString("ActivationMode", controller.activationMode.name)
		return super.toClientTag(tag)
	}

	override fun fromClientTag(tag: CompoundTag) {
		super.fromClientTag(tag)
		controller.activationMode = ActivationMode.valueOf(tag.getString("ActivationMode"))
	}

	class PendingInsertion(stack: ItemStack, timestamp: Long): NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
		lateinit var inventory: FixedItemInv
		var inventorySlot by Delegates.notNull<Int>()
	}
}