local elixir_duration = 3600


local elixir_ingredients = {
	'default:acacia_leaves',
	'default:acacia_sapling',
	'default:acacia_tree',
	'default:acacia_wood',
	'default:apple',
	'default:aspen_leaves',
	'default:aspen_sapling',
	'default:aspen_tree',
	'default:aspen_wood',
	'default:cactus',
	'default:clay_lump',
	'default:cloud',
	'default:coal_lump',
	'default:copper_lump',
	'default:desert_sand',
	'default:desert_stone',
	'default:diamond',
	'default:dirt',
	'default:dry_shrub',
	'default:gold_lump',
	'default:gravel',
	'default:ice',
	'default:iron_lump',
	'default:junglegrass',
	'default:jungleleaves',
	'default:junglesapling',
	'default:jungletree',
	'default:junglewood',
	'default:leaves',
	'default:pine_needles',
	'default:pine_sapling',
	'default:pine_tree',
	'default:pine_wood',
	'default:sand',
	'default:sandstone',
	'default:sapling',
	'default:snow',
	'default:stone',
	'default:tree',
	'default:wood',
	'farming:seed_cotton',
	'farming:seed_wheat',
	'flowers:dandelion_white',
	'flowers:dandelion_yellow',
	'flowers:geranium',
	'flowers:mushroom_brown',
	'flowers:mushroom_red',
	'flowers:rose',
	'flowers:tulip',
	'flowers:viola',
	'flowers:waterlily',
	'fun_caves:amber',
	'fun_caves:bark',
	'fun_caves:bird_of_paradise',
	'fun_caves:black_sand',
	'fun_caves:brain_coral',
	'fun_caves:diamondwood',
	'fun_caves:dragon_eye',
	'fun_caves:dry_fiber',
	'fun_caves:gerbera',
	'fun_caves:giant_mushroom_cap',
	'fun_caves:giant_mushroom_stem',
	'fun_caves:hibiscus',
	'fun_caves:huge_mushroom_cap',
	'fun_caves:icicle_down',
	'fun_caves:icicle_up',
	'fun_caves:ironwood',
	'fun_caves:leaves',
	'fun_caves:onion',
	'fun_caves:orchid',
	'fun_caves:petrified_wood',
	'fun_caves:pillar_coral',
	'fun_caves:small_rocks',
	'fun_caves:staghorn_coral',
	'fun_caves:stalactite',
	'fun_caves:stalactite_mossy',
	'fun_caves:stalactite_slimy',
	'fun_caves:stalagmite',
	'fun_caves:stalagmite_mossy',
	'fun_caves:stalagmite_slimy',
	'fun_caves:thin_ice',
	'fun_caves:tree',
	'wool:white',
	'wool:black',
}

local count = 0
for _, name in pairs(elixir_ingredients) do
	local item = minetest.registered_items[name]
	if not item then
		item = minetest.registered_nodes[name]
	end
	if item then
		if item.groups then
			groups = table.copy(item.groups)
		else
			groups = {}
		end
		groups.elixir_ingredient = 1
		minetest.override_item(name, {groups = groups})
		count = count + 1
	else
		--print(name)
	end
end

if count > 15 then
	--for _, list in pairs({'registered_items', 'registered_nodes', 'registered_craftitems'}) do
	--	for _, item in pairs(minetest[list]) do
	--		if item and item.groups.elixir_ingredient then
	--			print(item.name)
	--		end
	--	end
	--end

	local elixirs = {}

	minetest.register_craftitem("fun_caves:elixir", {
		description = "unknown elixir",
		inventory_image = "fun_caves_elixir.png",
		on_use = minetest.item_eat(-2),
	})

	minetest.register_craft({
		type = "shapeless",
		output = 'fun_caves:elixir',
		recipe = {
			'mobs_slimes:green_slimeball',
			'group:elixir_ingredient',
			'group:elixir_ingredient',
			'group:elixir_ingredient',
			"vessels:glass_bottle",
		},
	})

	minetest.register_craft({
		type = "shapeless",
		output = 'fun_caves:elixir',
		recipe = {
			'fun_caves:syrup',
			'group:elixir_ingredient',
			'group:elixir_ingredient',
		},
	})

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

		local ingredients = {}
		for i = 1, player:get_inventory():get_size("craft") do
			local name = old_craft_grid[i]:get_name()
			if name ~= '' and name ~= 'fun_caves:syrup' and not name:find('green_slimeball$') then
				ingredients[#ingredients+1] = name
				--print(name)
			end
		end
	end)
