package ic2.api.energy.prefab;

import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;

import cpw.mods.fml.common.FMLCommonHandler;

import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;

import ic2.api.energy.EnergyNet;
import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.tile.IEnergySource;
import ic2.api.item.ElectricItem;

/**
 * BasicSource is a simple adapter to provide an ic2 energy source.
 * 
 * It's designed to be attached to a tile entity as a delegate. Functionally BasicSource acts as a
 * one-time configurable output energy buffer, thus providing a common use case for generators.
 * 
 * The constraints set by BasicSource like the strict tank-like energy buffering should provide a
 * more easy to use and stable interface than using IEnergySource directly while aiming for
 * optimal performance.
 * 
 * Using BasicSource involves the following steps:
 * - create a BasicSource instance in your TileEntity, typically in a field
 * - forward invalidate, onChunkUnload, readFromNBT, writeToNBT and updateEntity to the BasicSource
 *   instance.
 *   If you have other means of determining when the tile entity is fully loaded, notify onLoaded
 *   that way instead of forwarding updateEntity.
 * - call addEnergy whenever appropriate, using getFreeCapacity may determine if e.g. the generator
 *   should run
 * - optionally use getEnergyStored to display the output buffer charge level
 * - optionally use setEnergyStored to sync the stored energy to the client (e.g. in the Container)
 *
 * Example implementation code:
 * @code{.java}
 * public class SomeTileEntity extends TileEntity {
 *     // new basic energy source, 1000 EU buffer, tier 1 (32 EU/t, LV)
 *     private BasicSource ic2EnergySource = new BasicSource(this, 1000, 1);
 * 
 *     @Override
 *     public void invalidate() {
 *         ic2EnergySource.onInvalidate(); // notify the energy source
 *         ...
 *         super.invalidate(); // this is important for mc!
 *     }
 * 
 *     @Override
 *     public void onChunkUnload() {
 *         ic2EnergySource.onOnChunkUnload(); // notify the energy source
 *         ...
 *     }
 * 
 *     @Override
 *     public void readFromNBT(NBTTagCompound tag) {
 *         super.readFromNBT(tag);
 * 
 *         ic2EnergySource.onReadFromNbt(tag);
 *         ...
 *     }
 * 
 *     @Override
 *     public void writeToNBT(NBTTagCompound tag) {
 *         super.writeToNBT(tag);
 * 
 *         ic2EnergySource.onWriteToNbt(tag);
 *         ...
 *     }
 * 
 *     @Override
 *     public void updateEntity() {
 *         ic2EnergySource.onUpdateEntity(); // notify the energy source
 *         ...
 *         ic2EnergySource.addEnergy(5); // add 5 eu to the source's buffer this tick
 *         ...
 *     }
 * 
 *     ...
 * }
 * @endcode
 */
public class BasicSource extends TileEntity implements IEnergySource {

	// **********************************
	// *** Methods for use by the mod ***
	// **********************************

	/**
	 * Constructor for a new BasicSource delegate.
	 * 
	 * @param parent TileEntity represented by this energy source.
	 * @param capacity Maximum amount of eu to store.
	 * @param tier IC2 tier, 1=LV, 2=MV, ...
	 */
	public BasicSource(TileEntity parent, int capacity, int tier) {
		int power = EnergyNet.instance.getPowerFromTier(tier);

		this.parent = parent;
		this.capacity = capacity < power ? power : capacity;
		this.tier = tier;
	}

	// in-world te forwards	>>

	/**
	 * Forward for the TileEntity's updateEntity(), used for creating the energy net link.
	 * Either onUpdateEntity or onLoaded have to be used.
	 */
	public void onUpdateEntity() {
		if (!addedToEnet) onLoaded();
	}

	/**
	 * Notification that the TileEntity finished loaded, for advanced uses.
	 * Either onUpdateEntity or onLoaded have to be used.
	 */
	public void onLoaded() {
		if (!addedToEnet && !FMLCommonHandler.instance().getEffectiveSide().isClient()) {
			worldObj = parent.worldObj;
			xCoord = parent.xCoord;
			yCoord = parent.yCoord;
			zCoord = parent.zCoord;

			MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));

			addedToEnet = true;
		}
	}

	/**
	 * Forward for the TileEntity's invalidate(), used for destroying the energy net link.
	 * Both onInvalidate and onOnChunkUnload have to be used.
	 */
	public void onInvalidate() {
		if (addedToEnet) {
			MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));

			addedToEnet = false;
		}
	}

	/**
	 * Forward for the TileEntity's onChunkUnload(), used for destroying the energy net link.
	 * Both onInvalidate and onOnChunkUnload have to be used.
	 */
	public void onOnChunkUnload() {
		onInvalidate();
	}

	/**
	 * Forward for the TileEntity's readFromNBT(), used for loading the state.
	 * 
	 * @param tag Compound tag as supplied by TileEntity.readFromNBT()
	 */
	public void onReadFromNbt(NBTTagCompound tag) {
		NBTTagCompound data = tag.getCompoundTag("IC2BasicSource");

		energyStored = data.getDouble("energy");
	}

	/**
	 * Forward for the TileEntity's writeToNBT(), used for saving the state.
	 * 
	 * @param tag Compound tag as supplied by TileEntity.writeToNBT()
	 */
	public void onWriteToNbt(NBTTagCompound tag) {
		NBTTagCompound data = new NBTTagCompound();

		data.setDouble("energy", energyStored);

		tag.setTag("IC2BasicSource", data);
	}

	// << in-world te forwards
	// methods for using this adapter >>

	/**
	 * Determine the energy stored in the source's output buffer.
	 * 
	 * @return amount in EU
	 */
	public double getEnergyStored() {
		return energyStored;
	}

	/**
	 * Set the stored energy to the specified amount.
	 * 
	 * This is intended for server -> client synchronization, e.g. to display the stored energy in
	 * a GUI through getEnergyStored().
	 * 
	 * @param amount
	 */
	public void setEnergyStored(double amount) {
		energyStored = amount;
	}

	/**
	 * Determine the free capacity in the source's output buffer.
	 * 
	 * @return amount in EU
	 */
	public double getFreeCapacity() {
		return capacity - energyStored;
	}

	/**
	 * Add some energy to the output buffer.
	 * 
	 * @param amount maximum amount of energy to add
	 * @return amount added/used, NOT remaining
	 */
	public double addEnergy(double amount) {
		if (FMLCommonHandler.instance().getEffectiveSide().isClient()) return 0;
		if (amount > capacity - energyStored) amount = capacity - energyStored;

		energyStored += amount;

		return amount;
	}

	/**
	 * Charge the supplied ItemStack from this source's energy buffer.
	 * 
	 * @param stack ItemStack to charge (null is ignored)
	 * @return true if energy was transferred
	 */
	public boolean charge(ItemStack stack) {
		if (stack == null) return false;

		int amount = ElectricItem.manager.charge(stack, (int) energyStored, tier, false, false);

		energyStored -= amount;

		return amount > 0;
	}

	// << methods for using this adapter

	// ******************************
	// *** Methods for use by ic2 ***
	// ******************************

	// energy net interface >>

	@Override
	public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction) {
		return true;
	}

	@Override
	public double getOfferedEnergy() {
		int power = EnergyNet.instance.getPowerFromTier(tier);

		if (energyStored >= power) {
			return power;
		} else {
			return 0;
		}
	}

	@Override
	public void drawEnergy(double amount) {
		energyStored -= amount;
	}

	// << energy net interface


	public final TileEntity parent;
	public final int capacity;
	public final int tier;

	protected double energyStored;
	protected boolean addedToEnet;
}