local path = nether.path
local in_mapgen_env = nether.env_type == "ssm_mapgen"

-- vars
local v = nether.v
local nether_middle = v.nether_middle
local f_bottom_scale = v.f_bottom_scale
local f_h_min = v.f_h_min
local f_h_max = v.f_h_max
local tree_rarity = v.tree_rarity
local glowflower_rarity = v.glowflower_rarity
local grass_rarity = v.grass_rarity
local mushroom_rarity = v.mushroom_rarity
local nether_start = v.nether_start
local NETHER_HEIGHT = v.NETHER_HEIGHT
local NETHER_RANDOM = v.NETHER_RANDOM
local GLOWSTONE_FREQ_ROOF = v.GLOWSTONE_FREQ_ROOF
local LAVA_FREQ = v.LAVA_FREQ
local nether_structure_freq = v.nether_structure_freq
local NETHER_SHROOM_FREQ = v.NETHER_SHROOM_FREQ
local NETHER_BOTTOM = v.NETHER_BOTTOM
local nether_buildings = v.nether_buildings

local nether_weird_noise = dofile(path .. "/weird_mapgen_noise.lua")

-- Weierstrass function stuff from https://github.com/slemonide/gen
local get_ws_list
do
	local SIZE = 1000
	local ssize = math.ceil(math.abs(SIZE))
	local function do_ws_func(depth, a, x)
		local n = math.pi * x / (16 * SIZE)
		local y = 0
		for k=1,depth do
			y = y + math.sin(k^a * n) / k^a
		end
		return SIZE * y / math.pi
	end

	local chunksize = minetest.settings:get"chunksize" or 5
	local ws_lists = {}
	get_ws_list = function(a,x)
			ws_lists[a] = ws_lists[a] or {}
			local v = ws_lists[a][x]
			if v then
					return v
			end
			v = {}
			for x=x,x + (chunksize*16 - 1) do
			local y = do_ws_func(ssize, a, x)
					v[x] = y
			end
			ws_lists[a][x] = v
			return v
	end
end

local function dif(z1, z2)
	return math.abs(z1-z2)
end

local function pymg(x1, x2, z1, z2)
	return math.max(dif(x1, x2), dif(z1, z2))
end

-- Generated variables
--~ local NETHER_ROOF_ABS = (nether_middle - NETHER_RANDOM)
local f_yscale_top = (f_h_max-f_h_min)/2
local f_yscale_bottom = f_yscale_top/2
--HADES_THRONE_STARTPOS_ABS = {x=HADES_THRONE_STARTPOS.x, y=(NETHER_BOTTOM +
--HADES_THRONE_STARTPOS.y), z=HADES_THRONE_STARTPOS.z}
--LAVA_Y = (NETHER_BOTTOM + LAVA_HEIGHT)
--HADES_THRONE_ABS = {}
--HADES_THRONE_ENDPOS_ABS = {}
--HADES_THRONE_GENERATED = minetest.get_worldpath() .. "/netherhadesthrone.txt"
--NETHER_SPAWNPOS_ABS = {x=NETHER_SPAWNPOS.x, y=(NETHER_BOTTOM +
--NETHER_SPAWNPOS.y), z=NETHER_SPAWNPOS.z}
--[[for i,v in ipairs(HADES_THRONE) do
	v.pos.x = v.pos.x + HADES_THRONE_STARTPOS_ABS.x
	v.pos.y = v.pos.y + HADES_THRONE_STARTPOS_ABS.y
	v.pos.z = v.pos.z + HADES_THRONE_STARTPOS_ABS.z
	HADES_THRONE_ABS[i] = v
end
local htx = 0
local hty = 0
local htz = 0
for i,v in ipairs(HADES_THRONE_ABS) do
	if v.pos.x > htx then
		htx = v.pos.x
	end
	if v.pos.y > hty then
		hty = v.pos.y
	end
	if v.pos.z > htz then
		htz = v.pos.z
	end
end
HADES_THRONE_ENDPOS_ABS = {x=htx, y=hty, z=htz}]]

local c, nether_tree_nodes, contents_defined
local function define_contents()
	if not contents_defined then
		c, nether_tree_nodes = nether.query_contents()
		contents_defined = true
	end
end

local pr

