ESOUI SVN TaosGroupUltimate

local LIB_IDENTIFIER = "LibMapPing"
local lib = LibStub:NewLibrary(LIB_IDENTIFIER, 6)

if not lib then
    return -- already loaded and no upgrade necessary
end

local function Log(message, ...)
    df("[%s] %s", LIB_IDENTIFIER, message:format(...))
end

local MAP_PIN_TYPE_PLAYER_WAYPOINT = MAP_PIN_TYPE_PLAYER_WAYPOINT
local MAP_PIN_TYPE_PING = MAP_PIN_TYPE_PING
local MAP_PIN_TYPE_RALLY_POINT = MAP_PIN_TYPE_RALLY_POINT

local MAP_PIN_TAG_PLAYER_WAYPOINT = "waypoint"
local MAP_PIN_TAG_RALLY_POINT = "rally"
local PING_CATEGORY = "pings"

local PING_EVENT_WATCHDOG_TIME = 400 -- ms

local MAP_PIN_TAG = {
    [MAP_PIN_TYPE_PLAYER_WAYPOINT] = MAP_PIN_TAG_PLAYER_WAYPOINT,
    --[MAP_PIN_TYPE_PING] = group pings have individual tags for each member
    [MAP_PIN_TYPE_RALLY_POINT] = MAP_PIN_TAG_RALLY_POINT,
}

local originalPingMap, originalRemovePlayerWaypoint, originalRemoveRallyPoint
local GET_MAP_PING_FUNCTION = {} -- is initialized in Load()
local REMOVE_MAP_PING_FUNCTION = {} -- also initialized in Load()

--- MapPingState is an enumeration of the possible states of a map ping.
lib.MAP_PING_NOT_SET = 0 --- There is no ping.
lib.MAP_PING_NOT_SET_PENDING = 1 --- The ping has been removed, but EVENT_MAP_PING has not been processed.
lib.MAP_PING_SET_PENDING = 2 --- A ping was added, but EVENT_MAP_PING has not been processed.
lib.MAP_PING_SET = 3 --- There is a ping.

lib.mutePing = lib.mutePing or {}
lib.suppressPing = lib.suppressPing or {}
lib.pingState = lib.pingState or {}
lib.pendingPing = lib.pendingPing or {}
lib.cm = lib.cm or ZO_CallbackObject:New()
local g_mapPinManager = lib.mapPinManager

local function GetPingTagFromType(pingType)
    return MAP_PIN_TAG[pingType] or GetGroupUnitTagByIndex(GetGroupIndexByUnitTag("player")) or ""
end

local function GetKey(pingType, pingTag)
    pingTag = pingTag or GetPingTagFromType(pingType)
    return string.format("%d_%s", pingType, pingTag)
end

-- TODO keep an eye on worldmap.lua for changes
local function HandleMapPing(eventCode, pingEventType, pingType, pingTag, x, y, isPingOwner)
    local key = GetKey(pingType, pingTag)
    local data = lib.pendingPing[key]
    if data and data[1] == pingEventType then
        lib.pendingPing[key] = nil
    end
    if(pingEventType == PING_EVENT_ADDED) then
        lib.cm:FireCallbacks("BeforePingAdded", pingType, pingTag, x, y, isPingOwner)
        lib.pingState[key] = lib.MAP_PING_SET
        g_mapPinManager:RemovePins(PING_CATEGORY, pingType, pingTag)
        if(not lib:IsPingSuppressed(pingType, pingTag)) then
            g_mapPinManager:CreatePin(pingType, pingTag, x, y)
            if(isPingOwner and not lib:IsPingMuted(pingType, pingTag)) then
                PlaySound(SOUNDS.MAP_PING)
            end
        end
        lib.cm:FireCallbacks("AfterPingAdded", pingType, pingTag, x, y, isPingOwner)
    elseif(pingEventType == PING_EVENT_REMOVED) then
        lib.cm:FireCallbacks("BeforePingRemoved", pingType, pingTag, x, y, isPingOwner)
        lib.pingState[key] = lib.MAP_PING_NOT_SET
        g_mapPinManager:RemovePins(PING_CATEGORY, pingType, pingTag)
        if (isPingOwner and not lib:IsPingSuppressed(pingType, pingTag) and not lib:IsPingMuted(pingType, pingTag)) then
            PlaySound(SOUNDS.MAP_PING_REMOVE)
        end
        lib.cm:FireCallbacks("AfterPingRemoved", pingType, pingTag, x, y, isPingOwner)
    end
