UI.lua

local addonName, BBT = ...
BBT = BBT or _G.BigBotTracker or {}
_G.BigBotTracker = BBT

BBT.UI = BBT.UI or {}

local UI = BBT.UI
local Util = BBT.Util
local Storage = BBT.Storage
local Report = BBT.Report

local function createFrame(frameType, name, parent, template, fallbackTemplates)
    if BBT.Compat and BBT.Compat.CreateFrame then
        return BBT.Compat.CreateFrame(frameType, name, parent, template, fallbackTemplates)
    end
    return CreateFrame(frameType, name, parent, template)
end

local FRAME_NAME = "BigBotTrackerFrame"
local REPORT_ASSIST_FRAME_NAME = "BigBotTrackerReportAssistFrame"
local ADDON_ICON_TEXTURE = "Interface\\AddOns\\BigBotTracker\\logo"
local FRAME_WIDTH = 1180
local FRAME_HEIGHT = 900
local REPORT_ASSIST_WIDTH = 520
local REPORT_ASSIST_HEIGHT = 420
local OUTER_MARGIN = 20
local TABLE_CONTENT_WIDTH = 1120
local TABLE_VIEW_WIDTH = 1120
local WINDOW_ICON_SIZE = 66
local HEADER_ICON_GAP = 24
local HEADER_CONTENT_WIDTH = TABLE_VIEW_WIDTH - WINDOW_ICON_SIZE - HEADER_ICON_GAP
local HEADER_ICON_RIGHT = OUTER_MARGIN + TABLE_VIEW_WIDTH - FRAME_WIDTH
local HEADER_ICON_TOP = -40
local TABLE_HEIGHT = 244
local ROW_HEIGHT = 22
local HEADER_HEIGHT = 24
local TITLE_TOP = -36
local SUBTITLE_TOP = -64
local STATUS_TOP = -98
local FILTER_TOP = -128
local HEADER_TOP = -158
local TABLE_TOP = -184
local DETAIL_TITLE_TOP = -440
local DETAIL_TOP = -476
local REASONS_TOP = DETAIL_TOP - 250
local DETAIL_TITLE_MAX_WIDTH = 520
local DETAIL_TITLE_BUTTON_GAP = 12

local frame
local tableScroll
local tableContent
local emptyState
local headerButtons = {}
local filterButtons = {}
local channelDropdownButton
local channelDropdownMenu
local channelDropdownButtons = {}
local rows = {}
local detail = {}
local reportAssistFrame
local selectedCandidate
local selectedKey
local dirty = false
local dirtyReason = nil
local dirtyElapsed = 0
local passiveElapsed = 0
local statusElapsed = 0
local refreshCount = 0

local DIRTY_REFRESH_SECONDS = 0.5
local PASSIVE_REFRESH_SECONDS = 5
local STATUS_REFRESH_SECONDS = 1

local statusRank = {
    Observing = 0,
    ["Peer Context Only"] = 0,
    ["Early Pattern"] = 1,
    ["Repeated Pattern"] = 2,
    ["Strong Pattern"] = 3,
    ["Very Strong Pattern"] = 4,
}

local sourceRank = {
    Local = 1,
    Net = 2,
    ["L+N"] = 3,
}

local filters = {
    { key = "all", label = "All", tooltip = "Show every stored candidate." },
    { key = "active", label = "Active", tooltip = "Show unhandled candidates and watched candidates." },
    { key = "watched", label = "Watched", tooltip = "Show watched candidates only." },
    { key = "reported", label = "Reported", tooltip = "Show candidates marked reported." },
    { key = "ignored", label = "Ignored", tooltip = "Show ignored candidates." },
}

local columns = {
    {
        key = "watch",
        label = "",
        width = 36,
        align = "CENTER",
        sortable = false,
        tooltip = "Eye button for keeping a candidate visible in the clean Active view.",
    },
    {
        key = "status",
        label = "Status",
        width = 150,
        align = "LEFT",
        defaultDescending = true,
        tooltip = "Plain-language evidence status derived from local observed patterns.",
    },
    {
        key = "character",
        label = "Character-Realm",
        width = 160,
        align = "LEFT",
        defaultDescending = false,
        tooltip = "Tracked character and realm. Same names on different realms are kept separate.",
    },
    {
        key = "signals",
        label = "Observed Signals",
        width = 280,
        align = "LEFT",
        defaultDescending = true,
        tooltip = "Short summary of the local patterns that caused the candidate to appear.",
    },
    {
        key = "messages",
        label = "Msgs",
        width = 48,
        align = "RIGHT",
        defaultDescending = true,
        tooltip = "Total locally observed messages for this candidate.",
    },
    {
        key = "cadence",
        label = "Cadence",
        width = 178,
        align = "LEFT",
        defaultDescending = true,
        tooltip = "Player-friendly timing pattern. Hover rows for interval details.",
    },
    {
        key = "reuse",
        label = "Text Reuse",
        width = 70,
        align = "RIGHT",
        defaultDescending = true,
        tooltip = "Percent of messages matching the most reused normalized template.",
    },
    {
        key = "lastSeen",
        label = "Last Seen",
        width = 110,
        align = "LEFT",
        defaultDescending = true,
        tooltip = "Most recent monitored-channel message or network sighting.",
    },
    {
        key = "source",
        label = "Src",
        width = 52,
        align = "LEFT",
        defaultDescending = true,
        tooltip = "Local, network, or combined evidence source.",
    },
}

local columnIndexByKey = {}
for index, column in ipairs(columns) do
    columnIndexByKey[column.key] = index
end

local statusColors = {
    ["Very Strong Pattern"] = { 1.00, 0.28, 0.18 },
    ["Strong Pattern"] = { 1.00, 0.58, 0.16 },
    ["Repeated Pattern"] = { 1.00, 0.84, 0.16 },
    ["Early Pattern"] = { 0.56, 0.78, 1.00 },
    ["Peer Context Only"] = { 0.66, 0.78, 1.00 },
    Observing = { 0.66, 0.66, 0.66 },
}

local cadenceColors = {
    ["Fixed Cadence"] = { 1.00, 0.34, 0.22 },
    ["Dominant Active-Run Cadence"] = { 1.00, 0.44, 0.20 },
    ["Jittered Cadence"] = { 1.00, 0.56, 0.22 },
    ["Mixed Cadence"] = { 1.00, 0.64, 0.20 },
    ["Burst Pattern"] = { 1.00, 0.76, 0.28 },
    Variable = { 0.70, 0.82, 1.00 },
    Sparse = { 0.60, 0.60, 0.60 },
}

local cadenceRank = {
    Sparse = 0,
    Variable = 1,
    ["Burst Pattern"] = 2,
    ["Jittered Cadence"] = 3,
    ["Dominant Active-Run Cadence"] = 4,
    ["Mixed Cadence"] = 5,
    ["Fixed Cadence"] = 6,
}

local function createFont(parent, layer, template, point, relativeTo, relativePoint, x, y)
    local font = parent:CreateFontString(nil, layer or "OVERLAY", template or "GameFontHighlightSmall")
    font:SetPoint(point, relativeTo or parent, relativePoint or point, x or 0, y or 0)
    font:SetJustifyH("LEFT")
    return font
end

local function createButton(parent, text, width, height)
    local button = createFrame("Button", nil, parent, "UIPanelButtonTemplate")
    button.width = width or 96
    button.height = height or 22
    button:SetSize(button.width, button.height)
    button:SetText(text)
    return button
end

local function addDivider(parent, x, y, width)
    local divider = parent:CreateTexture(nil, "ARTWORK")
    divider:SetPoint("TOPLEFT", parent, "TOPLEFT", x, y)
    divider:SetSize(width, 1)
    divider:SetColorTexture(1, 0.82, 0, 0.28)
    return divider
end

local function setTextColor(font, color)
    if font and font.SetTextColor and color then
        font:SetTextColor(color[1], color[2], color[3])
    end
end

local function setShown(widget, shown)
    if not widget then
        return
    end
    if widget.SetShown then
        widget:SetShown(shown)
    elseif shown then
        widget:Show()
    else
        widget:Hide()
    end
end

local function raiseFrame()
    if frame and frame.Raise then
        frame:Raise()
    end
end

local function registerSpecialFrame(targetFrameName)
    if type(UISpecialFrames) ~= "table" then
        return
    end

    for _, registeredFrameName in ipairs(UISpecialFrames) do
        if registeredFrameName == targetFrameName then
            return
        end
    end

    table.insert(UISpecialFrames, targetFrameName)
end

local function registerEscapeClose()
    registerSpecialFrame(FRAME_NAME)
end

local function bindTooltip(owner, title, lines)
    owner:SetScript("OnEnter", function(self)
        if not GameTooltip then
            return
        end

        GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
        GameTooltip:AddLine(title, 1, 1, 1)

        local tooltipLines = type(lines) == "function" and lines(self) or lines
        for _, line in ipairs(tooltipLines or {}) do
            if type(line) == "table" then
                GameTooltip:AddLine(line.text or "", line.r or 0.85, line.g or 0.85, line.b or 0.85, true)
            else
                GameTooltip:AddLine(tostring(line), 0.85, 0.85, 0.85, true)
            end
        end

        GameTooltip:Show()
    end)
    owner:SetScript("OnLeave", function()
        if GameTooltip then
            GameTooltip:Hide()
        end
    end)
end

local isSortableColumnKey

local function getSettingsUi()
    local settings = Storage.GetSettings()
    settings.ui = settings.ui or {}
    settings.ui.sortKey = settings.ui.sortKey or "status"
    if not isSortableColumnKey(settings.ui.sortKey) then
        settings.ui.sortKey = "status"
    end
    if settings.ui.sortDescending == nil then
        settings.ui.sortDescending = true
    end
    settings.ui.filterKey = settings.ui.filterKey or "active"
    if settings.ui.channelFilter ~= nil and Util.Trim(settings.ui.channelFilter) == "" then
        settings.ui.channelFilter = nil
    end
    return settings.ui
end

local function isValidFilterKey(key)
    for _, filter in ipairs(filters) do
        if filter.key == key then
            return true
        end
    end
    return false
end

isSortableColumnKey = function(key)
    for _, column in ipairs(columns) do
        if column.key == key then
            return column.sortable ~= false
        end
    end
    return false
end

local function isCandidateWatched(candidate)
    return Storage.IsCandidateWatched and Storage.IsCandidateWatched(candidate) or false
end

local function isCandidateReported(candidate)
    return Storage.IsCandidateReported and Storage.IsCandidateReported(candidate) or false
end

local function isCandidateIgnored(candidate)
    return Storage.IsCandidateIgnored and Storage.IsCandidateIgnored(candidate) or false
end

local function isCandidateHandled(candidate)
    return Storage.IsCandidateHandled and Storage.IsCandidateHandled(candidate) or false
end