end


fun_caves.register_status({
	name = 'breathe',
	terminate = function(player)
		local player_name = player:get_player_name()
		minetest.chat_send_player(player_name, minetest.colorize('#FF0000', 'Your breathing becomes more difficult...'))
	end,
})

minetest.register_craftitem("fun_caves:elixir_breathe", {
	description = 'Dr Robertson\'s Patented Easy Breathing Elixir',
	inventory_image = "fun_caves_elixir_breathe.png",
	on_use = function(itemstack, user, pointed_thing)
		local player_name = user:get_player_name()
		fun_caves.set_status(user:get_player_name(), 'breathe', elixir_duration)
		minetest.chat_send_player(player_name, 'Your breathing becomes easier...')
		itemstack:take_item()
		return itemstack
	end,
})

minetest.register_craft({
	type = "shapeless",
	output = 'fun_caves:elixir_breathe',
	recipe = {
		'mobs_slimes:green_slimeball',
		'fun_caves:coral_gem',
		"vessels:glass_bottle",
	},
})

minetest.register_craft({
	type = "shapeless",
	output = 'fun_caves:elixir_breathe',
	recipe = {
		'fun_caves:syrup',
		'fun_caves:coral_gem',
	},
})


fun_caves.register_status({
	name = 'damage_elixir',
	terminate = function(player)
		local player_name = player:get_player_name()
		minetest.chat_send_player(player_name, minetest.colorize('#FF0000', 'You feel weaker...'))
		fun_caves.db.status[player_name].damage_elixir = nil
	end,
})


fun_caves.register_status({
	name = 'armor_elixir',
	terminate = function(player)
		local player_name = player:get_player_name()
		local armor_elixir = fun_caves.db.status[player_name].armor_elixir
		local factor = armor_elixir.factor
		local armor = player:get_armor_groups()
		armor.fleshy = math.min(100, math.max(1, math.ceil(armor.fleshy / factor)))
		player:set_armor_groups(armor)
		minetest.chat_send_player(player_name, minetest.colorize('#FF0000', 'Your skin feels softer...'))
		fun_caves.db.status[player_name].armor_elixir = nil
		fun_caves.display_armor(player)
	end,
})


if fun_caves.expire_elixir_on_death then
	minetest.register_on_dieplayer(function(player)
		local player_name = player:get_player_name()
		if fun_caves.db.status[player_name] and fun_caves.db.status[player_name].armor_elixir then
			local factor = fun_caves.db.status[player_name].armor_elixir.factor
			local armor = player:get_armor_groups()
			armor.fleshy = math.min(100, math.max(1, math.ceil(armor.fleshy / factor)))
			player:set_armor_groups(armor)
			fun_caves.db.status[player_name].armor_elixir = nil
			fun_caves.display_armor(player)
		end
	end)
end


local function increase_damage(user, bonus)
	local player_name = user:get_player_name()

	minetest.chat_send_player(player_name, 'You feel strong...')
	fun_caves.set_status(player_name, 'damage_elixir', elixir_duration, {bonus = bonus})
end