local function return_nether_ore(id, glowstone)
	if glowstone
	and pr:next(0,GLOWSTONE_FREQ_ROOF) == 1 then
		return c.glowstone
	end
	if id == c.coal then
		return c.netherrack_tiled
	end
	if id == c.gravel then
		return c.netherrack_black
	end
	if id == c.diamond then
		return c.netherrack_blue
	end
	if id == c.mese then
		return c.white
	end
	return c.netherrack
end

local f_perlins = {}

-- abs(v) < 1-(persistance^octaves))/(1-persistance) = amp
--local perlin1 = minetest.get_perlin(13,3, 0.5, 50) --Get map specific perlin
--	local perlin2 = minetest.get_perlin(133,3, 0.5, 10)
--	local perlin3 = minetest.get_perlin(112,3, 0.5, 5)
local tmp = f_yscale_top*4
local tmp2 = tmp/f_bottom_scale
local perlins = {
	{ -- amp 1.75
		seed = 13,
		octaves = 3,
		persist = 0.5,
		spread = {x=50, y=50, z=50},
		scale = 1,
		offset = 0,
	},
	{-- amp 1.75
		seed = 133,
		octaves = 3,
		persist = 0.5,
		spread = {x=10, y=10, z=10},
		scale = 1,
		offset = 0,
	},
	{-- amp 1.75
		seed = 112,
		octaves = 3,
		persist = 0.5,
		spread = {x=5, y=5, z=5},
		scale = 1,
		offset = 0,
	},
	--[[forest_bottom = {
		seed = 11,
		octaves = 3,
		persist = 0.8,
		spread = {x=tmp2, y=tmp2, z=tmp2},
		scale = 1,
		offset = 0,
	},]]
	forest_top = {-- amp 2.44
		seed = 21,
		octaves = 3,
		persist = 0.8,
		spread = {x=tmp, y=tmp, z=tmp},
		scale = 1,
		offset = 0,
	},
}

-- buffers, see https://forum.minetest.net/viewtopic.php?f=18&t=16043
local pelin_maps
local pmap1 = {}
local pmap2 = {}
local pmap3 = {}
local pmap_f_top = {}
local data = {}

