package projectzombie.entity;

import bdf.types.BdfNamedList;
import bdf.types.BdfObject;
import projectzombie.display.Camera;
import projectzombie.init.Models;
import projectzombie.model.Model;
import projectzombie.util.gl.GlHelpers;
import projectzombie.util.gl.texture.TextureReference;
import projectzombie.util.math.ItemStack;
import projectzombie.util.math.random.RandomHelpers;
import gl_engine.vec.Vec2d;
import projectzombie.world.chunk.Chunk;
import projectzombie.world.layer.Layer;

public class EntityItem extends Entity
{
	private ItemStack stack;
	private double height = 0;
	private double height_speed;
	private int pickup_time = 200;
	private long age = 0;
	
	public double angle;
	
	public EntityItem(BdfObject bdf) {
		super(bdf);
	}
	
	@Override
	public void BdfClassLoad(BdfObject bdf) {
		super.BdfClassLoad(bdf);
		
		BdfNamedList nl = bdf.getNamedList();
		stack = new ItemStack(nl.get("stack"));
		height = nl.get("height").getDouble();
		height_speed = nl.get("speed_h").getDouble();
		pickup_time = nl.get("pickup").getInteger();
		age = nl.get("age").getLong();
		angle = nl.get("angle").getDouble();
	}
	
	@Override
	public void BdfClassSave(BdfObject bdf) {
		super.BdfClassSave(bdf);
		
		BdfNamedList nl = bdf.getNamedList();
		stack.BdfClassSave(nl.get("stack"));
		nl.set("height", BdfObject.withDouble(height));
		nl.set("speed_h", BdfObject.withDouble(height_speed));
		nl.set("pickup", BdfObject.withInteger(pickup_time));
		nl.set("age", BdfObject.withLong(age));
		nl.set("angle", BdfObject.withDouble(angle));
	}
	
	public EntityItem(Vec2d pos, ItemStack stack) {
		super(pos);
		
		this.emitsLight = true;
		this.stack = stack;
		this.angle = RandomHelpers.randrange(rand, 360);
		height_speed = RandomHelpers.randrange(rand, 10000) / 200000.0;
	}
	
	@Override
	public double getLightLevel() {
		if(this.stack.isEmpty()) return 0;
		return getLightWithHeight(this.stack.item.getLightLevel());
	}
	
	@Override
	public void tick(Chunk chunk, Layer layer) {
		super.tick(chunk, layer);
		
		age += 1;
		
		height += height_speed;
		height_speed -= 0.001;
		
		pickup_time -= 1;
		if(pickup_time < 0) {
			pickup_time = 0;
		}
		
		if(height <= 0) {
			height_speed = 0;
		}
		
		else {
			moveTowards(angle, 0.01);
		}
		
		// Merge nearby stacks
		for(Entity e : layer.getNearbyEntities(pos, 1))
		{
			if(e instanceof EntityItem && e != this) {
				EntityItem ei = (EntityItem) e;
				
				if(
						ei.stack.meta == this.stack.meta &&
						ei.stack.item == this.stack.item &&
						ei.age > this.age
				) {
					this.pickup_time = 200;
					this.stack.count += ei.stack.count;
					this.pos = new Vec2d(
							ei.pos.x / 2 + this.pos.x / 2,
							ei.pos.y / 2 + this.pos.y / 2);
					this.height = ei.height / 2 + this.height / 2;
					this.height_speed = ei.height_speed / 2 + this.height_speed / 2;
					ei.kill();
				}
			}
		}
		
		if(pickup_time == 0)
		{
			for(Entity e : layer.getNearbyEntities(pos, 1))
			{
				if(e instanceof EntityInventory)
				{
					// Pick the stack up if its an inventory
					stack.item.onPickedUp(stack, layer, chunk, e);
				}
			}
		}
		
		// Kill this entity if the stack is empty
		if(stack.isEmpty()) {
			kill();
			return;
		}
	}

	@Override
	public Model getModel() {
		return Models.ITEM_NONE;
	}
	
	
}