end

local function HandleMapPingEventNotFired()
    EVENT_MANAGER:UnregisterForUpdate(LIB_IDENTIFIER)
    for key, data in pairs(lib.pendingPing) do
        local pingEventType, pingType, x, y, zoneIndex = unpack(data)
        local pingTag = GetPingTagFromType(pingType)
        -- The event is delayed and thus may not match the current map anymore.
        if GetCurrentMapZoneIndex() ~= zoneIndex then
            -- The coords do not match the current map. Do not draw a pin.
            lib:SuppressPing(pingType, pingTag) -- Will be set to zero afterwards, see below.
        end
        HandleMapPing(0, pingEventType, pingType, pingTag, x, y, true)
        lib.pendingPing[key] = nil
        lib.mutePing[key] = 0
        lib.suppressPing[key] = 0
    end
end

local function ResetEventWatchdog(key, ...)
    lib.pendingPing[key] = {...}
    EVENT_MANAGER:UnregisterForUpdate(LIB_IDENTIFIER)
    EVENT_MANAGER:RegisterForUpdate(LIB_IDENTIFIER, PING_EVENT_WATCHDOG_TIME, HandleMapPingEventNotFired)
end

local function CustomPingMap(pingType, mapType, x, y)
    if(pingType == MAP_PIN_TYPE_PING and not IsUnitGrouped("player")) then return end
    local key = GetKey(pingType)
    lib.pingState[key] = lib.MAP_PING_SET_PENDING
    ResetEventWatchdog(key, PING_EVENT_ADDED, pingType, x, y, GetCurrentMapZoneIndex())
    return originalPingMap(pingType, mapType, x, y)
end

local function CustomGetMapPlayerWaypoint()
    if(lib:IsPingSuppressed(MAP_PIN_TYPE_PLAYER_WAYPOINT, MAP_PIN_TAG_PLAYER_WAYPOINT)) then
        return 0, 0
    end
    return GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_PLAYER_WAYPOINT]()
end

local function CustomGetMapPing(pingTag)
    if(lib:IsPingSuppressed(MAP_PIN_TYPE_PING, pingTag)) then
        return 0, 0
    end
    return GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_PING](pingTag)
end

local function CustomGetMapRallyPoint()
    if(lib:IsPingSuppressed(MAP_PIN_TYPE_RALLY_POINT, MAP_PIN_TAG_RALLY_POINT)) then
        return 0, 0
    end
    return GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_RALLY_POINT]()
end

local function CustomRemovePlayerWaypoint()
    local key = GetKey(MAP_PIN_TYPE_PLAYER_WAYPOINT, MAP_PIN_TAG_PLAYER_WAYPOINT)
    lib.pingState[key] = lib.MAP_PING_NOT_SET_PENDING
    ResetEventWatchdog(key, PING_EVENT_REMOVED, MAP_PIN_TYPE_PLAYER_WAYPOINT, 0, 0, GetCurrentMapZoneIndex())
    return originalRemovePlayerWaypoint()
end

local function CustomRemoveMapPing()
    -- there is no such function for group pings, but we can set it to 0, 0 which effectively hides it
    PingMap(MAP_PIN_TYPE_PING, MAP_TYPE_LOCATION_CENTERED, 0, 0)
end

local function CustomRemoveRallyPoint()
    local key = GetKey(MAP_PIN_TYPE_RALLY_POINT, MAP_PIN_TAG_RALLY_POINT)
    lib.pingState[key] = lib.MAP_PING_NOT_SET_PENDING
    ResetEventWatchdog(key, PING_EVENT_REMOVED, MAP_PIN_TYPE_RALLY_POINT, 0, 0)
    originalRemoveRallyPoint()
end

--- Wrapper for PingMap.
--- pingType is one of the three possible MapDisplayPinType for map pings (MAP_PIN_TYPE_PLAYER_WAYPOINT, MAP_PIN_TYPE_PING or MAP_PIN_TYPE_RALLY_POINT).
--- mapType is usually MAP_TYPE_LOCATION_CENTERED.
--- x and y are the normalized coordinates on the current map.
function lib:SetMapPing(pingType, mapType, x, y)
    PingMap(pingType, mapType, x, y)
