src/main/scala/li/cil/oc/integration/fmp/EventHandler.scala

package li.cil.oc.integration.fmp

import codechicken.lib.packet.PacketCustom
import codechicken.lib.raytracer.RayTracer
import codechicken.lib.vec.BlockCoord
import codechicken.lib.vec.Vector3
import codechicken.multipart.TileMultipart
import cpw.mods.fml.common.eventhandler.SubscribeEvent
import li.cil.oc.Settings
import li.cil.oc.api.Items
import li.cil.oc.client.PacketSender
import li.cil.oc.common.block.SimpleBlock
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.item.ItemBlock
import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement
import net.minecraft.util.MovingObjectPosition
import net.minecraftforge.common.MinecraftForge
import net.minecraftforge.common.util.ForgeDirection
import net.minecraftforge.event.entity.player.PlayerDestroyItemEvent
import net.minecraftforge.event.entity.player.PlayerInteractEvent
import net.minecraftforge.event.entity.player.PlayerInteractEvent.Action

object EventHandler {
  private var currentlyPlacing = false

  private val yaw2Direction = Array(ForgeDirection.SOUTH, ForgeDirection.WEST, ForgeDirection.NORTH, ForgeDirection.EAST)

  @SubscribeEvent
  def playerInteract(event: PlayerInteractEvent) {
    this.synchronized {
      if (currentlyPlacing) return
      try {
        currentlyPlacing = true
        val player = event.entityPlayer
        if (event.action == Action.RIGHT_CLICK_BLOCK && player.getEntityWorld.isRemote) {
          if (place(player)) {
            event.setCanceled(true)
          }
        }
      }
      finally {
        currentlyPlacing = false
      }
    }
  }

  def place(player: EntityPlayer) = {
    val world = player.getEntityWorld
    val hit = RayTracer.reTrace(world, player)
    if (hit != null && player.getHeldItem != null) player.getHeldItem.getItem match {
      case itemBlock: ItemBlock =>
        itemBlock.field_150939_a match {
          case simpleBlock: SimpleBlock =>
            if (simpleBlock == Items.get("cable").block()) {
              placeDelegatePart(player, hit, new CablePart())
            }
            else if (simpleBlock == Items.get("print").block()) {
              val part = new PrintPart()
              part.data.load(player.getHeldItem)
              part.facing = yaw2Direction((player.rotationYaw / 360 * 4).round & 3).getOpposite
              placeDelegatePart(player, hit, part)
            }
            else false
          case _ => false
        }
      case _ => false
    }
    else false
  }


  protected def placeDelegatePart(player: EntityPlayer, hit: MovingObjectPosition, part: SimpleBlockPart): Boolean = {
    val world = player.getEntityWorld
    if (world.isRemote && !player.isSneaking) {
      // Attempt to use block activated like normal and tell the server the right stuff
      val f = new Vector3(hit.hitVec.xCoord - hit.blockX, hit.hitVec.yCoord - hit.blockY, hit.hitVec.zCoord - hit.blockZ)
      val block = world.getBlock(hit.blockX, hit.blockY, hit.blockZ)
      if (block != null && block.onBlockActivated(world, hit.blockX, hit.blockY, hit.blockZ, player, hit.sideHit, f.x.toFloat, f.y.toFloat, f.z.toFloat)) {
        player.swingItem()
        PacketCustom.sendToServer(new C08PacketPlayerBlockPlacement(
          hit.blockX, hit.blockY, hit.blockZ, hit.sideHit,
          player.inventory.getCurrentItem,
          f.x.toFloat, f.y.toFloat, f.z.toFloat))
        return true
      }
    }

    val pos = new BlockCoord(hit.blockX, hit.blockY, hit.blockZ)
    val posOutside = pos.copy().offset(hit.sideHit)
    val inside = Option(TileMultipart.getOrConvertTile(world, pos))
    val outside = Option(TileMultipart.getOrConvertTile(world, posOutside))
    inside match {
      case Some(t) if t.canAddPart(part) && canAddPrint(t, part) => placeMultiPart(player, part, pos)
      case _ => outside match {
        case Some(t) if t.canAddPart(part) && canAddPrint(t, part) => placeMultiPart(player, part, posOutside)
        case _ => false
      }
    }
  }

  protected def canAddPrint(t: TileMultipart, p: SimpleBlockPart): Boolean = p match {
    case print: PrintPart =>
      val (offSum, onSum) = t.partList.foldLeft((print.data.stateOff.size, print.data.stateOn.size))((acc, part) => {
        val (offAcc, onAcc) = acc
        val (offCount, onCount) = part match {
          case innerPrint: PrintPart => (innerPrint.data.stateOff.size, innerPrint.data.stateOn.size)
          case _ => (0, 0)
        }
        (offAcc + offCount, onAcc + onCount)
      })
      offSum <= Settings.get.maxPrintComplexity && onSum <= Settings.get.maxPrintComplexity
    case _ => true
  }

  protected def placeMultiPart(player: EntityPlayer, part: SimpleBlockPart, pos: BlockCoord) = {
    val world = player.getEntityWorld
    if (world.isRemote) {
      player.swingItem()
      PacketSender.sendMultiPlace()
    }
    else {
      TileMultipart.addPart(world, pos, part)
      world.playSoundEffect(pos.x + 0.5, pos.y + 0.5, pos.z + 0.5,
        part.simpleBlock.stepSound.func_150496_b,
        (part.simpleBlock.stepSound.getVolume + 1.0F) / 2.0F,
        part.simpleBlock.stepSound.getPitch * 0.8F)
      if (!player.capabilities.isCreativeMode) {
        val held = player.getHeldItem
        held.stackSize -= 1
        if (held.stackSize == 0) {
          player.inventory.mainInventory(player.inventory.currentItem) = null
          MinecraftForge.EVENT_BUS.post(new PlayerDestroyItemEvent(player, held))
        }
      }
    }
    true
  }
}