local structures_enabled = true
local vine_maxlength = math.floor(NETHER_HEIGHT/4+0.5)
-- Create the Nether
local function on_generated(minp, maxp, seed)
	--avoid big map generation
	if not (maxp.y >= NETHER_BOTTOM-100 and minp.y <= nether_start) then
		return
	end

	local t1 = minetest.get_us_time()
	nether:inform("generates at: x=["..minp.x.."; "..maxp.x.."]; y=[" ..
		minp.y.."; "..maxp.y.."]; z=["..minp.z.."; "..maxp.z.."]", 2)

	define_contents()

	local buildings = 0
	if maxp.y <= NETHER_BOTTOM then
		buildings = 1
	elseif minp.y <= nether_buildings then
		buildings = 2
	end

	local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
	vm:get_data(data)
	local area = VoxelArea:new{MinEdge=emin, MaxEdge=emax}

	pr = PseudoRandom(seed+33)
	local tab,num = {},1
	local trees,num_trees = {},1

	--local perlin1 = minetest.get_perlin(13,3, 0.5, 50)
	--local perlin2 = minetest.get_perlin(133,3, 0.5, 10)
	--local perlin3 = minetest.get_perlin(112,3, 0.5, 5)

	local side_length = maxp.x - minp.x + 1
	local map_lengths_xyz = {x=side_length, y=side_length, z=side_length}

	if not pelin_maps then
		pelin_maps = {
			a = minetest.get_perlin_map(perlins[1], map_lengths_xyz),
			b = minetest.get_perlin_map(perlins[2], map_lengths_xyz),
			c = minetest.get_perlin_map(perlins[3], map_lengths_xyz),
			forest_top = minetest.get_perlin_map(perlins.forest_top,
				map_lengths_xyz),
		}
	end
	pelin_maps.a:get_2d_map_flat({x=minp.x, y=minp.z}, pmap1)
	pelin_maps.b:get_2d_map_flat({x=minp.x, y=minp.z}, pmap2)
	pelin_maps.c:get_2d_map_flat({x=minp.x, y=minp.z}, pmap3)

	local forest_possible = maxp.y > f_h_min and minp.y < f_h_max

	--local pmap_f_bottom = minetest.get_perlin_map(perlins.forest_bottom,
	-- map_lengths_xyz):get_2d_map_flat({x=minp.x, y=minp.z})
	local perlin_f_bottom, strassx, strassz
	if forest_possible then
		perlin_f_bottom = minetest.get_perlin(11, 3, 0.8, tmp2)
		pelin_maps.forest_top:get_2d_map_flat({x=minp.x, y=minp.z}, pmap_f_top)
		strassx = get_ws_list(2, minp.x)
		strassz = get_ws_list(2, minp.z)
	end

	local num2, tab2
	if buildings >= 1 then
		num2 = 1
		tab2 = nether_weird_noise({x=minp.x, y=nether_buildings-79, z=minp.z},
			pymg, 200, 8, 10, side_length-1)
	end

	local count = 0
	for z=minp.z, maxp.z do
		for x=minp.x, maxp.x do

			count = count+1

			local test = pmap1[count]+1
			local test2 = pmap2[count]
			local test3 = math.abs(pmap3[count])

			local t = math.floor(test*3+0.5)

			local h
			if test2 < 0 then
				h = math.floor(test2*3+0.5)-1
			else
				h = 3+t+pr:next(0,NETHER_RANDOM)
			end

			local generate_vine = false
			if test3 >= 0.72+pr:next(0,NETHER_RANDOM)/10
			and pr:next(0,NETHER_RANDOM) == 1 then
				generate_vine = true
			end

			local bottom = NETHER_BOTTOM+h
			local top = nether_middle-pr:next(0,NETHER_RANDOM)+t

			local py_h = 0
			local difn, noisp, py_h_g
			if buildings >= 1 then
				py_h = tab2[num2].y
				num2 = num2+1

				difn = nether_buildings-py_h
				if difn == 5 then
					noisp = 1
				elseif difn < 5 then
					noisp = 2
				end
				py_h_g = nether_buildings-7
			end

			local vi = area:index(x, minp.y, z)
			if buildings == 1
			and noisp then
				if noisp == 1 then
					for _ = 1,side_length do
						data[vi] = c.netherrack_brick
						vi = vi + area.ystride
					end
				else
					for _ = 1,side_length do
						data[vi] = c.lava
						vi = vi + area.ystride
					end
				end
			else

				local r_structure = pr:next(1,nether_structure_freq)
				local r_shroom = pr:next(1,NETHER_SHROOM_FREQ)
				local r_glowstone = pr:next(0,GLOWSTONE_FREQ_ROOF)
				local r_vine_length = pr:next(1,vine_maxlength)

				local f_bottom, f_top, is_forest, f_h_dirt
				if forest_possible then
					local p = {x=math.floor(x/f_bottom_scale),
						z=math.floor(z/f_bottom_scale)}
					local pstr = p.x.." "..p.z
					if not f_perlins[pstr] then
						f_perlins[pstr] = math.floor(f_h_min + (math.abs(
							perlin_f_bottom:get_2d{x=p.x, y=p.z} + 1))
							* f_yscale_bottom + 0.5)
					end
					local top_noise = pmap_f_top[count]+1
					if top_noise < 0 then
						top_noise = -top_noise/10
						--nether:inform("ERROR: (perlin noise) "..
						-- pmap_f_top[count].." is not inside [-1; 1]", 1)
					end
					f_top = math.floor(f_h_max - top_noise*f_yscale_top + 0.5)
					f_bottom = f_perlins[pstr]+pr:next(0,f_bottom_scale-1)
					is_forest = f_bottom < f_top
					f_h_dirt = f_bottom-pr:next(0,1)
				end

				for y=minp.y, maxp.y do
					local d_p_addp = data[vi]
					--if py_h >= maxp.y-4 then
					if y <= py_h
					and noisp then
						if noisp == 1 then
							data[vi] = c.netherrack_brick
						elseif noisp == 2 then
							if y == py_h then
								data[vi] = c.netherrack_brick
							elseif y == py_h_g
							and pr:next(1,3) <= 2 then
								data[vi] = c.netherrack
							elseif y <= py_h_g then
								data[vi] = c.lava
							else
								data[vi] = c.air
							end
						end
					elseif d_p_addp ~= c.air then

						if is_forest
						and y == f_bottom then
							data[vi] = c.nether_dirt_top
						elseif is_forest
						and y < f_bottom
						and y >= f_h_dirt then
							data[vi] = c.nether_dirt
						elseif is_forest
						and y == f_h_dirt-1 then
							data[vi] = c.nether_dirt_bottom
						elseif is_forest
						and y == f_h_dirt+1 then
							if pr:next(1,tree_rarity) == 1 then
								trees[num_trees] = {x=x, y=y, z=z}
								num_trees = num_trees+1
							elseif pr:next(1,mushroom_rarity) == 1 then
								data[vi] = c.nether_shroom
							elseif pr:next(1,glowflower_rarity) == 1 then
								data[vi] = c.glowflower
							elseif pr:next(1,grass_rarity) == 1 then
								data[vi] = c.nether_grass[pr:next(1,3)]
							else
								data[vi] = c.air
							end
						elseif is_forest
						and y > f_bottom
						and y < f_top then
							if not nether_tree_nodes[d_p_addp] then
								data[vi] = c.air
							end
						elseif is_forest
						and y == f_top then
							local sel = math.floor(strassx[x]+strassz[z]+0.5)%10
							if sel <= 5 then
								data[vi] = return_nether_ore(d_p_addp, true)
							elseif sel == 6 then
								data[vi] = c.netherrack_black
							elseif sel == 7 then
								data[vi] = c.glowstone
							else
								data[vi] = c.air
							end

						elseif y <= NETHER_BOTTOM then
							if y <= bottom then
								data[vi] = return_nether_ore(d_p_addp, true)
							else
								data[vi] = c.lava
							end
						elseif r_structure == 1
						and y == bottom then
							tab[num] = {x=x, y=y-1, z=z}
							num = num+1
						elseif y <= bottom then
							if pr:next(1,LAVA_FREQ) == 1 then
								data[vi] = c.lava
							else
								data[vi] = return_nether_ore(d_p_addp, false)
							end
						elseif r_shroom == 1
						and r_structure ~= 1
						and y == bottom+1 then
							data[vi] = c.nether_shroom
						elseif (y == top and r_glowstone == 1) then
							data[vi] = c.glowstone
						elseif y >= top then
							data[vi] = return_nether_ore(d_p_addp, true)
						elseif y <= top-1
						and generate_vine
						and y >= top-r_vine_length then
							data[vi] = c.nether_vine
						else
							data[vi] = c.air
						end
					end
					vi = vi + area.ystride
				end
			end
		end
	end

	nether:inform("most stuff set", 2, t1)

	local t2 = minetest.get_us_time()
	local bl_cnt = 0
	local tr_cnt = 0
	local tr_snd_cnt = 0

	if structures_enabled then -- Blood netherstructures
		bl_cnt = #tab
		for i = 1, #tab do
			nether.grow_netherstructure_into(area, data, tab[i], true)
		end
	end

	if bl_cnt > 0 then
		nether:inform(bl_cnt .. " blood structures set", 2, t2)
	end

	t2 = minetest.get_us_time()
	vm:set_data(data)
