local max_depth = 31000

local function teleporter(user, area, power)
	if not user then
		return
	end

	local name = user:get_player_name()
	local pos = user:getpos()

	if not fun_caves.db.teleport_data[name] then
		fun_caves.db.teleport_data[name] = {}
	end

	local out = io.open(fun_caves.world..'/fun_caves_data.txt','w')	
	if not (out and name) then
		return
	end

	if fun_caves.db.teleport_data[name].teleported_from then
		user:setpos(fun_caves.db.teleport_data[name].teleported_from)
		fun_caves.db.teleport_data[name].teleported_from = nil
	else
		local newpos
		if area == 'overworld' then
			newpos = {
				x = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6)),
				y = 120,
				z = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6))
			}
		elseif area == 'hell' then
			newpos = {
				x = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6)),
				y = fun_caves.underzones[({'Caina','Phlegethos','Dis','Minauros', 'Phlegethos','Styx'})[power+1]].ceiling-30,
				z = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6))
			}
		elseif area == 'sky' then
			newpos = {
				x = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6)),
				y = ({4368, 8768, 13168, 4368, 4368, 4368})[power+1]+76,
				z = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6))
			}
		elseif area == 'dungeon' then
			newpos = {}
			local base_pos = table.copy(pos)
			if power > 0 then
				base_pos.y = fun_caves.underzones[({'Caina','Phlegethos','Dis','Minauros', 'Phlegethos','Styx'})[power]].lower_bound
			end

			-- check below the top level
			base_pos.y = base_pos.y - (base_pos.y + 32) % 80 - 12

			for i = 1, 1000 do
				newpos = {
					x = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6)),
					y =  base_pos.y - math.random(50) * 80,
					z = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6))
				}

				-- avoid walls
				if newpos.x % 16 == 0 then
					newpos.x = newpos.x + 1
				end
				if newpos.z % 16 == 0 then
					newpos.z = newpos.z + 1
				end

				if fun_caves.is_fortress(newpos) then
					break
				end
			end

			if not fun_caves.is_fortress(newpos) then
				return
			end

			-- place on the top level
			newpos.y = newpos.y + 10
		elseif area == 'underworld' then
			local good = false
			local base_pos = table.copy(pos)
			base_pos.y = -100
			if power > 0 then
				base_pos.y = fun_caves.underzones[({'Caina','Phlegethos','Dis','Minauros', 'Phlegethos','Styx'})[power]].lower_bound
			end

			local c1, c2
			for i = 1, 1000 do
				newpos = {
					x = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6)),
					y =  base_pos.y - math.random(50) * 80,
					z = (math.random(2)*2-3)*(math.random(math.floor(max_depth/6))+power*math.floor(max_depth/6))
				}

				c1 = minetest.get_perlin(fun_caves.cave_noise_1):get3d(newpos)
				c2 = minetest.get_perlin(fun_caves.cave_noise_2):get3d(newpos)
				if c1 * c2 > fun_caves.cave_width then
					newpos.y = newpos.y - 1
					c1 = minetest.get_perlin(fun_caves.cave_noise_1):get3d(newpos)
					c2 = minetest.get_perlin(fun_caves.cave_noise_2):get3d(newpos)
					if c1 * c2 > fun_caves.cave_width then
						good = true
						break
					end
				end
			end

			if not good then
				return
			end
		else
			return
		end

		user:setpos(newpos)
		print('Fun Caves: '..name..' teleported to ('..pos.x..','..pos.y..','..pos.z..')')
		fun_caves.db.teleport_data[name].teleported_from = pos
		user:set_physics_override({gravity=0.1})

		minetest.after(20, function()
			user:set_physics_override({gravity=1})
		end)
	end
end

local gems = {
	{gem = 'Moonstone', teleport = 'sky', ore = true},
	{gem = 'Garnet', teleport = 'underworld', ore = true},
	{gem = 'Coral Gem', teleport = 'hell'},
	{gem = 'Zoisite', teleport = 'dungeon', ore = true},
	{gem = 'Aquamarine', teleport = 'overworld', ore = true},
}

for _, gem in pairs(gems) do
	if not gem.lower then
		gem.lower = gem.gem:lower()
		gem.lower = gem.lower:gsub(' ', '_')
	end

	minetest.register_craftitem("fun_caves:"..gem.lower, {
		description = gem.gem,
		drawtype = "plantlike",
		paramtype = "light",
		tiles = {'fun_caves_'..gem.lower..'.png'},
		inventory_image = 'fun_caves_'..gem.lower..'.png',
		groups = {dig_immediate = 3},
		sounds = default.node_sound_stone_defaults(),
	})

	if gem.ore then
		minetest.register_node('fun_caves:stone_with_'..gem.lower..'s', {
			description = gem.gem..' Ore',
			tiles = {'default_stone.png^fun_caves_mineral_'..gem.lower..'.png'},
			groups = {cracky = 1},
			drop = 'fun_caves:'..gem.lower..'',
			sounds = default.node_sound_stone_defaults(),
		})

		minetest.register_ore({
			ore_type       = "scatter",
			ore            = 'fun_caves:stone_with_'..gem.lower..'s',
			wherein        = "default:stone",
			clust_scarcity = 21 * 21 * 21,
			clust_num_ores = 1,
			clust_size     = 1,
			y_min          = -31000,
			y_max          = 31000,
		})
	end
