map.lua

-- multi api compat
local compat = pfQuestCompat

-- Performance: cache frequently-used globals
local pairs, ipairs, next = pairs, ipairs, next
local strfind, strlower, strsub = strfind, strlower, strsub
local format = string.format
local min, max, abs = math.min, math.max, math.abs
local sqrt, sin, cos = sqrt or math.sqrt, sin or math.sin, cos or math.cos
local floor, ceil = floor or math.floor, ceil or math.ceil
local getn, insert = table.getn, table.insert
local tostring, tonumber, type, unpack = tostring, tonumber, type, unpack
local GetTime = GetTime
local MouseIsOver = MouseIsOver

-- fake the pfQuest minimap node names to Gatherer names,
-- if any minimap-breaking addon collector is found.
local nodename = "pfMiniMapPin"
local minimapbreakers = {
  ["ElvUI_MinimapButtons"] = true,
  ["MBB"] = true,
}

local compatnamefake = CreateFrame("Frame")
compatnamefake:RegisterEvent("PLAYER_ENTERING_WORLD")
compatnamefake:SetScript("OnEvent", function()
  -- only run once on login
  this:UnregisterAllEvents()

  -- scan through all addons to identify button collectors
  for i = 1, GetNumAddOns() do
    local name, title, notes, enabled = GetAddOnInfo(i)
    if enabled and minimapbreakers[name] then
      nodename = "GatherNoteCompatFake"
    end
  end
end)

-- checking for control key is very time expensive in 1.12
-- Poll IsControlKeyDown() frequently enough that Ctrl feels responsive.
-- Always clear when the map is not shown to avoid sticky state from a
-- previous session (e.g. Ctrl released while mouse was off the map).
local controlkey = CreateFrame("Frame", "pfQuestControlKey", UIParent)
controlkey:SetScript("OnUpdate", function()
  if (this.throttle or 0.05) > GetTime() then
    return
  else
    this.throttle = GetTime() + 0.05
  end
  if WorldMapFrame:IsShown() and MouseIsOver(WorldMapFrame) then
    controlkey.pressed = IsControlKeyDown()
  elseif MouseIsOver(pfMap.drawlayer) then
    controlkey.pressed = IsControlKeyDown()
  else
    controlkey.pressed = nil
  end
end)

-- mainmap_inversescale separates two distinct scale events on the world map:
--   * MAP MODE change (windowed/questlist/fullmap): Blizzard scales BOTH
--     WorldMapDetailFrame and WorldMapButton by WORLDMAP_SETTINGS.size.
--     Their LOCAL scales stay equal -> ratio = 1 -> no compensation, pins
--     scale naturally with the map.
--   * ZOOM addons (Magnify): scale ONLY WorldMapDetailFrame while keeping
--     WorldMapButton.local at 1 (Magnify reparents Button under DetailFrame).
--     Local ratio diverges -> we compensate so pins keep a constant screen
--     pixel size through the zoom.
-- Formula: mainmap_inversescale = WorldMapButton:GetScale() / WorldMapDetailFrame:GetScale()
-- Global (no `local`) so pfQuest-epoch's continent pins can read the same value.
mainmap_inversescale = 1.0

local validmaps = setmetatable({}, { __mode = "kv" })
local rgbcache = setmetatable({}, { __mode = "kv" })
local minimap_sizes = pfDB["minimap"]
local minimap_zoom = {
  [0] = {
    [0] = 300,
    [1] = 240,
    [2] = 180,
    [3] = 120,
    [4] = 80,
    [5] = 50,
  },

  [1] = {
    [0] = 466 + 2 / 3,
    [1] = 400,
    [2] = 333 + 1 / 3,
    [3] = 266 + 2 / 6,
    [4] = 200,
    [5] = 133 + 1 / 3,
  },
}

local unifiedcache = {}

-- used to store/cache combined meta data across nodes of
-- the same kind to avoid duplicating data for each pin
-- the objects here get directly attached to the pfMap nodes
local similar_nodes = {}

-- Coordinate parse cache (shared between UpdateNodes and UpdateMinimap)
local coord_cache = {}

local function IsEmpty(tabl)
  for k, v in pairs(tabl) do
    return false
  end
  return true
end

-- Ensure pfQuestConfig.path exists (fallback if config.lua failed)
local addon_path = (pfQuestConfig and pfQuestConfig.path) or "Interface\\AddOns\\pfQuest"

local layers = {
  -- regular icons
  [addon_path .. "\\img\\available"] = 1,
  [addon_path .. "\\img\\available_c"] = 2,
  [addon_path .. "\\img\\complete"] = 3,
  [addon_path .. "\\img\\complete_c"] = 4,
  [addon_path .. "\\img\\icon_vendor"] = 5,
  [addon_path .. "\\img\\fav"] = 6,

  -- cluster textures
  [addon_path .. "\\img\\cluster_item"] = 9,
  [addon_path .. "\\img\\cluster_mob"] = 9,
  [addon_path .. "\\img\\cluster_misc"] = 9,
  [addon_path .. "\\img\\cluster_mob_mono"] = 9,
  [addon_path .. "\\img\\cluster_item_mono"] = 9,
  [addon_path .. "\\img\\cluster_misc_mono"] = 9,
}

-- Pre-computed texture paths (avoid string concatenation in hot paths)
local TEX_NODECUT = addon_path .. "\\img\\nodecut"
local TEX_NODE = addon_path .. "\\img\\node"

local function GetLayerByTexture(tex)
  if layers[tex] then
    return layers[tex]
  else
    return 1
  end
end

