assert(modlib.version >= 103, "character_anim requires at least version rolling-103 of modlib")
local workaround_model = modlib.mod.require"workaround"

character_anim = {}

character_anim.conf = modlib.mod.configuration()

local quaternion = modlib.quaternion
-- TODO deduplicate code: move to modlib (see ghosts mod)
local media_paths = modlib.minetest.media.paths

local static_model_names = {}
local animated_model_names = {}
for name in pairs(media_paths) do
	if (name:find"character" or name:find"player") and name:match"%.b3d$" then
		local fixed, data = pcall(workaround_model, name)
		if fixed then
			local static_name = "_character_anim_" .. name
			minetest.dynamic_add_media({
				filename = static_name,
				filedata = data,
			})
			static_model_names[name] = static_name
			animated_model_names[static_name] = name
		else
			minetest.log("warning", "character_anim: failed to workaround model " .. name)
		end
	end
end

local function find_node(root, name)
	if root.name == name then return root end
	for _, child in ipairs(root.children) do
		local node = find_node(child, name)
		if node then return node end
	end
end

local models = setmetatable({}, {__index = function(self, filename)
	if animated_model_names[filename] then
		return self[animated_model_names[filename]]
	end
	local _, ext = modlib.file.get_extension(filename)
	if not ext or ext:lower() ~= "b3d" then
		-- Only B3D support currently
		return
	end
	local path = assert(media_paths[filename], filename)
	local stream = io.open(path, "rb")
	local model = assert(modlib.b3d.read(stream))
	assert(stream:read(1) == nil, "EOF expected")
	stream:close()
	self[filename] = model
	return model
end})

function character_anim.is_interacting(player)
	local control = player:get_player_control()
	return minetest.check_player_privs(player, "interact") and (control.RMB or control.LMB)
end

local function get_look_horizontal(player)
	return -math.deg(player:get_look_horizontal())
end

local players = {}
character_anim.players = players

local function get_playerdata(player)
	local name = player:get_player_name()
	local data = players[name]
	if data then return data end
	-- Initialize playerdata if it doesn't already exist
	data = {
		interaction_time = 0,
		animation_time = 0,
		look_horizontal = get_look_horizontal(player),
		bone_positions = {}
	}
	players[name] = data
	return data
end

function character_anim.set_bone_override(player, bonename, position, rotation)
	local value = {
		position = position,
		euler_rotation = rotation
	}
	get_playerdata(player).bone_positions[bonename] = next(value) and value
end

local function nil_default(value, default)
	if value == nil then return default end
	return value
end

