package darkevilmac.functionality.tileentity

import cofh.api.energy.IEnergyHandler
import cpw.mods.fml.common.FMLCommonHandler
import darkevilmac.functionality.energy.MultiBattery
import darkevilmac.functionality.util.IC2EnergyUtils
import ic2.api.energy.event.{EnergyTileLoadEvent, EnergyTileUnloadEvent}
import ic2.api.energy.tile.IEnergySource
import ic2.api.info.Info
import net.minecraft.nbt.NBTTagCompound
import net.minecraft.tileentity.TileEntity
import net.minecraftforge.common.MinecraftForge
import net.minecraftforge.common.util.ForgeDirection

/**
 * A class you can add to your tileentity to emit energy from IC2, Buildcraft, and mods that support Redstone Flux
 *
 * @param dir the direction the tile can outputs from
 * @param parent the the tile this is in
 */
class TileMultiPowerEmitter(var battery: MultiBattery, var dir: ForgeDirection, parent: TileEntity) extends TileEntity with IEnergySource with IEnergyHandler {

  var tileBuffer: Array[TileBuffer] = null
  var addedToEnet: Boolean = false

  override def updateEntity() {
    if (!addedToEnet) onLoaded
    if (worldObj != null) {
      if (tileBuffer == null) {
        tileBuffer = TileBuffer.makeBuffer(worldObj, xCoord, yCoord, zCoord, false)
      }
    }
  }

  def onLoaded() {
    if (!addedToEnet && !FMLCommonHandler.instance.getEffectiveSide.isClient && Info.isIc2Available) {
      worldObj = parent.getWorldObj
      xCoord = parent.xCoord
      yCoord = parent.yCoord
      zCoord = parent.zCoord

      MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this))
      addedToEnet = true
    }
  }

  override def validate() {
    tileBuffer = null
  }

  override def invalidate() {
    onChunkUnload
  }

  override def onChunkUnload(): Unit = {
    if (addedToEnet && Info.isIc2Available) {
      MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this))
      addedToEnet = false
    }
  }

  override def readFromNBT(nbt: NBTTagCompound) {
  }

  override def writeToNBT(nbt: NBTTagCompound) {
  }

  def getTile(side: ForgeDirection): TileEntity = {
    if (tileBuffer == null) {
      tileBuffer = TileBuffer.makeBuffer(worldObj, xCoord, yCoord, zCoord, false)
    }

    tileBuffer(side.ordinal).getTile
  }

  /**
   * IC2's emitter direction
   *
   * @param receiver
   * @param direction
   * @return
   */
  override def emitsEnergyTo(receiver: TileEntity, direction: ForgeDirection): Boolean = {
    if (dir == null || receiver == null) {
      false
    }
    if (dir == ForgeDirection.UNKNOWN || dir == direction) {
      true
    }
    false
  }

  /**
   *
   * @return
   */
  override def getOfferedEnergy: Double = {
    battery.getEU
  }

  /**
   * IC2's energy extraction
   *
   * @param amount
   */
  override def drawEnergy(amount: Double) = {
    if (amount < 0) {
      battery.addEU(amount, false)
    } else {
      battery.useEU(amount, false)
    }
  }

  /**
   * The power tier used for IC2
   *
   * @return
   */
  override def getSourceTier: Int = {
    IC2EnergyUtils.getIC2TierFromEnergyRate(battery.transferRate)
  }

  /**
   * Redstone Flux's energy reception
   *
   * @param from
     * Orientation the energy is received from.
   * @param maxReceive
     * Maximum amount of energy to receive.
   * @param simulate
     * If TRUE, the charge will only be simulated.
   **/
  override def receiveEnergy(from: ForgeDirection, maxReceive: Int, simulate: Boolean): Int = {
    0
  }

  /**
   * Redstone Flux's energy extraction
   *
   * @param from
     * Orientation the energy is extracted from.
   * @param maxExtract
     * Maximum amount of energy to extract.
   * @param simulate
     * If TRUE, the extraction will only be simulated.
   **/
  override def extractEnergy(from: ForgeDirection, maxExtract: Int, simulate: Boolean): Int = {
    if (dir == null) {
      0
    }
    if (dir == ForgeDirection.UNKNOWN || dir == from) {
      if (battery.getRF() > maxExtract) {
        battery.useRF(maxExtract, false)
      } else {
        battery.useRF(battery.getRF(), false)
      }
    }
    0
  }

  /**
   * Redstone Flux's current energy storage
   *
   * @param from
   * @return
   */
  override def getEnergyStored(from: ForgeDirection): Int = {
    battery.getRF()
  }

  /**
   * Redstone Flux's max energy
   *
   * @param from
   * @return
   */
  override def getMaxEnergyStored(from: ForgeDirection): Int = {
    battery.getRF
  }

  override def canConnectEnergy(from: ForgeDirection): Boolean = {
    if (dir == null) {
      false
    }
    if (dir == ForgeDirection.UNKNOWN || dir == from) {
      true
    }
    false
  }


}

class IC2Source