local function getTriageSummary(candidate)
    local parts = {}
    if isCandidateWatched(candidate) then
        parts[#parts + 1] = "Watched"
    end
    if isCandidateReported(candidate) then
        parts[#parts + 1] = "Reported"
    end
    if isCandidateIgnored(candidate) then
        parts[#parts + 1] = "Ignored"
    end
    return #parts > 0 and table.concat(parts, ", ") or "Active"
end

local function candidateMatchesFilter(candidate, filterKey)
    filterKey = isValidFilterKey(filterKey) and filterKey or "active"
    if filterKey == "all" then
        return true
    end
    if filterKey == "watched" then
        return isCandidateWatched(candidate)
    end
    if filterKey == "reported" then
        return isCandidateReported(candidate)
    end
    if filterKey == "ignored" then
        return isCandidateIgnored(candidate)
    end
    return isCandidateWatched(candidate) or not isCandidateHandled(candidate)
end

local function truncateChannelName(channelName, maxLength)
    channelName = tostring(channelName or "")
    maxLength = maxLength or 28
    if #channelName <= maxLength then
        return channelName
    end
    return channelName:sub(1, math.max(1, maxLength - 3)) .. "..."
end

local function candidateMatchesChannel(candidate, channelFilter)
    if not channelFilter or channelFilter == "" then
        return true
    end

    local channels = candidate and candidate.channels or nil
    return type(channels) == "table" and (channels[channelFilter] or 0) > 0
end

function UI.GetChannelFilterOptions(candidates)
    local seen = {}
    for _, candidate in ipairs(candidates or {}) do
        for channelName, count in pairs(candidate.channels or {}) do
            if type(channelName) == "string" and channelName ~= "" and (tonumber(count) or 0) > 0 then
                seen[channelName] = true
            end
        end
    end
    return Util.TableKeysSorted(seen)
end

local function channelOptionExists(channelName, options)
    if not channelName or channelName == "" then
        return true
    end
    for _, option in ipairs(options or {}) do
        if option == channelName then
            return true
        end
    end
    return false
end

local function validateChannelFilter(uiSettings, candidates)
    local channelFilter = uiSettings and uiSettings.channelFilter or nil
    if not channelFilter or channelFilter == "" then
        if uiSettings then
            uiSettings.channelFilter = nil
        end
        return nil, UI.GetChannelFilterOptions(candidates)
    end

    local options = UI.GetChannelFilterOptions(candidates)
    if not channelOptionExists(channelFilter, options) then
        uiSettings.channelFilter = nil
        return nil, options
    end

    return channelFilter, options
end

local function getSourceMarker(candidate)
    local hasLocal = (candidate.totalMessages or 0) > 0
    local peerCount = candidate.network and candidate.network.peerCount or 0
    if hasLocal and peerCount > 0 then
        return "L+N"
    end
    if peerCount > 0 then
        return "Net"
    end
    return "Local"
end

local function getEvidenceSourceText(candidate)
    local marker = getSourceMarker(candidate)
    if marker == "L+N" then
        return "Local + peer"
    end
    if marker == "Net" then
        return "Peer only"
    end
    return "Local only"
end

local function formatLastSeen(candidate)
    if not candidate.lastSeen or candidate.lastSeen <= 0 then
        return "-"
    end
    local age = Util.GetNow() - candidate.lastSeen
    if age < 86400 then
        return Util.FormatDuration(age) .. " ago"
    end
    return Util.FormatTimestamp(candidate.lastSeen)
end

local function formatFirstSeen(candidate)
    return Util.FormatTimestamp(candidate.firstSeen)
end

local function formatPercentForDisplay(value, count)
    value = tonumber(value) or 0
    if (count or 0) > 0 and value < 1 then
        return "<1%"
    end
    return tostring(math.floor(value + 0.5)) .. "%"
end

local function topBucketsText(candidate)
    local buckets = candidate and candidate.timing and candidate.timing.dominantBuckets or {}
    local parts = {}
    for _, bucket in ipairs(buckets) do
        local count = bucket.count or 0
        local percent = bucket.percent or 0
        if percent >= 1 or count >= 2 then
            parts[#parts + 1] =
                string.format("~%ds %s (%d)", bucket.bucket or 0, formatPercentForDisplay(percent, count), count)
        end
        if #parts >= 3 then
            break
        end
    end
    return #parts > 0 and table.concat(parts, ", ") or "-"
end

local function phasesText(candidate)
    local phases = candidate and candidate.timing and candidate.timing.cadencePhases or {}
    if #phases == 0 then
        return "-"
    end

    local groups = {}
    local byBucket = {}
    for index, phase in ipairs(phases) do
        local bucket = phase.bucket or 0
        local group = byBucket[bucket]
        local duration = phase.duration or ((phase.endTime or 0) - (phase.startTime or 0))
        if not group then
            group = {
                bucket = bucket,
                firstIndex = index,
                count = 0,
                duration = 0,
                longestDuration = 0,
                runCount = 0,
            }
            byBucket[bucket] = group
            groups[#groups + 1] = group
        end
        group.count = group.count + (phase.count or 0)
        group.duration = group.duration + math.max(0, duration or 0)
        group.longestDuration = math.max(group.longestDuration or 0, duration or 0)
        group.runCount = group.runCount + 1
    end

    table.sort(groups, function(left, right)
        return (left.firstIndex or 0) < (right.firstIndex or 0)
    end)

    local parts = {}
    for index = 1, math.min(2, #groups) do
        local group = groups[index]
        if (group.runCount or 0) > 1 then
            parts[#parts + 1] = string.format(
                "~%ds across %d runs; longest %s",
                group.bucket or 0,
                group.runCount or 0,
                Util.FormatDuration(group.longestDuration or 0)
            )
        else
            parts[#parts + 1] =
                string.format("~%ds for %s", group.bucket or 0, Util.FormatDuration(group.duration or 0))
        end
    end
    if #groups > 2 then
        parts[#parts + 1] = "+" .. tostring(#groups - 2) .. " more"
    end
    return table.concat(parts, ", ")
end

local function getPeakPostsPerHour(candidate)
    local behavior = candidate and candidate.behavior or {}
    local timing = candidate and candidate.timing or {}
    local rate = behavior.postsPerHour or 0
    for _, summary in pairs(timing.windowSummaries or {}) do
        rate = math.max(rate, summary.postsPerHour or 0)
    end
    return rate
end

local function rateText(candidate)
    local average = candidate and candidate.behavior and candidate.behavior.postsPerHour or 0
    local peak = getPeakPostsPerHour(candidate)
    if peak >= average + 1 then
        return string.format("avg %s/hr; peak %s/hr", Util.FormatNumber(average, 1), Util.FormatNumber(peak, 1))
    end
    return Util.FormatNumber(average, 1) .. "/hr"
end

local function joinSummaryPhrases(phrases)
    if #phrases == 0 then
        return "limited local signals"
    end
    if #phrases == 1 then
        return phrases[1]
    end
    if #phrases == 2 then
        return phrases[1] .. " and " .. phrases[2]
    end
    return phrases[1] .. ", " .. phrases[2] .. ", and " .. phrases[3]
end

local function addSummaryPhrase(phrases, text)
    if text and text ~= "" and #phrases < 3 then
        phrases[#phrases + 1] = text
    end
end

local function getStatus(candidate)
    local score = candidate and candidate.score or {}
    local status = score.status or score.tier or "Observing"
    if status == "Critical" then
        return "Very Strong Pattern"
    elseif status == "High" then
        return "Strong Pattern"
    elseif status == "Medium" then
        return "Repeated Pattern"
    elseif status == "Low" then
        return "Early Pattern"
    elseif status == "Preliminary" then
        return "Peer Context Only"
    elseif status == "Insufficient Data" then
        return "Observing"
    end
    return status
end

local function getStatusReason(candidate)
    local score = candidate and candidate.score or {}
    local reasons = score.statusCapReasons
        or (candidate and candidate.features and candidate.features.statusCapReasons)
        or {}
    if type(reasons) == "table" and #reasons > 0 then
        return table.concat(reasons, "; ")
    end

    local status = getStatus(candidate)
    if status == "Very Strong Pattern" then
        return "multiple local signal types agree"
    elseif status == "Strong Pattern" then
        return "multiple local signal types agree"
    elseif status == "Repeated Pattern" then
        return "a repeated local pattern is clear enough to review"
    elseif status == "Early Pattern" then
        return "evidence is still limited"
    elseif status == "Peer Context Only" then
        return "this client has no local evidence"
    end
    return "not enough local evidence yet"
end

local function collectSignalPhrases(candidate, includePeer)
    local phrases = {}
    local timing = candidate and candidate.timing or {}
    local content = candidate and candidate.content or {}
    local baseline = candidate and candidate.baseline or {}
    local network = candidate and candidate.network or {}

    local templateReuse = content.templateReusePercent or 0
    local shingleReuse = content.shingleReusePercent or 0
    if templateReuse >= 80 then
        addSummaryPhrase(phrases, string.format("%d%% same text", math.floor(templateReuse + 0.5)))
    elseif templateReuse >= 60 then
        addSummaryPhrase(phrases, "repeated text")
    elseif shingleReuse >= 75 then
        addSummaryPhrase(phrases, string.format("%d%% similar wording", math.floor(shingleReuse + 0.5)))
    end

    local cadence = UI.GetCadenceDisplay(candidate)
    local topBucket = timing.dominantBuckets and timing.dominantBuckets[1]
    local interval = topBucket and topBucket.bucket or timing.medianInterval or timing.averageInterval or 0
    if cadence.label == "Fixed Cadence" and interval > 0 then
        addSummaryPhrase(phrases, string.format("fixed ~%ds cadence", math.floor(interval + 0.5)))
    elseif cadence.label == "Dominant Active-Run Cadence" and interval > 0 then
        addSummaryPhrase(phrases, string.format("dominant ~%ds active-run cadence", math.floor(interval + 0.5)))
    elseif cadence.label == "Mixed Cadence" then
        addSummaryPhrase(phrases, "mixed stable cadences")
    elseif cadence.label == "Jittered Cadence" then
        addSummaryPhrase(phrases, "jittered repeat cadence")
    elseif cadence.label == "Burst Pattern" then
        addSummaryPhrase(phrases, "burst-heavy activity")
    end

    local peakRate = getPeakPostsPerHour(candidate)
    if peakRate >= 30 then
        addSummaryPhrase(phrases, string.format("peak %s/hr", Util.FormatNumber(peakRate, 0)))
    end

    if (baseline.sampleCount or 0) >= 50 then
        if (baseline.regularityPercentile or 0) >= 95 then
            addSummaryPhrase(phrases, "timing above local baseline")
        elseif (baseline.postsPerHourPercentile or 0) >= 95 then
            addSummaryPhrase(phrases, "rate above local baseline")
        elseif (baseline.templateReusePercentile or 0) >= 95 then
            addSummaryPhrase(phrases, "reuse above local baseline")
        end
    end

    local dayCount = Util.CountMap(candidate and candidate.daysSeen)
    if dayCount >= 2 then
        addSummaryPhrase(phrases, string.format("%d days observed", dayCount))
    end

    if includePeer and (network.peerCount or 0) > 0 then
        addSummaryPhrase(phrases, string.format("%d peer clients", network.peerCount or 0))
    end

    return phrases
end

function UI.BuildObservedSignals(candidate)
    if not candidate then
        return "-"
    end
    local phrases = collectSignalPhrases(candidate, false)
    if
        #phrases == 0
        and (candidate.totalMessages or 0) == 0
        and candidate.network
        and (candidate.network.peerCount or 0) > 0
    then
        return "peer context only"
    end
    if #phrases == 0 then
        return "collecting local evidence"
    end
    return table.concat(phrases, " + ")
end

function UI.BuildEvidenceSummary(candidate)
    if not candidate then
        return "Select a row to view structured local and peer evidence."
    end

    local status = getStatus(candidate)
    local network = candidate.network or {}
    local peerCount = network.peerCount or 0
    local localMessages = candidate.totalMessages or 0

    if status == "Peer Context Only" or (localMessages == 0 and peerCount > 0) then
        return "Observed: peer clients shared compact evidence. Meaning: this is informational peer context only. Why this status: this client has no local evidence."
    end

    if status == "Observing" then
        return string.format(
            "Observed: %d local messages. Meaning: not enough local evidence for a clear repeated pattern yet. Why this status: %s.",
            localMessages,
            getStatusReason(candidate)
        )
    end

    local phrases = collectSignalPhrases(candidate, true)
    return string.format(
        "Observed: %s. Meaning: %s. Why this status: %s.",
        joinSummaryPhrases(phrases),
        status == "Early Pattern" and "early repeated chat behavior is present"
            or "this repeated chat pattern is worth reviewing",
        getStatusReason(candidate)
    )
end

local function getIntervalCount(candidate)
    local timing = candidate and candidate.timing or {}
    return timing.intervalCount or #(timing.intervals or {})
end

function UI.GetCadenceDisplay(candidate)
    local timing = candidate and candidate.timing or {}
    local intervalCount = getIntervalCount(candidate)
    local buckets = timing.dominantBuckets or {}
    local topBucket = buckets[1]
    local topBucketPercent = topBucket and (topBucket.percent or 0) or 0
    local rollingEntropy = timing.lowestRollingEntropy
    local globalEntropy = timing.globalEntropy
    local cadenceSwitches = timing.cadenceSwitchCount or 0
    local phaseCount = #(timing.cadencePhases or {})
    local averageInterval = timing.averageInterval or 0
    local medianInterval = timing.medianInterval or 0
    local hasGapOutliers = medianInterval > 0 and averageInterval > (medianInterval * 1.5)
    local label = timing.cadenceClass or "Variable"

    if label == "Very Regular" then
        label = "Fixed Cadence"
    elseif label == "Regular" then
        label = "Jittered Cadence"
    elseif label == "Dominant Cadence" then
        label = "Dominant Active-Run Cadence"
    elseif label == "Mixed Regular" then
        label = "Mixed Cadence"
    elseif label == "Burst-Only" then
        label = "Burst Pattern"
    elseif intervalCount < 3 then
        label = "Sparse"
    elseif not cadenceRank[label] then
        if cadenceSwitches > 0 and phaseCount >= 2 then
            label = "Mixed Cadence"
        elseif
            topBucketPercent >= 95
            and (rollingEntropy or 1) <= 0.25
            and (globalEntropy or 1) <= 0.25
            and not hasGapOutliers
        then
            label = "Fixed Cadence"
        elseif topBucketPercent >= 75 and (rollingEntropy or 1) <= 0.25 then
            label = "Dominant Active-Run Cadence"
        elseif topBucketPercent >= 55 and (rollingEntropy or 1) <= 0.45 then
            label = "Jittered Cadence"
        else
            label = "Variable"
        end
    elseif label == "" then
        label = "Variable"
    end

    local tooltip = {}
    tooltip[#tooltip + 1] = string.format("Timing samples: %d", intervalCount)
    tooltip[#tooltip + 1] = string.format("Timing entropy: %.2f", rollingEntropy or 1)
    tooltip[#tooltip + 1] = string.format("Global entropy: %.2f", globalEntropy or 1)
    tooltip[#tooltip + 1] = string.format("Interval variation: %.2f", timing.robustCoefficientVariation or 1)
    tooltip[#tooltip + 1] = string.format("Median interval: %s", Util.FormatDuration(timing.medianInterval or 0))
    tooltip[#tooltip + 1] = "Common intervals: " .. topBucketsText(candidate or {})
    tooltip[#tooltip + 1] = string.format("Cadence changes: %d", cadenceSwitches)

    if label == "Sparse" then
        tooltip[#tooltip + 1] = "Not enough interval samples for a strong timing read."
    elseif label == "Mixed Cadence" then
        tooltip[#tooltip + 1] = "Multiple stable posting cadences were detected."
    elseif label == "Fixed Cadence" then
        tooltip[#tooltip + 1] = "Nearly all intervals are concentrated around one cadence."
    elseif label == "Dominant Active-Run Cadence" then
        tooltip[#tooltip + 1] =
            "Active posting runs use one cadence, with gaps or outlier intervals in the full history."
    elseif label == "Jittered Cadence" then
        tooltip[#tooltip + 1] = "Timing has jitter, but still stays inside a repeatable cadence."
    elseif label == "Burst Pattern" then
        tooltip[#tooltip + 1] = "Activity is concentrated into bursts without enough regular cadence evidence."
    else
        tooltip[#tooltip + 1] = "Timing is spread out or lacks a stable cadence."
    end

    return {
        label = label,
        rank = cadenceRank[label] or 0,
        color = cadenceColors[label],
        tooltip = tooltip,
    }
end

local function scoreValue(candidate)
    local score = candidate.score or {}
    return math.floor((score.localScore or 0) + 0.5)
end

local function confidenceValue(candidate)
    local score = candidate.score or {}
    return score.confidence or 0
end

local function getSortValue(candidate, key)
    local score = candidate.score or {}
    local timing = candidate.timing or {}
    local content = candidate.content or {}
    local behavior = candidate.behavior or {}

    if key == "watch" then
        return isCandidateWatched(candidate) and 1 or 0
    elseif key == "character" then
        return string.lower(candidate.displayName or "")
    elseif key == "status" then
        return statusRank[getStatus(candidate)] or 0
    elseif key == "signals" then
        return UI.BuildObservedSignals(candidate)
    elseif key == "score" then
        return score.networkAdjustedScore or 0
    elseif key == "confidence" then
        return score.confidence or 0
    elseif key == "firstSeen" then
        return candidate.firstSeen or 0
    elseif key == "lastSeen" then
        return candidate.lastSeen or 0
    elseif key == "messages" then
        return candidate.totalMessages or 0
    elseif key == "rate" then
        return behavior.postsPerHour or 0
    elseif key == "averageInterval" then
        return timing.averageInterval or 0
    elseif key == "cadence" then
        return UI.GetCadenceDisplay(candidate).rank
    elseif key == "reuse" then
        return content.templateReusePercent or 0
    elseif key == "source" then
        return sourceRank[getSourceMarker(candidate)] or 0
    end
    return statusRank[getStatus(candidate)] or 0
end

local function compareFallback(left, right)
    local leftStatus = statusRank[getStatus(left)] or 0
    local rightStatus = statusRank[getStatus(right)] or 0
    if leftStatus ~= rightStatus then
        return leftStatus > rightStatus
    end

    local leftSeen = left.lastSeen or 0
    local rightSeen = right.lastSeen or 0
    if leftSeen ~= rightSeen then
        return leftSeen > rightSeen
    end

    return string.lower(left.displayName or "") < string.lower(right.displayName or "")
end

function UI.SortCandidates(candidates)
    local uiSettings = getSettingsUi()
    local sortKey = uiSettings.sortKey or "status"
    local sortDescending = uiSettings.sortDescending ~= false
    local decorated = {}

    for index, candidate in ipairs(candidates or {}) do
        decorated[#decorated + 1] = {
            index = index,
            candidate = candidate,
        }
    end

    table.sort(decorated, function(leftRow, rightRow)
        local left = leftRow.candidate
        local right = rightRow.candidate
        local leftValue = getSortValue(left, sortKey)
        local rightValue = getSortValue(right, sortKey)

        if leftValue ~= rightValue then
            if type(leftValue) == "string" or type(rightValue) == "string" then
                leftValue = tostring(leftValue)
                rightValue = tostring(rightValue)
                if sortDescending then
                    return leftValue > rightValue
                end
                return leftValue < rightValue
            end

            if sortDescending then
                return leftValue > rightValue
            end
            return leftValue < rightValue
        end

        if compareFallback(left, right) ~= compareFallback(right, left) then
            return compareFallback(left, right)
        end

        return leftRow.index < rightRow.index
    end)

    local sorted = {}
    for index, row in ipairs(decorated) do
        sorted[index] = row.candidate
    end
    return sorted
end

function UI.FilterCandidates(candidates)
    local uiSettings = getSettingsUi()
    local filterKey = uiSettings.filterKey or "active"
    local channelFilter = validateChannelFilter(uiSettings, candidates)
    local filtered = {}

    for _, candidate in ipairs(candidates or {}) do
        if candidateMatchesFilter(candidate, filterKey) and candidateMatchesChannel(candidate, channelFilter) then
            filtered[#filtered + 1] = candidate
        end
    end

    return filtered
end

function UI.SetFilter(key)
    local uiSettings = getSettingsUi()
    uiSettings.filterKey = isValidFilterKey(key) and key or "active"
end

function UI.GetFilterState()
    local uiSettings = getSettingsUi()
    return isValidFilterKey(uiSettings.filterKey) and uiSettings.filterKey or "active"
end

function UI.SetChannelFilter(channelName)
    local uiSettings = getSettingsUi()
    channelName = Util.Trim(channelName or "")
    uiSettings.channelFilter = channelName ~= "" and channelName or nil
end

function UI.GetChannelFilterState()
    local uiSettings = getSettingsUi()
    return uiSettings.channelFilter
end

function UI.SetSort(key, descending)
    if not isSortableColumnKey(key) then
        key = "status"
        descending = true
    end
    local uiSettings = getSettingsUi()
    uiSettings.sortKey = key or "status"
    uiSettings.sortDescending = descending ~= false
end

function UI.GetSortState()
    local uiSettings = getSettingsUi()
    return uiSettings.sortKey, uiSettings.sortDescending ~= false
end

function UI.GetColumnKeys()
    local keys = {}
    for index, column in ipairs(columns) do
        keys[index] = column.key
    end
    return keys
end

function UI.GetHeaderState(key)
    local button = headerButtons[key]
    if not button then
        return nil
    end

    return {
        label = button.text and button.text.text or nil,
        arrowShown = button.arrow and button.arrow:IsShown() or false,
        arrowTexCoord = button.arrow and button.arrow.texCoord or nil,
        activeShown = button.active and button.active:IsShown() or false,
    }
end

local function updateHeaderLabels()
    local sortKey, sortDescending = UI.GetSortState()
    for _, column in ipairs(columns) do
        local button = headerButtons[column.key]
        if button and button.text then
            local active = column.key == sortKey
            button.text:SetText(column.label)
            setShown(button.active, active)
            setShown(button.arrow, active)
            if active and button.arrow and button.arrow.SetTexCoord then
                if sortDescending then
                    button.arrow:SetTexCoord(0, 1, 1, 0)
                else
                    button.arrow:SetTexCoord(0, 1, 0, 1)
                end
            end
        end
    end
end

local function updateFilterButtons()
    local filterKey = UI.GetFilterState()
    for _, filter in ipairs(filters) do
        local button = filterButtons[filter.key]
        if button then
            local active = filter.key == filterKey
            if button.SetAlpha then
                button:SetAlpha(active and 1 or 0.68)
            end
            if button.SetText then
                button:SetText(active and ("[" .. filter.label .. "]") or filter.label)
            end
        end
    end
end

local function getChannelDropdownLabel(channelName)
    if not channelName or channelName == "" then
        return "Channel: All"
    end
    return "Channel: " .. truncateChannelName(channelName, 22)
end

local function hideChannelFilterMenu()
    if channelDropdownMenu then
        channelDropdownMenu:Hide()
    end
end

local function ensureChannelFilterMenu()
    if channelDropdownMenu then
        return channelDropdownMenu
    end

    channelDropdownMenu = createFrame("Frame", nil, frame or UIParent)
    channelDropdownMenu:SetFrameStrata("DIALOG")
    channelDropdownMenu:SetFrameLevel(120)
    channelDropdownMenu.bg = channelDropdownMenu:CreateTexture(nil, "BACKGROUND")
    channelDropdownMenu.bg:SetAllPoints()
    channelDropdownMenu.bg:SetColorTexture(0.04, 0.04, 0.05, 0.96)
    channelDropdownMenu:Hide()
    return channelDropdownMenu
end

local function updateChannelFilterDropdown()
    if not channelDropdownButton then
        return
    end

    local allCandidates = Storage.GetAllCandidates()
    local uiSettings = getSettingsUi()
    local channelFilter = validateChannelFilter(uiSettings, allCandidates)
    channelDropdownButton:SetText(getChannelDropdownLabel(channelFilter))
end

local function showChannelFilterMenu()
    if not channelDropdownButton then
        return
    end

    local menu = ensureChannelFilterMenu()
    local options = UI.GetChannelFilterOptions(Storage.GetAllCandidates())
    local selected = UI.GetChannelFilterState()
    local rowHeight = 22
    local rowWidth = 214
    local optionCount = #options + 1

    menu:ClearAllPoints()
    menu:SetPoint("TOPLEFT", channelDropdownButton, "BOTTOMLEFT", 0, -2)
    menu:SetSize(rowWidth + 8, (optionCount * rowHeight) + 8)

    for index = 1, optionCount do
        local button = channelDropdownButtons[index]
        if not button then
            button = createButton(menu, "", rowWidth, rowHeight)
            button:SetScript("OnClick", function(self)
                UI.SetChannelFilter(self.channelFilter)
                hideChannelFilterMenu()
                updateChannelFilterDropdown()
                UI.Refresh()
            end)
            bindTooltip(button, "Channel Filter", function(self)
                return { self.channelFilter or "All Channels" }
            end)
            channelDropdownButtons[index] = button
        end

        local channelName = index == 1 and nil or options[index - 1]
        button.channelFilter = channelName
        button:ClearAllPoints()
        button:SetPoint("TOPLEFT", menu, "TOPLEFT", 4, -4 - ((index - 1) * rowHeight))
        button:SetText(channelName and truncateChannelName(channelName, 24) or "All Channels")
        if button.SetAlpha then
            local active = channelName == selected or (not channelName and not selected)
            button:SetAlpha(active and 1 or 0.82)
        end
        button:Show()
    end

    for index = optionCount + 1, #channelDropdownButtons do
        channelDropdownButtons[index]:Hide()
    end

    menu:Show()
end

function UI.GetChannelDropdownState()
    local options = UI.GetChannelFilterOptions(Storage.GetAllCandidates())
    return {
        selected = UI.GetChannelFilterState(),
        label = channelDropdownButton
                and (channelDropdownButton.GetText and channelDropdownButton:GetText() or channelDropdownButton.text)
            or nil,
        menuShown = channelDropdownMenu and channelDropdownMenu:IsShown() or false,
        options = options,
    }
end

local function setRowVisual(row)
    if not row or not row.bg then
        return
    end

    if row.selected then
        row.bg:SetColorTexture(0.22, 0.42, 0.62, 0.58)
    elseif row.hovered then
        row.bg:SetColorTexture(0.26, 0.26, 0.30, 0.58)
    elseif row.index and row.index % 2 == 0 then
        row.bg:SetColorTexture(0.10, 0.10, 0.12, 0.42)
    else
        row.bg:SetColorTexture(0.07, 0.07, 0.08, 0.30)
    end
end

local function updateAllRowVisuals()
    for _, row in ipairs(rows) do
        row.selected = row.candidate and row.candidate.fullKey == selectedKey
        setRowVisual(row)
    end
end

local function showCandidateTooltip(owner)
    local candidate = owner.candidate
    if not candidate or not GameTooltip then
        return
    end

    local cadence = UI.GetCadenceDisplay(candidate)
    local score = candidate.score or {}
    local status = getStatus(candidate)

    GameTooltip:SetOwner(owner, "ANCHOR_RIGHT")
    GameTooltip:AddLine(candidate.displayName or "Candidate", 1, 1, 1)
    GameTooltip:AddDoubleLine("Status", status, 0.85, 0.85, 0.85, 1, 0.82, 0.20)
    GameTooltip:AddDoubleLine("Pattern Strength", tostring(scoreValue(candidate)), 0.85, 0.85, 0.85, 1, 1, 1)
    GameTooltip:AddDoubleLine("Local Evidence", Util.FormatPercent(score.confidence or 0), 0.85, 0.85, 0.85, 1, 1, 1)
    GameTooltip:AddLine("Signals: " .. UI.BuildObservedSignals(candidate), 0.85, 0.85, 0.85, true)
    GameTooltip:AddLine(" ")
    GameTooltip:AddLine("Cadence: " .. cadence.label, 1, 0.82, 0.2)
    for _, line in ipairs(cadence.tooltip or {}) do
        GameTooltip:AddLine(line, 0.85, 0.85, 0.85, true)
    end
    GameTooltip:AddLine(" ")
    GameTooltip:AddLine("Source: " .. getSourceMarker(candidate), 0.85, 0.85, 0.85, true)
    GameTooltip:AddLine("Review: " .. getTriageSummary(candidate), 0.85, 0.85, 0.85, true)
    GameTooltip:Show()
end

local function setButtonEnabled(button, enabled)
    if not button then
        return
    end

    button.enabled = enabled
    if button.SetEnabled then
        button:SetEnabled(enabled)
    elseif enabled and button.Enable then
        button:Enable()
    elseif not enabled and button.Disable then
        button:Disable()
    end
    if button.SetAlpha then
        button:SetAlpha(enabled and 1 or 0.45)
    end
end

local positionReportButton

local function updateReportControls(candidate)
    local isCritical = Report and Report.IsCriticalCandidate and Report.IsCriticalCandidate(candidate)
    local hasCandidate = candidate ~= nil
    local reported = isCandidateReported(candidate)
    local ignored = isCandidateIgnored(candidate)
    local watched = isCandidateWatched(candidate)

    if detail.reportButton then
        setShown(detail.reportButton, isCritical)
        setButtonEnabled(detail.reportButton, isCritical)
    end
    if detail.watchButton then
        setShown(detail.watchButton, hasCandidate)
        setButtonEnabled(detail.watchButton, hasCandidate)
        detail.watchButton:SetText(watched and "Unwatch" or "Watch")
    end
    if detail.ignoreButton then
        setShown(detail.ignoreButton, hasCandidate)
        setButtonEnabled(detail.ignoreButton, hasCandidate)
        detail.ignoreButton:SetText(ignored and "Unignore" or "Ignore")
    end
    if detail.reportedButton then
        setShown(detail.reportedButton, hasCandidate)
        setButtonEnabled(detail.reportedButton, hasCandidate)
        detail.reportedButton:SetText(reported and "Clear Reported" or "Mark Reported")
        detail.reportedButton.width = reported and 122 or 112
        detail.reportedButton:SetSize(detail.reportedButton.width, 22)
    end
    positionReportButton()
end

local function getTitleTextWidth()
    if detail.title and detail.title.GetStringWidth then
        local ok, width = pcall(detail.title.GetStringWidth, detail.title)
        if ok and type(width) == "number" and width > 0 then
            return math.min(math.ceil(width), DETAIL_TITLE_MAX_WIDTH)
        end
    end

    if detail.title and detail.title.GetText then
        local ok, text = pcall(detail.title.GetText, detail.title)
        if ok and type(text) == "string" and text ~= "" then
            return math.min(#text * 8, DETAIL_TITLE_MAX_WIDTH)
        end
    end

    return 160
end

positionReportButton = function()
    if not detail.title then
        return
    end

    local titleWidth = getTitleTextWidth()
    detail.title:SetWidth(titleWidth)

    local x = titleWidth + DETAIL_TITLE_BUTTON_GAP
    local buttons = {
        detail.reportButton,
        detail.watchButton,
        detail.ignoreButton,
        detail.reportedButton,
    }
    for _, button in ipairs(buttons) do
        if button then
            if button.ClearAllPoints then
                button:ClearAllPoints()
            end
            button:SetPoint("LEFT", detail.title, "LEFT", x, 0)
            x = x + (button.width or 96) + 8
        end
    end
end

local openReportAssistForCandidate

local function positionReportAssistFrame()
    if not reportAssistFrame then
        return
    end

    if reportAssistFrame.ClearAllPoints then
        reportAssistFrame:ClearAllPoints()
    end

    if ReportFrame then
        reportAssistFrame:SetPoint("TOPLEFT", ReportFrame, "TOPRIGHT", 14, 0)
    else
        reportAssistFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
    end
end

local function setReportAssistStatus(opened, diagnostic)
    if not reportAssistFrame or not reportAssistFrame.statusText then
        return
    end

    if opened then
        reportAssistFrame.statusText:SetText(
            "Blizzard report opened and this candidate was marked reported. Clear it here if needed."
        )
        setTextColor(reportAssistFrame.statusText, { 0.66, 1.00, 0.66 })
    else
        local reason = diagnostic and diagnostic.reason or "unknown"
        reportAssistFrame.statusText:SetText("Blizzard report did not open: " .. tostring(reason))
        setTextColor(reportAssistFrame.statusText, { 1.00, 0.74, 0.32 })
    end
end

local function setReportAssistComment(comment)
    if not reportAssistFrame or not reportAssistFrame.commentEdit then
        return
    end

    local editBox = reportAssistFrame.commentEdit
    if editBox.SetMaxLetters then
        editBox:SetMaxLetters(Report and Report.REPORT_COMMENT_LIMIT or 127)
    end
    editBox:SetText(comment or "")
    if editBox.SetCursorPosition then
        editBox:SetCursorPosition(0)
    end
end

local function selectReportAssistText()
    if not reportAssistFrame or not reportAssistFrame.commentEdit then
        return
    end

    local editBox = reportAssistFrame.commentEdit
    if editBox.SetFocus then
        editBox:SetFocus()
    end
    if editBox.HighlightText then
        editBox:HighlightText()
    end
end

local function createReportAssistFrame()
    if reportAssistFrame then
        return reportAssistFrame
    end

    reportAssistFrame = createFrame("Frame", REPORT_ASSIST_FRAME_NAME, UIParent, "BasicFrameTemplateWithInset")
    reportAssistFrame:SetSize(REPORT_ASSIST_WIDTH, REPORT_ASSIST_HEIGHT)
    if reportAssistFrame.SetFrameStrata then
        reportAssistFrame:SetFrameStrata("DIALOG")
    end
    if reportAssistFrame.SetFrameLevel then
        reportAssistFrame:SetFrameLevel(130)
    end
    if reportAssistFrame.SetToplevel then
        reportAssistFrame:SetToplevel(true)
    end
    reportAssistFrame:SetMovable(true)
    reportAssistFrame:SetClampedToScreen(true)
    reportAssistFrame:EnableMouse(true)
    reportAssistFrame:RegisterForDrag("LeftButton")
    reportAssistFrame:SetScript("OnMouseDown", function(self)
        if self.Raise then
            self:Raise()
        end
    end)
    reportAssistFrame:SetScript("OnDragStart", function(self)
        if self.Raise then
            self:Raise()
        end
        self:StartMoving()
    end)
    reportAssistFrame:SetScript("OnDragStop", reportAssistFrame.StopMovingOrSizing)
    reportAssistFrame:Hide()
    registerSpecialFrame(REPORT_ASSIST_FRAME_NAME)

    local title = createFont(
        reportAssistFrame,
        "OVERLAY",
        "GameFontHighlightLarge",
        "TOPLEFT",
        reportAssistFrame,
        "TOPLEFT",
        OUTER_MARGIN,
        TITLE_TOP
    )
    title:SetText("Big Bot Tracker Report Assist")
    reportAssistFrame.title = title

    local subtitle = createFont(
        reportAssistFrame,
        "OVERLAY",
        "GameFontDisableSmall",
        "TOPLEFT",
        reportAssistFrame,
        "TOPLEFT",
        OUTER_MARGIN,
        SUBTITLE_TOP
    )
    subtitle:SetWidth(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2))
    subtitle:SetText("Local guidance for Blizzard's manual report flow.")
    reportAssistFrame.subtitle = subtitle

    local assistStatus = createFrame("Frame", nil, reportAssistFrame)
    assistStatus:SetPoint("TOPLEFT", reportAssistFrame, "TOPLEFT", OUTER_MARGIN, STATUS_TOP)
    assistStatus:SetSize(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2), 24)
    assistStatus:EnableMouse(true)
    reportAssistFrame.assistStatusFrame = assistStatus

    local statusBg = assistStatus:CreateTexture(nil, "BACKGROUND")
    statusBg:SetAllPoints(assistStatus)
    statusBg:SetColorTexture(0.05, 0.05, 0.06, 0.58)
    assistStatus.bg = statusBg

    local instruction = createFont(assistStatus, "OVERLAY", "GameFontNormalSmall", "LEFT", assistStatus, "LEFT", 8, 0)
    instruction:SetWidth(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2) - 16)
    instruction:SetText("In Blizzard's report window, select Cheating > Botting.")
    reportAssistFrame.instruction = instruction

    local commentLabel = createFont(
        reportAssistFrame,
        "OVERLAY",
        "GameFontNormalSmall",
        "TOPLEFT",
        reportAssistFrame,
        "TOPLEFT",
        OUTER_MARGIN,
        -138
    )
    commentLabel:SetText("Selectable report comment")
    reportAssistFrame.commentLabel = commentLabel

    local commentCount = createFont(
        reportAssistFrame,
        "OVERLAY",
        "GameFontDisableSmall",
        "TOPRIGHT",
        reportAssistFrame,
        "TOPRIGHT",
        -OUTER_MARGIN,
        -138
    )
    commentCount:SetJustifyH("RIGHT")
    commentCount:SetWidth(90)
    reportAssistFrame.commentCount = commentCount
    reportAssistFrame.commentDivider =
        addDivider(reportAssistFrame, OUTER_MARGIN, -155, REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2))

    local commentBox = createFrame("Frame", nil, reportAssistFrame)
    commentBox:SetPoint("TOPLEFT", reportAssistFrame, "TOPLEFT", OUTER_MARGIN, -164)
    commentBox:SetSize(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2), 70)
    reportAssistFrame.commentBox = commentBox

    local commentBg = commentBox:CreateTexture(nil, "BACKGROUND")
    commentBg:SetAllPoints(commentBox)
    commentBg:SetColorTexture(0.05, 0.05, 0.06, 0.58)
    commentBox.bg = commentBg

    local commentEdit = createFrame("EditBox", nil, commentBox)
    commentEdit:SetPoint("TOPLEFT", commentBox, "TOPLEFT", 8, -7)
    commentEdit:SetSize(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2) - 16, 56)
    if commentEdit.SetAutoFocus then
        commentEdit:SetAutoFocus(false)
    end
    if commentEdit.SetMultiLine then
        commentEdit:SetMultiLine(true)
    end
    if commentEdit.SetFontObject and GameFontHighlightSmall then
        commentEdit:SetFontObject(GameFontHighlightSmall)
    end
    if commentEdit.SetJustifyH then
        commentEdit:SetJustifyH("LEFT")
    end
    if commentEdit.SetJustifyV then
        commentEdit:SetJustifyV("TOP")
    end
    if commentEdit.SetTextInsets then
        commentEdit:SetTextInsets(0, 0, 0, 0)
    end
    commentEdit:SetScript("OnEscapePressed", function(self)
        if self.ClearFocus then
            self:ClearFocus()
        end
    end)
    reportAssistFrame.commentEdit = commentEdit

    local evidenceHeader = createFont(
        reportAssistFrame,
        "OVERLAY",
        "GameFontNormalSmall",
        "TOPLEFT",
        reportAssistFrame,
        "TOPLEFT",
        OUTER_MARGIN,
        -252
    )
    evidenceHeader:SetText("Most meaningful observed behavior")
    reportAssistFrame.evidenceHeader = evidenceHeader
    reportAssistFrame.evidenceDivider =
        addDivider(reportAssistFrame, OUTER_MARGIN, -269, REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2))

    reportAssistFrame.bulletLines = {}
    for index = 1, 4 do
        local line = createFont(
            reportAssistFrame,
            "OVERLAY",
            "GameFontHighlightSmall",
            "TOPLEFT",
            reportAssistFrame,
            "TOPLEFT",
            OUTER_MARGIN + 10,
            -278 - ((index - 1) * 17)
        )
        line:SetWidth(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2) - 18)
        line:SetWordWrap(false)
        reportAssistFrame.bulletLines[index] = line
    end

    local statusText = createFont(
        reportAssistFrame,
        "OVERLAY",
        "GameFontHighlightSmall",
        "TOPLEFT",
        reportAssistFrame,
        "TOPLEFT",
        OUTER_MARGIN,
        -360
    )
    statusText:SetWidth(REPORT_ASSIST_WIDTH - (OUTER_MARGIN * 2))
    statusText:SetText("")
    reportAssistFrame.statusText = statusText

    local closeButton = createButton(reportAssistFrame, "Close", 72, 22)
    closeButton:SetPoint("BOTTOMRIGHT", reportAssistFrame, "BOTTOMRIGHT", -OUTER_MARGIN, 16)
    closeButton:SetScript("OnClick", function()
        reportAssistFrame:Hide()
    end)
    reportAssistFrame.closeButton = closeButton

    local openButton = createButton(reportAssistFrame, "Open/Retry Report", 128, 22)
    openButton:SetPoint("RIGHT", closeButton, "LEFT", -8, 0)
    openButton:SetScript("OnClick", function()
        if reportAssistFrame and reportAssistFrame.candidate and openReportAssistForCandidate then
            openReportAssistForCandidate(reportAssistFrame.candidate)
        end
    end)
    reportAssistFrame.openButton = openButton

    local clearReportedButton = createButton(reportAssistFrame, "Clear Reported", 112, 22)
    clearReportedButton:SetPoint("RIGHT", openButton, "LEFT", -8, 0)
    clearReportedButton:SetScript("OnClick", function()
        if reportAssistFrame and reportAssistFrame.candidate and Storage.ClearReported then
            Storage.ClearReported(reportAssistFrame.candidate)
            Util.Print("Cleared reported status for " .. tostring(reportAssistFrame.candidate.displayName) .. ".")
            UI.Refresh()
            setButtonEnabled(clearReportedButton, false)
        end
    end)
    reportAssistFrame.clearReportedButton = clearReportedButton

    local selectButton = createButton(reportAssistFrame, "Select Text", 92, 22)
    selectButton:SetPoint("RIGHT", clearReportedButton, "LEFT", -8, 0)
    selectButton:SetScript("OnClick", selectReportAssistText)
    reportAssistFrame.selectButton = selectButton

    return reportAssistFrame
end

local function showReportAssist(candidate, opened, diagnostic)
    if not Report or not Report.BuildReportAssist then
        return
    end

    local assist = Report.BuildReportAssist(candidate)
    local assistFrame = createReportAssistFrame()
    assistFrame.candidate = candidate
    assistFrame.diagnostic = diagnostic
    assistFrame.opened = opened == true

    assistFrame.instruction:SetText(assist.instruction or "In Blizzard's report window, select Cheating > Botting.")
    setReportAssistComment(assist.comment)
    assistFrame.commentCount:SetText(string.format("%d / %d", #(assist.comment or ""), assist.commentLimit or 127))
    setButtonEnabled(assistFrame.clearReportedButton, isCandidateReported(candidate))

    for index, line in ipairs(assistFrame.bulletLines or {}) do
        local bullet = assist.bullets and assist.bullets[index]
        line:SetText(bullet and ("- " .. bullet) or "")
    end

    setReportAssistStatus(opened, diagnostic)
    positionReportAssistFrame()
    assistFrame:Show()
    if assistFrame.Raise then
        assistFrame:Raise()
    end
end

openReportAssistForCandidate = function(candidate)
    if not candidate then
        Util.Print("Select a candidate first.")
        return false, nil
    end
    if not Report or not Report.OpenBottingReport then
        Util.Print("Report helper unavailable.")
        return false, nil
    end
    if not Report.IsCriticalCandidate(candidate) then
        Util.Print("Report assist is available for Very Strong Pattern candidates only.")
        return false, nil
    end

    local opened, diagnostic = Report.OpenBottingReport(candidate)
    showReportAssist(candidate, opened, diagnostic)
    if opened then
        Util.Print(
            "Opened Blizzard report frame. Select Cheating > Botting, paste the assist text, and review before submitting."
        )
    else
        Util.Print("Could not open botting report: " .. tostring(diagnostic and diagnostic.reason or "unknown"))
    end
    updateReportControls(candidate)
    return opened, diagnostic
end

local function clearDetails()
    selectedCandidate = nil
    selectedKey = nil

    if detail.title then
        detail.title:SetText("Candidate Detail")
        positionReportButton()
    end
    if detail.subtitle then
        detail.subtitle:SetText("Select a row to view structured local and network evidence.")
    end

    for _, group in pairs(detail.groups or {}) do
        for _, line in ipairs(group.lines or {}) do
            line:SetText("")
        end
    end

    if detail.reasons then
        for _, line in ipairs(detail.reasons) do
            line:SetText("")
        end
    end

    updateReportControls(nil)
end

local function setGroupLine(groupName, index, label, value)
    local group = detail.groups and detail.groups[groupName]
    local line = group and group.lines and group.lines[index]
    if line then
        line:SetText(string.format("|cffbbbbbb%s:|r %s", label, tostring(value or "-")))
    end
end

local function refreshDetails(candidate)
    if not frame then
        return
    end

    if candidate then
        selectedCandidate = candidate
        selectedKey = candidate.fullKey
    elseif selectedKey then
        for _, rowCandidate in ipairs(Storage.GetAllCandidates()) do
            if rowCandidate.fullKey == selectedKey then
                selectedCandidate = rowCandidate
                candidate = rowCandidate
                break
            end
        end
    end

    candidate = candidate or selectedCandidate
    if not candidate then
        clearDetails()
        return
    end

    local score = candidate.score or {}
    local timing = candidate.timing or {}
    local content = candidate.content or {}
    local behavior = candidate.behavior or {}
    local network = candidate.network or {}
    local familyScores = score.familyScores or {}
    local baseline = candidate.baseline or {}
    local cadence = UI.GetCadenceDisplay(candidate)
    local status = getStatus(candidate)
    local channels = {}
    for _, key in ipairs(Util.TableKeysSorted(candidate.channels)) do
        channels[#channels + 1] = key
    end

    detail.title:SetText(candidate.displayName or "Candidate Detail")
    positionReportButton()
    detail.subtitle:SetText(UI.BuildEvidenceSummary(candidate))

    setGroupLine("summary", 1, "Status", status)
    setGroupLine("summary", 2, "Pattern Strength", tostring(math.floor((score.localScore or 0) + 0.5)))
    setGroupLine("summary", 3, "Local Evidence", Util.FormatPercent(score.confidence or 0))
    setGroupLine("summary", 4, "Review", getTriageSummary(candidate))
    setGroupLine("summary", 5, "Evidence Source", getEvidenceSourceText(candidate))

    setGroupLine("activity", 1, "First Seen", Util.FormatTimestamp(candidate.firstSeen))
    setGroupLine("activity", 2, "First Flagged", Util.FormatTimestamp(candidate.firstPromoted))
    setGroupLine("activity", 3, "Last Seen", Util.FormatTimestamp(candidate.lastSeen))
    setGroupLine("activity", 4, "Local Messages", tostring(candidate.totalMessages or 0))
    setGroupLine("activity", 5, "Channels", #channels > 0 and table.concat(channels, ", ") or "-")

    setGroupLine("timing", 1, "Cadence", cadence.label)
    setGroupLine("timing", 2, "Average Interval", Util.FormatDuration(timing.averageInterval or 0))
    setGroupLine("timing", 3, "Median Interval", Util.FormatDuration(timing.medianInterval or 0))
    setGroupLine("timing", 4, "Interval Variation", Util.FormatNumber(timing.robustCoefficientVariation or 1, 2))
    setGroupLine("timing", 5, "Timing Entropy", Util.FormatNumber(timing.lowestRollingEntropy or 1, 2))
    setGroupLine("timing", 6, "Common Intervals", topBucketsText(candidate))
    setGroupLine("timing", 7, "Stable Runs", phasesText(candidate))
    setGroupLine("timing", 8, "Cadence Changes", tostring(timing.cadenceSwitchCount or 0))
    setGroupLine("timing", 9, "Rate", rateText(candidate))

    setGroupLine("content", 1, "Exact Text Reuse", Util.FormatPercent(content.templateReusePercent or 0))
    setGroupLine("content", 2, "Similar Wording", Util.FormatPercent(content.shingleReusePercent or 0))
    setGroupLine("content", 3, "Unique Text Patterns", tostring(content.uniqueTemplateCount or 0))
    setGroupLine("content", 4, "Near-Duplicate Messages", tostring(content.nearDuplicateCount or 0))
    setGroupLine("content", 5, "Ad-like Messages", tostring(content.adIntentTotal or 0))

    setGroupLine("families", 1, "Signal Types", tostring(score.evidenceFamilyCount or 0))
    setGroupLine("families", 2, "Timing", tostring(familyScores.timing or 0) .. " / 35")
    setGroupLine("families", 3, "Content", tostring(familyScores.content or 0) .. " / 30")
    setGroupLine("families", 4, "Activity", tostring(familyScores.activity or 0) .. " / 20")
    setGroupLine("families", 5, "Persistence", tostring(familyScores.persistence or 0) .. " / 10")
    setGroupLine("families", 6, "Baseline", tostring(familyScores.baseline or 0) .. " / 15")

    setGroupLine("baseline", 1, "Status", baseline.label or "Collecting baseline")
    setGroupLine("baseline", 2, "Baseline Samples", tostring(baseline.sampleCount or 0))
    setGroupLine("baseline", 3, "Rate vs Baseline", Util.FormatPercent(baseline.postsPerHourPercentile or 0))
    setGroupLine("baseline", 4, "Regularity vs Baseline", Util.FormatPercent(baseline.regularityPercentile or 0))
    setGroupLine("baseline", 5, "Reuse vs Baseline", Util.FormatPercent(baseline.templateReusePercentile or 0))

    setGroupLine("network", 1, "Peers", tostring(network.peerCount or 0))
    setGroupLine("network", 2, "Overlap", network.overlap or "None")
    setGroupLine("network", 3, "Last Update", Util.FormatTimestamp(network.lastReceived))
    setGroupLine(
        "network",
        4,
        "Pattern Strength / Peer Signal",
        string.format("%d / %d", score.localScore or 0, score.networkScore or 0)
    )

    local reasons = score.reasons or {}
    for index, line in ipairs(detail.reasons or {}) do
        if reasons[index] then
            line:SetText(string.format("%d. %s", index, reasons[index]))
        else
            line:SetText(index == 1 and "No strong evidence reasons yet." or "")
        end
    end

    updateReportControls(candidate)
end

function UI.GetSelectedCandidate()
    return selectedCandidate
end

function UI.SelectCandidate(candidate)
    if candidate then
        selectedCandidate = candidate
        selectedKey = candidate.fullKey
        refreshDetails(candidate)
    else
        clearDetails()
    end
    updateAllRowVisuals()
end

function UI.OpenSelectedReportAssist()
    return openReportAssistForCandidate(selectedCandidate)
end

local function buttonIsShown(button)
    if not button then
        return false
    end
    if button.IsShown then
        return button:IsShown()
    end
    return button.shown == true
end

function UI.GetReportControlState()
    return {
        reportShown = buttonIsShown(detail.reportButton),
        reportEnabled = detail.reportButton and detail.reportButton.enabled == true or false,
    }
end

function UI.GetReportAssistState()
    local bullets = {}
    if reportAssistFrame and reportAssistFrame.bulletLines then
        for index, line in ipairs(reportAssistFrame.bulletLines) do
            bullets[index] = line.text or ""
        end
    end

    local comment = ""
    if reportAssistFrame and reportAssistFrame.commentEdit then
        if reportAssistFrame.commentEdit.GetText then
            comment = reportAssistFrame.commentEdit:GetText()
        else
            comment = reportAssistFrame.commentEdit.text or ""
        end
    end

    return {
        shown = buttonIsShown(reportAssistFrame),
        comment = comment,
        status = reportAssistFrame and reportAssistFrame.statusText and reportAssistFrame.statusText.text or "",
        bullets = bullets,
        clearReportedEnabled = reportAssistFrame
                and reportAssistFrame.clearReportedButton
                and reportAssistFrame.clearReportedButton.enabled == true
            or false,
    }
end

local function widgetText(widget)
    if not widget then
        return ""
    end
    if widget.GetText then
        local ok, value = pcall(widget.GetText, widget)
        if ok then
            return value or ""
        end
    end
    return widget.text or ""
end

function UI.GetDetailState()
    local groups = {}
    for name, group in pairs(detail.groups or {}) do
        local lines = {}
        for index, line in ipairs(group.lines or {}) do
            lines[index] = widgetText(line)
        end
        groups[name] = {
            header = widgetText(group.header),
            lines = lines,
        }
    end

    local reasons = {}
    for index, line in ipairs(detail.reasons or {}) do
        reasons[index] = widgetText(line)
    end

    return {
        title = widgetText(detail.title),
        assessment = widgetText(detail.subtitle),
        groups = groups,
        reasonHeader = widgetText(detail.reasonHeader),
        reasons = reasons,
    }
end

function UI.GetTriageControlState()
    return {
        watchShown = buttonIsShown(detail.watchButton),
        watchText = detail.watchButton and detail.watchButton.text or "",
        ignoreShown = buttonIsShown(detail.ignoreButton),
        ignoreText = detail.ignoreButton and detail.ignoreButton.text or "",
        reportedShown = buttonIsShown(detail.reportedButton),
        reportedText = detail.reportedButton and detail.reportedButton.text or "",
    }
end

function UI.GetRowState(index)
    local row = rows[index]
    if not row then
        return nil
    end
    return {
        shown = row:IsShown(),
        candidate = row.candidate,
        watchText = row.watchButton and row.watchButton.text and row.watchButton.text.text or "",
        watched = row.candidate and isCandidateWatched(row.candidate) or false,
    }
end

function UI.ClickRowWatch(index)
    local row = rows[index]
    if row and row.watchButton and row.watchButton.scripts and row.watchButton.scripts.OnClick then
        row.watchButton.scripts.OnClick(row.watchButton)
        return true
    end
    return false
end

local function createHeader(parent)
    local header = createFrame("Frame", nil, parent)
    header:SetPoint("TOPLEFT", parent, "TOPLEFT", OUTER_MARGIN, HEADER_TOP)
    header:SetSize(TABLE_VIEW_WIDTH, HEADER_HEIGHT)
    parent.header = header

    local bg = header:CreateTexture(nil, "BACKGROUND")
    bg:SetAllPoints(header)
    bg:SetColorTexture(0.07, 0.07, 0.08, 0.82)
    header.bg = bg

    local bottomLine = header:CreateTexture(nil, "ARTWORK")
    bottomLine:SetPoint("BOTTOMLEFT", header, "BOTTOMLEFT", 0, 0)
    bottomLine:SetSize(TABLE_VIEW_WIDTH, 1)
    bottomLine:SetColorTexture(1, 0.82, 0, 0.28)
    header.bottomLine = bottomLine

    local x = 0
    for _, column in ipairs(columns) do
        local button = createFrame("Button", nil, header)
        button:SetPoint("LEFT", header, "LEFT", x, 0)
        button:SetSize(column.width, HEADER_HEIGHT)
        button.column = column

        local active = button:CreateTexture(nil, "BACKGROUND")
        active:SetAllPoints(button)
        active:SetColorTexture(0.20, 0.28, 0.36, 0.55)
        active:Hide()
        button.active = active

        local highlight = button:CreateTexture(nil, "HIGHLIGHT")
        highlight:SetAllPoints(button)
        highlight:SetColorTexture(1, 1, 1, 0.08)
        if button.SetHighlightTexture then
            button:SetHighlightTexture(highlight)
        end
        button.highlight = highlight

        local text = createFont(button, "OVERLAY", "GameFontNormalSmall", "LEFT", button, "LEFT", 4, 0)
        text:SetWidth(column.width - 22)
        text:SetJustifyH(column.align or "LEFT")
        button.text = text

        local arrow = button:CreateTexture(nil, "OVERLAY")
        arrow:SetPoint("RIGHT", button, "RIGHT", -4, 0)
        arrow:SetSize(12, 12)
        if arrow.SetAtlas then
            arrow:SetAtlas("auctionhouse-ui-sortarrow", true)
        elseif arrow.SetTexture then
            arrow:SetTexture("Interface\\Buttons\\UI-SortArrow")
        end
        arrow:Hide()
        button.arrow = arrow

        if x > 0 then
            local separator = header:CreateTexture(nil, "ARTWORK")
            separator:SetPoint("LEFT", header, "LEFT", x - 2, 0)
            separator:SetSize(1, HEADER_HEIGHT - 4)
            separator:SetColorTexture(1, 1, 1, 0.08)
        end

        if column.sortable ~= false then
            button:SetScript("OnClick", function(self)
                local uiSettings = getSettingsUi()
                if uiSettings.sortKey == self.column.key then
                    uiSettings.sortDescending = not uiSettings.sortDescending
                else
                    uiSettings.sortKey = self.column.key
                    uiSettings.sortDescending = self.column.defaultDescending ~= false
                end
                updateHeaderLabels()
                UI.Refresh()
            end)
        end
        button:SetScript("OnEnter", function(self)
            if not GameTooltip then
                return
            end
            GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
            GameTooltip:AddLine(self.column.label ~= "" and self.column.label or "Watch", 1, 1, 1)
            GameTooltip:AddLine(self.column.tooltip, 0.85, 0.85, 0.85, true)
            if self.column.sortable ~= false then
                GameTooltip:AddLine("Click to sort. Click again to reverse direction.", 0.85, 0.85, 0.85, true)
            end
            GameTooltip:Show()
        end)
        button:SetScript("OnLeave", function()
            if GameTooltip then
                GameTooltip:Hide()
            end
        end)

        headerButtons[column.key] = button
        x = x + column.width + 4
    end

    parent.headerButtons = headerButtons
    updateHeaderLabels()
end

local function setWatchButtonVisual(button, candidate)
    if not button then
        return
    end

    local watched = isCandidateWatched(candidate)
    button.candidate = candidate
    if button.text then
        button.text:SetText(watched and "*" or "o")
        setTextColor(button.text, watched and { 1.00, 0.82, 0.20 } or { 0.70, 0.70, 0.70 })
    end
    if button.icon then
        local atlasSet = false
        if button.icon.SetAtlas then
            atlasSet = pcall(button.icon.SetAtlas, button.icon, "common-icon-eye", true)
        end
        if not atlasSet and button.icon.SetTexture then
            button.icon:SetTexture(
                watched and "Interface\\Buttons\\UI-CheckBox-Check" or "Interface\\Buttons\\UI-CheckBox-Up"
            )
        end
    end
    if button.SetAlpha then
        button:SetAlpha(watched and 1 or 0.72)
    end
end

local function showWatchTooltip(owner)
    if not owner or not GameTooltip then
        return
    end
    GameTooltip:SetOwner(owner, "ANCHOR_RIGHT")
    GameTooltip:AddLine(isCandidateWatched(owner.candidate) and "Unwatch" or "Watch", 1, 1, 1)
    GameTooltip:AddLine("Keeps this candidate visible in the clean Active view.", 0.85, 0.85, 0.85, true)
    if owner.candidate then
        GameTooltip:AddLine("Review: " .. getTriageSummary(owner.candidate), 0.85, 0.85, 0.85, true)
    end
    GameTooltip:Show()
end

local function createRow(index)
    local row = createFrame("Button", nil, tableContent)
    row:SetPoint("TOPLEFT", tableContent, "TOPLEFT", 0, -((index - 1) * ROW_HEIGHT))
    row:SetSize(TABLE_CONTENT_WIDTH, ROW_HEIGHT - 1)
    row.index = index
    row.fields = {}

    row.bg = row:CreateTexture(nil, "BACKGROUND")
    row.bg:SetAllPoints(row)

    local x = 0
    for columnIndex, column in ipairs(columns) do
        if column.key == "watch" then
            local button = createFrame("Button", nil, row)
            button:SetPoint("LEFT", row, "LEFT", x + 5, 0)
            button:SetSize(column.width - 10, ROW_HEIGHT - 4)
            button:SetScript("OnClick", function(self)
                if not self.candidate then
                    return
                end
                local watched = Storage.ToggleWatched(self.candidate)
                Util.Print(
                    string.format(
                        "%s %s.",
                        watched and "Watching" or "Stopped watching",
                        tostring(self.candidate.displayName)
                    )
                )
                UI.Refresh()
            end)
            button:SetScript("OnEnter", showWatchTooltip)
            button:SetScript("OnLeave", function()
                if GameTooltip then
                    GameTooltip:Hide()
                end
            end)

            local icon = button:CreateTexture(nil, "ARTWORK")
            icon:SetPoint("CENTER", button, "CENTER", 0, 0)
            icon:SetSize(16, 16)
            button.icon = icon

            local text = createFont(button, "OVERLAY", "GameFontHighlightSmall", "CENTER", button, "CENTER", 0, 0)
            text:SetJustifyH("CENTER")
            text:SetWidth(column.width - 10)
            button.text = text
            row.watchButton = button
        else
            local field = createFont(row, "OVERLAY", "GameFontHighlightSmall", "LEFT", row, "LEFT", x + 4, 0)
            field:SetWidth(column.width - 8)
            field:SetJustifyH(column.align or "LEFT")
            field:SetText("")
            row.fields[columnIndex] = field
        end
        x = x + column.width + 4
    end

    row:SetScript("OnClick", function(self)
        if self.candidate then
            selectedCandidate = self.candidate
            selectedKey = self.candidate.fullKey
            refreshDetails(self.candidate)
            updateAllRowVisuals()
        end
    end)
    row:SetScript("OnEnter", function(self)
        self.hovered = true
        setRowVisual(self)
        showCandidateTooltip(self)
    end)
    row:SetScript("OnLeave", function(self)
        self.hovered = false
        setRowVisual(self)
        if GameTooltip then
            GameTooltip:Hide()
        end
    end)

    rows[index] = row
    return row
end

local function setRowField(row, index, text, color)
    local field = row.fields[index]
    if not field then
        return
    end
    field:SetText(text or "-")
    setTextColor(field, color or { 1, 1, 1 })
end

local function setRowFieldByKey(row, key, text, color)
    setRowField(row, columnIndexByKey[key], text, color)
end

local function populateRow(row, candidate)
    local timing = candidate.timing or {}
    local content = candidate.content or {}
    local cadence = UI.GetCadenceDisplay(candidate)
    local status = getStatus(candidate)

    row.candidate = candidate
    row.selected = candidate.fullKey == selectedKey
    row:Show()

    setWatchButtonVisual(row.watchButton, candidate)
    setRowFieldByKey(
        row,
        "character",
        candidate.displayName or "-",
        isCandidateIgnored(candidate) and { 0.62, 0.62, 0.62 } or { 1, 1, 1 }
    )
    setRowFieldByKey(row, "status", status, statusColors[status])
    setRowFieldByKey(row, "signals", UI.BuildObservedSignals(candidate), { 0.92, 0.92, 0.92 })
    setRowFieldByKey(row, "messages", tostring(candidate.totalMessages or 0), { 1, 1, 1 })
    setRowFieldByKey(row, "cadence", cadence.label, cadence.color)
    setRowFieldByKey(row, "reuse", Util.FormatPercent(content.templateReusePercent or 0), { 1, 1, 1 })
    setRowFieldByKey(row, "lastSeen", formatLastSeen(candidate), { 0.82, 0.82, 0.82 })
    setRowFieldByKey(row, "source", getSourceMarker(candidate), { 0.82, 0.92, 1.00 })

    setRowVisual(row)
end

local function createTable(parent)
    createHeader(parent)

    tableScroll = createFrame("ScrollFrame", nil, parent, "UIPanelScrollFrameTemplate")
    tableScroll:SetPoint("TOPLEFT", parent, "TOPLEFT", OUTER_MARGIN, TABLE_TOP)
    tableScroll:SetSize(TABLE_VIEW_WIDTH, TABLE_HEIGHT)
    tableScroll:EnableMouseWheel(true)
    tableScroll:SetScript("OnMouseWheel", function(self, delta)
        local current = self:GetVerticalScroll() or 0
        local maxScroll = math.max(0, ((tableContent and tableContent.contentHeight) or TABLE_HEIGHT) - TABLE_HEIGHT)
        self:SetVerticalScroll(Util.Clamp(current - (delta * ROW_HEIGHT * 3), 0, maxScroll))
    end)

    tableContent = createFrame("Frame", nil, tableScroll)
    tableContent:SetSize(TABLE_CONTENT_WIDTH, TABLE_HEIGHT)
    tableContent.contentHeight = TABLE_HEIGHT
    tableScroll:SetScrollChild(tableContent)

    emptyState = createFont(parent, "OVERLAY", "GameFontDisableSmall", "CENTER", tableScroll, "CENTER", 0, 0)
    emptyState:SetWidth(TABLE_CONTENT_WIDTH)
    emptyState:SetJustifyH("CENTER")
    emptyState:SetText("No tracked candidates yet. Monitoring joined public channels.")
    emptyState:Hide()
end

local function createSection(parent, title, x, y, width, lineCount)
    local section = {
        lines = {},
    }

    local header = createFont(parent, "OVERLAY", "GameFontNormalSmall", "TOPLEFT", parent, "TOPLEFT", x, y)
    header:SetText(title)
    section.header = header

    local divider = parent:CreateTexture(nil, "ARTWORK")
    divider:SetPoint("TOPLEFT", parent, "TOPLEFT", x, y - 17)
    divider:SetSize(width, 1)
    divider:SetColorTexture(1, 0.82, 0, 0.28)
    section.divider = divider

    for index = 1, lineCount do
        local line = createFont(
            parent,
            "OVERLAY",
            "GameFontHighlightSmall",
            "TOPLEFT",
            parent,
            "TOPLEFT",
            x,
            y - 24 - ((index - 1) * 15)
        )
        line:SetWidth(width)
        line:SetWordWrap(false)
        section.lines[index] = line
    end

    return section
end

local function createDetails(parent)
    detail.title =
        createFont(parent, "OVERLAY", "GameFontNormal", "TOPLEFT", parent, "TOPLEFT", OUTER_MARGIN, DETAIL_TITLE_TOP)
    detail.title:SetWidth(DETAIL_TITLE_MAX_WIDTH)
    detail.title:SetWordWrap(false)
    detail.title:SetText("Candidate Detail")

    local reportButton = createButton(parent, "Report", 72, 22)
    reportButton:SetPoint("LEFT", detail.title, "LEFT", 160 + DETAIL_TITLE_BUTTON_GAP, 0)
    reportButton:SetScript("OnClick", function()
        openReportAssistForCandidate(selectedCandidate)
    end)
    bindTooltip(reportButton, "Report", {
        "Opens Blizzard's in-world report flow for a Very Strong Pattern candidate when a reportable player location is available.",
        "The addon does not submit the report.",
    })
    detail.reportButton = reportButton
    parent.reportButton = reportButton

    local watchButton = createButton(parent, "Watch", 72, 22)
    watchButton:SetScript("OnClick", function()
        if not selectedCandidate then
            Util.Print("Select a candidate first.")
            return
        end
        local watched = Storage.ToggleWatched(selectedCandidate)
        Util.Print(
            string.format(
                "%s %s.",
                watched and "Watching" or "Stopped watching",
                tostring(selectedCandidate.displayName)
            )
        )
        UI.Refresh()
    end)
    bindTooltip(watchButton, "Watch", {
        "Keeps the selected candidate visible in the clean Active view.",
        "This is local display state and does not change pattern strength.",
    })
    detail.watchButton = watchButton
    parent.watchButton = watchButton

    local ignoreButton = createButton(parent, "Ignore", 84, 22)
    ignoreButton:SetScript("OnClick", function()
        if not selectedCandidate then
            Util.Print("Select a candidate first.")
            return
        end
        local ignored = Storage.SetIgnored(selectedCandidate, not isCandidateIgnored(selectedCandidate))
        Util.Print(
            string.format("%s %s.", ignored and "Ignored" or "Unignored", tostring(selectedCandidate.displayName))
        )
        UI.Refresh()
    end)
    bindTooltip(ignoreButton, "Ignore", {
        "Hides the selected candidate from the clean Active view without deleting evidence.",
        "Watched candidates remain visible even when ignored.",
    })
    detail.ignoreButton = ignoreButton
    parent.ignoreButton = ignoreButton

    local reportedButton = createButton(parent, "Mark Reported", 112, 22)
    reportedButton:SetScript("OnClick", function()
        if not selectedCandidate then
            Util.Print("Select a candidate first.")
            return
        end
        if isCandidateReported(selectedCandidate) then
            Storage.ClearReported(selectedCandidate)
            Util.Print("Cleared reported status for " .. tostring(selectedCandidate.displayName) .. ".")
        else
            Storage.MarkReported(selectedCandidate)
            Util.Print("Marked " .. tostring(selectedCandidate.displayName) .. " as reported.")
        end
        UI.Refresh()
    end)
    bindTooltip(reportedButton, "Reported", {
        "Tracks that this player has been handled by your local report workflow.",
        "You can clear this if the report flow was opened by mistake or not completed.",
    })
    detail.reportedButton = reportedButton
    parent.reportedButton = reportedButton

    positionReportButton()
    updateReportControls(nil)

    detail.subtitle = createFont(
        parent,
        "OVERLAY",
        "GameFontHighlightSmall",
        "TOPLEFT",
        parent,
        "TOPLEFT",
        OUTER_MARGIN,
        DETAIL_TITLE_TOP - 20
    )
    detail.subtitle:SetWidth(TABLE_CONTENT_WIDTH)
    detail.subtitle:SetText("Select a row to view structured local and network evidence.")

    detail.groups = {
        summary = createSection(parent, "Summary", OUTER_MARGIN, DETAIL_TOP, 250, 5),
        activity = createSection(parent, "Activity", OUTER_MARGIN, DETAIL_TOP - 102, 340, 5),
        network = createSection(parent, "Peer Evidence", OUTER_MARGIN, DETAIL_TOP - 220, 340, 4),
        timing = createSection(parent, "Timing", 380, DETAIL_TOP, 350, 9),
        content = createSection(parent, "Content", 380, DETAIL_TOP - 176, 330, 5),
        families = createSection(parent, "Why This Was Flagged", 760, DETAIL_TOP, 360, 6),
        baseline = createSection(parent, "Local Channel Baseline", 760, DETAIL_TOP - 146, 360, 5),
    }

    local reasonHeader =
        createFont(parent, "OVERLAY", "GameFontNormalSmall", "TOPLEFT", parent, "TOPLEFT", 760, REASONS_TOP)
    reasonHeader:SetText("Observed Signals")
    detail.reasonHeader = reasonHeader

    local divider = parent:CreateTexture(nil, "ARTWORK")
    divider:SetPoint("TOPLEFT", parent, "TOPLEFT", 760, REASONS_TOP - 17)
    divider:SetSize(360, 1)
    divider:SetColorTexture(1, 0.82, 0, 0.28)
    detail.reasonDivider = divider

    detail.reasons = {}
    for index = 1, 4 do
        local line = createFont(
            parent,
            "OVERLAY",
            "GameFontHighlightSmall",
            "TOPLEFT",
            parent,
            "TOPLEFT",
            760,
            REASONS_TOP - 26 - ((index - 1) * 32)
        )
        line:SetWidth(360)
        line:SetWordWrap(true)
        detail.reasons[index] = line
    end
end

local function createStatusStrip(parent)
    local statusFrame = createFrame("Frame", nil, parent)
    statusFrame:SetPoint("TOPLEFT", parent, "TOPLEFT", OUTER_MARGIN, STATUS_TOP)
    statusFrame:SetSize(HEADER_CONTENT_WIDTH, 24)
    statusFrame:EnableMouse(true)
    parent.statusFrame = statusFrame

    local bg = statusFrame:CreateTexture(nil, "BACKGROUND")
    bg:SetAllPoints(statusFrame)
    bg:SetColorTexture(0.05, 0.05, 0.06, 0.58)
    statusFrame.bg = bg

    local scan = createFont(statusFrame, "OVERLAY", "GameFontNormalSmall", "LEFT", statusFrame, "LEFT", 8, 0)
    scan:SetWidth(140)
    scan:SetText("Live: scanning")
    parent.scanStatusText = scan

    local tracked = createFont(statusFrame, "OVERLAY", "GameFontHighlightSmall", "LEFT", statusFrame, "LEFT", 160, 0)
    tracked:SetWidth(190)
    tracked:SetText("Tracked: 0")
    parent.trackedStatusText = tracked

    local sync = createFont(statusFrame, "OVERLAY", "GameFontHighlightSmall", "LEFT", statusFrame, "LEFT", 370, 0)
    sync:SetWidth(250)
    sync:SetText("Sync: Off")
    parent.syncStatusText = sync

    local hint = createFont(statusFrame, "OVERLAY", "GameFontDisableSmall", "RIGHT", statusFrame, "RIGHT", -8, 0)
    hint:SetWidth(360)
    hint:SetJustifyH("RIGHT")
    hint:SetText("Shows observed chat patterns for review, not verdicts.")
    parent.statusHintText = hint

    bindTooltip(statusFrame, "Live Scanner Status", function()
        return {
            "The report refreshes while this window is open.",
            "Sync uses hidden guild/group addon channels.",
            "Big Bot Tracker never joins a custom chat channel.",
            "Current sync state: " .. tostring(BBT.Sync and BBT.Sync.status or "Off"),
        }
    end)
end

local function createFilterBar(parent)
    local filterFrame = createFrame("Frame", nil, parent)
    filterFrame:SetPoint("TOPLEFT", parent, "TOPLEFT", OUTER_MARGIN, FILTER_TOP)
    filterFrame:SetSize(TABLE_VIEW_WIDTH, 22)
    parent.filterFrame = filterFrame

    local x = 0
    for _, filter in ipairs(filters) do
        local width = filter.key == "all" and 52 or filter.key == "reported" and 86 or 78
        local button = createButton(filterFrame, filter.label, width, 22)
        button:SetPoint("LEFT", filterFrame, "LEFT", x, 0)
        button.filterKey = filter.key
        button:SetScript("OnClick", function(self)
            UI.SetFilter(self.filterKey)
            updateFilterButtons()
            UI.Refresh()
        end)
        bindTooltip(button, filter.label .. " Filter", { filter.tooltip })
        filterButtons[filter.key] = button
        x = x + width + 6
    end

    channelDropdownButton = createButton(filterFrame, "Channel: All", 180, 22)
    channelDropdownButton:SetPoint("LEFT", filterFrame, "LEFT", x + 8, 0)
    channelDropdownButton:SetScript("OnClick", function()
        if channelDropdownMenu and channelDropdownMenu:IsShown() then
            hideChannelFilterMenu()
        else
            showChannelFilterMenu()
        end
    end)
    bindTooltip(channelDropdownButton, "Channel Filter", function()
        local selected = UI.GetChannelFilterState()
        return {
            selected and ("Showing candidates seen in " .. selected .. ".") or "Showing candidates from all channels.",
        }
    end)

    updateFilterButtons()
    updateChannelFilterDropdown()
end

local function confirmPopup(name, text, onAccept)
    if StaticPopupDialogs and StaticPopup_Show then
        StaticPopupDialogs[name] = {
            text = text,
            button1 = "Confirm",
            button2 = "Cancel",
            OnAccept = onAccept,
            timeout = 0,
            whileDead = true,
            hideOnEscape = true,
            preferredIndex = 3,
        }
        StaticPopup_Show(name)
    else
        onAccept()
    end
end

local function createControls(parent)
    local refresh = createButton(parent, "Refresh", 82, 22)
    refresh:SetPoint("BOTTOMLEFT", parent, "BOTTOMLEFT", OUTER_MARGIN, 16)
    refresh:SetScript("OnClick", function()
        UI.Refresh()
    end)
    bindTooltip(refresh, "Refresh", { "Manually rebuild the visible report." })

    local export = createButton(parent, "Export", 72, 22)
    export:SetPoint("LEFT", refresh, "RIGHT", 8, 0)
    export:SetScript("OnClick", function()
        Storage.GetSettings().lastDebugSummary = Storage.BuildDebugSummary()
        Util.Print("Debug summary saved in BigBotTrackerDB.settings.lastDebugSummary.")
    end)
    bindTooltip(export, "Export Debug Summary", { "Stores a compact debug summary in SavedVariables." })

    local sync = createButton(parent, "Sync", 72, 22)
    sync:SetPoint("LEFT", export, "RIGHT", 8, 0)
    sync:SetScript("OnClick", function()
        local settings = Storage.GetSettings()
        BBT.Sync.SetEnabled(not settings.sync.enabled)
        UI.Refresh()
    end)
    bindTooltip(sync, "Sync", {
        "Enable or disable evidence capsule sharing with guild or group members.",
        "Does not join a custom chat channel.",
    })

    local purgeAll = createButton(parent, "Purge All", 88, 22)
    purgeAll:SetPoint("BOTTOMRIGHT", parent, "BOTTOMRIGHT", -OUTER_MARGIN, 16)
    purgeAll:SetScript("OnClick", function()
        confirmPopup("BIGBOTTRACKER_PURGE_ALL", "Purge all Big Bot Tracker candidate data?", function()
            Storage.PurgeAll()
            clearDetails()
            Util.Print("All Big Bot Tracker data purged.")
            UI.Refresh()
        end)
    end)
    bindTooltip(purgeAll, "Purge All", { "Destructive: removes all persisted candidate evidence." })

    local purgeSelected = createButton(parent, "Purge Selected", 122, 22)
    purgeSelected:SetPoint("RIGHT", purgeAll, "LEFT", -8, 0)
    purgeSelected:SetScript("OnClick", function()
        if not selectedCandidate then
            Util.Print("Select a candidate first.")
            return
        end

        local candidate = selectedCandidate
        confirmPopup(
            "BIGBOTTRACKER_PURGE_SELECTED",
            "Purge Big Bot Tracker data for " .. tostring(candidate.displayName) .. "?",
            function()
                Storage.PurgeCandidate(candidate)
                Util.Print("Purged " .. tostring(candidate.displayName) .. ".")
                clearDetails()
                UI.Refresh()
            end
        )
    end)
    bindTooltip(purgeSelected, "Purge Selected", { "Destructive: removes evidence for the selected candidate." })

    local clearBuffers = createButton(parent, "Clear Buffers", 112, 22)
    clearBuffers:SetPoint("RIGHT", purgeSelected, "LEFT", -8, 0)
    clearBuffers:SetScript("OnClick", function()
        confirmPopup("BIGBOTTRACKER_CLEAR_BUFFERS", "Clear runtime scan buffers?", function()
            Storage.ClearRuntimeBuffers()
            Util.Print("Runtime scan buffers cleared.")
            UI.Refresh()
        end)
    end)
    bindTooltip(clearBuffers, "Clear Buffers", { "Clears unpromoted runtime scan buffers." })

    updateReportControls(nil)
end

function UI.Refresh()
    if not frame or not frame:IsShown() then
        return
    end

    refreshCount = refreshCount + 1
    updateHeaderLabels()
    updateFilterButtons()
    updateChannelFilterDropdown()

    local allCandidates = Storage.GetAllCandidates()
    local candidates = UI.SortCandidates(UI.FilterCandidates(allCandidates))
    if #allCandidates == 0 then
        emptyState:SetText("No tracked candidates yet. Monitoring joined public channels.")
    else
        emptyState:SetText("No candidates match the current filter.")
    end
    emptyState:SetShown(#candidates == 0)

    local contentHeight = math.max(TABLE_HEIGHT, #candidates * ROW_HEIGHT)
    tableContent.contentHeight = contentHeight
    tableContent:SetSize(TABLE_CONTENT_WIDTH, contentHeight)

    local maxScroll = math.max(0, contentHeight - TABLE_HEIGHT)
    if (tableScroll:GetVerticalScroll() or 0) > maxScroll then
        tableScroll:SetVerticalScroll(maxScroll)
    end

    local selectedStillPresent = false
    for index, candidate in ipairs(candidates) do
        if candidate.fullKey == selectedKey then
            selectedCandidate = candidate
            selectedStillPresent = true
        end

        local row = rows[index] or createRow(index)
        row.index = index
        populateRow(row, candidate)
    end

    for index = #candidates + 1, #rows do
        rows[index].candidate = nil
        if rows[index].watchButton then
            rows[index].watchButton.candidate = nil
        end
        rows[index]:Hide()
    end

    if selectedKey and not selectedStillPresent then
        clearDetails()
    elseif selectedCandidate then
        refreshDetails(selectedCandidate)
    else
        refreshDetails(nil)
    end

    updateAllRowVisuals()
    UI.UpdateStatus()
end

function UI.Create()
    if frame then
        return frame
    end

    frame = createFrame("Frame", FRAME_NAME, UIParent, "BasicFrameTemplateWithInset")
    frame:SetSize(FRAME_WIDTH, FRAME_HEIGHT)
    frame:SetPoint("CENTER")
    if frame.SetFrameStrata then
        frame:SetFrameStrata("DIALOG")
    end
    if frame.SetFrameLevel then
        frame:SetFrameLevel(100)
    end
    if frame.SetToplevel then
        frame:SetToplevel(true)
    end
    frame:SetMovable(true)
    frame:SetClampedToScreen(true)
    frame:EnableMouse(true)
    frame:RegisterForDrag("LeftButton")
    frame:SetScript("OnMouseDown", function()
        raiseFrame()
    end)
    frame:SetScript("OnDragStart", function(self)
        raiseFrame()
        self:StartMoving()
    end)
    frame:SetScript("OnDragStop", frame.StopMovingOrSizing)
    frame:Hide()
    registerEscapeClose()

    frame.title =
        createFont(frame, "OVERLAY", "GameFontHighlightLarge", "TOPLEFT", frame, "TOPLEFT", OUTER_MARGIN, TITLE_TOP)
    frame.title:SetText("Big Bot Tracker")

    frame.subtitle =
        createFont(frame, "OVERLAY", "GameFontDisableSmall", "TOPLEFT", frame, "TOPLEFT", OUTER_MARGIN, SUBTITLE_TOP)
    frame.subtitle:SetWidth(HEADER_CONTENT_WIDTH)
    frame.subtitle:SetText("Chat evidence viewer for repeated public-channel patterns.")

    frame.iconArea = createFrame("Frame", nil, frame)
    frame.iconArea:SetSize(WINDOW_ICON_SIZE, WINDOW_ICON_SIZE)
    frame.iconArea:SetPoint("TOPRIGHT", frame, "TOPRIGHT", HEADER_ICON_RIGHT, HEADER_ICON_TOP)

    frame.icon = frame.iconArea:CreateTexture(nil, "OVERLAY")
    frame.icon:SetAllPoints(frame.iconArea)
    frame.icon:SetTexture(ADDON_ICON_TEXTURE)

    createStatusStrip(frame)
    createFilterBar(frame)
    createTable(frame)
    createDetails(frame)
    createControls(frame)
    clearDetails()

    frame:SetScript("OnShow", function()
        UI.Refresh()
    end)

    return frame
end

function UI.Open()
    UI.Create()
    frame:Show()
    UI.Refresh()
end

function UI.Toggle()
    UI.Create()
    if frame:IsShown() then
        frame:Hide()
    else
        frame:Show()
        UI.Refresh()
    end
end

function UI.UpdateStatus()
    if not frame then
        return
    end

    local tracked = Storage.GetAllCandidates()
    local visible = UI.FilterCandidates(tracked)
    if frame.scanStatusText then
        frame.scanStatusText:SetText("Live: scanning")
    end
    if frame.trackedStatusText then
        frame.trackedStatusText:SetText(string.format("Tracked: %d (%d visible)", #tracked, #visible))
    end
    if frame.syncStatusText then
        frame.syncStatusText:SetText("Sync: " .. tostring(BBT.Sync and BBT.Sync.status or "Off"))
    end
end

function UI.MarkDirty(reason)
    dirty = true
    dirtyReason = reason or dirtyReason or "data"
end

function UI.IsDirty()
    return dirty
end

function UI.GetRefreshCount()
    return refreshCount
end

function UI.OnUpdate(elapsed)
    if not frame or not frame:IsShown() then
        return
    end

    elapsed = elapsed or 0
    dirtyElapsed = dirtyElapsed + elapsed
    passiveElapsed = passiveElapsed + elapsed
    statusElapsed = statusElapsed + elapsed

    if statusElapsed >= STATUS_REFRESH_SECONDS then
        UI.UpdateStatus()
        statusElapsed = 0
    end

    if dirty and dirtyElapsed >= DIRTY_REFRESH_SECONDS then
        dirty = false
        dirtyReason = nil
        dirtyElapsed = 0
        passiveElapsed = 0
        UI.Refresh()
        return
    end

    if not dirty and passiveElapsed >= PASSIVE_REFRESH_SECONDS then
        passiveElapsed = 0
        UI.Refresh()
    end
end