local DEFAULT_DESCRIPTION = "Waypoint compass\n(sneak+place to set point)"
local UPDATE_INTERVAL = 1.31415
local COMPASS_PRECISION = 10 -- set to 1 to show whole number or 10 for 1 decimal
local DEFAULT_WAYPOINT_COLOR = 0xFFFFFF
local TARGET_ABOVE = false -- place waypoint inside the block or above it
local POINT_TO_OBJECTS = false -- unimplemented
local POINT_TO_LIQUIDS = true
local COMPASS_RANGE = 180
local WAYPOINT_ICON = "waypoint_compass_waypoint.png"
local WAYPOINT_SCALE = {x=-1/16*9,y=-1}

local waypoint_lib = dofile(minetest.get_modpath("waypoint_compass") .. DIR_DELIM .. "waypoint_lib.lua")

-- internal mod state
local player_waypoints = {} -- store a current player waypoint to see if it needs to be updated
local compass_dialog_context = {} -- store a compass item that player is editing via dialog


local function get_compass_meta_is_set(meta)
    local pos_str = meta:get_string("waypoint_compass:position")
    return pos_str ~= ""
end


local function get_compass_meta_pos(meta)
    return minetest.string_to_pos(meta:get_string("waypoint_compass:position"))
end


local function get_compass_meta_owner(meta)
    return meta:get_string("waypoint_compass:owner")
end


local function get_compass_meta_label(meta)
    return meta:get_string("waypoint_compass:label")
end


local function update_compass_meta_label(meta)
    if get_compass_meta_is_set(meta) then
        local label = get_compass_meta_label(meta)
        local owner = get_compass_meta_owner(meta) -- or "no owner"

        if label == "" then
            local pos = get_compass_meta_pos(meta)
            if pos then
                meta:set_string("description", string.format("Waypoint compass to %s [%s]",
                                                             minetest.pos_to_string(pos),
                                                             owner))
                return
            end
        else
            meta:set_string("description", string.format("Waypoint compass to \"%s\" [%s]", label, owner))
            return
        end
    end
    meta:set_string("description", DEFAULT_DESCRIPTION)
end

local function set_compass_meta_label(meta, label)
    meta:set_string("waypoint_compass:label", label)
    update_compass_meta_label(meta)
end


local function set_compass_meta_pos(meta, pos)
    local pos_str = minetest.pos_to_string(pos)
    meta:set_string("waypoint_compass:position", pos_str)
    update_compass_meta_label(meta)
end


local function set_compass_meta_color(meta, color)
    meta:set_int("waypoint_compass:color", color)
    -- thanks to Boot@YL for suggesting this
    meta:set_string("color", ("#%06X"):format(color))
end


local function get_compass_meta_color(meta)
    local color = meta:get_int("waypoint_compass:color")
    if color > 0 then
        return color
    else
        return DEFAULT_WAYPOINT_COLOR
    end
end


local function set_compass_meta_owner(meta, player_name)
    meta:set_string("waypoint_compass:owner", player_name)
    update_compass_meta_label(meta)
end



local function set_waypoint_at_pointed_place(itemstack, pointed_thing)
    if pointed_thing and pointed_thing.type == "node" then
        local pointed_pos = TARGET_ABOVE and pointed_thing.above or pointed_thing.under
        local meta = itemstack:get_meta()
        set_compass_meta_pos(meta, pointed_pos)
        -- TODO change only if default?
        --set_compass_meta_label(meta, minetest.pos_to_string(pointed_pos))
        return itemstack
    end
    -- TODO handle entities?
end


local function hide_hud_waypoint(player)
    local player_name = player:get_player_name()
    local hud = player_waypoints[player_name]
    player_waypoints[player_name] = nil
    hud.waypoint:hide(player)
    player:hud_remove(hud.background)
end


