package game.worldgen;

import game.rng.OctaveGen;
import game.rng.Random;
import game.util.ExtMath;
import game.world.State;
import game.world.WorldServer;

public class GeneratorIsland implements ChunkGenerator
{
    private final OctaveGen noiseGen1;
    private final OctaveGen noiseGen2;
    private final OctaveGen noiseGen3;
    private final OctaveGen noiseGen4;
    private final OctaveGen noiseGen5;
    
    private final double[] densities = new double[297];
    private final double[] noiseData1 = new double[297];
    private final double[] noiseData2 = new double[297];
    private final double[] noiseData3 = new double[297];
    private final double[] noiseData4 = new double[9];
    private final double[] noiseData5 = new double[9];
    
    private final State filler;
    
//    public GeneratorIsland(Dimension dim, Random rand) {
//    	this(rand, dim.getFiller());
//    }

    public GeneratorIsland(Random rand, State filler)
    {
        this.noiseGen1 = new OctaveGen(rand, 16);
        this.noiseGen2 = new OctaveGen(rand, 16);
        this.noiseGen3 = new OctaveGen(rand, 8);
        this.noiseGen4 = new OctaveGen(rand, 10);
        this.noiseGen5 = new OctaveGen(rand, 16);
        this.filler = filler;
    }
    
	public int getMaximumHeight() {
		return 128;
	}

    public void generateChunk(WorldServer world, int x, int z, ChunkPrimer primer)
    {
        int range = 2;
        int xr = range + 1;
        int yr = 33;
        int zr = range + 1;
        this.genNoisemap(x * range, 0, z * range);

        for (int i1 = 0; i1 < range; ++i1)
        {
            for (int j1 = 0; j1 < range; ++j1)
            {
                for (int k1 = 0; k1 < 32; ++k1)
                {
                    double d0 = 0.25D;
                    double d1 = this.densities[((i1 + 0) * zr + j1 + 0) * yr + k1 + 0];
                    double d2 = this.densities[((i1 + 0) * zr + j1 + 1) * yr + k1 + 0];
                    double d3 = this.densities[((i1 + 1) * zr + j1 + 0) * yr + k1 + 0];
                    double d4 = this.densities[((i1 + 1) * zr + j1 + 1) * yr + k1 + 0];
                    double d5 = (this.densities[((i1 + 0) * zr + j1 + 0) * yr + k1 + 1] - d1) * d0;
                    double d6 = (this.densities[((i1 + 0) * zr + j1 + 1) * yr + k1 + 1] - d2) * d0;
                    double d7 = (this.densities[((i1 + 1) * zr + j1 + 0) * yr + k1 + 1] - d3) * d0;
                    double d8 = (this.densities[((i1 + 1) * zr + j1 + 1) * yr + k1 + 1] - d4) * d0;

                    for (int l1 = 0; l1 < 4; ++l1)
                    {
                        double d9 = 0.125D;
                        double d10 = d1;
                        double d11 = d2;
                        double d12 = (d3 - d1) * d9;
                        double d13 = (d4 - d2) * d9;

                        for (int i2 = 0; i2 < 8; ++i2)
                        {
                            double d14 = 0.125D;
                            double d15 = d10;
                            double d16 = (d11 - d10) * d14;

                            for (int j2 = 0; j2 < 8; ++j2)
                            {
                                State iblockstate = null;

                                if (d15 > 0.0D)
                                {
                                    iblockstate = this.filler;
                                }

                                int k2 = i2 + i1 * 8;
                                int l2 = l1 + k1 * 4;
                                int i3 = j2 + j1 * 8;
                                primer.set(k2, l2, i3, iblockstate);
                                d15 += d16;
                            }

                            d10 += d12;
                            d11 += d13;
                        }

                        d1 += d5;
                        d2 += d6;
                        d3 += d7;
                        d4 += d8;
                    }
                }
            }
        }
    }
    
    private void genNoisemap(int x, int y, int z)
    {
    	int xs = 3;
    	int ys = 33;
    	int zs = 3;
        double d0 = 684.412D;
        double d1 = 684.412D;
        this.noiseGen4.generate(this.noiseData4, x, z, xs, zs, 1.121D, 1.121D, 0.5D);
        this.noiseGen5.generate(this.noiseData5, x, z, xs, zs, 200.0D, 200.0D, 0.5D);
        d0 = d0 * 2.0D;
        this.noiseGen3.generate(this.noiseData1, x, y, z, xs, ys, zs, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D);
        this.noiseGen1.generate(this.noiseData2, x, y, z, xs, ys, zs, d0, d1, d0);
        this.noiseGen2.generate(this.noiseData3, x, y, z, xs, ys, zs, d0, d1, d0);
        int i = 0;

        for (int j = 0; j < xs; ++j)
        {
            for (int k = 0; k < zs; ++k)
            {
                float f = (float)(j + x) / 1.0F;
                float f1 = (float)(k + z) / 1.0F;
                float f2 = 100.0F - ExtMath.sqrtf(f * f + f1 * f1) * 8.0F;

                if (f2 > 80.0F)
                {
                    f2 = 80.0F;
                }

                if (f2 < -100.0F)
                {
                    f2 = -100.0F;
                }

                for (int l = 0; l < ys; ++l)
                {
                    double d2 = 0.0D;
                    double d3 = this.noiseData2[i] / 512.0D;
                    double d4 = this.noiseData3[i] / 512.0D;
                    double d5 = (this.noiseData1[i] / 10.0D + 1.0D) / 2.0D;

                    if (d5 < 0.0D)
                    {
                        d2 = d3;
                    }
                    else if (d5 > 1.0D)
                    {
                        d2 = d4;
                    }
                    else
                    {
                        d2 = d3 + (d4 - d3) * d5;
                    }

                    d2 = d2 - 8.0D;
                    d2 = d2 + (double)f2;
                    int i1 = 2;

                    if (l > ys / 2 - i1)
                    {
                        double d6 = (double)((float)(l - (ys / 2 - i1)) / 64.0F);
                        d6 = ExtMath.clampd(d6, 0.0D, 1.0D);
                        d2 = d2 * (1.0D - d6) + -3000.0D * d6;
                    }

                    i1 = 8;

                    if (l < i1)
                    {
                        double d7 = (double)((float)(i1 - l) / ((float)i1 - 1.0F));
                        d2 = d2 * (1.0D - d7) + -30.0D * d7;
                    }

                    this.densities[i] = d2;
                    ++i;
                }
            }
        }
    }
}