local elixir_duration = 3600
local armor_mod = minetest.get_modpath("3d_armor") and armor and armor.set_player_armor


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:silver_lump',
	'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',
			"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 not (player and itemstack and old_craft_grid and itemstack:get_name() == "fun_caves:elixir") then
			return
		end

		local ingredients = {}
		local inv = player:get_inventory()
		if not inv then
			return
		end

		for i = 1, inv:get_size("craft") do
			local name = old_craft_grid[i]:get_name()
			if name ~= '' and name ~= 'fun_caves:syrup' and type(name) == 'string' and not name:find('green_slimeball$') then
				ingredients[#ingredients+1] = name
			end
		end
	end)
end


if fun_caves.register_status and fun_caves.set_status then
	fun_caves.register_status({
		name = 'breathe',
		terminate = function(player)
			if not player then
				return
			end

			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)
			if not (itemstack and user) then
				return
			end

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

			fun_caves.set_status(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)
			if not (player and fun_caves.db.status) then
				return
			end

			local player_name = player:get_player_name()
			if not (player_name and type(player_name) == 'string' and player_name ~= '') then
				return
			end

			minetest.chat_send_player(player_name, minetest.colorize('#FF0000', 'You feel weaker...'))
		end,
	})

	local function increase_damage(user, bonus)
		if not (user and fun_caves.set_status) then
			return
		end

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

		minetest.chat_send_player(player_name, 'You feel strong...')
		fun_caves.set_status(player_name, 'damage_elixir', elixir_duration, {bonus = bonus})
	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)
				if not (itemstack and user) then
					return
				end

				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


	fun_caves.reconcile_armor = function(elixir_armor, worn_armor)
		if elixir_armor < worn_armor then
			return elixir_armor
		end

		return worn_armor
	end

	-- set_armor assumes any armor mods have already set the normal armor values.
	local function set_armor(player, value, delay)
		if not (player and fun_caves.reconcile_armor) then
			return
		end

		local armor = player:get_armor_groups()
		if not (armor and armor.fleshy and armor.fleshy >= value) then
			return
		end

		if armor_mod then
			armor.fleshy = fun_caves.reconcile_armor(value, armor.fleshy)
		else
			armor.fleshy = value
		end

		player:set_armor_groups(armor)

		if fun_caves.display_armor then
			if delay then
				-- Delay display, in case of lag.
				minetest.after(delay, function()
					fun_caves.display_armor(player)
				end)
			else
				fun_caves.display_armor(player)
			end
		end

		return true
	end

	-- called only by armor elixirs
	local function ingest_armor_elixir(player, value)
		if not (player and fun_caves.set_status) then
			return
		end

		-- support for 3d_armor
		-- This may or may not work with all versions.
		if armor_mod then
			armor:set_player_armor(player)
		end

		if not set_armor(player, value) then
			return
		end

		local player_name = player:get_player_name()
		if not (player_name and type(player_name) == 'string' and player_name ~= '') then
			return
		end

		minetest.chat_send_player(player_name, 'Your skin feels harder...')
		fun_caves.set_status(player_name, 'armor_elixir', elixir_duration, {value = value})
	end

	-- called on joinplayer and every time an armor mod updates
	fun_caves.load_armor_elixir = function(player)
		if not (player and fun_caves.db.status) then
			return
		end

		local player_name = player:get_player_name()
		if not (player_name and type(player_name) == 'string' and player_name ~= '') then
			return
		end

		if fun_caves.db.status[player_name] and fun_caves.db.status[player_name].armor_elixir then
			local value = fun_caves.db.status[player_name].armor_elixir.value
			set_armor(player, value, 3)
		end
	end

	fun_caves.register_status({
		name = 'armor_elixir',
		terminate = function(player)
			if not player then
				return
			end

			player:set_armor_groups({fleshy = 100})

			-- support for 3d_armor
			-- This may or may not work with all versions.
			if armor_mod then
				minetest.after(1, function()
					armor:set_player_armor(player)
				end)
			end

			local player_name = player:get_player_name()
			if not (player_name and type(player_name) == 'string' and player_name ~= '') then
				return
			end

			minetest.chat_send_player(player_name, minetest.colorize('#FF0000', 'Your skin feels softer...'))
		end,
	})

	local descs = {
		{'wood', 95, 'group:wood'},
		{'stone', 90, 'group:stone'},
		{'steel', 80, 'default:steel_ingot'},
		{'copper', 85, 'default:copper_ingot'},
		{'bronze', 70, 'default:bronze_ingot'},
		{'gold', 60, 'default:gold_ingot'},
		{'diamond', 50, 'default:diamond'},
		{'silver', 40, 'fun_caves:silver_ingot'},
		{'mese', 30, 'default:mese_crystal'},
		--{'', 20, ''},
		--{'adamant', 10, '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)
					if not (itemstack and user) then
						return
					end

					ingest_armor_elixir(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
end