local function show_hud_waypoint(player, compass_item_meta)
    if not get_compass_meta_is_set(compass_item_meta) then
        -- do not show unset compass position
        return
    end
    
    local player_name = player:get_player_name()
    local waypoint_pos = get_compass_meta_pos(compass_item_meta)
    local waypoint_name = get_compass_meta_label(compass_item_meta)
    -- show coords instead of name
    if waypoint_name == "" and waypoint_pos then
	waypoint_name = minetest.pos_to_string(waypoint_pos)
    end
    local waypoint_color = get_compass_meta_color(compass_item_meta)
    local hexcolor = ("#%06X"):format(waypoint_color)

    local size = {x=-9, y=-16}
    local alignment = {x=100/9*1.47,y=100/16*1.63} -- near compass in your hand

    local background = player:hud_add({
	    hud_elem_type = "image",
	    scale = size,
	    text = "waypoint_compass_background.png",
	    alignment = alignment,
    })
    
    local waypoint = waypoint_lib.WaypointHUD:new(player, waypoint_pos,
						  waypoint_name, waypoint_color,
						  WAYPOINT_ICON, WAYPOINT_SCALE, hexcolor,
						  size, alignment, "waypoint_compass_arrow_%03d.png", hexcolor, 9,
						  true)

    waypoint:show(player)
    -- store HUD elemnt id to remove it later
    if player_waypoints[player_name] then
	minetest.log("error","[MOD] waypoint_compass: " ..
		     player_name ..
		     " got their HUD stuck on screen?")
    end
    player_waypoints[player_name] = {waypoint = waypoint, background = background}
end


-- if item is a compass, then show stored waypoint
-- force - force hud update even if position is unchanged
local function update_hud_waypoint(player, itemstack, force)
    if not player:is_player() then
        return
    end
    local player_name = player:get_player_name()
    -- player is holding compass
    if (itemstack and itemstack:get_name() == "waypoint_compass:compass") then
        local meta = itemstack:get_meta()
        local waypoint_pos = get_compass_meta_pos(meta)
        -- remove different waypoint if it exists
        if player_waypoints[player_name] and
            (player_waypoints[player_name].waypoint.point_pos ~= waypoint_pos
             or force
             or not get_compass_meta_is_set(meta)) then
            
            hide_hud_waypoint(player)
        end
        -- show new waypoint
        if not player_waypoints[player_name] then
            show_hud_waypoint(player, meta)
        end
    else
        -- not holding it anymore
        if player_waypoints[player_name] then
            hide_hud_waypoint(player)
        end
    end
end


local timer = 0
minetest.register_globalstep(function(dtime)
	-- check if wielded item is a compass and update waypoints
        timer = timer + dtime
        if timer > UPDATE_INTERVAL then
            for _,player in pairs(minetest.get_connected_players()) do
                local itemstack = player:get_wielded_item()
                update_hud_waypoint(player, itemstack)
            end
            timer = 0
        end
end)


minetest.register_on_leaveplayer(function(player, timed_out)
        local player_name = player:get_player_name()
        if player_name ~= "" then
            -- delete info about players that are left
            player_waypoints[player_name] = nil
            compass_dialog_context[player_name] = nil
        end
end)


local function coords_to_string(pos)
    -- strip "()"
    if not pos then
        pos = {x = 0, y = 0, z = 0}
    end
    return string.sub(minetest.pos_to_string(pos), 2, -2)
end


function trim(s)
    -- code from lua-users.org
    return s:match'^()%s*$' and '' or s:match'^%s*(.*%S)'
end


local function clamp(x, min, max)
    return math.max(math.min(x, max), min)
end


local function coords_from_string(str)
    -- parse "1,2,3" or "1 2 3" or "(1,2,3)" or "{x=1,y=2,z=3}" or return nil on fail
    local function parse(str)
	str = trim(str)
	local result = nil
	local first = string.sub(str, 1, 1)
	local last = string.sub(str, -1, -1)
	if first == "{" and last == "}" then
	    local maybe_pos = minetest.deserialize("return " .. str)
	    result = {x = maybe_pos.x, y = maybe_pos.y, z = maybe_pos.z}
	end
	
	if not result and first == "(" and last == ")" then
	    str = string.sub(str, 2, -2)
	end
	
	if not result then
	    -- numbers are separated by "," or " "
	    local tmp = {}
	    for n in string.gmatch(str, "([^, ]+)") do
		table.insert(tmp, n)
	    end
	    result = {x = tonumber(tmp[1]), y = tonumber(tmp[2]), z = tonumber(tmp[3])}
	end
	-- if any of xyz are not numbers, this will throw an error and pcall will fail
	result.x = clamp(result.x, -32000, 32000)
	result.y = clamp(result.y, -32000, 32000)
	result.z = clamp(result.z, -32000, 32000)
	return result
    end
    local success, result = pcall(parse, str)
    if success then
	return result
    else
	return nil
    end