-- Forward declaration
local handle_player_animations
-- Raw PlayerRef methods
local set_bone_position, set_animation, set_local_animation
minetest.register_on_joinplayer(function(player)
	get_playerdata(player) -- Initalizes playerdata if it isn't already initialized
	if not set_bone_position then
		local PlayerRef = getmetatable(player)

		-- Keep our model hack completely opaque to the outside world

		local set_properties = PlayerRef.set_properties
		function PlayerRef:set_properties(props)
			if not self:is_player() then
				return set_properties(self, props)
			end
			local old_mesh = props.mesh
			props.mesh = static_model_names[old_mesh] or old_mesh
			set_properties(self, props)
			props.mesh = old_mesh
		end

		local get_properties = PlayerRef.get_properties
		function PlayerRef:get_properties()
			if not self:is_player() then
				return get_properties(self)
			end
			local props = get_properties(self)
			if not props then return nil end
			props.mesh = animated_model_names[props.mesh] or props.mesh
			return props
		end

		set_bone_position = PlayerRef.set_bone_position
		function PlayerRef:set_bone_position(bonename, position, rotation)
			if self:is_player() then
				character_anim.set_bone_override(self, bonename or "",
					position or {x = 0, y = 0, z = 0},
					rotation or {x = 0, y = 0, z = 0})
			end
			return set_bone_position(self, bonename, position, rotation)
		end

		set_animation = PlayerRef.set_animation
		function PlayerRef:set_animation(frame_range, frame_speed, frame_blend, frame_loop)
			if not self:is_player() then
				return set_animation(self, frame_range, frame_speed, frame_blend, frame_loop)
			end
			local player_animation = get_playerdata(self)
			if not player_animation then
				return
			end
			local prev_anim = player_animation.animation
			local new_anim = {
				nil_default(frame_range, {x = 1, y = 1}),
				nil_default(frame_speed, 15),
				nil_default(frame_blend, 0),
				nil_default(frame_loop, true)
			}
			player_animation.animation = new_anim
			if not prev_anim or (prev_anim[1].x ~= new_anim[1].x or prev_anim[1].y ~= new_anim[1].y) then
				-- Reset animation only if the animation changed
				player_animation.animation_time = 0
				handle_player_animations(0, player)
			elseif prev_anim[2] ~= new_anim[2] then
				-- Adapt time to new speed
				player_animation.animation_time = player_animation.animation_time * prev_anim[2] / new_anim[2]
			end
		end
		local set_animation_frame_speed = PlayerRef.set_animation_frame_speed
		function PlayerRef:set_animation_frame_speed(frame_speed)
			if not self:is_player() then
				return set_animation_frame_speed(self, frame_speed)
			end
			frame_speed = nil_default(frame_speed, 15)
			local player_animation = get_playerdata(self)
			if not player_animation then
				return
			end
			local prev_speed = player_animation.animation[2]
			player_animation.animation[2] = frame_speed
			-- Adapt time to new speed
			player_animation.animation_time = player_animation.animation_time * prev_speed / frame_speed
		end

		local get_animation = PlayerRef.get_animation
		function PlayerRef:get_animation()
			if not self:is_player() then
				return get_animation(self)
			end
			local anim = get_playerdata(self).animation
			if anim then
				return unpack(anim, 1, 4)
			end
			return get_animation(self)
		end

		set_local_animation = PlayerRef.set_local_animation
		function PlayerRef:set_local_animation(idle, walk, dig, walk_while_dig, frame_speed)
			if not self:is_player() then return set_local_animation(self) end
			frame_speed = frame_speed or 30
			get_playerdata(self).local_animation = {idle, walk, dig, walk_while_dig, frame_speed}
		end
		local get_local_animation = PlayerRef.get_local_animation
		function PlayerRef:get_local_animation()
			if not self:is_player() then return get_local_animation(self) end
			local local_anim = get_playerdata(self).local_animation
			if local_anim then
				return unpack(local_anim, 1, 5)
			end
			return get_local_animation(self)
		end
	end

	-- First update `character_anim` with the current animation
	-- which mods like `player_api` might have already set
	-- (note: these two methods are already hooked)
	player:set_animation(player:get_animation())
	-- Then disable animation & local animation
	local no_anim = {x = 0, y = 0}
	set_animation(player, no_anim, 0, 0, false)
	set_local_animation(player, no_anim, no_anim, no_anim, no_anim, 1)
end)

minetest.register_on_leaveplayer(function(player) players[player:get_player_name()] = nil end)

local function clamp(value, range)
	if value > range.max then
		return range.max
	end
	if value < range.min then
		return range.min
	end
	return value
end

local function normalize_angle(angle)
	return ((angle + 180) % 360) - 180
end

local function normalize_rotation(euler_rotation)
	return vector.apply(euler_rotation, normalize_angle)
end