end

--- Wrapper for the different ping removal functions.
--- For waypoints and rally points it calls their respective removal function
--- For group pings it just sets the position to 0, 0 as there is no function to clear them
function lib:RemoveMapPing(pingType)
    if(REMOVE_MAP_PING_FUNCTION[pingType]) then
        REMOVE_MAP_PING_FUNCTION[pingType]()
    end
end

--- Wrapper for the different get ping functions. Returns coordinates regardless of their suppression state.
--- The game API functions return 0, 0 when the ping type is suppressed.
--- pingType is the same as for SetMapPing.
--- pingTag is optionally used if another group member's MAP_PIN_TYPE_PING should be returned (possible values: group1 .. group24).
function lib:GetMapPing(pingType, pingTag)
    local x, y = 0, 0
    if(GET_MAP_PING_FUNCTION[pingType]) then
        x, y = GET_MAP_PING_FUNCTION[pingType](pingTag or GetPingTagFromType(pingType))
    end
    return x, y
end

--- Returns the MapPingState for the pingType and pingTag.
function lib:GetMapPingState(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    local state = lib.pingState[key]
    if state == nil then
        local x, y = lib:GetMapPing(pingType, pingTag)
        state = (x ~= 0 or y ~= 0) and lib.MAP_PING_SET or lib.MAP_PING_NOT_SET
        lib.pingState[key] = state
    end
    return lib.pingState[key]
end
--- Returns true if ping state is MAP_PING_SET_PENDING or MAP_PING_SET
function lib:HasMapPing(pingType, pingTag)
    local state = lib:GetMapPingState(pingType, pingTag)
    return state == lib.MAP_PING_SET_PENDING or state == lib.MAP_PING_SET
end

--- Refreshes the pin icon for the pingType on the worldmap
--- Returns true if the pin has been refreshed.
function lib:RefreshMapPin(pingType, pingTag)
    if(not g_mapPinManager) then
        Log("PinManager not available. Using ZO_WorldMap_UpdateMap instead.")
        ZO_WorldMap_UpdateMap()
        return true
    end

    pingTag = pingTag or GetPingTagFromType(pingType)
    g_mapPinManager:RemovePins(PING_CATEGORY, pingType, pingTag)

    local x, y = lib:GetMapPing(pingType, pingTag)
    if(lib:IsPositionOnMap(x, y)) then
        g_mapPinManager:CreatePin(pingType, pingTag, x, y)
        return true
    end
    return false
end

--- Returns true if the normalized position is within 0 and 1.
function lib:IsPositionOnMap(x, y)
    return not (x < 0 or y < 0 or x > 1 or y > 1 or (x == 0 and y == 0))
end

--- Mutes the map ping of the specified type, so it does not make a sound when it is set.
--- Do not forget to call UnmutePing later, otherwise the sound will be permanently muted!
function lib:MutePing(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    local mute = lib.mutePing[key] or 0
    lib.mutePing[key] = mute + 1
end

--- Unmutes the map ping of the specified type.
--- Do not call this more often than you called MutePing, or you might interfere with other addons.
--- The sounds are played between the BeforePing* and AfterPing* callbacks are fired.
function lib:UnmutePing(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    local mute = (lib.mutePing[key] or 0) - 1
    if(mute < 0) then mute = 0 end
    lib.mutePing[key] = mute
end

--- Returns true if the map ping has been muted
function lib:IsPingMuted(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    return lib.mutePing[key] and lib.mutePing[key] > 0
end

--- Suppresses the map ping of the specified type, so that it neither makes a sound nor shows up on the map.
--- This also makes the API functions return 0, 0 for that ping.
--- In order to access the actual coordinates lib:GetMapPing has to be used.
--- Do not forget to call UnsuppressPing later, otherwise map pings won't work anymore for the user and other addons!
function lib:SuppressPing(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    local suppress = lib.suppressPing[key] or 0
    lib.suppressPing[key] = suppress + 1
end

--- Unsuppresses the map ping so it shows up again
--- Do not call this more often than you called SuppressPing, or you might interfere with other addons.
function lib:UnsuppressPing(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    local suppress = (lib.suppressPing[key] or 0) - 1
    if(suppress < 0) then suppress = 0 end
    lib.suppressPing[key] = suppress
end

--- Returns true if the map ping has been suppressed
function lib:IsPingSuppressed(pingType, pingTag)
    local key = GetKey(pingType, pingTag)
    return lib.suppressPing[key] and lib.suppressPing[key] > 0
end

local function InterceptMapPinManager()
    if (g_mapPinManager) then return end
    local orgRefreshCustomPins = ZO_WorldMapPins.RefreshCustomPins
    function ZO_WorldMapPins:RefreshCustomPins()
        g_mapPinManager = self
        lib.mapPinManager = self
    end
    ZO_WorldMap_RefreshCustomPinsOfType()
    ZO_WorldMapPins.RefreshCustomPins = orgRefreshCustomPins
end

--- Register to callbacks from the library.
--- Valid events are BeforePingAdded, AfterPingAdded, BeforePingRemoved and AfterPingRemoved.
--- These are fired at certain points during handling EVENT_MAP_PING.
function lib:RegisterCallback(eventName, callback)
    lib.cm:RegisterCallback(eventName, callback)
end

--- Unregister from callbacks. See lib:RegisterCallback.
function lib:UnregisterCallback(eventName, callback)
    lib.cm:UnregisterCallback(eventName, callback)
end

local function Unload()
    EVENT_MANAGER:UnregisterForEvent(LIB_IDENTIFIER, EVENT_ADD_ON_LOADED)
    EVENT_MANAGER:UnregisterForEvent(LIB_IDENTIFIER, EVENT_MAP_PING)
    PingMap = originalPingMap
    GetMapPlayerWaypoint = GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_PLAYER_WAYPOINT]
    GetMapPing = GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_PING]
    GetMapRallyPoint = GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_RALLY_POINT]
    RemovePlayerWaypoint = originalRemovePlayerWaypoint
    RemoveRallyPoint = originalRemoveRallyPoint
end

local function Load()
    InterceptMapPinManager()

    originalPingMap = PingMap
    PingMap = CustomPingMap

    GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_PLAYER_WAYPOINT] = GetMapPlayerWaypoint
    GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_PING] = GetMapPing
    GET_MAP_PING_FUNCTION[MAP_PIN_TYPE_RALLY_POINT] = GetMapRallyPoint
    GetMapPlayerWaypoint = CustomGetMapPlayerWaypoint
    GetMapPing = CustomGetMapPing
    GetMapRallyPoint = CustomGetMapRallyPoint

    -- we want to use the altered versions in the library in order to set the correct ping state
    -- so we need to also save the originals
    originalRemovePlayerWaypoint = RemovePlayerWaypoint
    originalRemoveRallyPoint = RemoveRallyPoint
    RemovePlayerWaypoint = CustomRemovePlayerWaypoint
    RemoveRallyPoint = CustomRemoveRallyPoint
    REMOVE_MAP_PING_FUNCTION[MAP_PIN_TYPE_PLAYER_WAYPOINT] = CustomRemovePlayerWaypoint
    REMOVE_MAP_PING_FUNCTION[MAP_PIN_TYPE_PING] = CustomRemoveMapPing -- has no real api equivalent
    REMOVE_MAP_PING_FUNCTION[MAP_PIN_TYPE_RALLY_POINT] = CustomRemoveRallyPoint

    EVENT_MANAGER:RegisterForEvent(LIB_IDENTIFIER, EVENT_ADD_ON_LOADED, function(_, addonName)
        if(addonName == "ZO_Ingame") then
            EVENT_MANAGER:UnregisterForEvent(LIB_IDENTIFIER, EVENT_ADD_ON_LOADED)
            -- don't let worldmap do anything as we manage it instead
            EVENT_MANAGER:UnregisterForEvent("ZO_WorldMap", EVENT_MAP_PING)
            EVENT_MANAGER:RegisterForEvent(LIB_IDENTIFIER, EVENT_MAP_PING, HandleMapPing)
        end
    end)

    lib.Unload = Unload
end

if(lib.Unload) then lib.Unload() end
Load()