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

import alexiil.mc.lib.attributes.SearchOptions
import alexiil.mc.lib.attributes.item.GroupedItemInv
import alexiil.mc.lib.attributes.item.ItemAttributes
import net.minecraft.block.BlockState
import net.minecraft.nbt.CompoundTag
import net.minecraft.util.math.Direction
import net.shadowfacts.phycon.api.packet.Packet
import net.shadowfacts.phycon.api.util.IPAddress
import net.shadowfacts.phycon.init.PhyBlockEntities
import net.shadowfacts.phycon.network.DeviceBlockEntity
import net.shadowfacts.phycon.network.component.ActivationController
import net.shadowfacts.phycon.network.packet.CapacityPacket
import net.shadowfacts.phycon.network.packet.CheckCapacityPacket
import net.shadowfacts.phycon.network.packet.ItemStackPacket
import net.shadowfacts.phycon.network.packet.RemoteActivationPacket
import net.shadowfacts.phycon.util.ActivationMode

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

	companion object {
		val SLEEP_TIME = 40L
	}

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

	private var inventory: GroupedItemInv? = null
	private var shouldExtract = false
	override val controller = ActivationController(SLEEP_TIME, this)

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

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

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

	private fun handleCapacity(packet: CapacityPacket) {
		if (shouldExtract && packet.capacity > 0) {
			getInventory()?.also { inv ->
				shouldExtract = false
				val extracted = inv.extract(packet.stack, packet.capacity)
				sendPacket(ItemStackPacket(extracted, ipAddress, packet.stackReceiver.ipAddress))
			}
		}
	}

	override fun tick() {
		super.tick()

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

	override fun activate(): Boolean {
		val inventory = getInventory() ?: return false
		val stack = inventory.storedStacks.firstOrNull() ?: return false
		shouldExtract = true
		sendPacket(CheckCapacityPacket(stack, ipAddress, IPAddress.BROADCAST))
		return true
	}

	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"))
	}
}