li/cil/oc/common/tileentity/ComponentInventory.scala

package li.cil.oc.common.tileentity

import li.cil.oc.Items
import li.cil.oc.api.driver.Slot
import li.cil.oc.api.network.{PoweredNode, Node}
import li.cil.oc.common.item
import li.cil.oc.server.component
import li.cil.oc.server.driver.Registry
import net.minecraft.inventory.IInventory
import net.minecraft.item.ItemStack
import net.minecraft.nbt.NBTTagCompound
import net.minecraft.nbt.NBTTagList
import net.minecraft.world.World

trait ComponentInventory extends IInventory with PoweredNode {
  protected val inventory = new Array[ItemStack](inventorySize)

  protected val itemComponents = Array.fill[Option[Node]](inventorySize)(None)

  protected val computer: component.Computer

  def world: World

  def inventorySize = 8

  def installedMemory = inventory.foldLeft(0)((sum, stack) => sum + (Registry.driverFor(stack) match {
    case Some(driver) if driver.slot(stack) == Slot.RAM => Items.multi.subItem(stack) match {
      case Some(ram: item.Memory) => ram.kiloBytes * 1024
      case _ => 0
    }
    case _ => 0
  }))

  override def load(nbt: NBTTagCompound) = {
    super.load(nbt)
    val list = nbt.getTagList("list")
    for (i <- 0 until list.tagCount) {
      val slotNbt = list.tagAt(i).asInstanceOf[NBTTagCompound]
      val slot = slotNbt.getByte("slot")
      if (slot >= 0 && slot < inventory.length) {
        inventory(slot) = ItemStack.loadItemStackFromNBT(
          slotNbt.getCompoundTag("item"))
        itemComponents(slot) = Registry.driverFor(inventory(slot)) match {
          case None => None
          case Some(driver) => driver.node(inventory(slot))
        }
      }
    }
    computer.recomputeMemory()
  }

  override def save(nbt: NBTTagCompound) = {
    super.save(nbt)
    val list = new NBTTagList
    inventory.zipWithIndex filter {
      case (stack, slot) => stack != null
    } foreach {
      case (stack, slot) => {
        val slotNbt = new NBTTagCompound
        slotNbt.setByte("slot", slot.toByte)

        itemComponents(slot) match {
          case None => // Nothing special to save.
          case Some(node) =>
            // We're guaranteed to have a driver for entries.
            node.save(Registry.driverFor(stack).get.nbt(stack))
        }

        val itemNbt = new NBTTagCompound
        stack.writeToNBT(itemNbt)
        slotNbt.setCompoundTag("item", itemNbt)
        list.appendTag(slotNbt)
      }
    }
    nbt.setTag("list", list)
  }

  // ----------------------------------------------------------------------- //
  // NetworkNode
  // ----------------------------------------------------------------------- //

  override protected def onConnect() {
    super.onConnect()
    for (node <- itemComponents.filter(_.isDefined).map(_.get))
      network.foreach(_.connect(this, node))
  }

  override protected def onDisconnect() {
    super.onDisconnect()
    for (node <- itemComponents.filter(_.isDefined).map(_.get))
      node.network.foreach(_.remove(node))
  }

  // ----------------------------------------------------------------------- //
  // IInventory
  // ----------------------------------------------------------------------- //

  def getInventoryStackLimit = 1

  def getInvName = "oc.container.computer"

  def getSizeInventory = inventory.length

  def getStackInSlot(i: Int) = inventory(i)

  def decrStackSize(slot: Int, amount: Int) = {
    val stack = getStackInSlot(slot)
    if (stack == null)
      null
    else if (stack.stackSize <= amount) {
      setInventorySlotContents(slot, null)
      stack
    }
    else {
      val subStack = stack.splitStack(amount)
      if (stack.stackSize == 0) {
        setInventorySlotContents(slot, null)
      }
      subStack
    }
  }

  def getStackInSlotOnClosing(slot: Int) = null

  def setInventorySlotContents(slot: Int, item: ItemStack) = {
    // Uninstall component previously in that slot.
    if (!world.isRemote) itemComponents(slot) match {
      case None => // Nothing to do.
      case Some(node) =>
        itemComponents(slot) = None
        node.network.foreach(_.remove(node))
        node.save(Registry.driverFor(inventory(slot)).get.nbt(inventory(slot)))
    }

    inventory(slot) = item
    if (item != null && item.stackSize > getInventoryStackLimit)
      item.stackSize = getInventoryStackLimit

    if (!world.isRemote) {
      Registry.driverFor(inventory(slot)) match {
        case None => // No driver.
        case Some(driver) =>
          driver.node(inventory(slot)) match {
            case None => // No node.
            case Some(node) =>
              itemComponents(slot) = Some(node)
              network.foreach(_.connect(this, node))
          }
      }

      computer.recomputeMemory()
    }
  }

  def isItemValidForSlot(slot: Int, item: ItemStack) = (slot, Registry.driverFor(item)) match {
    case (_, None) => false // Invalid item.
    case (0, Some(driver)) => driver.slot(item) == Slot.PSU
    case (1 | 2 | 3, Some(driver)) => driver.slot(item) == Slot.PCI
    case (4 | 5, Some(driver)) => driver.slot(item) == Slot.RAM
    case (6 | 7, Some(driver)) => driver.slot(item) == Slot.HDD
    case _ => false // Invalid slot.
  }

  def isInvNameLocalized = false

  def openChest() {}

  def closeChest() {}
}