function handle_player_animations(dtime, player)
	local mesh
	do
		local props = player:get_properties()
		if not props then
			-- HACK inside on_joinplayer, the player object may be invalid
			-- causing get_properties() to return nothing - just ignore this
			return
		end
		mesh = props.mesh
	end
	if static_model_names[mesh] then
		player:set_properties{mesh = mesh}
	elseif animated_model_names[mesh] then
		mesh = animated_model_names[mesh]
	end
	local model = models[mesh]
	if not model then
		return
	end
	local conf = character_anim.conf.models[mesh] or character_anim.conf.default
	local player_animation = get_playerdata(player)
	local anim = player_animation.animation
	if not anim then
		return
	end
	local range, frame_speed, _, frame_loop = unpack(anim, 1, 4)
	local animation_time = player_animation.animation_time
	animation_time = animation_time + dtime
	player_animation.animation_time = animation_time
	local range_min, range_max = range.x + 1, range.y + 1
	local keyframe
	if range_min == range_max then
		keyframe = range_min
	elseif frame_loop then
		keyframe = range_min + ((animation_time * frame_speed) % (range_max - range_min))
	else
		keyframe = math.min(range_max, range_min + animation_time * frame_speed)
	end
	local bones = {}
	local animated_bone_props = model:get_animated_bone_properties(keyframe, true)
	local body_quaternion
	for _, props in ipairs(animated_bone_props) do
		local bone = props.bone_name
		if bone == "Body" then
			body_quaternion = props.rotation
		end
		local position, rotation = modlib.vector.to_minetest(props.position), props.rotation
		-- Invert quaternion to match Minetest's coordinate system
		rotation = {-rotation[1], -rotation[2], -rotation[3], rotation[4]}
		local euler_rotation = quaternion.to_euler_rotation(rotation)
		bones[bone] = {position = position, rotation = rotation, euler_rotation = euler_rotation}
	end
	local Body = (bones.Body or {}).euler_rotation
	local Head = (bones.Head or {}).euler_rotation
	local Arm_Right = (bones.Arm_Right or {}).euler_rotation
	local look_vertical = math.deg(player:get_look_vertical())
	if Head then Head.x = -look_vertical end
	local interacting = character_anim.is_interacting(player)
	if interacting and Arm_Right then
		local interaction_time = player_animation.interaction_time
		-- Note: -90 instead of -Arm_Right.x because it looks better
		Arm_Right.x = -90 - look_vertical - math.sin(-interaction_time) * conf.arm_right.radius
		Arm_Right.y = Arm_Right.y + math.cos(-interaction_time) * conf.arm_right.radius
		player_animation.interaction_time = interaction_time + dtime * math.rad(conf.arm_right.speed)
	else
		player_animation.interaction_time = 0
	end
	local look_horizontal = get_look_horizontal(player)
	local diff = look_horizontal - player_animation.look_horizontal
	if math.abs(diff) > 180 then
		diff = math.sign(-diff) * 360 + diff
	end
	local moving_diff = math.sign(diff) * math.abs(diff) * math.min(1, dtime / conf.body.turn_speed)
	player_animation.look_horizontal = player_animation.look_horizontal + moving_diff
	if math.abs(moving_diff) < 1e-6 then
		player_animation.look_horizontal = look_horizontal
	end
	local lag_behind = diff - moving_diff
	local attach_parent, _, _, attach_rotation = player:get_attach()
	if attach_parent then
		local parent_rotation
		if attach_parent.get_rotation then
			parent_rotation = attach_parent:get_rotation()
		else -- 0.4.x doesn't have get_rotation(), only yaw
			parent_rotation = {x = 0, y = attach_parent:get_yaw(), z = 0}
		end
		if attach_rotation and parent_rotation then
			parent_rotation = vector.apply(parent_rotation, math.deg)
			local total_rotation = normalize_rotation(vector.subtract(attach_rotation, parent_rotation))
			local function rotate_relative(euler_rotation)
				if not euler_rotation then return end
				euler_rotation.y = euler_rotation.y + look_horizontal
				local new_rotation = normalize_rotation(vector.subtract(euler_rotation, total_rotation))
				modlib.table.add_all(euler_rotation, new_rotation)
			end

			rotate_relative(Head)
			if interacting then rotate_relative(Arm_Right) end
		end
	elseif Body and not modlib.table.nilget(rawget(_G, "player_api"), "player_attached", player:get_player_name()) then
		Body.y = Body.y + lag_behind
		if Head then Head.y = Head.y + lag_behind end
		if interacting and Arm_Right then Arm_Right.y = Arm_Right.y + lag_behind end
	end

	-- HACK this essentially only works for very character.b3d-like models;
	-- it tries to find the (sole) X-rotation of the body relative to a subsequent (180°) Y-rotation.
	if body_quaternion then
		local body_rotation = assert(assert(find_node(model.node, "Body")).rotation)
		local body_x = quaternion.to_euler_rotation(modlib.quaternion.compose(body_rotation, body_quaternion)).x
		if Head then Head.x = normalize_angle(Head.x - body_x) end
		if interacting and Arm_Right then Arm_Right.x = normalize_angle(Arm_Right.x - body_x) end
	end

	if Head then
		Head.x = clamp(Head.x, conf.head.pitch)
		Head.y = clamp(Head.y, conf.head.yaw)
		if math.abs(Head.y) > conf.head.yaw_restriction then
			Head.x = clamp(Head.x, conf.head.yaw_restricted)
		end
	end
	if Arm_Right then Arm_Right.y = clamp(Arm_Right.y, conf.arm_right.yaw) end

	-- Replace animation with serverside bone animation
	for bone, values in pairs(bones) do
		local overridden_values = player_animation.bone_positions[bone]
		overridden_values = overridden_values or {}
		set_bone_position(player, bone,
			overridden_values.position or values.position,
			overridden_values.euler_rotation or values.euler_rotation)
	end
end

minetest.register_globalstep(function(dtime)
	for _, player in pairs(minetest.get_connected_players()) do
		handle_player_animations(dtime, player)
	end
end)