local function armor(user, factor)
	local player_name = user:get_player_name()
	local armor = user:get_armor_groups()

	if fun_caves.db.status[player_name].armor_elixir then
		local old_factor = fun_caves.db.status[player_name].armor_elixir.factor
		armor.fleshy = math.min(100, math.max(1, math.ceil(armor.fleshy / old_factor)))
	end

	armor.fleshy = math.min(100, math.max(1, math.ceil(armor.fleshy * factor)))
	user:set_armor_groups(armor)
	minetest.chat_send_player(player_name, 'Your skin feels harder...')
	fun_caves.set_status(player_name, 'armor_elixir', elixir_duration, {factor = factor})
	fun_caves.display_armor(user)
end

local descs = {
	{'wood', 0.95, 'group:wood'},
	{'stone', 0.9, 'group:stone'},
	{'steel', 0.8, 'default:steel_ingot'},
	{'copper', 0.85, 'default:copper_ingot'},
	{'bronze', 0.7, 'default:bronze_ingot'},
	{'gold', 0.6, 'default:gold_ingot'},
	{'diamond', 0.5, 'default:diamond'},
	{'silver', 0.4, 'fun_caves:silver_ingot'},
	{'mese', 0.3, 'default:mese_crystal'},
	--{'', 0.2, ''},
	--{'adamant', 0.1, 'fun_caves:adamant'},
}

if fun_caves.elixir_armor then
	for _, desc in pairs(descs) do
		local name = desc[1]
		local value = desc[2]
		local cap = name:gsub('^%l', string.upper)
		minetest.register_craftitem("fun_caves:liquid_"..name, {
			description = 'Dr Robertson\'s Patented Liquid '..cap..' Elixir',
			drawtype = "plantlike",
			paramtype = "light",
			tiles = {'fun_caves_liquid_'..name..'.png'},
			inventory_image = 'fun_caves_liquid_'..name..'.png',
			groups = {dig_immediate = 3, vessel = 1},
			sounds = default.node_sound_glass_defaults(),
			on_use = function(itemstack, user, pointed_thing)
				armor(user, value)
				itemstack:take_item()
				return itemstack
			end,
		})

		minetest.register_craft({
			type = "shapeless",
			output = 'fun_caves:liquid_'..name,
			recipe = {
				'mobs_slimes:green_slimeball',
				desc[3],
				"vessels:glass_bottle",
			},
		})

		minetest.register_craft({
			type = "shapeless",
			output = 'fun_caves:liquid_'..name,
			recipe = {
				'fun_caves:syrup',
				desc[3],
			},
		})
	end
end


local descs = {
	{'boar', 2, 'fun_caves:meteorite'},
	{'lion', 4, 'fun_caves:eternal_ice_crystal'},
	{'grizzly', 6},
	{'bull', 8},
	{'rhino', 10},
	{'elephant', 12},
}

for _, desc in pairs(descs) do
	local name = desc[1]
	local uname = name:gsub("(%l)(%w*)", function(a,b) return string.upper(a)..b end)
	local bonus = desc[2]
	minetest.register_craftitem("fun_caves:elixir_strength_"..name, {
		description = 'Dr Robertson\'s Patented '..uname..' Strength Elixir',
		drawtype = "plantlike",
		paramtype = "light",
		tiles = {'fun_caves_elixir_strength_'..name..'.png'},
		inventory_image = 'fun_caves_elixir_strength_'..name..'.png',
		groups = {dig_immediate = 3, vessel = 1},
		sounds = default.node_sound_glass_defaults(),
		on_use = function(itemstack, user, pointed_thing)
			increase_damage(user, bonus)
			itemstack:take_item()
			return itemstack
		end,
	})

	if desc[3] then
		minetest.register_craft({
			type = "shapeless",
			output = 'fun_caves:elixir_strength_'..name,
			recipe = {
				'mobs_slimes:green_slimeball',
				desc[3],
				"vessels:glass_bottle",
			},
		})

		minetest.register_craft({
			type = "shapeless",
			output = 'fun_caves:elixir_strength_'..name,
			recipe = {
				'fun_caves:syrup',
				desc[3],
			},
		})
	end
end