-- Reforged: the indoor/outdoor probe below CHANGES the minimap zoom twice to
-- disambiguate, and it used to run on every UpdateMinimap pass -- up to ~20
-- times a second while moving. Any addon that hooks Minimap.SetZoom therefore
-- got hammered: ElvUI's "reset zoom" feature hooks exactly that and re-arms a
-- timer which forces the zoom back, so pfQuest's cached zoom and the real one
-- drift apart and every node is culled as out-of-range -- an empty minimap
-- while the world map is fine (issue #15). The state only changes when the
-- player moves indoors/outdoors or the zoom actually changes, so compute it on
-- those events instead and cache it. Also removes ~40 SetZoom calls a second.
-- ... except it did not, until the guard below. The probe detects indoor/outdoor
-- by NUDGING the minimap zoom and reading it back, and Minimap:SetZoom fires
-- MINIMAP_UPDATE_ZOOM, which is one of the events that dirties this cache. So
-- the probe invalidated itself, re-ran on the very next call, and kept the ~40
-- SetZoom calls a second it was written to remove. Worse than wasted work: every
-- one of those is an event other minimap addons react to, and with ElvUI loaded
-- the result was a minimap that only showed its pins for the split second after
-- a zone change (issue #15). Ignore the events the probe causes itself.
local indoorstate, indoordirty, indoorprobing = 1, true, nil
local indoorwatch = CreateFrame("Frame")
indoorwatch:RegisterEvent("PLAYER_ENTERING_WORLD")
indoorwatch:RegisterEvent("ZONE_CHANGED")
indoorwatch:RegisterEvent("ZONE_CHANGED_INDOORS")
indoorwatch:RegisterEvent("ZONE_CHANGED_NEW_AREA")
indoorwatch:RegisterEvent("MINIMAP_UPDATE_ZOOM")
indoorwatch:SetScript("OnEvent", function()
  if indoorprobing then
    return
  end
  indoordirty = true
end)

-- GetMinimapShape is an addon convention rather than a client API: square
-- minimap addons (ElvUI, and pfUI through its own flag above) define this
-- global so pin addons can widen the round cull to the corners. Guarded call,
-- because nothing defines it on a stock client.
local function squareminimap()
  if type(GetMinimapShape) ~= "function" then return nil end
  local ok, shape = pcall(GetMinimapShape)
  return ok and shape and shape ~= "ROUND" and true or nil
end

local function minimap_indoor_probe()
  local state = 1
  -- remember the real zoom rather than trying to undo the nudge by arithmetic:
  -- SetZoom clamps to 0..5, so stepping off either end and adding the step back
  -- left the minimap one level away from where it started, every probe.
  local zoom = pfMap.drawlayer:GetZoom()
  indoorprobing = true

  if GetCVar("minimapZoom") == GetCVar("minimapInsideZoom") then
    -- the two CVars are equal, so the zoom alone cannot say which one is in
    -- effect: nudge one step, in whichever direction stays in range
    pfMap.drawlayer:SetZoom(zoom > 0 and zoom - 1 or zoom + 1)
  end

  if GetCVar("minimapInsideZoom") + 0 == pfMap.drawlayer:GetZoom() then
    state = 0
  end

  pfMap.drawlayer:SetZoom(zoom)
  indoorprobing = nil
  return state
end

local function minimap_indoor()
  if indoordirty then
    indoordirty = nil
    indoorstate = minimap_indoor_probe()
  end
  return indoorstate
end

local function str2rgb(text)
  if not text then
    return 1, 1, 1
  end
  if pfQuest_colors[text] then
    return unpack(pfQuest_colors[text])
  end
  if rgbcache[text] then
    return unpack(rgbcache[text])
  end
  local counter = 1
  local l = string.len(text)
  for i = 1, l, 3 do
    counter = compat.mod(counter * 8161, 4294967279)
      + (string.byte(text, i) * 16776193)
      + ((string.byte(text, i + 1) or (l - i + 256)) * 8372226)
      + ((string.byte(text, i + 2) or (l - i + 256)) * 3932164)
  end
  local hash = compat.mod(compat.mod(counter, 4294967291), 16777216)
  local r = (hash - (compat.mod(hash, 65536))) / 65536
  local g = ((hash - r * 65536) - (compat.mod((hash - r * 65536), 256))) / 256
  local b = hash - r * 65536 - g * 256
  rgbcache[text] = { r / 255, g / 255, b / 255 }
  return unpack(rgbcache[text])
end

local fpsmod, step
local function NodeAnimate(self, zoom, alpha, fps)
  local cur_zoom = self:GetWidth()
  local cur_alpha = self:GetAlpha()
  local change = nil
  self:EnableMouse(true)
  fpsmod = math.min(2 / fps, 2)
  step = fpsmod / 10

  -- update size
  if math.abs(cur_zoom - zoom) < 3 then
    self:SetWidth(zoom)
    self:SetHeight(zoom)
  elseif cur_zoom < zoom then
    self:SetWidth(cur_zoom + fpsmod)
    self:SetHeight(cur_zoom + fpsmod)
    change = true
  elseif cur_zoom > zoom then
    self:SetWidth(cur_zoom - fpsmod)
    self:SetHeight(cur_zoom - fpsmod)
    change = true
  end

  -- update alpha
  if math.abs(cur_alpha - alpha) < step then
    self:SetAlpha(alpha)

    -- disable mouse on hidden
    if alpha < 0.1 then
      self:EnableMouse(nil)
    end
  elseif cur_alpha < alpha then
    self:SetAlpha(cur_alpha + step)
    change = true
  elseif cur_alpha > alpha then
    self:SetAlpha(cur_alpha - step)
    change = true
  end

  return change
end

-- put player position above everything on worldmap
for k, v in pairs({ WorldMapFrame:GetChildren() }) do
  if v:IsObjectType("Model") and not v:GetName() then
    if string.find(strlower(v:GetModel()), "interface\\minimap\\minimaparrow") then
      v:SetFrameLevel(255)
      break
    end
  end
end

pfMap = CreateFrame("Frame", "pfQuestMap", WorldFrame)
pfMap.str2rgb = str2rgb
pfMap.tooltips = {}
pfMap.nodes = {}
pfMap.pins = {}
pfMap.mpins = {}
pfMap.drawlayer = Minimap
pfMap.unifiedcache = unifiedcache

-- Reverse indexes for O(1) DeleteNode lookups.
-- titleIndex[addon][title][map][coords] = true  — set by AddNode
-- tooltipIndex[title][spawn] = true             — set by AddNode
pfMap.titleIndex = {}
pfMap.tooltipIndex = {}

-- Set of node tables that have been modified since the last UpdateNodes call.
-- Keyed by node table reference so the node table itself stays clean.
-- AddNode/DeleteNode insert here; UpdateNodes reads and clears entries.
pfMap.dirtyNodes = {}

-- Set of map IDs that have at least one dirty node table.
-- Keyed by zone map ID (integer). Allows WORLD_MAP_UPDATE to cheaply check
-- whether the current zone has pending writes without scanning all dirtyNodes.
pfMap.dirtyMaps = {}

pfMap.minimap_indoor = minimap_indoor
pfMap.minimap_zoom = minimap_zoom
pfMap.minimap_sizes = minimap_sizes

pfMap.tooltip = CreateFrame("Frame", "pfMapTooltip", GameTooltip)
pfMap.tooltip:SetScript("OnShow", function()
  local focus = GetMouseFocus()
  -- abort on pfQuest nodes
  if focus and focus.title then
    return
  end
  -- abort on quest timers
  if focus and focus.GetName and strsub((focus:GetName() or ""), 0, 10) == "QuestTimer" then
    return
  end
  -- abort if tooltips are disabled
  if pfQuest_config.showtooltips == "0" then
    return
  end

  local name = getglobal("GameTooltipTextLeft1") and getglobal("GameTooltipTextLeft1"):GetText() or "__NONE__"
  local zone = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())

  -- remove all colors from received tooltip text
  name = string.gsub(name, "|c%x%x%x%x%x%x%x%x", "")
  name = string.gsub(name, "|r", "")

  if pfMap.tooltips[name] and pfMap.tooltips[name] then
    for title, obj in pairs(pfMap.tooltips[name]) do
      if obj[zone] then
        pfMap:ShowTooltip(obj[zone], GameTooltip)
        GameTooltip:Show()
      end
    end
  end
end)

-- dummy function that can be used by extensions
-- to avoid drawing the minimap at some locations
function pfMap:HasMinimap()
  return true
end

function pfMap.tooltip:GetColor(min, max)
  local max = max or 1
  local min = min or max or 1

  local perc = min / max
  local r1, g1, b1, r2, g2, b2
  if perc <= 0.5 then
    perc = perc * 2
    r1, g1, b1 = 1, 0, 0
    r2, g2, b2 = 1, 1, 0
  else
    perc = perc * 2 - 1
    r1, g1, b1 = 1, 1, 0
    r2, g2, b2 = 0, 1, 0
  end
  r = r1 + (r2 - r1) * perc
  g = g1 + (g2 - g1) * perc
  b = b1 + (b2 - b1) * perc

  return r, g, b
end

function pfMap:HexDifficultyColor(level, force)
  if force and UnitLevel("player") < level then
    return "|cffff5555"
  else
    local c = pfQuestCompat.GetDifficultyColor(level)
    return string.format("|cff%02x%02x%02x", c.r * 255, c.g * 255, c.b * 255)
  end
end

function pfMap:ShowTooltip(meta, tooltip)
  local catch = nil
  local catch_obj = nil
  local tooltip = tooltip or GameTooltip

  -- add quest data
  if meta["quest"] then
    -- scan all quest entries for matches
    for qid = 1, GetNumQuestLogEntries() do
      local qtitle, _, _, _, _, complete = compat.GetQuestLogTitle(qid)

      if meta["quest"] == qtitle then
        -- handle active quests
        local objectives = GetNumQuestLeaderBoards(qid)
        catch = true

        local symbol = (complete or objectives == 0) and "|cff555555[|cffffcc00?|cff555555]|r "
          or "|cff555555[|cffffcc00!|cff555555]|r "
        tooltip:AddLine(symbol .. meta["quest"], 1, 1, 0)

        if objectives then
          for i = 1, objectives, 1 do
            local text, type, finished = GetQuestLogLeaderBoard(i, qid)

            if type == "monster" then
              -- kill
              local i, j, monsterName, objNum, objNeeded =
                strfind(text, pfUI.api.SanitizePattern(QUEST_MONSTERS_KILLED))
              if monsterName and meta["spawn"] == monsterName then
                catch_obj = true
                local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
                tooltip:AddLine("|cffaaaaaa- |r" .. monsterName .. ": " .. objNum .. "/" .. objNeeded, r, g, b)
              end
            elseif table.getn(meta["item"]) > 0 and type == "item" and meta["droprate"] then
              -- loot
              local i, j, itemName, objNum, objNeeded = strfind(text, pfUI.api.SanitizePattern(QUEST_OBJECTS_FOUND))

              for mid, item in pairs(meta["item"]) do
                if item == itemName then
                  catch_obj = true
                  local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
                  local dr, dg, db = pfMap.tooltip:GetColor(tonumber(meta["droprate"]), 100)
                  local lootcolor = string.format("%02x%02x%02x", dr * 255, dg * 255, db * 255)
                  tooltip:AddLine(
                    "|cffaaaaaa- |r"
                      .. itemName
                      .. ": "
                      .. objNum
                      .. "/"
                      .. objNeeded
                      .. " |cff555555[|cff"
                      .. lootcolor
                      .. meta["droprate"]
                      .. "%|cff555555]",
                    r,
                    g,
                    b
                  )
                end
              end
            elseif table.getn(meta["item"]) > 0 and type == "item" and meta["sellcount"] then
              -- vendor
              local i, j, itemName, objNum, objNeeded = strfind(text, pfUI.api.SanitizePattern(QUEST_OBJECTS_FOUND))

              for mid, item in pairs(meta["item"]) do
                if item == itemName then
                  catch_obj = true
                  local r, g, b = pfMap.tooltip:GetColor(objNum, objNeeded)
                  local sellcount = tonumber(meta["sellcount"]) > 0
                      and " |cff555555[|cffcccccc" .. meta["sellcount"] .. "x" .. "|cff555555]"
                    or ""
                  tooltip:AddLine(
                    "|cffaaaaaa- |r"
                      .. pfQuest_Loc["Buy"]
                      .. ": "
                      .. itemName
                      .. ": "
                      .. objNum
                      .. "/"
                      .. objNeeded
                      .. sellcount,
                    r,
                    g,
                    b
                  )
                end
              end
            end
          end
        end
      end
    end

    if not catch then
      tooltip:AddLine("|cff555555[|cffffcc00!|cff555555]|r " .. meta["quest"], 1, 1, 0.7)
    end

    if not catch_obj then
      -- handle inactive quests
      local catchFallback = nil

      if meta["item"] and meta["item"][1] and meta["droprate"] then
        for mid, item in pairs(meta["item"]) do
          catchFallback = true
          local dr, dg, db = pfMap.tooltip:GetColor(tonumber(meta["droprate"]), 100)
          local lootcolor = string.format("%02x%02x%02x", dr * 255, dg * 255, db * 255)
          tooltip:AddLine(
            "|cffaaaaaa- |r" .. item .. " |cff555555[|cff" .. lootcolor .. meta["droprate"] .. "%|cff555555]",
            0.7,
            0.7,
            0.7
          )
        end
      end

      if meta["item"] and meta["item"][1] and meta["sellcount"] then
        for mid, item in pairs(meta["item"]) do
          catchFallback = true
          local sellcount = tonumber(meta["sellcount"]) > 0
              and " |cff555555[|cffcccccc" .. meta["sellcount"] .. "x" .. "|cff555555]"
            or ""
          tooltip:AddLine("|cffaaaaaa- |r" .. pfQuest_Loc["Buy"] .. ": " .. item .. sellcount, 0.7, 0.7, 0.7)
        end
      end

      if not catchFallback and meta["spawn"] and not meta["texture"] then
        catchFallback = true
        tooltip:AddLine(
          "|cffaaaaaa- |r"
            .. (meta["spawntype"] and meta["spawntype"] == "Trigger" and pfQuest_Loc["Explore"] or meta["spawn"]),
          0.7,
          0.7,
          0.7
        )
      end

      if not catchFallback and meta["texture"] and meta["qlvl"] then
        local texts = meta["questid"] and pfDB["quests"]["loc"][meta["questid"]] or nil

        if texts and texts["O"] and texts["O"] ~= "" then
          tooltip:AddLine(pfDatabase:FormatQuestText(texts["O"]), 1, 1, 0.9, true)
        end

        local qlvlstr = pfQuest_Loc["Level"] .. ": " .. pfMap:HexDifficultyColor(meta["qlvl"]) .. meta["qlvl"] .. "|r"
        local qminstr = meta["qmin"]
            and " / " .. pfQuest_Loc["Required"] .. ": " .. pfMap:HexDifficultyColor(meta["qmin"], true) .. meta["qmin"] .. "|r"
          or ""
        tooltip:AddLine("|cffaaaaaa- |r" .. qlvlstr .. qminstr, 0.8, 0.8, 0.8)
      end
    end
  else
    -- handle non-quest objects
    if meta["item"][1] and meta["itemid"] and not meta["itemlink"] then
      local _, _, itemQuality = GetItemInfo(meta["itemid"])
      if itemQuality then
        local itemColor = "|c"
          .. string.format(
            "%02x%02x%02x%02x",
            255,
            ITEM_QUALITY_COLORS[itemQuality].r * 255,
            ITEM_QUALITY_COLORS[itemQuality].g * 255,
            ITEM_QUALITY_COLORS[itemQuality].b * 255
          )

        meta["itemlink"] = itemColor .. "|Hitem:" .. meta["itemid"] .. ":0:0:0|h[" .. meta["item"][1] .. "]|h|r"
      end
    end

    if meta["sellcount"] then
      local item = meta["itemlink"] or "[" .. meta["item"][1] .. "]"
      local sellcount = tonumber(meta["sellcount"]) > 0
          and " |cff555555[|cffcccccc" .. meta["sellcount"] .. "x" .. "|cff555555]"
        or ""
      tooltip:AddLine(pfQuest_Loc["Vendor"] .. ": " .. item .. sellcount, 1, 1, 1)
    elseif meta["item"][1] then
      local item = meta["itemlink"] or "[" .. meta["item"][1] .. "]"
      local r, g, b = pfMap.tooltip:GetColor(tonumber(meta["droprate"]), 100)
      tooltip:AddLine(
        "|cffffffff" .. pfQuest_Loc["Loot"] .. ": " .. item .. " |cff555555[|r" .. meta["droprate"] .. "%|cff555555]",
        r,
        g,
        b
      )
    end
  end

  tooltip:Show()
end

function pfMap:GetMapNameByID(id)
  id = tonumber(id)
  return pfDB["zones"]["loc"][id] or nil
end

function pfMap:GetMapIDByName(search)
  for id, name in pairs(pfDB["zones"]["loc"]) do
    if name == search then
      return id
    end
  end
end

function pfMap:ShowMapID(map)
  if map then
    if ToggleWorldMap then
      -- vanilla & tbc
      if not WorldMapFrame:IsShown() then
        ToggleWorldMap()
      end
    else
      -- wotlk
      WorldMapFrame:Show()
    end

    pfMap:SetMapByID(map)
    pfMap:UpdateNodes()
    return true
  end

  return nil
end

function pfMap:SetMapByID(id)
  local search = pfDB["zones"]["loc"][id]

  for cid, cname in pairs({ GetMapContinents() }) do
    for mid, mname in pairs({ GetMapZones(cid) }) do
      if mname == search then
        SetMapZoom(cid, mid)
        return
      end
    end
  end
end

local customids = {
  ["AlteracValley"] = 2597,
}

-- Reforged: sub-maps -- a map area that is a PIECE of a zone pfQuest has data
-- for, rather than a zone of its own (issue #20).
--
-- The Caverns and Mines client patch, which the WDM addon collection is built
-- for, registers the eight starter zones as their own map areas. pfQuest has no
-- data keyed to them (its coordinates are all on the parent zone's rectangle),
-- so GetMapID found no match, UpdateNodes bailed on a nil map, and the whole
-- starter experience showed nothing at all.
--
-- The entry is { parent zone id, left, top, width, height }, the sub-map's
-- rectangle expressed in the PARENT map's percentages. A parent coordinate
-- becomes a sub-map coordinate with (value - left) / size * 100, and anything
-- landing outside 0..100 is simply not on this map and gets culled.
--
-- DERIVED, not guessed. The WDM collection ships continent offsets and extents
-- for both the sub-maps and their parents in its bundled Astrolabe, so each
-- rectangle is (child.xOffset - parent.xOffset) / parent.width and so on. Three
-- checks before trusting them: WDM's GatherMate ships the same eight extents
-- independently and agrees to four decimals on every one; every rectangle comes
-- out square in percentage terms (width% within 0.1% of height%), which has to
-- hold because parent and child are both 3:2; and each one lands where the zone
-- actually is, with Camp Narache and Ammen Vale reaching ~1.5% past the parent
-- edge exactly as they should, both sitting on the map border.
--
-- The KEYS are GetMapInfo() values. Confirmed from two independent tables in
-- that collection that are documented in code to be GetMapInfo()-keyed
-- (Astrolabe's zoneData, GatherMate's zone_data) plus WDM's own mdlevels, which
-- carries Blizzard's "Ogrimmar" misspelling as a giveaway that these are raw
-- map file names. Inert without the patch: these map areas do not exist, so
-- GetMapInfo() never returns any of them.
local submaps = {
  -- Eastern Kingdoms
  ["Northshire"]          = { 12,   38.84, 27.27, 27.91, 27.90 }, -- Elwynn Forest
  ["ColdridgeValley"]     = { 1,    16.71, 63.51, 19.59, 19.61 }, -- Dun Morogh
  ["DeathknellStart"]     = { 85,   19.59, 52.00, 24.11, 24.14 }, -- Tirisfal Glades
  ["SunstriderIsleStart"] = { 3430, 18.19,  6.34, 32.49, 32.49 }, -- Eversong Woods
  -- Kalimdor
  ["ShadowglenStart"]     = { 141,  45.62, 23.51, 28.48, 28.48 }, -- Teldrassil
  ["ValleyofTrialsStart"] = { 14,   31.75, 51.30, 25.53, 25.53 }, -- Durotar
  ["CampNaracheStart"]    = { 215,  35.32, 67.28, 34.39, 34.37 }, -- Mulgore
  ["AmmenValeStart"]      = { 3524, 56.85, 29.86, 44.68, 44.67 }, -- Azuremyst Isle

  -- The mine, cave and cavern interiors the same patch adds (issue #20 again).
  -- Same mechanism, and the same reason they were empty: pfQuest stores what is
  -- inside them at the PARENT zone's coordinates, because that is the only
  -- rectangle its data has ever had. Generated straight from the patch's
  -- WorldMapArea.dbc rather than derived, walking parentWorldMapID up to the
  -- first ancestor pfQuest holds coordinates for. That resolves the awkward
  -- ones by construction: Frostmane Hovel is a floor of Coldridge Valley, which
  -- is itself a sub-map, and both reduce to Dun Morogh; Scarlet Monastery and
  -- the Deadmines carry no parent at all and are placed by containment.
  --
  -- KNOWN LIMIT, and it is worth saying plainly: pfQuest has no z coordinate,
  -- so "inside this rectangle" cannot distinguish the cave from the hillside
  -- above it. Surface nodes over a mine will appear on the mine's map. That is
  -- tolerable for the small ones, where nearly everything in the rectangle IS
  -- the mine, and noticeable for the big ones, where Blackrock Mountain, Uldaman
  -- and Ragefire Chasm each cover a fifth or more of their zone. An overlaid
  -- pin is still better than the blank map these all drew before.
  ["Fargodeepmine1_"]             = { 12,     36.12,  76.06,  6.91,  6.91 }, -- Elwynn
  ["Fargodeepmine2_"]             = { 12,     35.90,  76.49,  7.35,  7.34 }, -- Elwynn
  ["EchoRidgeMine3_"]             = { 12,     45.02,  24.21,  8.04,  8.04 }, -- Elwynn
  ["GoldCoastQuarry4_"]           = { 40,     26.30,  44.14,  7.50,  7.50 }, -- Westfall
  ["JangolodeMine5_"]             = { 40,     41.32,  17.09,  7.91,  7.91 }, -- Westfall
  ["ColdridgePass6_"]             = { 1,      31.62,  65.27,  6.70,  6.70 }, -- DunMorogh
  ["TheGrizzledDen7_"]            = { 1,      35.93,  43.73, 10.26, 10.26 }, -- DunMorogh
  ["FrostmaneHold8_"]             = { 1,      19.37,  48.97,  6.94,  7.14 }, -- DunMorogh
  ["FrostmaneHovel9_"]            = { 1,      26.27,  78.23,  5.41,  5.41 }, -- DunMorogh
  ["GnomereganEntrance10_"]       = { 1,      14.60,  26.98, 14.83, 14.23 }, -- DunMorogh
  ["GolBolarQuarry11_"]           = { 1,      67.92,  49.03,  7.59,  7.59 }, -- DunMorogh
  ["NightWebsHollow12_"]          = { 85,     22.43,  56.90,  4.87,  4.87 }, -- Tirisfal
  ["ScarletMonasteryEntrance13_"] = { 28,     25.04,  14.58,  4.77,  4.77 }, -- WesternPlaguelands
  ["BlackrockMountain14_"]        = { 46,     16.88,  15.05, 24.32, 24.33 }, -- BurningSteppes
  ["BlackrockMountain15_"]        = { 46,     29.99,  22.99,  8.71,  8.71 }, -- BurningSteppes
  ["BlackrockMountain16_"]        = { 46,     12.32,   2.84, 25.95, 25.96 }, -- BurningSteppes
  ["DeadminesWestfall17_"]        = { 40,     34.98,  70.93, 12.86, 12.86 }, -- Westfall
  ["Uldaman18_"]                  = { 3,      26.92,   3.94, 22.61, 22.61 }, -- Badlands
  ["JasperlodeMine19_"]           = { 12,     57.08,  45.17,  9.31,  9.31 }, -- Elwynn
  ["Ogrimmar1_"]                  = { 1637,   34.46,  36.52, 25.82, 25.81 }, -- Ogrimmar
  ["ShadowthreadCave2_"]          = { 141,    52.53,  23.46,  9.43,  9.43 }, -- Teldrassil
  ["FelRock3_"]                   = { 141,    50.37,  47.72,  5.49,  5.49 }, -- Teldrassil
  ["BanethilBarrowden4_"]         = { 141,    41.82,  57.45,  4.52,  4.52 }, -- Teldrassil
  ["BanethilBarrowden5_"]         = { 141,    40.84,  55.97,  7.46,  7.46 }, -- Teldrassil
  ["PalemaneRock6_"]              = { 215,    28.57,  58.11,  6.81,  6.81 }, -- Mulgore
  ["TheVentureCoMine7_"]          = { 215,    55.78,  33.96, 14.42, 14.42 }, -- Mulgore
  ["BurningBladeCoven8_"]         = { 14,     41.68,  51.14,  5.03,  5.03 }, -- Durotar
  ["TiragardeKeep10_"]            = { 14,     58.44,  57.07,  2.36,  2.36 }, -- Durotar
  ["TiragardeKeep11_"]            = { 14,     58.44,  57.07,  2.36,  2.36 }, -- Durotar
  ["SkullRock12_"]                = { 14,     50.43,   6.46,  5.11,  5.11 }, -- Durotar
  ["TwilightsRun13_"]             = { 1377,   68.22,   9.69,  7.25,  7.25 }, -- Silithus
  ["TheSlitheringScar14_"]        = { 490,    41.00,  79.59, 10.34, 10.34 }, -- UngoroCrater
  ["TheNoxiousLair15_"]           = { 440,    28.57,  38.37, 10.87, 10.87 }, -- Tanaris
  ["TheGapingChasm16_"]           = { 440,    49.18,  65.76, 12.83, 12.83 }, -- Tanaris
  ["CavernsofTime17_"]            = { 440,    57.17,  45.24, 16.05, 16.05 }, -- Tanaris
  ["CavernsofTime18_"]            = { 440,    50.56,  46.99, 18.93, 18.93 }, -- Tanaris
  ["DustwindCave19_"]             = { 14,     50.31,  23.75,  4.88,  4.88 }, -- Durotar
  ["WailingCavernsBarrens20_"]    = { 17,     44.66,  31.12,  5.63,  5.62 }, -- Barrens
  ["MaraudonOutside21_"]          = { 405,    25.53,  56.78, 13.35, 13.34 }, -- Desolace
  ["MaraudonOutside22_"]          = { 405,    23.76,  51.52, 12.46, 12.45 }, -- Desolace
  ["AmaniCatacombs1_"]            = { 3433,   57.47,  25.30,  9.09,  9.09 }, -- Ghostlands
  ["TidesHollow2_"]               = { 3524,   21.35,  68.01,  9.21,  9.21 }, -- AzuremystIsle
  ["StillpineHold3_"]             = { 3524,   42.93,   7.94, 11.67, 11.67 }, -- AzuremystIsle
}

-- The same eight, keyed by the zone id pfQuest ALREADY has for them: it has
-- always known them as SUBZONES of their parent, so Northshire Valley is 9,
-- Coldridge Valley is 132, and so on. Not one of those ids holds a single
-- coordinate; every node in those places is stored on the parent zone, which is
-- where pfQuest's own rectangle puts it. So anything resolving a zone by NAME
-- has to be redirected or it lands on an empty zone and draws nothing. That is
-- exactly what GetRealZoneText() gives while the player stands in a starter
-- zone, which the minimap and the tracker's proximity list both key off.
local subzoneparent = {
  [9] = 12,      -- Northshire Valley -> Elwynn Forest
  [132] = 1,     -- Coldridge Valley  -> Dun Morogh
  [154] = 85,    -- Deathknell        -> Tirisfal Glades
  [3431] = 3430, -- Sunstrider Isle   -> Eversong Woods
  [188] = 141,   -- Shadowglen        -> Teldrassil
  [363] = 14,    -- Valley of Trials  -> Durotar
  [221] = 215,   -- Camp Narache      -> Mulgore
  [3526] = 3524, -- Ammen Vale        -> Azuremyst Isle
}

function pfMap:ParentZone(id)
  if not id then return nil end
  return subzoneparent[id] or id
end

-- The sub-map currently being VIEWED, or nil. Keyed on GetMapInfo() on purpose:
-- that is the same frame of reference GetPlayerMapPosition answers in, so the
-- world map and the minimap stay in step even while the player browses a map
-- they are not standing in.
function pfMap:GetSubmap()
  return submaps[GetMapInfo() or ""]
end

-- Parent percentage -> sub-map percentage. Second return is false when the
-- point is not inside this sub-map at all.
function pfMap:ToSubmap(sub, x, y)
  x = (x - sub[2]) / sub[4] * 100
  y = (y - sub[3]) / sub[5] * 100
  -- the epsilon is for float equality only, not a margin: a node sitting
  -- exactly on the sub-map's edge divides out to 100.00000000000001 and would
  -- otherwise be culled from the map it is actually on
  local e = 0.000001
  return x, y, (x >= -e and x <= 100 + e and y >= -e and y <= 100 + e)
end

-- Sub-map percentage -> parent percentage. The minimap converts this way round
-- instead: the player position is the ONE value it reads in sub-map space, and
-- lifting it into the parent leaves node coordinates, zone sizes and the yard
-- scale all in the space they were already in.
function pfMap:FromSubmap(sub, x, y)
  return sub[2] + x / 100 * sub[4], sub[3] + y / 100 * sub[5]
end

local map_zone_cache = {}
function pfMap:GetMapID(cid, mid)
  cid = cid or GetCurrentMapContinent()
  mid = mid or GetCurrentMapZone()

  -- GetMapZones() should always return the same amount
  -- of zones for each continent, so we can cache it to
  -- avoid further creations of the same table.
  if not map_zone_cache[cid] then
    map_zone_cache[cid] = { GetMapZones(cid) }
  end

  local list = map_zone_cache[cid]
  local name = list[mid]

  -- A sub-map answers with its PARENT: that is the zone the coordinates in the
  -- database belong to. This has to take PRECEDENCE over the name lookup, not
  -- fall back to it. The patch puts these map areas in GetMapZones under their
  -- real names, and pfQuest has always had those names as subzone ids, so
  -- "Northshire Valley" resolves to 9 -- a zone that holds no coordinates at
  -- all. Answering 9 is worse than answering nothing: it looks like a perfectly
  -- good zone with an empty map, which is what shipped in v1.0.47.
  local sub = submaps[GetMapInfo() or ""]
  if sub then
    return sub[1]
  end

  local id = pfMap:GetMapIDByName(name)
  id = id or customids[GetMapInfo()]
  -- and the same redirect for anything that resolved to a starter subzone by
  -- name without the map area being a sub-map (SetMapByID, addons, /way)
  return pfMap:ParentZone(id)
end

function pfMap:AddNode(meta)
  if not meta then
    return
  end
  if not meta["zone"] then
    return
  end
  if not meta["title"] then
    return
  end

  -- only compute description if the caller hasn't already done it
  -- (SearchMobID / SearchObjectID hoist this call outside their coord loops)
  if meta["description"] == nil then
    meta["description"] = pfDatabase:BuildQuestDescription(meta)
  end

  local addon = meta["addon"] or "PFDB"
  local map = meta["zone"]
  local coords = meta["x"] .. "|" .. meta["y"]
  local title = meta["title"]
  local layer = GetLayerByTexture(meta["texture"])
  local spawn = meta["spawn"]
  local item = meta["item"]

  local sindex = string.format(
    "%s:%s:%s:%s:%s:%s",
    (addon or ""),
    (map or ""),
    (coords or ""),
    (title or ""),
    (layer or ""),
    (spawn or ""),
    (item or "")
  )

  -- use prioritized clusters
  if layer >= 9 and meta["priority"] then
    layer = layer + (10 - min(meta["priority"], 10))
  end

  if not pfMap.nodes[addon] then
    pfMap.nodes[addon] = {}
  end
  if not pfMap.nodes[addon][map] then
    pfMap.nodes[addon][map] = {}
  end
  if not pfMap.nodes[addon][map][coords] then
    pfMap.nodes[addon][map][coords] = {}
  end

  -- skip early on existing nodes
  if pfMap.nodes[addon][map][coords][title] then
    if item and table.getn(pfMap.nodes[addon][map][coords][title].item) > 0 then
      -- check if item already exists
      for id, name in pairs(pfMap.nodes[addon][map][coords][title].item) do
        if name == item then
          return
        end
      end

      -- add new item and exit
      table.insert(pfMap.nodes[addon][map][coords][title].item, item)
      return
    end

    if
      pfMap.nodes[addon][map][coords][title]
      and pfMap.nodes[addon][map][coords][title].layer
      and layer
      and pfMap.nodes[addon][map][coords][title].layer >= layer
    then
      -- identical node already exists, exit here
      return
    end
  end

  -- create new combined data node from given meta data
  if not similar_nodes[sindex] then
    similar_nodes[sindex] = {}
    for key, val in pairs(meta) do
      similar_nodes[sindex][key] = val
    end
    similar_nodes[sindex].item = { [1] = item }
  end

  -- set current node to combined node
  pfMap.nodes[addon][map][coords][title] = similar_nodes[sindex]

  -- mark this coord's node table dirty so UpdateNodes knows to reprocess it
  pfMap.dirtyNodes[pfMap.nodes[addon][map][coords]] = true
  pfMap.dirtyMaps[map] = true

  -- maintain reverse title index for O(1) DeleteNode
  if not pfMap.titleIndex[addon] then
    pfMap.titleIndex[addon] = {}
  end
  if not pfMap.titleIndex[addon][title] then
    pfMap.titleIndex[addon][title] = {}
  end
  if not pfMap.titleIndex[addon][title][map] then
    pfMap.titleIndex[addon][title][map] = {}
  end
  pfMap.titleIndex[addon][title][map][coords] = true

  -- add node to unified cluster cache
  if not meta["cluster"] and not meta["texture"] then
    local node_index = meta.item or meta.spawn or UNKNOWN
    local x, y = tonumber(meta.x), tonumber(meta.y)

    -- create prerequisite table structure
    unifiedcache[title] = unifiedcache[title] or {}
    unifiedcache[title][map] = unifiedcache[title][map] or {}

    if not unifiedcache[title][map][node_index] then
      -- create new unified node from given meta data
      local unified_meta = {}
      for key, val in pairs(meta) do
        unified_meta[key] = val
      end

      -- save node to unified cache
      unifiedcache[title][map][node_index] = { meta = unified_meta, coords = {} }
    end

    -- append new coords to unified cache unified cache
    table.insert(unifiedcache[title][map][node_index].coords, { x, y })
  end

  -- add to gametooltips
  if spawn and title then
    pfMap.tooltips[spawn] = pfMap.tooltips[spawn] or {}
    pfMap.tooltips[spawn][title] = pfMap.tooltips[spawn][title] or {}
    pfMap.tooltips[spawn][title][map] = pfMap.tooltips[spawn][title][map] or similar_nodes[sindex]

    -- maintain reverse tooltip index for O(1) DeleteNode
    if not pfMap.tooltipIndex[title] then
      pfMap.tooltipIndex[title] = {}
    end
    pfMap.tooltipIndex[title][spawn] = true
  end

  pfMap.queue_update = GetTime()
end

function pfMap:GetNodes(addon, title)
  local nodes = {}

  if title and pfMap.nodes[addon] then
    for map, foo in pairs(pfMap.nodes[addon]) do
      for coords, node in pairs(pfMap.nodes[addon][map]) do
        if pfMap.nodes[addon][map][coords][title] then
          table.insert(nodes, pfMap.nodes[addon][map][coords][title])
        end
      end
    end
  end

  return nodes
end

function pfMap:DeleteNode(addon, title)
  if not addon then
    -- wipe everything
    pfMap.tooltips = {}
    pfMap.nodes = {}
    pfMap.titleIndex = {}
    pfMap.tooltipIndex = {}
    pfMap.dirtyNodes = {}
    pfMap.dirtyMaps = {}
  elseif not title then
    -- wipe all nodes for this addon; clean up both reverse indexes
    if pfMap.titleIndex[addon] then
      for t, maps in pairs(pfMap.titleIndex[addon]) do
        -- clean tooltipIndex entries that belonged to this addon's titles
        local spawns = pfMap.tooltipIndex[t]
        if spawns then
          for spawn in pairs(spawns) do
            if pfMap.tooltips[spawn] then
              pfMap.tooltips[spawn][t] = nil
              if IsEmpty(pfMap.tooltips[spawn]) then
                pfMap.tooltips[spawn] = nil
              end
            end
          end
          pfMap.tooltipIndex[t] = nil
        end
      end
      pfMap.titleIndex[addon] = nil
    end
    pfMap.nodes[addon] = nil
  elseif pfMap.titleIndex[addon] and pfMap.titleIndex[addon][title] then
    -- fast path: use reverse index to find exactly which (map, coords) to clear
    for map, coords_set in pairs(pfMap.titleIndex[addon][title]) do
      if pfMap.nodes[addon] and pfMap.nodes[addon][map] then
        for coords in pairs(coords_set) do
          if pfMap.nodes[addon][map][coords] then
            pfMap.nodes[addon][map][coords][title] = nil
            if IsEmpty(pfMap.nodes[addon][map][coords]) then
              pfMap.nodes[addon][map][coords] = nil
            else
              -- coord survives with remaining titles; reprocess on next UpdateNodes
              pfMap.dirtyNodes[pfMap.nodes[addon][map][coords]] = true
              pfMap.dirtyMaps[map] = true
            end
          end
        end
      end
    end
    pfMap.titleIndex[addon][title] = nil

    -- clean up tooltip entries for this title using the reverse tooltip index
    local spawns = pfMap.tooltipIndex[title]
    if spawns then
      for spawn in pairs(spawns) do
        if pfMap.tooltips[spawn] then
          pfMap.tooltips[spawn][title] = nil
          if IsEmpty(pfMap.tooltips[spawn]) then
            pfMap.tooltips[spawn] = nil
          end
        end
      end
      pfMap.tooltipIndex[title] = nil
    end
  end

  pfMap.queue_update = GetTime()
  -- Force an immediate minimap refresh. UpdateMinimap throttles to once per
  -- second for stationary players; clearing the tick bypasses that so the
  -- deleted node's pin disappears within one OnUpdate tick (~0.05s) instead
  -- of up to 1 second later.
  pfMap.tick = nil
end

function pfMap:NodeClick()
  if IsShiftKeyDown() then
    if this.questid and this.texture and this.layer < 5 then
      -- mark questnode as done
      pfQuest_history[this.questid] = { time(), UnitLevel("player") }
    end

    if this.node and this.title and this.node[this.title] then
      -- delete node from map
      pfMap:DeleteNode(this.node[this.title].addon, this.title)
    end

    pfQuest.updateQuestGivers = true
  elseif
    this.texture
    and pfQuest.route
    and (
      (pfQuest_config["routecluster"] == "1" and this.layer >= 9)
      or (pfQuest_config["routeender"] == "1" and this.layer == 4)
      or (pfQuest_config["routestarter"] == "1" and this.layer == 1)
      or (pfQuest_config["routestarter"] == "1" and this.layer == 2)
    )
  then
    -- set as arrow target priority
    pfQuest.route.SetTarget((not pfQuest.route.IsTarget(this) and this))
    pfMap.dirtyNodes[this.node] = true
    pfMap.queue_update = GetTime()
  else
    -- switch color
    pfQuest_colors[this.color] = { str2rgb(this.color .. GetTime()) }
    -- dirty every coord table containing this title so all related pins re-render
    local addon = this.node and this.node[this.title] and this.node[this.title].addon
    if addon and pfMap.titleIndex[addon] and pfMap.titleIndex[addon][this.title] then
      for mapId, coords in pairs(pfMap.titleIndex[addon][this.title]) do
        for coord in pairs(coords) do
          local nt = pfMap.nodes[addon][mapId] and pfMap.nodes[addon][mapId][coord]
          if nt then pfMap.dirtyNodes[nt] = true end
        end
      end
    else
      pfMap.dirtyNodes[this.node] = true
    end
    pfMap.queue_update = GetTime()
  end
end

-- Reforged: one spot can hold more than one thing, and UpdateNode can only pick
-- ONE of them to describe the pin -- the entry with the highest layer, or an
-- arbitrary one when the layers tie. Naming only that winner hid the rest
-- completely: the server pools Cobalt with Rich Cobalt and Saronite with
-- Titanium at identical coordinates, so whole Northrend zones read as a single
-- ore (issue #22). Collect everything else standing here, once per name and in
-- a stable order, so the tooltip can list it under the header.
local function collectextras(node, spawn)
  local extras, seen = nil, nil
  for _, meta in pairs(node or {}) do
    if meta.spawn and meta.spawn ~= spawn then
      seen = seen or {}
      if not seen[meta.spawn] then
        seen[meta.spawn] = true
        extras = extras or {}
        table.insert(extras, meta)
      end
    end
  end
  if extras then
    table.sort(extras, function(a, b)
      return a.spawn < b.spawn
    end)
  end
  return extras
end
pfMap.CollectExtraSpawns = collectextras

function pfMap:NodeEnter()
  -- wotlk: need to disable blop tooltips first
  if compat.client >= 30300 then
    WorldMapPOIFrame.allowBlobTooltip = false
  end

  local tooltip = this:GetParent() == WorldMapButton and WorldMapTooltip or GameTooltip
  tooltip:SetOwner(this, "ANCHOR_LEFT")
  this.spawn = this.spawn or UNKNOWN
  tooltip:SetText(
    this.spawn .. (pfQuest_config.showids == "1" and " |cffcccccc(" .. this.spawnid .. ")|r" or ""),
    0.3,
    1,
    0.8
  )
  tooltip:AddDoubleLine(pfQuest_Loc["Level"] .. ":", (this.level or UNKNOWN), 0.8, 0.8, 0.8, 1, 1, 1)
  -- Reforged: a number of rares belong to one faction and simply cannot be
  -- fought by the other, which sent players across a zone after a mob they were
  -- never going to be able to attack (issue #31). pfQuest already knows this: it
  -- stores who a unit is friendly to in units[id].fac, the same field the
  -- browser's Reaction block and the quest faction filter read. Shown only when
  -- it is ONE side -- "AH" and nil mean the mob belongs to neither, which is the
  -- normal case and tells the player nothing.
  if this.faction == "A" or this.faction == "H" then
    tooltip:AddDoubleLine(
      pfQuest_Loc["Faction"] .. ":",
      this.faction == "A" and pfQuest_Loc["Alliance"] or pfQuest_Loc["Horde"],
      0.8, 0.8, 0.8,
      1, 1, 1
    )
  end
  tooltip:AddDoubleLine(pfQuest_Loc["Type"] .. ":", (this.spawntype or UNKNOWN), 0.8, 0.8, 0.8, 1, 1, 1)
  tooltip:AddDoubleLine(pfQuest_Loc["Respawn"] .. ":", (this.respawn or UNKNOWN), 0.8, 0.8, 0.8, 1, 1, 1)

  local extras = collectextras(this.node, this.spawn)
  if extras then
    tooltip:AddLine(pfQuest_Loc["Also here"] .. ":", 0.3, 1, 0.8)
    for i = 1, table.getn(extras) do
      local meta = extras[i]
      tooltip:AddDoubleLine(
        meta.spawn .. (pfQuest_config.showids == "1" and meta.spawnid and " |cffcccccc(" .. meta.spawnid .. ")|r" or ""),
        (meta.level or ""),
        1,
        1,
        1,
        0.8,
        0.8,
        0.8
      )
    end
  end

  for title, meta in pairs(this.node) do
    pfMap:ShowTooltip(meta, tooltip)
  end

  -- add tooltip help if setting is enabled
  if pfQuest_config["tooltiphelp"] == "1" then
    local text = pfQuest_Loc["Use <Shift>-Click To Remove Nodes"]

    if this.cluster then
      text = pfQuest_Loc["Hold <Ctrl> To Hide Cluster"]
    elseif tooltip == GameTooltip then
      text = pfQuest_Loc["Hold <Ctrl> To Hide Minimap Nodes"]
    elseif not this.texture then
      text = pfQuest_Loc["Click Node To Change Color"]
    elseif this.questid and this.texture and this.layer < 5 then
      text = pfQuest_Loc["Use <Shift>-Click To Mark Quest As Done"]
    end

    -- update tooltip and sizes
    tooltip:AddLine(text, 0.6, 0.6, 0.6)
    tooltip:Show()
  end

  pfMap.highlight = pfQuest_config["mouseover"] == "1" and this.title
end

function pfMap:NodeLeave()
  -- wotlk: re-enable blop tooltips
  if compat.client >= 30300 then
    WorldMapPOIFrame.allowBlobTooltip = true
  end

  local tooltip = this:GetParent() == WorldMapButton and WorldMapTooltip or GameTooltip
  tooltip:Hide()
  pfMap.highlight = nil
end

function pfMap:BuildNode(name, parent)
  local f = CreateFrame("Button", name, parent)

  if parent == WorldMapButton then
    f.defalpha = tonumber(pfQuest_config["worldmaptransp"]) or 1
    f.defsize = tonumber(pfQuest_config["worldmapNodeSize"]) or 14
  else
    f.defalpha = tonumber(pfQuest_config["minimaptransp"]) or 1
    f.defsize = tonumber(pfQuest_config["minimapNodeSize"]) or 14
    f.minimap = true
  end

  f:SetWidth(f.defsize)
  f:SetHeight(f.defsize)

  f.Animate = NodeAnimate
  f:SetScript("OnEnter", pfMap.NodeEnter)
  f:SetScript("OnLeave", pfMap.NodeLeave)

  f.tex = f:CreateTexture(nil, "BACKGROUND")
  f.tex:SetAllPoints(f)

  f.pic = f:CreateTexture(nil, "NORMAL")
  f.pic:SetPoint("TOPLEFT", f, "TOPLEFT", 1, -1)
  f.pic:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", -1, 1)

  f.hl = f:CreateTexture(nil, "BORDER")
  f.hl:SetTexture(pfQuestConfig.path .. "\\img\\track")
  f.hl:SetPoint("TOPLEFT", f, "TOPLEFT", -5, 5)
  f.hl:SetWidth(12)
  f.hl:SetHeight(12)
  return f
end

pfMap.highlightdb = {}
-- Reforged: a minimap pin is a CHILD of the minimap, and a child whose frame
-- level is below its parent's renders BEHIND the parent's own textures. Upstream
-- levels minimap pins at a fixed 4 + layer, which works only while the minimap
-- itself sits near level 0, as Blizzard's does. ElvUI puts it at 10, so every
-- pin below layer 7 was drawn behind ElvUI's minimap art: created, positioned
-- and :IsShown() true, but invisible (issue #15, confirmed by a report showing
-- pins=14 shown=14 with the minimap at level 10).
--
-- Level relative to whatever the minimap is actually at, so it does not matter
-- which addon owns it. The minimap loop keeps pfMap.mlevel in step; fall back to
-- asking the frame directly the first time through.
local function minimapNodeLevel(layer)
  local base = pfMap.mlevel
    or (pfMap.drawlayer and pfMap.drawlayer.GetFrameLevel and pfMap.drawlayer:GetFrameLevel())
    or 0
  return base + 5 + (layer or 0)
end
pfMap.MinimapNodeLevel = minimapNodeLevel

function pfMap:UpdateNode(frame, node, color, obj, distance)
  -- clear node to title association table
  if pfMap.highlightdb[frame] then
    for k, v in pairs(pfMap.highlightdb[frame]) do
      pfMap.highlightdb[frame][k] = nil
    end
  else
    pfMap.highlightdb[frame] = {}
  end

  -- reset layer
  frame.layer = 0

  for title, tab in pairs(node) do
    pfMap.highlightdb[frame][title] = true

    tab.layer = GetLayerByTexture(tab.texture)

    -- use prioritized clusters
    if tab.cluster and tab.priority then
      tab.layer = tab.layer + (10 - min(tab.priority, 10))
    end

    if tab.spawn and (tab.layer > frame.layer or not frame.spawn) then
      frame.updateTexture = (frame.texture ~= tab.texture)
      frame.updateVertex = (frame.vertex ~= tab.vertex)
      frame.updateColor = (frame.color ~= tab.color)
      frame.updateLayer = (frame.layer ~= tab.layer)
      frame.updateIcon = (frame.icon ~= tab.icon)

      -- set title and texture to the entry with highest layer
      -- and add core information
      frame.layer = tab.layer
      frame.spawn = tab.spawn
      frame.spawnid = tab.spawnid
      frame.spawntype = tab.spawntype
      frame.respawn = tab.respawn
      frame.level = tab.level
      frame.faction = tab.faction
      frame.questid = tab.questid
      frame.texture = tab.texture
      frame.vertex = tab.vertex
      frame.title = title
      frame.func = tab.func
      frame.cluster = tab.cluster
      frame.description = tab.description
      frame.priority = tab.priority
      frame.quest = tab.quest
      frame.qlvl = tab.qlvl
      frame.itemreq = tab.itemreq
      frame.arrow = tab.arrow
      frame.icon = tab.icon
      frame.fade_range = tab.fade_range

      if pfQuest_config["spawncolors"] == "1" then
        frame.color = tab.spawn or tab.title
      else
        frame.color = tab.title
      end
    end
  end

  if (frame.updateTexture or frame.updateVertex or not frame.tex:GetTexture()) and frame.texture then
    frame.tex:SetTexture(frame.texture)
    frame.tex:SetVertexColor(1, 1, 1)
    frame.pic:Hide()

    if frame.updateVertex and frame.vertex then
      local r, g, b = unpack(frame.vertex)
      if r > 0 or g > 0 or b > 0 then
        frame.tex:SetVertexColor(r, g, b, 1)
      end
    end
  end

  if (frame.updateColor or frame.updateTexture or frame.updateIcon or not frame.tex:GetTexture()) and not frame.texture then
    local r, g, b = str2rgb(frame.color)

    if (frame.title and pfQuest.icons[frame.title]) or frame.icon then
      local texture = (frame.title and pfQuest.icons[frame.title]) or frame.icon
      frame.pic:SetTexture(texture)
      frame.pic:Show()

      if obj == "minimap" then
        local halfsize = pfMap.drawlayer:GetWidth() / 2
        local fade_range = frame.fade_range or 8
        local fade_in = halfsize / 100 * (fade_range - 4)
        local fade_out = halfsize / 100 * (fade_range + 4)
        local alpha = ((distance or fade_out) - fade_in) / (fade_out - fade_in)
        alpha = math.max(alpha, 0)
        alpha = math.min(alpha, 1)
        frame.pic:SetAlpha(alpha)
      end
    else
      frame.pic:Hide()
    end

    if obj == "minimap" and pfQuest_config["cutoutminimap"] == "1" then
      frame.tex:SetTexture(TEX_NODECUT)
      frame.tex:SetVertexColor(r, g, b, 1)
    elseif obj ~= "minimap" and pfQuest_config["cutoutworldmap"] == "1" then
      frame.tex:SetTexture(TEX_NODECUT)
      frame.tex:SetVertexColor(r, g, b, 1)
    else
      frame.tex:SetTexture(TEX_NODE)
      frame.tex:SetVertexColor(r, g, b, 1)
    end
  end

  if frame.updateLayer then
    if obj == "minimap" then
      frame:SetFrameLevel(minimapNodeLevel(frame.layer))
    else
      frame:SetFrameLevel(112 + frame.layer)
    end
  end

  if frame.updateTexture or frame.updateVertex or frame.updateColor or frame.updateLayer or frame.updateIcon then
    frame:SetScript("OnClick", (frame.func or pfMap.NodeClick))
  end

  pfMap:ResizeNode(frame, obj)

  frame.node = node
end

function pfMap:ResizeNode(frame, obj)
  local highlight = frame.texture and pfMap.highlightdb[frame][pfMap.highlight] and true or nil
  local target = frame.texture and pfQuest.route and pfQuest.route.IsTarget(frame) or nil
  local isCluster = frame.cluster or frame.layer == 4
  local isIcon = (frame.title and pfQuest.icons[frame.title]) or frame.icon
  local isWorld = obj ~= "minimap"

  -- Default sizes. Cluster pins stay at a fixed 18 so they remain visually
  -- distinct. Minimap pins use the legacy fixed default. World-map regular
  -- and utility (icon) pins read user-configurable sizes from the options
  -- panel (defined in pfQuest-epoch alongside the continent equivalents).
  if isCluster then
    frame.defsize = 18
  elseif isWorld and isIcon then
    -- icon pins follow the regular world-map size unless the advanced
    -- utility key is set explicitly
    frame.defsize = tonumber(pfQuest_config["worldmapUtilityNodeSize"])
      or tonumber(pfQuest_config["worldmapNodeSize"]) or 14
  elseif isWorld then
    frame.defsize = tonumber(pfQuest_config["worldmapNodeSize"]) or 14
  else
    frame.defsize = tonumber(pfQuest_config["minimapNodeSize"]) or 14
  end

  -- Apply main-map zoom compensation only on the world map. Icons get a
  -- 1 unit padding compensation so they don't shrink to nothing.
  if isWorld then
    if isIcon then
      frame.defsize = (frame.defsize - 2) * mainmap_inversescale + 2
    else
      frame.defsize = frame.defsize * mainmap_inversescale
    end
  end

  -- make the current route target visible
  if target then
    frame.hl:Show()
  else
    frame.hl:Hide()
  end

  -- reset frame size except for highlights
  if not highlight then
    frame:SetWidth(frame.defsize)
    frame:SetHeight(frame.defsize)
  end
end

function pfMap:ResizeNodes()
  if pfMap.pins then
    for i = 1, table.getn(pfMap.pins) do
      pfMap:ResizeNode(pfMap.pins[i])
    end
  end
end

function pfMap:UpdateNodes()
  pfQuest:Debug("Update Nodes")

  local color = pfQuest_config["spawncolors"] == "1" and "spawn" or "title"
  local map = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())

  -- reset tracker and route before the map check so the tracker is always
  -- updated from questlog even when the current zone is not in the database
  -- (e.g. unknown zone, continent view). Without this the tracker frame
  -- stays at 0px height if UpdateNodes only ever fires with map=nil.
  pfQuest.tracker.Reset()
  pfQuest.route:Reset()

  if not map then
    if pfQuest.tracker and pfQuest.tracker.DoLayout then
      pfQuest.tracker.DoLayout()
    end
    return
  end
  local i = 1

  -- refresh all nodes
  local n_pins, n_skipped = 0, 0
  -- hoist map dimensions: same for every pin this call, and if the map
  -- is resized between calls the new values will invalidate cached px/py.
  local mapW = WorldMapButton:GetWidth()
  local mapH = WorldMapButton:GetHeight()
  -- nil on every ordinary map, so this costs one table lookup per call there
  local submap = pfMap:GetSubmap()
  for addon, _ in pairs(pfMap.nodes) do
    if pfMap.nodes[addon][map] then
      for coords, node in pairs(pfMap.nodes[addon][map]) do
        if not pfMap.pins[i] then
          pfMap.pins[i] = pfMap:BuildNode("pfMapPin" .. i, WorldMapButton)
        end

        -- skip UpdateNode if this pin is already bound to this exact node table
        -- and nothing has been added/removed from it since the last UpdateNodes call.
        -- pfMap.dirtyNodes[node] is set by AddNode/DeleteNode on any real write.
        -- frame.node ~= node catches coord-slot shifts from insertions/removals.
        if pfMap.pins[i].node ~= node or pfMap.dirtyNodes[node] then
          pfMap:UpdateNode(pfMap.pins[i], node, color)
          pfMap.dirtyNodes[node] = nil
        else
          n_skipped = n_skipped + 1
        end

        -- set position (use cached coord parse to avoid strfind alloc)
        local x, y
        if coord_cache[coords] then
          x, y = coord_cache[coords][1], coord_cache[coords][2]
        else
          local _, _, strx, stry = strfind(coords, "(.*)|(.*)")
          x, y = strx + 0, stry + 0
          coord_cache[coords] = { x, y }
        end

        -- Reforged: on a sub-map, lift the parent zone's percentages into this
        -- map's own before anything reads them (issue #20). Done here rather
        -- than at the SetPoint below so the route planner gets the converted
        -- values too. Only the LOCALS are rewritten; coord_cache stays in
        -- parent space, which is what every other map expects.
        local onmap = true
        if submap then
          x, y, onmap = pfMap:ToSubmap(submap, x, y)
        end

        -- write points to the route plan
        if
          onmap and (
          (pfQuest_config["routecluster"] == "1" and pfMap.pins[i].layer >= 9)
          or (pfQuest_config["routeender"] == "1" and pfMap.pins[i].layer == 4)
          or (pfQuest_config["routestarter"] == "1" and pfMap.pins[i].layer == 1 and pfMap.pins[i].texture)
          or (pfQuest_config["routestarter"] == "1" and pfMap.pins[i].layer == 2)
          or pfMap.pins[i].arrow == true)
        then
          local watched = nil
          local questid = pfMap.pins[i].questid
          local qdata = questid and pfQuest.questlog and pfQuest.questlog[questid]
          if qdata and qdata.qlogid and IsQuestWatched(qdata.qlogid) then
            watched = true
          end
          -- Route candidates are positional tuples consumed by route.lua:
          -- { x, y, node, distance, watched, questid }.
          pfQuest.route:AddPoint({ x, y, pfMap.pins[i], nil, watched, questid })
        end

        -- a node belonging to the parent zone but lying outside this sub-map
        if not onmap then
          pfMap.pins[i]:Hide()
        -- hide cluster nodes if set
        elseif pfQuest_config["showcluster"] == "0" and pfMap.pins[i].cluster then
          pfMap.pins[i]:Hide()
        -- hide individual quest spawns
        elseif pfQuest_config["showspawn"] == "0" and addon == "PFQUEST" and not pfMap.pins[i].texture then
          pfMap.pins[i]:Hide()
        else
          -- populate quest list on map
          for title, node in pairs(pfMap.pins[i].node) do
            pfQuest.tracker.ButtonAdd(title, node)
          end

          local px = x / 100 * mapW
          local py = y / 100 * mapH

          -- skip layout calls when the pin hasn't moved; ClearAllPoints +
          -- SetPoint are the dominant cost in UpdateNodes for large pin counts
          if pfMap.pins[i].lastX ~= px or pfMap.pins[i].lastY ~= py then
            pfMap.pins[i].lastX = px
            pfMap.pins[i].lastY = py
            pfMap.pins[i]:ClearAllPoints()
            pfMap.pins[i]:SetPoint("CENTER", WorldMapButton, "TOPLEFT", px, -py)
          end

          pfMap.pins[i]:Show()
        end

        n_pins = n_pins + 1
        i = i + 1
      end
    end
  end
  pfQuest:Debug(format("UpdateNodes pins=%d skipped=%d", n_pins, n_skipped))

  -- hide remaining pins
  for j = i, table.getn(pfMap.pins) do
    if pfMap.pins[j] then
      pfMap.pins[j]:Hide()
      pfMap.pins[j].lastX = nil
      pfMap.pins[j].lastY = nil
    end
  end

  -- Perform tracker layout once after all ButtonAdd calls complete
  if pfQuest.tracker and pfQuest.tracker.DoLayout then
    pfQuest.tracker.DoLayout()
  end

  -- record which zone was rendered so WORLD_MAP_UPDATE can skip no-op opens.
  -- The map FILE is recorded too, because a sub-map reports its parent's zone
  -- id: without this, switching between Elwynn Forest and Northshire looks like
  -- "same zone" and the redraw that converts the coordinates never runs.
  pfMap.lastUpdateZone = map
  pfMap.lastUpdateMap = GetMapInfo()
  pfMap.dirtyMaps[map] = nil
  -- map has fully rendered; subsequent zone changes are deliberate user actions
  pfMap.mapJustOpened = nil
end

-- Reforged perf: memoized zone-name -> mapID for the minimap loop (see below).
local mm_zonename, mm_zoneid

function pfMap:UpdateMinimap()
  -- check for disabled minimap nodes
  if pfQuest_config["minimapnodes"] == "0" then
    return
  end

  -- hide all minimap nodes while shift is pressed
  if controlkey.pressed and MouseIsOver(pfMap.drawlayer) then
    this.xPlayer = nil

    for id, pin in pairs(pfMap.mpins) do
      pin:Hide()
    end

    return
  end

  -- hide nodes and skip further processing in dungeons
  local xPlayer, yPlayer = GetPlayerMapPosition("player")
  if xPlayer == 0 and yPlayer == 0 then
    for pins, pin in pairs(pfMap.mpins) do
      pin:Hide()
    end
    return
  end

  local mZoom = pfMap.drawlayer:GetZoom()
  xPlayer, yPlayer = xPlayer * 100, yPlayer * 100

  -- force refresh every second even without changed values, otherwise skip
  if this.xPlayer == xPlayer and this.yPlayer == yPlayer and this.mZoom == mZoom then
    if (this.tick or 1) > GetTime() then
      return
    else
      this.tick = GetTime() + 1
    end
  end

  this.xPlayer, this.yPlayer, this.mZoom = xPlayer, yPlayer, mZoom
  local color = pfQuest_config["spawncolors"] == "1" and "spawn" or "title"
  -- Reforged perf: GetMapIDByName does a linear scan over every zone name in the
  -- DB. This runs ~20x/sec while the player moves (the minimap loop's whole
  -- reason to exist), re-deriving a value that only changes on a zone change.
  -- Memoize by the raw zone-text string so the scan happens once per zone.
  local rz = GetRealZoneText()
  if rz ~= mm_zonename then
    -- ParentZone because the zone TEXT is the subzone's own name while the
    -- player is in a starter zone, and that id holds no coordinates
    mm_zonename, mm_zoneid = rz, pfMap:ParentZone(pfMap:GetMapIDByName(rz))
  end
  local mapID = mm_zoneid

  -- Reforged: while a sub-map is the one being viewed, GetPlayerMapPosition
  -- answers in ITS percentages, but the nodes, the pfDB.minimap rectangle and
  -- the yard scale below are all the parent zone's (issue #20). Lift the player
  -- into the parent, which is the single value that is in the wrong space, and
  -- everything downstream stays as it was.
  --
  -- mapID is corrected too, for the case where the patch also renames the zone
  -- text: normally GetRealZoneText still says "Elwynn Forest" inside Northshire
  -- and the lookup above already answers, but if it ever says "Northshire
  -- Valley" that lookup returns nil and the minimap goes quiet, which is
  -- exactly the failure this issue is about.
  local msub = pfMap:GetSubmap()
  if msub then
    xPlayer, yPlayer = pfMap:FromSubmap(msub, xPlayer, yPlayer)
    mapID = mapID or msub[1]
  end
  -- an addon-driven zoom outside the known levels must not nil-index here: that
  -- would throw out of the loop and leave the minimap blank until a reload
  local zoomrow = minimap_zoom[minimap_indoor()] or minimap_zoom[1]
  local mapZoom = zoomrow[mZoom] or zoomrow[0]
  local mapWidth = minimap_sizes[mapID] and minimap_sizes[mapID][1] or 0
  local mapHeight = minimap_sizes[mapID] and minimap_sizes[mapID][2] or 0

  local xScale = mapZoom / mapWidth
  local yScale = mapZoom / mapHeight

  local xDraw = pfMap.drawlayer:GetWidth() / xScale / 100
  local yDraw = pfMap.drawlayer:GetHeight() / yScale / 100

  -- Reforged perf: the drawlayer is a fixed size for the whole call, so hoist
  -- its half-extents out of the per-node cull check (was 1-2 GetWidth/GetHeight
  -- C-calls per node, per ~20/sec tick while moving).
  local halfW = pfMap.drawlayer:GetWidth() / 2
  local halfH = pfMap.drawlayer:GetHeight() / 2
  -- shape and frame level are per-call properties of the minimap, not per node
  local square = pfUI.minimap or squareminimap()

  -- Reforged: keep the pins above the minimap in the frame-level order. Pins are
  -- children of Minimap and inherit their level from it AT CREATION TIME, but a
  -- UI addon may raise the minimap afterwards (ElvUI sets Minimap frame level 10
  -- during its own init) -- and a child whose level is BELOW its parent renders
  -- behind the parent's own textures, so every pin silently disappears while the
  -- world map keeps working (issue #15). Cheap to keep honest: compare once per
  -- call and only re-level when the minimap actually moved.
  local mlevel = pfMap.drawlayer:GetFrameLevel() or 0
  if pfMap.mlevel ~= mlevel then
    pfMap.mlevel = mlevel
    for _, pin in pairs(pfMap.mpins) do
      pin:SetFrameLevel(minimapNodeLevel(pin.layer))
    end
  end

  local i = 1

  -- refresh all nodes
  for addon, data in pairs(pfMap.nodes) do
    -- hide minimap nodes in continent view
    if data[mapID] and minimap_sizes[mapID] and pfMap:HasMinimap(mapID) then
      for coords, node in pairs(data[mapID]) do
        local x, y
        if coord_cache[coords] then
          x, y = coord_cache[coords][1], coord_cache[coords][2]
        else
          local _, _, strx, stry = strfind(coords, "(.*)|(.*)")
          x, y = strx + 0, stry + 0
          coord_cache[coords] = { x, y }
        end

        local xPos = (x - xPlayer) * xDraw
        local yPos = (y - yPlayer) * yDraw

        if pfQuestCompat.rotateMinimap then
          -- TODO: this part is broken and does not work yet.
          local sinFacing = sin(pfQuestCompat.GetPlayerFacing())
          local cosFacing = cos(pfQuestCompat.GetPlayerFacing())

          local dx, dy = xPos, -yPos
          xPos = (dx * cosFacing) + (dy * sinFacing)
          yPos = -((-dx * sinFacing) + (dy * cosFacing))
        end

        local display = nil
        local distance = sqrt(xPos * xPos + yPos * yPos)

        if square then
          display = (abs(xPos) + 8 < halfW and abs(yPos) + 8 < halfH)
              and true
            or nil
        else
          display = (distance + 8 < halfW) and true or nil
        end

        if display then
          if not pfMap.mpins[i] then
            pfMap.mpins[i] = pfMap:BuildNode(nodename .. i, pfMap.drawlayer)
            pfMap.mpins[i]:SetFrameLevel(minimapNodeLevel(pfMap.mpins[i].layer))
          end

          -- skip expensive UpdateNode work (highlightdb rebuild, node iteration,
          -- size calls) when this pin is already showing the correct node and
          -- nothing has been added or removed from it since the last render.
          -- dirtyNodes is intentionally NOT cleared here: UpdateNodes (world map)
          -- relies on that flag and would skip the re-render if we cleared it now.
          -- The minimap's own cache guard (mpins[i].node ~= node) handles staleness
          -- independently, so dirtyNodes cleanup is left to UpdateNodes.
          if pfMap.mpins[i].node ~= node or pfMap.dirtyNodes[node] then
            pfMap:UpdateNode(pfMap.mpins[i], node, color, "minimap", distance)
          end

          pfMap.mpins[i].hl:Hide()

          if pfQuest_config["showclustermini"] == "0" and pfMap.mpins[i].cluster then
            pfMap.mpins[i]:Hide()
          elseif pfQuest_config["showspawnmini"] == "0" and addon == "PFQUEST" and not pfMap.mpins[i].texture then
            pfMap.mpins[i]:Hide()
          else
            pfMap.mpins[i]:ClearAllPoints()
            pfMap.mpins[i]:SetPoint("CENTER", pfMap.drawlayer, "CENTER", xPos, -yPos)
            pfMap.mpins[i]:Show()
          end

          i = i + 1
        end
      end
    end
  end

  -- hide remaining pins
  for j = i, table.getn(pfMap.mpins) do
    if pfMap.mpins[j] then
      pfMap.mpins[j]:Hide()
    end
  end
end

local zone
pfMap:RegisterEvent("ZONE_CHANGED")
pfMap:RegisterEvent("ZONE_CHANGED_NEW_AREA")
pfMap:RegisterEvent("MINIMAP_ZONE_CHANGED")
pfMap:RegisterEvent("PLAYER_ENTERING_WORLD")
pfMap:RegisterEvent("WORLD_MAP_UPDATE")
pfMap:SetScript("OnEvent", function()
  -- save current zone
  zone = GetCurrentMapZone()

  -- set map to current zone when possible
  if event == "ZONE_CHANGED" or event == "MINIMAP_ZONE_CHANGED"
     or event == "ZONE_CHANGED_NEW_AREA" or event == "PLAYER_ENTERING_WORLD" then
    if not WorldMapFrame:IsShown() then
      SetMapToCurrentZone()
      -- Cache the player's physical zone while the map is synced to it.
      -- GetMapID is safe here because SetMapToCurrentZone() was just called.
      pfMap.playerZone = pfMap:ParentZone(pfMap:GetMapIDByName(GetRealZoneText()))
        or pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())
    else
      -- Map is open; only trust GetRealZoneText() which reads physical zone.
      -- GetMapID would return the user-browsed zone, not the player's.
      pfMap.playerZone = pfMap:ParentZone(pfMap:GetMapIDByName(GetRealZoneText()))
    end

    -- Mode 5: refresh tracker from player's physical zone,
    -- independent of UpdateNodes (which may not run in instances)
    if pfQuest and pfQuest.tracker and pfQuest.tracker.RefreshZoneTracker then
      pfQuest.tracker.RefreshZoneTracker()
    end
  end

  -- update nodes on world map changes.
  -- Three distinct cases:
  -- (1) Map just opened (burst of ~100 events while frame renders): use the
  --     debounce to coalesce them into one call once rendering settles.
  -- (2) Zone changed by user (deliberate click): call UpdateNodes immediately.
  -- (3) Continent view (newzone == nil): hide all pins immediately.
  -- (4) Same zone, dirty nodes: stamp debounce.
  if event == "WORLD_MAP_UPDATE" then
    local newzone = pfMap:GetMapID(GetCurrentMapContinent(), GetCurrentMapZone())

    if newzone == nil then
      -- continent view: hide all worldmap pins and route lines immediately
      for j = 1, table.getn(pfMap.pins) do
        if pfMap.pins[j] then
          pfMap.pins[j]:Hide()
        end
      end
      if pfQuest and pfQuest.route and pfQuest.route.drawlayer then
        pfQuest.route.drawlayer:Hide()
      end
      pfMap.lastUpdateZone = nil
      pfMap.lastUpdateMap = nil
    elseif pfMap.mapJustOpened then
      -- map just opened on a zone: ensure route layer is visible and debounce
      if pfQuest and pfQuest.route and pfQuest.route.drawlayer then
        pfQuest.route.drawlayer:Show()
      end
      pfMap.queue_update = GetTime()
    elseif newzone ~= pfMap.lastUpdateZone or GetMapInfo() ~= pfMap.lastUpdateMap then
      -- deliberate zone change: update immediately, no debounce. The map file is
      -- compared as well as the zone id, so moving between a sub-map and its
      -- parent counts as a change even though both answer with the same id.
      if pfQuest and pfQuest.route and pfQuest.route.drawlayer then
        pfQuest.route.drawlayer:Show()
      end
      pfMap.queue_update = nil
      pfMap:UpdateNodes()
    elseif pfMap.dirtyMaps[newzone] then
      -- same zone, pending writes: coalesce via debounce
      pfMap.queue_update = GetTime()
    end
  end
end)

local hlstate, shiftstate, transition, hidecluster, fps, resetmap
pfMap:SetScript("OnUpdate", function()
  -- handle highlights and animations
  if pfMap.queue_update or transition or pfMap.highlight ~= hlstate or shiftstate ~= hidecluster then
    hlstate, shiftstate, transition = pfMap.highlight, hidecluster, nil
    fps = math.max(0.2, GetFramerate() / 30)

    for frame, data in pairs(pfMap.highlightdb) do
      local highlight = pfMap.highlightdb[frame][pfMap.highlight] and true or nil

      if hidecluster and frame.cluster then
        -- hide clusters
        transition = frame:Animate(frame.defsize, 0, fps) or transition
      elseif highlight then
        -- zoom node
        transition = frame:Animate((frame.texture and frame.defsize + 4 or frame.defsize), 1, fps) or transition
      elseif not highlight and pfMap.highlight then
        -- fade node
        transition = frame:Animate(frame.defsize, tonumber(pfQuest_config["nodefade"]) or 0.3, fps) or transition
      elseif frame.texture or frame.cluster then
        -- defaults for textured nodes
        transition = frame:Animate(frame.defsize, 1, fps) or transition
      else
        -- defaults
        transition = frame:Animate(frame.defsize, frame.defalpha, fps) or transition
      end
    end
  end

  -- limit all map updates to once per .05 seconds
  if (this.throttle or 0.2) > GetTime() then
    return
  else
    this.throttle = GetTime() + 0.05
  end

  -- process node updates if required
  if pfMap.queue_update and pfMap.queue_update + 0.25 < GetTime() then
    -- don't fire while the quest system still has work pending: each queue entry
    -- and SearchQuests/UpdateQuestlog call will push queue_update to a newer time,
    -- so the debounce will settle naturally once the whole batch is done.
    -- This prevents UpdateNodes from firing between queue entries when a prior
    -- queue_update stamp happens to be 0.25s old mid-drain.
    local questBusy = pfQuest and ((pfQuest.queueCount or 0) > 0 or pfQuest.updateQuestGivers or pfQuest.updateQuestLog)
    if not questBusy then
      pfMap.queue_update = nil
      pfMap:UpdateNodes()
      -- Mode 5: refresh tracker after quest nodes are rebuilt.
      -- Runs even when UpdateNodes exits early (e.g. instances).
      if pfQuest and pfQuest.tracker and pfQuest.tracker.RefreshZoneTracker then
        pfQuest.tracker.RefreshZoneTracker()
      end
    end
  end

  -- reset map to current zone once map is closed
  -- also flag the frame as just-opened so the WORLD_MAP_UPDATE handler
  -- knows to use the debounce instead of calling UpdateNodes immediately
  -- (the burst of ~100 events during map-open rendering would otherwise
  -- trigger multiple immediate UpdateNodes calls)
  if WorldMapFrame:IsShown() then
    if not resetmap then
      pfMap.mapJustOpened = true
    end
    resetmap = true
  elseif resetmap == true then
    SetMapToCurrentZone()
    resetmap = nil
  end

  -- refresh minimap
  pfMap:UpdateMinimap()

  -- update hidecluster detection
  if controlkey.pressed then
    hidecluster = MouseIsOver(WorldMapFrame)
  else
    hidecluster = nil
  end
end)

-- only hook for 3.3.5
if compat.client >= 30300 then
  -- Initialize a variable to track the previous clicked title
  local previousTitle = nil
  -- Highlight Map Quest Log Selection Nodes
  local pfHookWorldMapQuestFrame_OnMouseUp = WorldMapQuestFrame_OnMouseUp
  WorldMapQuestFrame_OnMouseUp = function(self)
    pfHookWorldMapQuestFrame_OnMouseUp(self)
    WorldMapBlobFrame:Hide()
    WorldMapFrame_ClearQuestPOIs()
    if not IsShiftKeyDown() then
      pfMap.highlight = nil
      local questLogIndex = GetQuestLogSelection()
      local title = GetQuestLogTitle(questLogIndex)

      if title then
        if previousTitle == title then
          -- Reset the highlight if the same title is clicked again
          pfMap.highlight = nil
          previousTitle = nil
        else
          -- Logic for highlighting nodes associated with the clicked quest
          pfMap.highlight = title
          previousTitle = title
          pfMap.queue_update = GetTime()
        end
      end
    end
  end
end

-- Recompute mainmap_inversescale from local scales when DetailFrame or
-- Button is rescaled. Also keep WorldMapTooltip's scale in sync with the
-- current map mode so Blizzard's tooltip (parent = WorldMapFrame, never
-- scaled by the mode toggles) shrinks together with windowed/questlist mode.
function pfMap:OnMapScaleChanged(frame, scale, hookedfunction)
  hookedfunction(frame, scale)

  local dl = WorldMapDetailFrame:GetScale()
  local bl = WorldMapButton and WorldMapButton:GetScale() or 0
  if dl <= 0 or bl <= 0 then return end

  local new_inversescale = bl / dl
  if math.abs(new_inversescale - mainmap_inversescale) > 0.001 then
    mainmap_inversescale = new_inversescale
    pfMap:ResizeNodes()
  end

  if WorldMapTooltip and WORLDMAP_SETTINGS then
    local target = WORLDMAP_SETTINGS.size or 1.0
    if math.abs(WorldMapTooltip:GetScale() - target) > 0.001 then
      WorldMapTooltip:SetScale(target)
    end
  end
end

-- Hook DetailFrame and WorldMapButton scale changes. In 3.3.5 Blizzard's mode
-- toggles (WorldMap_ToggleSizeDown/Up, SetFullMapView, SetQuestMapView, OnLoad)
-- scale BOTH frames in sequence: DetailFrame:SetScale(x) then
-- WorldMapButton:SetScale(x). After both fire, the local ratio is 1.0 (any
-- stale intermediate ratio latched by the first hook is replaced by the
-- second). Magnify scales DetailFrame independently while keeping
-- WorldMapButton.local = 1, so the DetailFrame hook alone catches zoom.
local pfHookWorldMapDetailFrame_SetScale = WorldMapDetailFrame.SetScale
WorldMapDetailFrame.SetScale = function(frame, scale) pfMap:OnMapScaleChanged(frame, scale, pfHookWorldMapDetailFrame_SetScale) end

local pfHookWorldMapButton_SetScale = WorldMapButton.SetScale
WorldMapButton.SetScale = function(frame, scale) pfMap:OnMapScaleChanged(frame, scale, pfHookWorldMapButton_SetScale) end