package ihl.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import ihl.recipes.IRecipeInputFluid;
import ihl.worldgen.ores.IHLFluid;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidTank;

public class IHLFluidTank implements IFluidTank {
	private final List<FluidStack> fluidList = new ArrayList<FluidStack>();
	private final int capacity;

	public IHLFluidTank(int capacity) {
		this.capacity = capacity;
	}

	public IHLFluidTank(int capacity, boolean isOpenVessel1) {
		this.capacity = capacity;
	}

	public IHLFluidTank readFromNBT(NBTTagCompound nbt) {
		if (!nbt.hasKey("Empty")) {
			NBTTagList fluidList1 = nbt.getTagList("fluids", 10);
			for (int i = 0; i < fluidList1.tagCount(); i++) {
				NBTTagCompound fluidNBT1 = fluidList1.getCompoundTagAt(i);
				FluidStack fluid = FluidStack.loadFluidStackFromNBT(fluidNBT1);
				if (fluid != null) {
					fluidList.add(fluid);
				}
			}
		}
		return this;
	}

	public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
		if (!fluidList.isEmpty()) {
			NBTTagList fluids = new NBTTagList();
			Iterator<FluidStack> fli = fluidList.iterator();
			while (fli.hasNext()) {
				FluidStack fluid = fli.next();
				if (fluid != null) {
					NBTTagCompound fluidNBT1 = new NBTTagCompound();
					fluid.writeToNBT(fluidNBT1);
					fluids.appendTag(fluidNBT1);
				}
			}
			nbt.setTag("fluids", fluids);
		} else {
			nbt.setString("Empty", "");
		}
		return nbt;
	}

	/* IFluidTank */
	@Override
	public FluidStack getFluid() {
		if (this.fluidList.isEmpty()) {
			return null;
		}
		return this.fluidList.get(0);
	}

	public FluidStack getLigthestFluid() {
		if (this.fluidList.isEmpty()) {
			return IHLUtils.getFluidStackWithSize("air", this.capacity);
		}
		return this.fluidList.get(this.fluidList.size() - 1);
	}

	@Override
	public int getFluidAmount() {
		int amount = 0;
		Iterator<FluidStack> fli = fluidList.iterator();
		while (fli.hasNext()) {
			FluidStack fluid = fli.next();
			if (fluid != null) {
				amount += fluid.amount;
			}
		}
		return amount;
	}

	@Override
	public int getCapacity() {
		return capacity;
	}

	@Override
	public FluidTankInfo getInfo() {
		return new FluidTankInfo(this);
	}

	@Override
	public int fill(FluidStack resource, boolean doFill) {
		if (resource == null)
			return 0;
		int freeSpace = capacity - this.getFluidAmount();
		int amount1 = Math.min(freeSpace, resource.amount);
		if (resource.getFluid() == null || amount1<=0) {
			return 0;
		}
		if (!doFill) {
			return amount1;
		}
		FluidStack fluid = getFluidStackWithSameFluid(resource);
		if (fluid != null) {
			fluid.amount += amount1;
			return amount1;
		}
		fluid = copyWithSize(resource, amount1);
		fluidList.add(fluid);
		this.sortFluidsByDensity();
		return amount1;
	}

	@Override
	public FluidStack drain(int maxDrain, boolean doDrain) {
		if (fluidList.isEmpty()) {
			return null;
		}
		FluidStack fstack = this.getFluid().copy();
		fstack.amount = maxDrain;
		return this.drain(fstack, doDrain);
	}

	public FluidStack drainLightest(int maxDrain, boolean doDrain) {
		if (fluidList.isEmpty()) {
			return null;
		}
		FluidStack fstack = this.getLigthestFluid().copy();
		fstack.amount = maxDrain;
		return this.drain(fstack, doDrain);
	}

	public FluidStack drain(Object fluidStack, boolean doDrain) {
		if (fluidList.isEmpty()) {
			return null;
		}
		int drained = 0;
		if (fluidStack instanceof FluidStack) {
			drained = ((FluidStack) fluidStack).amount;
		} else {
			drained = ((IRecipeInputFluid) fluidStack).getAmount();
		}
		FluidStack fluid = this.getFluidStackWithSameFluid(fluidStack);
		if (fluid == null) {
			return null;
		}
		if (fluid.amount < drained) {
			drained = fluid.amount;
		}
		FluidStack stack = copyWithSize(fluid, drained);
		if (doDrain) {
			fluid.amount -= drained;
			if (fluid.amount <= 0) {
				this.fluidList.remove(fluid);
			}
		}
		return stack;
	}

	public FluidStack getFluidStackWithSameFluid(Object fluidStack) {
		Iterator<FluidStack> fli = fluidList.iterator();
		while (fli.hasNext()) {
			FluidStack fluid = fli.next();
			if (fluid != null) {
				if (fluidStack instanceof FluidStack) {
					if (fluid.isFluidEqual((FluidStack) fluidStack)) {
						return fluid;
					}
				} else {
					if (((IRecipeInputFluid) fluidStack).matches(fluid)) {
						return fluid;
					}
				}
			}
		}
		return null;
	}

	public int getNumberOfFluids() {
		return this.fluidList.size();
	}

	public void setFluidAmount(int amount1, int index) {
		if (this.fluidList.size() <= index) {
			while (this.fluidList.size() <= index) {
				this.fluidList.add(new FluidStack(FluidRegistry.WATER, 1));
			}
		}
		this.fluidList.get(index).amount = amount1;
	}

	public int getFluidAmount(int index) {
		if (this.fluidList.size() <= index || this.fluidList.get(index) == null) {
			return 0;
		}
		return this.fluidList.get(index).amount;
	}

	public int getFluidID(int i) {
		if (this.fluidList.get(i) == null) {
			return -1;
		}
		return this.fluidList.get(i).getFluid().getID();
	}

	public void sortFluidsByDensity() {
		Map<Integer, FluidStack> sortMap = new HashMap<Integer, FluidStack>();
		int[] keysArray = new int[fluidList.size()];
		Iterator<FluidStack> fli = fluidList.iterator();
		while (fli.hasNext()) {
			FluidStack fluid = fli.next();
			if (fluid == null) {
				return;
			}
			int key = Math.round(IHLFluid.getRealDensity(fluid.getFluid()) * 100F);
			while (sortMap.containsKey(key)) {
				key++;
			}
			sortMap.put(key, fluid);
			keysArray[fluidList.indexOf(fluid)] = key;
		}
		Arrays.sort(keysArray);
		ArrayList<FluidStack> newFluidList = new ArrayList<FluidStack>();
		for (int i = keysArray.length - 1; i >= 0; i--) {
			newFluidList.add(sortMap.get(keysArray[i]));
		}
		this.fluidList.clear();
		this.fluidList.addAll(newFluidList);
	}

	public FluidStack getFluid(int i) {
		return this.fluidList.get(i);
	}

	public void setTag(String string, int t1_1) {
		if (this.getFluid().tag == null) {
			this.getFluid().tag = new NBTTagCompound();
		}
		this.getFluid().tag.setInteger(string, t1_1);
	}

	public void setEmpty() {
		this.fluidList.clear();
	}

	public List<FluidStack> getFluidList() {
		return this.fluidList;
	}

	public void drain(List<?> fluidInputs, boolean doDrain) {
		if (fluidInputs != null && !fluidInputs.isEmpty()) {
			Iterator<?> fsi = fluidInputs.iterator();
			while (fsi.hasNext()) {
				this.drain(fsi.next(), doDrain);
			}
		}
	}

	public void fill(List<FluidStack> fluidOutputs, boolean doFill) {
		if (fluidOutputs != null && !fluidOutputs.isEmpty()) {
			Iterator<FluidStack> fsi = fluidOutputs.iterator();
			while (fsi.hasNext()) {
				this.fill(fsi.next(), doFill);
			}
		}
	}

	private FluidStack copyWithSize(FluidStack resource, int amount1) {
		FluidStack fluid = resource.copy();
		fluid.amount = amount1;
		if (resource.tag != null) {
			fluid.tag = (NBTTagCompound) resource.tag.copy();
		}
		return fluid;
	}

	public FluidStack drain(IRecipeInputFluid fluidStack, int amount, boolean doDrain) {
		if (fluidList.isEmpty()) {
			return null;
		}
		int drained = amount;
		FluidStack fluid = this.getFluidStackWithSameFluid(fluidStack);
		if (fluid == null) {
			return null;
		}
		if (fluid.amount < drained) {
			drained = fluid.amount;
		}
		FluidStack stack = copyWithSize(fluid, drained);
		if (doDrain) {
			fluid.amount -= drained;
			if (fluid.amount <= 0) {
				this.fluidList.remove(fluid);
			}
		}
		return stack;
	}

	public void checkCorrectState() {
		if (!this.fluidList.isEmpty()) {
			Iterator<FluidStack> fsi = this.fluidList.iterator();
			while (fsi.hasNext()) {
				FluidStack fs = fsi.next();
				if (fs.amount <= 0) {
					fsi.remove();
				}
			}
		}
	}
}