--	vm:set_lighting(12)
--	vm:calc_lighting()
--	vm:update_liquids()
	if not in_mapgen_env then
		vm:write_to_map(false)
	end
	nether:inform("data written", 2, t2)

	t2 = minetest.get_us_time()
	if forest_possible then -- Forest trees
		if in_mapgen_env then
			-- Trees can get too big (>16 nodes in one direction) for usual
			-- overgeneration onion layer. nether.grow_tree will make new vmanips
			-- to emerge blank (= ignore-filled) blocks to overcome this. But the
			-- main server thread needs to do this.
			tr_snd_cnt = #trees
			local trees_hashed = {}
			for i = 1, #trees do
				trees_hashed[i] = minetest.hash_node_position(trees[i])
			end
			assert(minetest.save_gen_notify("nether:please_grow_trees", trees_hashed))
		else
			tr_cnt = #trees
			for i = 1, #trees do
				nether.grow_tree(trees[i], true)
			end
		end
	end

	if tr_cnt + tr_snd_cnt > 0 then
		nether:inform(string.format("%s trees set, %s trees sent",
				tr_cnt, tr_snd_cnt), 2, t2)
	end

	if in_mapgen_env then
		assert(minetest.save_gen_notify("nether:please_fix_light", {minp, maxp}))
	else
		t2 = minetest.get_us_time()
		minetest.fix_light(minp, maxp)

		nether:inform("light fixed", 2, t2)
	end

	nether:inform("done", 1, t1)
end

if in_mapgen_env then
	minetest.register_on_generated(function(_, minp, maxp, blockseed)
		return on_generated(minp, maxp, blockseed)
	end)
else
	minetest.register_on_generated(on_generated)
end