package projectzombie.world.layer.layergen;

import java.util.Random;

import gl_engine.MathHelpers;
import gl_engine.vec.Vec2d;
import gl_engine.vec.Vec2i;
import gl_engine.vec.Vec3d;
import projectzombie.Main;
import projectzombie.entity.Entity;
import projectzombie.entity.EntityZombie;
import projectzombie.init.Tiles;
import projectzombie.time.GameTimer;
import projectzombie.util.math.ColorRange;
import projectzombie.util.math.TileState;
import projectzombie.util.math.random.OpenSimplexNoise;
import projectzombie.util.math.random.RandomHelpers;
import projectzombie.world.chunk.Chunk;
import projectzombie.world.layer.Layer;

public class LayerGenEarth extends LayerGen
{

	@Override
	public double getTemperatureStatic(Layer layer, Vec2d pos)
	{
		// Get the noise generator
		OpenSimplexNoise terrain_noise = layer.noise_gens[0];
		return MathHelpers.map(terrain_noise.eval(pos.x/64.0, pos.y/64.0), -1, 1, 0, 0.8);
	}
	
	@Override
	public double getTemperatureDynamic(Layer layer, Vec2d pos)
	{
		// Get the noise generator
		double light = (MathHelpers.sin(GameTimer.getTime() / 7200.0 - MathHelpers.PI / 4) + 1) * 0.2;
		OpenSimplexNoise terrain_noise = layer.noise_gens[0];
		return MathHelpers.map(terrain_noise.eval(pos.x/64.0, pos.y/64.0), -1, 1, 0, 0.6 + light);
	}
	
	@Override
	public double getHumidity(Layer layer, Vec2d pos)
	{
		// Get the noise generator
		OpenSimplexNoise terrain_noise = layer.noise_gens[1];
		return MathHelpers.map(terrain_noise.eval(pos.x/64.0, pos.y/64.0), -1, 1, 0, 1);
	}
	
	@Override
	public void init(Layer layer) {
		super.init(layer);
		
		Random rand = new Random(layer.seed);
		
		layer.noise_gens = new OpenSimplexNoise[] {
				new OpenSimplexNoise(rand.nextLong()),
				new OpenSimplexNoise(rand.nextLong())
		};
	}
	
	@Override
	public void generateChunk(Chunk chunk, Layer layer, Random rand, Vec2i c_pos)
	{
		// Is there going to be a portal in this chunk
		boolean portal = PortalSpawnrates.WorldCavePortal(rand);
		Vec2i portal_pos = null;
		if(portal) portal_pos = new Vec2i(
				RandomHelpers.randrange(rand, Chunk.CHUNK_SIZE.mx),
				RandomHelpers.randrange(rand, Chunk.CHUNK_SIZE.my));
		
		// Get the noise generator
		OpenSimplexNoise noise_terrain = layer.noise_gens[0];
		
		// Loop over the layer dimensions and create land
		for(int x=0;x<Chunk.CHUNK_SIZE.mx;x++) {
			for(int y=0;y<Chunk.CHUNK_SIZE.my;y++)
			{
				Vec2d pos = new Vec2d(c_pos.x * 16 + x, c_pos.y * 16 + y);
				double n = noise_terrain.eval(pos.x / 64.0, pos.y / 64.0);
				
				byte rock_type = 0;
				
				if(n < -0.5) {
					chunk.setBackTile(Tiles.SNOW.getDefaultState(), pos.toInt());
					rock_type = (byte)1;
				}
				
				else if(n > 0.5) {
					chunk.setBackTile(Tiles.SAND.getDefaultState(), pos.toInt());
					rock_type = (byte)2;
					
					if(rand.nextDouble() > 0.98) {
						chunk.setFrontTile(Tiles.CACTUS.getDefaultState(), pos.toInt());
					}
				}
				
				else {
					chunk.setBackTile(Tiles.GRASS.getDefaultState(), pos.toInt());
					
					if(rand.nextDouble() > 0.95) {
						chunk.setFrontTile(Tiles.TREE.getDefaultState(), pos.toInt());
					}
				}
				
				if(rand.nextDouble() > 0.92) {
					chunk.setFrontTile(new TileState(Tiles.ROCK, rock_type), pos.toInt());
				}
			}
		}
		
		if(portal) {
			chunk.setBackTile(new TileState(Tiles.PORTAL_DOWN, (short)1), portal_pos);
			chunk.setFrontTile(Tiles.LADDER.getDefaultState(), portal_pos);
			//chunk.setFrontTile(Tiles.BOSS_PORTAL.getDefaultState(), portal_pos);
		}
	}

	@Override
	public void spawnEntities(Layer layer, Random rand)
	{
		if(rand.nextDouble() > 0.98 && getEarthLight() < -0.3)
		{
			Vec3d ppos = Main.player.getPos();
			
			Entity zombie = new EntityZombie(new Vec3d(
					RandomHelpers.randrange(rand, (int)ppos.x - 128, (int)ppos.x + 128), 0,
					RandomHelpers.randrange(rand, (int)ppos.y - 128, (int)ppos.y + 128)),
					new Vec3d(0, 0, 0));
			
			boolean exists = false;
			
			for(Entity e : layer.getChunk(zombie.getPos().xz()).entities) {
				if(e.getClass() == zombie.getClass()) {
					exists = true;
					break;
				}
			}
			
			if(!exists && zombie.getPos().squareDistance(ppos) > 64) {
				layer.spawnEntity(zombie);
			}
		}
	}
	
	@Override
	public TileState getTileDestroyed() {
		return Tiles.DIRT.getDefaultState();
	}
	
	private double getEarthLight() {
		return MathHelpers.sin(GameTimer.getTime() / 7200.0);
	}
	
	@Override
	public ColorRange getLightLevel()
	{
		double light = getEarthLight();
		
		ColorRange daylightRange = new ColorRange(
				new Vec3d(60/255.0, 74/255.0, 68/255.0),
				new Vec3d(205/255.0, 191/255.0, 162/255.0));
		
		return new ColorRange(new Vec3d(0, 0, 0), daylightRange.getColor(light));
	}
}