end

local _format_recent_dropbox -- defined later

local function show_basic_dialog(itemstack, player)
    local player_name = player:get_player_name()
    local meta = itemstack:get_meta()
    -- set focus to "close" button to prevent accidental edting
    local formspec_head = "formspec_version[4]size[14,4]set_focus[close;]"
    local coords = coords_to_string(get_compass_meta_pos(meta))
    local field_coords = ("field[0.5,0.6;4,0.8;coords;Coordinates;%s]"):format(minetest.formspec_escape(coords))
    local label = get_compass_meta_label(meta) or "destination"
    local field_destination = ("field[4.5,0.6;7,0.8;label;Label;%s]"):format(minetest.formspec_escape(label))
    local color = ("%06X"):format(get_compass_meta_color(meta))
    local field_color = ("field[11.5,0.6;2.0,0.8;color;Color;%s]"):format(minetest.formspec_escape(color))
    local dropdown_recent = ("dropdown[2.0,1.7;11.5,0.5;recent;%s;1,false]"):format(_format_recent_dropbox(player_name))
    local formspec = {
        formspec_head,
        field_coords,
        field_destination,
        field_color,
        "button_exit[0.5,1.7;1.5,0.5;set_recent;copy:]",
        dropdown_recent,
        "button_exit[3,2.7;3,0.8;save;save]",
        "button_exit[8,2.7;3,0.8;close;close]"}
    minetest.show_formspec(player:get_player_name(),
                           "waypoint_compass:basic",
                           table.concat(formspec, ""))
    compass_dialog_context[player_name] = itemstack
end


local function compass_use_callback(itemstack, user, pointed_thing)
    if not (user and user:is_player()) then
        return itemstack
    end
    local meta = itemstack:get_meta()
    local owner = get_compass_meta_owner(meta)
    local player_name = user:get_player_name()
    if owner == "" or not get_compass_meta_pos(meta) then
        -- set first user as owner or change it if pos is unset
        set_compass_meta_owner(meta, player_name)
    elseif owner ~= player_name then
        -- already has owner
        -- TODO show message "You are not the owner" (or maybe limit editing to color change?)
        minetest.chat_send_player(player_name, "You are not the owner of this compass. Owner is " .. owner .. ".")
        return itemstack
    end
    if user:get_player_control()["sneak"] then
        if pointed_thing.type == "nothing" then
	    pointed_thing = waypoint_lib.raycast_crosshair(user, COMPASS_RANGE, POINT_TO_OBJECTS, POINT_TO_LIQUIDS)
        end
        set_waypoint_at_pointed_place(itemstack, pointed_thing)
        update_hud_waypoint(user, itemstack)
    else
        if user:is_player() then
            show_basic_dialog(itemstack, user)
        end
    end
    return itemstack
end


minetest.register_on_player_receive_fields(function(player, formname, fields)
    if formname ~= "waypoint_compass:basic" then
        return
    end
    if fields.save or fields.set_recent or (fields.key_enter_field and fields.quit) then
        local compass_item = compass_dialog_context[player:get_player_name()]
        if not compass_item then
            -- should not happen normally
            minetest.log("error","[MOD] waypoint_compass: " ..
                         player:get_player_name() ..
                         " Closed compass dialog without opening it?")
            return
        end
        local meta = compass_item:get_meta()
        
        local color = tonumber("0x"..fields.color, 16)
        if color then
            color = math.max(math.min(color, 0xFFFFFF), 0x0) -- for some reason seems to work fine without this
            set_compass_meta_color(meta, color)
 	    -- print(dump(meta:to_table()))
        end
        
        local coords = coords_from_string(fields.coords)
        local label = fields.label

        -- player pressed "copy" button, ignore the "coordinates field"
        if fields.set_recent then
            local coord_string = fields.recent:match("%S+") or ""
            coords = coords_from_string(coord_string)
            label = fields.recent:match("(%S+ |[^>]+)>") or ""
        end

        if coords then
            set_compass_meta_pos(meta, coords)
        elseif fields.coords == "" then
            -- assume player wants to reset compass
            meta:set_string("waypoint_compass:position", "") -- TODO make unset()?
            -- TODO reset label too? or keep it to be safe?
        end

        set_compass_meta_label(meta, label)

        -- Prevent overwriting random item if user switched before
        -- formspec appeared. FIXME can still change another compass.
        local current_item = player:get_wielded_item()
        if current_item:get_name() == "waypoint_compass:compass" then
            local success = player:set_wielded_item(compass_item)
            if not success then
                -- no idea why this can happen
                minetest.log("error","[MOD] waypoint_compass: " ..
                             player:get_player_name() ..
                             " Failed to swap compass after editing it")
            end
        end
        -- assume dialog is closed and reset context
        compass_dialog_context[player:get_player_name()] = nil
        update_hud_waypoint(player, current_item, 'force')
    end
end)


