local max_depth = 31000

local function teleporter(user, area, power)
	if not (user and area and power and type(power) == 'number' and fun_caves.world and fun_caves.db and fun_caves.db.teleport_data and fun_caves.underzones and fun_caves.cave_noise_1 and fun_caves.cave_noise_2 and fun_caves.cave_width) then
		return
	end

	local name = user:get_player_name()
	local pos = user:getpos()
	if not (name and pos and name ~= '' and type(name) == 'string') then
		return
	end

	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 = pos.x + (math.random(5) - math.random(5)) * 80,
				y = fun_caves.underzones[({'Caina','Phlegethos','Dis','Minauros', 'Phlegethos','Styx'})[power+1]].ceiling-30,
				z = pos.z + (math.random(5) - math.random(5)) * 80,
			}
		elseif area == 'sky' then
			newpos = {
				x = pos.x + (math.random(5) - math.random(5)) * 80,
				y = ({4368, 8768, 13168, 4368, 4368, 4368})[power+1]+76,
				z = pos.z + (math.random(5) - math.random(5)) * 80,
			}
		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 = base_pos.x + (math.random(5) - math.random(5)) * 80,
					y = base_pos.y - math.random(50) * 80,
					z = base_pos.z + (math.random(5) - math.random(5)) * 80,
				}

				c1 = minetest.get_perlin(fun_caves.cave_noise_1):get3d(newpos)
				c2 = minetest.get_perlin(fun_caves.cave_noise_2):get3d(newpos)
				if not (c1 and c2 and type(c1) == 'number' and type(c2) == 'number') then
					return
				end

				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 not (c1 and c2 and type(c1) == 'number' and type(c2) == 'number') then
						return
					end

					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 = '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)
	if not (pos and clicker and fun_caves.db.translocators) then
		return
	end

	local meta = minetest.get_meta(pos)
	if not meta then
		return
	end

	local id = meta:get_string('id')
	local owner = meta:get_string('owner')
	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 = pair[1]
	else
		pos2 = pair[2]
	end

	if pos2 then
		clicker:setpos(pos2)

		-- If the mated translocator doesn't exist, recreate it.
		minetest.after(1, function()
			if not owner then
				return
			end

			-- If we can't get the node, we can't set it.
			local node = minetest.get_node_or_nil(pos2)
			if not node or node.name == 'fun_caves:translocator' then
				return
			end

			minetest.set_node(pos2, {name = 'fun_caves:translocator'})
			local meta = minetest.get_meta(pos2)
			if not meta then
				return
			end

			meta:set_string('id', id)
			meta:set_string('owner', owner)

			print('Fun Caves: recreated a missing translocator')
		end)
	end
end

local function trans_use(itemstack, user, pointed_thing)
	if not (itemstack and user) 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 placer and pointed_thing and fun_caves.db.translocators) then
		return
	end

	local data = minetest.deserialize(itemstack:get_metadata())
	if not (data and data.id and tonumber(data.id)) then
		return
	end

	local player_name = placer:get_player_name()
	if not data.owner or data.owner == '' then
		print('Fun Caves: Unowned translocator has been assigned to placer.')
		data.owner = player_name
	end

	local pos = pointed_thing.above
	local pair = fun_caves.db.translocators[tonumber(data.id)]
	if not pair or #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)
		if not meta then
			return
		end

		meta:set_string('id', data.id)
		meta:set_string('owner', data.owner)
	end
	return ret, place_good
end

local function trans_dig(pos, node, digger)
	if not (pos and node and digger and fun_caves.db.translocators) then
		return
	end

	local player_name = digger:get_player_name()
	if minetest.is_protected(pos, player_name) then
		return
	end

	local meta = minetest.get_meta(pos)
	if not meta then
		return
	end

	local id = meta:get_string('id')
	local owner = meta:get_string('owner')
	if owner == '' then
		owner = player_name
		print('Fun Caves: Unowned translocator has been assigned to taker.')
	end
	local data = { id = id, owner = owner }
	if not (data and data.id and data.owner == player_name) then
		local privs = minetest.check_player_privs(player_name, {server=true})
		if privs then
			print('Fun Caves: Admin has destroyed ['..data.owner..']\'s translocator')
			minetest.remove_node(pos)
		end
		return
	end

	local pair = fun_caves.db.translocators[tonumber(data.id)]
	if not pair or #pair < 1 then
		print('* Fun Caves: low error in translocator storage')
		minetest.remove_node(pos)
		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:room_for_item('main', item) or 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

local function trans_dest(pos)
	if not (pos and fun_caves.db.translocators) then
		return
	end

	local meta = minetest.get_meta(pos)
	if not meta then
		return
	end

	local id = meta:get_string('id')
	local owner = meta:get_string('owner')
	if not (id and owner) then
		return
	end

	if not fun_caves.db.translocators[tonumber(id)] then
		return
	end
	local pair = table.copy(fun_caves.db.translocators[tonumber(id)])

	minetest.after(1, function()
		if not fun_caves.db.translocators[tonumber(id)] or #fun_caves.db.translocators[tonumber(id)] < #pair then
			return
		end
		minetest.set_node(pos, {name = 'fun_caves:translocator'})
		local meta = minetest.get_meta(pos)
		if not meta then
			return
		end

		meta:set_string('id', id)
		meta:set_string('owner', owner)

		print('Fun Caves: recreated a destroyed translocator')
	end)
end

minetest.register_node("fun_caves:translocator", {
	visual = 'mesh',
	mesh = "fun_caves_translocator.obj",
	description = 'Translocator',
	tiles = {'fun_caves_translocator.png'},
	drawtype = 'mesh',
	sunlight_propagates = true,
	walkable = false,
	paramtype = 'light',
	paramtype2 = 'facedir',
	use_texture_alpha = true,
	groups = {cracky = 3, oddly_breakable_by_hand = 3},
	light_source = 13,
	sounds = default.node_sound_glass_defaults(),
	stack_max = 1,
	selection_box = {
		type = "fixed",
		fixed = {-0.25, -0.5, -0.25,  0.25, 0.5, 0.25}
	},
	on_rightclick = translocate,
	on_use = trans_use,
	on_place = trans_place,
	on_dig = trans_dig,
	on_destruct = trans_dest,
})

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

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

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