local node = loud_walking.node

local bevel = 40
local glass = "loud_walking:transparent_scrith"


local data = {}
local p2data = {}  -- vm rotation data buffer
local lightmap = {}
local vm, emin, emax, a, csize, heightmap, biomemap
local div_sz_x, div_sz_z, minp, maxp, terrain, cave

local terrain_noise = {offset = 0,
scale = 20, seed = 8829, spread = {x = 40, y = 40, z = 40},
octaves = 6, persist = 0.4, lacunarity = 2}

local cave_noise = {offset = 0, scale = 1,
seed = -3977, spread = {x = 30, y = 30, z = 30}, octaves = 3,
persist = 0.8, lacunarity = 2}

loud_walking.biomes = {}
local biomes = loud_walking.biomes
local biome_names = {}
biome_names["common"] = {}
biome_names["uncommon"] = {}
do
	local biome_terrain_scale = {}
	biome_terrain_scale["coniferous_forest"] = 0.75
	biome_terrain_scale["rainforest"] = 0.33
	biome_terrain_scale["underground"] = 1.5

	local tree_biomes = {}
	tree_biomes["deciduous_forest"] = {"deciduous_trees"}
	tree_biomes["coniferous_forest"] = {"conifer_trees"}
	tree_biomes["taiga"] = {"conifer_trees"}
	tree_biomes["rainforest"] = {"jungle_trees"}
	tree_biomes["rainforest_swamp"] = {"jungle_trees"}
	tree_biomes["coniferous_forest"] = {"conifer_trees"}

	for i, obiome in pairs(minetest.registered_biomes) do
		local biome = table.copy(obiome)
		local rarity = "common"
		biome.terrain_scale = biome_terrain_scale[biome] or 0.5
		if string.find(biome.name, "ocean") then
			biome.terrain_scale = 1
			rarity = "uncommon"
		end
		if string.find(biome.name, "swamp") then
			biome.terrain_scale = 0.25
			rarity = "uncommon"
		end
		if string.find(biome.name, "beach") then
			biome.terrain_scale = 0.25
			rarity = "uncommon"
		end
		if string.find(biome.name, "^underground$") then
			biome.node_top = "default:stone"
			rarity = "uncommon"
		end
		biome.special_trees = tree_biomes[biome.name]
		biomes[biome.name] = biome
		biome_names[rarity][#biome_names[rarity]+1] = biome.name
	end
end

local function place_schematic(pos, schem, center)
	local yslice = {}
	if schem.yslice_prob then
		for _, ys in pairs(schem.yslice_prob) do
			yslice[ys.ypos] = ys.prob
		end
	end

	if center then
		pos.x = pos.x - math.floor(schem.size.x / 2)
		pos.z = pos.z - math.floor(schem.size.z / 2)
	end

	for z = 0, schem.size.z - 1 do
		local dz = pos.z - minp.z + z
		for x = 0, schem.size.x - 1 do
			local dx = pos.x - minp.x + x
			if pos.x + x > minp.x and pos.x + x < maxp.x and pos.z + z > minp.z and pos.z + z < maxp.z then
				local ivm = a:index(pos.x + x, pos.y, pos.z + z)
				local isch = z * schem.size.y * schem.size.x + x + 1
				for y = 0, schem.size.y - 1 do
					local dy = pos.y - minp.y + y
					if math.min(dx, csize.x - dx) + math.min(dy, csize.y - dy) + math.min(dz, csize.z - dz) > bevel then
						if yslice[y] or 255 >= math.random(255) then
							local prob = schem.data[isch].prob or schem.data[isch].param1 or 255
							if prob >= math.random(255) and schem.data[isch].name ~= "air" then
								data[ivm] = node(schem.data[isch].name)
							end
							local param2 = schem.data[isch].param2 or 0
							p2data[ivm] = param2
						end
					end

					ivm = ivm + a.ystride
					isch = isch + schem.size.x
				end
			end
		end
	end
end

local function is_pod(x, y, z)
	local min_x = math.floor((x + 32) / csize.x)
	local min_y = math.floor((y + 32) / csize.y)
	local min_z = math.floor((z + 32) / csize.z)

	if min_x % 2 == 0 and min_y % 2 == 0 and min_z % 2 == 0 then
		return true
	end
	--if min_x % 2 == 1 and min_y % 4 == 0 and min_z % 2 == 1 then
	--	return true
	--elseif min_x % 2 == 0 and min_y % 4 == 2 and min_z % 2 == 0 then
	--	return true
	--end

	return false
end

local function connection(x, y, z)
	local min_x = math.floor((x + 32) / csize.x)
	local min_y = math.floor((y + 32) / csize.y)
	local min_z = math.floor((z + 32) / csize.z)

	--local seed_noise = minetest.get_perlin({offset = 0, scale = 32768,
	--seed = 5202, spread = {x = 80, y = 80, z = 80}, octaves = 2,
	--persist = 0.4, lacunarity = 2})
	--math.randomseed(seed_noise:get2d({x=minp.x, y=minp.z}))

	local ct = min_x % 2 + min_y % 2 + min_z % 2
	local r = min_x % 2 + 2 * (min_y % 2) + 4 * (min_z % 2)
	if ct == 1 then
		return r
	end

	return nil
end

local function get_height(dx, dz, terrain_scale, ocean, index)
	local terr
	local half = math.floor(csize.y / 2 + 0.5)

	--if index == true then
	--	terr = minetest.get_perlin(terrain_noise):get2d({x=dx, y=dz})
	--	-- Still need csize here...
	--	dx = (dx + 32) % 80
	--	dz = (dz + 32) % 80
	if not index then
		index = dz * csize.x + dx + 1
		terr = terrain[index]
	else
		terr = terrain[index]
	end

	terr = math.floor(terr * terrain_scale + 0.5)

	local d = half - 2 - math.abs(math.abs(dx - (half - 0.5)) - math.abs(dz - (half - 0.5)))
	if math.abs(terr) > d then
		if terr > 0 then
			terr = math.floor(d + 0.5)
		elseif not ocean then
			terr = math.floor(0.5 - d)
		end
	end

	return terr
end

local function get_biome(px, pz)
	local sr = math.random(5)
	local rarity = "common"
	if sr > 4 then
		rarity = "uncommon"
	end
	local biome = biome_names[rarity][math.random(#biome_names[rarity])]
	return biome
end

local function get_decoration(biome)
	for i, deco in pairs(loud_walking.decorations) do
		if not deco.biomes or deco.biomes[biome] then
			--local range = (string.find(biome, "rain") and deco.flower) and 500 or 1000
			local range = 1000
			if deco.deco_type == "simple" then
				if deco.fill_ratio and math.random(range) - 1 < deco.fill_ratio * 1000 then
					return deco.decoration
				end
			else
				-- nop
			end
		end
	end
end


function loud_walking.generate(p_minp, p_maxp, seed)
	minp, maxp = p_minp, p_maxp
	vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
	vm:get_data(data)
	vm:set_lighting({day = 15, night = 0}, minp, maxp)
	lightmap = vm:get_light_data()
	--p2data = vm:get_param2_data()
	a = VoxelArea:new({MinEdge = emin, MaxEdge = emax})
	csize = vector.add(vector.subtract(maxp, minp), 1)

	local write = false

	-- Deal with memory issues. This, of course, is supposed to be automatic.
	local mem = math.floor(collectgarbage("count")/1024)
	if mem > 300 then
		print("Loud Walking: Manually collecting garbage...")
		collectgarbage("collect")
	end

	-- use the same seed (based on perlin noise).
	local seed_noise = minetest.get_perlin({offset = 0, scale = 32768,
	seed = 5202, spread = {x = 80, y = 80, z = 80}, octaves = 2,
	persist = 0.4, lacunarity = 2})
	math.randomseed(seed_noise:get2d({x=minp.x, y=minp.z}))

	-- Keep this first after seeding!
	local px = math.floor((minp.x + 32) / csize.x)
	local pz = math.floor((minp.z + 32) / csize.z)
	local biome = get_biome(px, pz)

	local node_top = biomes[biome].node_top or "default:dirt_with_grass"
	local node_filler = biomes[biome].node_filler or "default:dirt"
	local node_water_top = biomes[biome].node_water_top or "default:water_source"
	local node_water = biomes[biome].node_water or "default:water_source"
	local depth_top = biomes[biome].depth_top or 1
	local depth_water_top = biomes[biome].node_water_top or 1
	local depth_filler = biomes[biome].depth_filler or 1
	local node_stone = biomes[biome].node_stone or "default:stone"
	local ocean = string.find(biome, "ocean") and true or false
	local swamp = string.find(biome, "swamp") and true or false
	local beach = string.find(biome, "beach") and true or false
	local dunes = string.find(biome, "dunes") and true or false
	local half = math.floor(csize.y / 2 + 0.5)
	local ground = half

	beach = beach or dunes
	if ocean then
		ground = ground - 15
	elseif swamp or beach then
		ground = ground - 3
	end

	terrain = minetest.get_perlin_map(terrain_noise, csize):get2dMap_flat(minp)
	cave = minetest.get_perlin_map(cave_noise, csize):get3dMap_flat(minp)

	local pod = is_pod(minp.x, minp.y, minp.z)
	local connection = connection(minp.x, minp.y, minp.z)

	local index = 0
	local index3d = 0
	for z = minp.z, maxp.z do
		local dz = z - minp.z
		for x = minp.x, maxp.x do
			index = index + 1
			local dx = x - minp.x
			index3d = dz * csize.y * csize.x + dx + 1
			local ivm = a:index(x, minp.y, z)

			local terr = get_height(dx, dz, biomes[biome].terrain_scale, ocean, index)
			local in_cave = false

			for y = minp.y, maxp.y do
				local dy = y - minp.y
				if pod then
					if math.min(dx, csize.x - dx) + math.min(dy, csize.y - dy) + math.min(dz, csize.z - dz) < bevel then
						data[ivm] = node("air")
						lightmap[ivm] = 0
						in_cave = false
					elseif math.min(dx, csize.x - dx) + math.min(dy, csize.y - dy) + math.min(dz, csize.z - dz) < bevel + 1 then
						if dy < half then
							data[ivm] = node("loud_walking:scrith")
							lightmap[ivm] = 0
						else
							data[ivm] = node(glass)
						end
						in_cave = false
						write = true
					elseif (dx == 0 or dx == csize.x - 1) or (dz == 0 or dz == csize.z - 1) or (dy == 0 or dy == csize.y - 1) then
						if math.abs(dy - half - 2) < 2 and (dz == half or dx == half) then
							data[ivm] = node("air")
						else
							if dy < half then
								data[ivm] = node("loud_walking:scrith")
								lightmap[ivm] = 0
							else
								data[ivm] = node(glass)
							end
							write = true
						end
						in_cave = false
					elseif (((dx == 35 or dx == 45) and dz >= 35 and dz <= 45) or ((dz == 35 or dz == 45) and dx >= 35 and dx <= 45)) and dx ~= 40 and dz ~= 40 and dy == csize.y - 2 then
						data[ivm] = node("loud_walking:controls")
					elseif (((dx == 35 or dx == 45) and dz >= 35 and dz <= 45) or ((dz == 35 or dz == 45) and dx >= 35 and dx <= 45)) and dx ~= 40 and dz ~= 40 and dy > csize.y - 5 then
						data[ivm] = node(glass)
					elseif dz >= 35 and dz <= 45 and dx >= 35 and dx <= 45 and dy == csize.y - 5 then
						data[ivm] = node(glass)
					elseif not in_cave and  (ocean or swamp or beach) and dy > terr + ground and dy <= half and dy == terr + ground + 1 then
						-- ** water decorations **
						--local deco = get_decoration(biome)
						--if deco then
						--	data[ivm] = node(deco)
						--end
						--write = true
					elseif not in_cave and dy == terr + ground + 1 then
						local deco = get_decoration(biome)
						if deco then
							data[ivm] = node(deco)
						end
						write = true
					elseif (ocean or swamp or beach) and dy > terr + ground and dy <= half and dy >= half - depth_water_top then
						data[ivm] = node(node_water_top)
						in_cave = false
					elseif (ocean or swamp or beach) and dy > terr + ground and dy <= half then
						data[ivm] = node(node_water)
						in_cave = false
					elseif dy > terr + ground then
						data[ivm] = node("air")
						in_cave = false
					elseif cave[index3d] ^ 2 > 0.1 + dy / half then
						if terr + ground >= dy and not in_cave and dy > terr + ground - 10 then
							data[ivm] = node(node_top)
						elseif dy == 1 then
							local sr = math.random(9)
							if not ocean and not swamp and not beach and sr == 1 then
								data[ivm] = node("default:lava_source")
							elseif sr > 6 then
								data[ivm] = node(node_stone)
							elseif ocean or swamp or beach then
								data[ivm] = node(node_filler)
							end
						elseif ocean or swamp or beach and dy < half then
							data[ivm] = node(node_water)
						else
							data[ivm] = node("air")
						end
						in_cave = true
						lightmap[ivm] = 0
					elseif dy > terr + ground - depth_top then
						data[ivm] = node(node_top)
						lightmap[ivm] = 0
						in_cave = false
						write = true
					elseif dy > terr + ground - depth_filler - depth_top then
						data[ivm] = node(node_filler)
						lightmap[ivm] = 0
						in_cave = false
						write = true
					else
						data[ivm] = node(node_stone)
						lightmap[ivm] = 0
						in_cave = false
						write = true
					end
				elseif connection and dy == half and ((dx == half and connection % 4 == 0) or (dz == half and connection % 2 == 1)) then
					data[ivm] = node("loud_walking:scrith")
					lightmap[ivm] = 0
					write = true
				end

				ivm = ivm + a.ystride
				index3d = index3d + csize.x
			end
		end
	end

	if pod then
		print(biome)
		for dz = 0, 75, 5 do
			for dx = 0, 75, 5 do
				if math.random(2) == 1 then
					local x = minp.x + dx + math.random(0, 4)
					local z = minp.z + dz + math.random(0, 4)
					local y = minp.y + get_height(x - minp.x, z - minp.z, biomes[biome].terrain_scale, ocean) + ground

					local ivm = a:index(x, y, z)
					if (swamp or data[ivm + a.ystride] ~= node("default:water_source")) and (data[ivm] == node("default:dirt") or data[ivm] == node("default:dirt_with_grass") or data[ivm] == node("default:dirt_with_snow")) then
						if biomes[biome].special_trees then
							local tree_type = biomes[biome].special_trees[math.random(#biomes[biome].special_trees)]
							if tree_type then
								local schem = loud_walking.schematics[tree_type][math.random(#loud_walking.schematics[tree_type])]
								local pos = {x=x, y=y, z=z}
								-- The minetest schematic functions don't seem very accurate.
								place_schematic(pos, schem, true)
							end
						else
							-- regular schematics?
						end
					end
				end
			end
		end
	end

	if write then
		vm:set_data(data)
		minetest.generate_ores(vm, minp, maxp)
		minetest.generate_decorations(vm, minp, maxp)
		--vm:set_param2_data(p2data)
		--vm:set_lighting({day = 15, night = 0})
		vm:set_light_data(lightmap)
		vm:calc_lighting(minp, maxp, false)
		vm:update_liquids()
		vm:write_to_map()
	end

	vm, a, heightmap, biomemap = nil, nil, nil, nil
end

function loud_walking.respawn(player)
	while true do
		local px = math.random(-10, 10) * 2 - 1
		local pz = math.random(-10, 10) * 2
		local x = 80 * px + 8
		local z = 80 * pz + 8
		local y = 9

		local pos = {x=x,y=y,z=z}
		local node = minetest.get_node(pos)
		if node.name ~= "air" then
			player:setpos(pos)
			return true
		end
	end
end