minetest.register_tool(
    "waypoint_compass:compass", {
        description = DEFAULT_DESCRIPTION,
        --short_description = "Waypoint compass",
        inventory_image = "waypoint_compass_inventory_image.png",
        inventory_overlay = "waypoint_compass_inventory_image_overlay.png",
	color = "#f6d0a5",
        wield_scale = {x = 0.5, y = 0.5, z = 0.5},
        range = 2.0, -- TODO what's the good range?
        on_place = function(itemstack, placer, pointed_thing)
            return compass_use_callback(itemstack, placer, pointed_thing)
        end,
        on_secondary_use = function(itemstack, user, pointed_thing)
            return compass_use_callback(itemstack, user, pointed_thing)
        end,
})

minetest.register_craft({
    type = "shaped",
    output = "waypoint_compass:compass",
    recipe = {
        {"default:copper_ingot", "default:copper_ingot", "default:copper_ingot"},
        {"default:copper_ingot", "default:mese_crystal_fragment", "default:copper_ingot"},
        {"default:copper_ingot", "default:copper_ingot", "default:copper_ingot"},
    }
})


minetest.register_craft({
	type = "shapeless",
	output = "waypoint_compass:compass",
	recipe = {"waypoint_compass:compass", "waypoint_compass:compass"}
})

local function waypoint_compass_copy_meta(itemstack, player, old_craft_grid, craft_inv)
    if itemstack:get_name() ~= "waypoint_compass:compass" then
        return
    end

    -- detect new compass recipie
    if old_craft_grid[1]:get_name() == "default:copper_ingot" then
	-- probably a new compass recipie
	return itemstack
    end

    local original
    local index
    for i = 1, #old_craft_grid do
        local meta = old_craft_grid[i]:get_meta()
        if get_compass_meta_is_set(meta) then
            if not original then
                original = old_craft_grid[i]
                index = i
            else
                return ""
            end
        end
    end
    if not original then
        return ""
    end
    local copymeta = original:get_meta():to_table()
    itemstack:get_meta():from_table(copymeta)
    set_compass_meta_owner(itemstack:get_meta(),
                           (player and player:get_player_name()) or
                           original:get_meta():get_string("waypoint_compass:owner"))
    -- put the compass with metadata back in the craft grid
    craft_inv:set_stack("craft", index, original)
end


minetest.register_on_craft(waypoint_compass_copy_meta)

minetest.register_craft_predict(waypoint_compass_copy_meta)

-- pos is {x=0,y=0,z=0}
-- owner_name is str
-- label is str
-- color is int in range [0,0xFFFFFF]
local function make_compass(pos, owner_name, label, color)
    local itemstack = ItemStack("waypoint_compass:compass")
    local meta = itemstack:get_meta()
    if not (pos and
	    tonumber(pos.x) and
	    tonumber(pos.y) and
	    tonumber(pos.z) and
	    type(owner_name) == 'string' and
	    type(label) == 'string' and
	    color and
	    type(color) == "number" and
	    color >= 0 and
	    color <= 0xFFFFFF ) then
	return nil
    end
    set_compass_meta_pos(meta, pos)
    set_compass_meta_owner(meta, owner_name)
    set_compass_meta_label(meta, label)
    set_compass_meta_color(meta, color)
    return itemstack
end

--------------------------------------------------------------------------------
-- TODO move chat scanner into separate file, make enabling optional