end

local metals = {
	{
		base = 'copper',
		crucible = 'copper_crucible',
		crucible_desc = 'Crucible of Copper',
		level = 0,
		metal = 'Copper',
		node = 'Very Pure Copper',
		node_lower = 'pure_copper',
		tile = 'default_copper_ingot.png',
	},
	{
		base = 'meteorite',
		base_desc = 'Iron Meteorite',
		crucible = 'meteoritic_iron_crucible',
		crucible_desc = 'Crucible of Meteoritic Iron',
		level = 0,
		metal = 'Iron',
		node = 'Sky Iron',
		tile = 'default_steel_ingot.png',
	},
	{
		base = 'eternal_ice_crystal',
		base_desc = 'Eternal Ice Crystal',
		crucible = 'metallic_ice_crucible',
		crucible_desc = 'Crucible of Metallic Ice',
		level = 1,
		metal = 'Metallic Ice',
		node = 'metallic_ice',
		tile = 'default_steel_ingot.png^[colorize:#385B72:150',
	},
}

for _, metal in pairs(metals) do
	if not metal.lower then
		metal.lower = metal.metal:lower()
		metal.lower = metal.lower:gsub(' ', '_')
	end
	if not metal.node_lower then
		metal.node_lower = metal.node:lower()
		metal.node_lower = metal.node_lower:gsub(' ', '_')
	end

	local full_base
	if minetest.registered_items['default:'..metal.base..'_ingot'] then
		full_base = 'default:'..metal.base..'_ingot'
	else
		full_base = 'fun_caves:'..metal.base
		minetest.register_craftitem(full_base, {
			description = metal.base_desc,
			drawtype = "plantlike",
			paramtype = "light",
			tiles = {'fun_caves_'..metal.base..'.png'},
			inventory_image = 'fun_caves_'..metal.base..'.png',
			groups = {dig_immediate = 3},
			sounds = default.node_sound_stone_defaults(),
		})
	end

	minetest.register_craftitem("fun_caves:"..metal.node_lower, {
		description = metal.node,
		drawtype = "plantlike",
		paramtype = "light",
		tiles = {metal.tile},
		inventory_image = metal.tile,
		groups = {dig_immediate = 3},
		sounds = default.node_sound_stone_defaults(),
	})

	minetest.register_craftitem("fun_caves:"..metal.crucible, {
		description = metal.crucible_desc,
		drawtype = "plantlike",
		paramtype = "light",
		tiles = {"fun_caves_crucible.png"},
		inventory_image = "fun_caves_crucible.png",
		groups = {dig_immediate = 3},
		sounds = default.node_sound_stone_defaults(),
	})

	minetest.register_craft({
		output = 'fun_caves:'..metal.crucible,
		recipe = {
			{full_base, full_base, full_base},
			{full_base, full_base, full_base},
			{full_base, 'fun_caves:crucible', full_base},
		}
	})

	minetest.register_craft({
		type = "cooking",
		output = "fun_caves:"..metal.node_lower,
		recipe = "fun_caves:"..metal.crucible,
		cooktime = 30,
	})

	if metal.base ~= 'copper' then
		for _, gem in pairs(gems) do
			minetest.register_craftitem('fun_caves:tesseract_'..metal.lower..'_'..gem.lower, {
				description = metal.metal..' and '..gem.gem..' Tesseract',
				drawtype = "plantlike",
				paramtype = "light",
				tiles = {'fun_caves_tesseract_'..metal.lower..'_'..gem.lower..'.png'},
				inventory_image = 'fun_caves_tesseract_'..metal.lower..'_'..gem.lower..'.png',
				groups = {dig_immediate = 3},
				sounds = default.node_sound_stone_defaults(),
				on_use = function(itemstack, user, pointed_thing)
					teleporter(user, gem.teleport, metal.level)
				end,
			})
			minetest.register_alias('fun_caves:teleporter_'..metal.lower..'_'..gem.lower, 'fun_caves:tesseract_'..metal.lower..'_'..gem.lower)

			minetest.register_craft({
				output = 'fun_caves:tesseract_'..metal.lower..'_'..gem.lower,
				recipe = {
					{'fun_caves:'..metal.node_lower, 'fun_caves:pure_copper', 'fun_caves:'..metal.node_lower},
					{'fun_caves:'..gem.lower, 'fun_caves:'..gem.lower, 'fun_caves:'..gem.lower},
					{'fun_caves:'..metal.node_lower, 'default:obsidian_shard', 'fun_caves:'..metal.node_lower},
				}
			})

		end
	end
end

minetest.register_craft({
	type = "cooking",
	output = "fun_caves:coral_gem",
	recipe = "fun_caves:precious_coral",
	cooktime = 5,
})


minetest.register_craftitem("fun_caves:crucible", {
	description = "Crucible",
	drawtype = "plantlike",
	paramtype = "light",
	tiles = {"fun_caves_crucible.png"},
	inventory_image = "fun_caves_crucible.png",
	groups = {dig_immediate = 3},
	sounds = default.node_sound_stone_defaults(),
})

minetest.register_craft({
	output = 'fun_caves:crucible',
	recipe = {
		{'default:clay', '', 'default:clay'},
		{'default:clay', '', 'default:clay'},
		{'', 'default:clay', ''},
	}
})


local function translocate(pos, node, clicker, itemstack, pointed_thing)
	local meta = minetest.get_meta(pos)
	local id = meta:get_string('id')
	if not (id and tonumber(id)) then
		return
	end
	local pair = fun_caves.db.translocators[tonumber(id)]
	if not pair or #pair < 2 then
		return
	end
	local pos2
	if minetest.serialize(pair[2]) == minetest.serialize(pos) then
		pos2 = table.copy(pair[1])
	else
		pos2 = table.copy(pair[2])
	end
	pos2.y = pos2.y + 1
	clicker:setpos(pos2)
end

local function trans_use(itemstack, user, pointed_thing)
	if not itemstack then
		return
	end
	local data = minetest.deserialize(itemstack:get_metadata())
	if not (data and data.id) then
		return
	end
	local player_name = user:get_player_name()
	minetest.chat_send_player(player_name, "You see a serial number: "..data.id)
end

local function trans_place(itemstack, placer, pointed_thing)
	if not (itemstack and pointed_thing) then
		return
	end

	local data = minetest.deserialize(itemstack:get_metadata())
	if not (data and data.id) then
		return
	end
	local pos = pointed_thing.above
	local pair = fun_caves.db.translocators[tonumber(data.id)]
	if #pair > 1 then
		print('* Fun Caves: high error in translocator storage')
		return
	end
	local ret, place_good = minetest.item_place_node(itemstack, placer, pointed_thing)
	if place_good then
		pair[#pair+1] = pos
		local meta = minetest.get_meta(pos)
		meta:set_string('id', data.id)
	end
	return ret, place_good
end

local function trans_dig(pos, node, digger)
	if not (pos and digger) then
		return
	end
	-------------------------------------
	-- This needs to check for protection.
	-------------------------------------
	local meta = minetest.get_meta(pos)
	local id = meta:get_string('id')
	local data = { id = id }
	if not (data and data.id) then
		return
	end
	local pair = fun_caves.db.translocators[tonumber(data.id)]
	if #pair < 1 then
		print('* Fun Caves: low error in translocator storage')
		return
	end
	local inv = digger:get_inventory()
	local item = ItemStack(node.name)
	local data_str = minetest.serialize(data)
	item:set_metadata(data_str)
	if not inv:add_item('main', item) then
		return
	end
	minetest.remove_node(pos)
	if #pair > 1 and minetest.serialize(pair[2]) == minetest.serialize(pos) then
		table.remove(pair, 2)
	else
		table.remove(pair, 1)
	end
end

newnode = fun_caves.clone_node("default:steelblock")
newnode.description = "Translocator"
newnode.on_rightclick = translocate
newnode.on_use = trans_use
newnode.on_place = trans_place
newnode.on_dig = trans_dig
newnode.stack_max = 1
newnode.groups = {cracky = 3, oddly_breakable_by_hand = 3}
minetest.register_node("fun_caves:translocator", newnode)

for _, gem in pairs(gems) do
	minetest.register_craft({
		output = 'fun_caves:translocator 2',
		type = 'shapeless',
		recipe = {
			'fun_caves:'..gem.lower,
			'default:mese_crystal',
			'default:steelblock',
		}
	})
end

minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv)
	if itemstack:get_name() ~= "fun_caves:translocator" then
		return
	end

	data = {}
	data.id = string.format('%d', #fun_caves.db.translocators+1)
	fun_caves.db.translocators[#fun_caves.db.translocators+1] = {}
	local data_str = minetest.serialize(data)
	itemstack:set_metadata(data_str)
end)