-- TODO API to add/rm "sticky" coordinates (that won't be pushed out of the list)?
local last_coords_log = {}
local last_coords_log_limit = 5 -- how many to keep

-- TODO when should we clear this? Should keep this even if player is
-- left (for some time at least)
-- Stores personal points for players
local last_coords_log_personal = {}

local function add_coords_log(pos, name, message)
    table.insert(last_coords_log, 1, {pos=pos, name=name, message=message})
    last_coords_log[last_coords_log_limit] = nil
end


local function add_coords_log_personal(playername, pos, name, message)
    if not last_coords_log_personal[playername] then
        last_coords_log_personal[playername] = {}
    end
    local personal = last_coords_log_personal[playername]
    table.insert(personal, 1, {pos=pos, name=name, message=message})
    personal[last_coords_log_limit] = nil
end


-- Trying to mach any three integer numbers separated at least by
-- spaces or punctuation.
--local FUZZY_COORD_PATTERN = ".-(%d+)%D?[%s.,:;]%D?(%d+)%D?[%s.,:;]%D?(%d+)"
local FUZZY_COORD_PATTERN = ".-(%d+)[^.%d]?[%s,:;]%D?(%d+)[^.%d]?[%s,:;]%D?(%d+)"


-- "usafe" means it may throw errors, use pcall()
local function fuzzy_parse_coords_unsafe(str)
    -- find any 3 numbers in a string separated by punctuarion/spaces
    local x,y,z = str:match(FUZZY_COORD_PATTERN)
    x = clamp(tonumber(x), -32000, 32000)
    y = clamp(tonumber(y), -32000, 32000)
    z = clamp(tonumber(z), -32000, 32000)
    return {x=x,y=y,z=z}
end


_format_recent_dropbox = function(playername)
    local out = {}
    for k,v in ipairs(last_coords_log) do
        local item = string.format("%d,%d,%d | %s> %s",
                                   v.pos.x, v.pos.y, v.pos.z,
                                   v.name,
                                   v.message:sub(1,50))
        table.insert(out, minetest.formspec_escape(item))
    end

    if last_coords_log_personal[playername] then
        table.insert(out, '------------------------------ Your personal points: ------------------------------')
        for k,v in ipairs(last_coords_log_personal[playername]) do
            local item = string.format("%d,%d,%d | %s> %s",
                                       v.pos.x, v.pos.y, v.pos.z,
                                       v.name,
                                       v.message:sub(1,50))
            table.insert(out, minetest.formspec_escape(item))
        end
    end

    return table.concat(out,",")
end


local function scan_chat_for_coords(name, message)
    local success, coords = pcall(fuzzy_parse_coords_unsafe, message)
    if success then
        add_coords_log(coords, name, message)
    end
    return nil -- do not handle messages, just check them
end


minetest.register_on_chat_message(scan_chat_for_coords)


--------------------------------------------------------------------------------

waypoint_compass={}


function waypoint_compass.make_compass(pos, owner_name, label, color)
	return make_compass(pos,owner_name, label, color)
end


-- A hook for "fake" global chat messages, that don't trigger the
-- on_chat_message hooks.
function waypoint_compass.process_message(name, message)
    name = name or "none"
    message = message or ""
    scan_chat_for_coords(name, message)
end


-- Add a custom point to global list (name/message can be any strings)
-- `pos` is table like {x=1,y=2,z=2}
function waypoint_compass.add_point_to_recent_global(pos, name, message)
    local success, ret = pcall(add_coords_log, pos, name, message)
    if not success then
 	minetest.log(
            string.format(
                "error [MOD] waypoint_compass: Failed add_point_to_recent_global(%s %s %s)",
                pos, name, message))
    end
    return success
end


-- Add a custom point to personal player's list (name/message can be any strings)
-- `pos` is table like {x=1,y=2,z=2}
function waypoint_compass.add_point_to_recent_personal(playername, pos, name, message)
    local success, ret = pcall(add_coords_log_personal, playername, pos, name, message)
    if not success then
        minetest.log(
            string.format(
                "error [MOD] waypoint_compass: Failed add_point_to_recent_personal(%s %s %s %s)",
                playername, pos, name, message))
    end
    return success
end


-- -- Usage example:
-- waypoint_compass.add_point_to_recent_personal('singleplayer', {x=0,y=1,z=2}, "death", "from lava")

if waypoint_announce and waypoint_announce.post_announcement_hooks then
    local _announcement_callback = function(announcer_name, message, pointed_pos)
        waypoint_compass.add_point_to_recent_global(pointed_pos, announcer_name, message)
    end

    local hooks = waypoint_announce.post_announcement_hooks
    hooks["waypoint_compass"] = _announcement_callback
end


return waypoint_compass