ICANNWiki

Module:AchievementSystem: Difference between revisions

← Older edit
MarkWD (talk | contribs)
Bureaucrats, Check users, Interface administrators, Administrators (Semantic MediaWiki), Curators (Semantic MediaWiki), Editors (Semantic MediaWiki), steward, Suppressors, Administrators, Temporary account IP viewers
25,069 edits
// via Wikitext Extension for VSCode
// via Wikitext Extension for VSCode
 
(35 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:AchievementSystem
--[[
-- Achievement system that loads data from MediaWiki:AchievementData.json.
* Name: AchievementSystem
-- STYLING NOTE: All achievement styling is defined in CSS/Templates.css, not in the JSON.
* Author: Mark W. Datysgeld
-- This module only assigns CSS classes based on achievement IDs in the format:
* Description: Comprehensive achievement system that manages user badges and titles throughout ICANNWiki, loading data from MediaWiki JSON files and providing rendering functions for Person templates
--   .person-template .template-title.achievement-{id}::after {}
* Notes: Loads from MediaWiki:AchievementData.json (user assignments) and MediaWiki:AchievementList.json (type definitions). CSS styling defined in Templates.css using achievement-{id} format. Includes caching and fallback mechanisms for robust JSON handling
--
]]
-- The module does not use any styling information from the JSON data structure.
 
---@class UserAchievement
---@field type string
---@field date? string


local Achievements = {}
local Achievements = {}
-- Debug configuration
local DEBUG_MODE = true
local function debugLog(message)
    if not DEBUG_MODE then return end
    pcall(function()
        mw.logObject({
            system = "achievement_simple",
            message = message,
            timestamp = os.date('%H:%M:%S')
        })
    end)
    mw.log("ACHIEVEMENT-DEBUG: " .. message)
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- JSON Handling
-- JSON Handling
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
local json
-- Helper function to ensure we get an array
local jsonLoaded = pcall(function()
local function ensureArray(value)
     json = require('Module:JSON')
    if type(value) ~= "table" then
end)
        return {}
    end
   
    -- Check if it's an array-like table
    local isArray = true
    local count = 0
    for _ in pairs(value) do
        count = count + 1
    end
   
    -- If it has no numeric indices or is empty, return empty array
    if count == 0 then
        return {}
    end
   
    -- If it's a single string, wrap it in an array
    if count == 1 and type(value[1]) == "string" then
        return {value[1]}
    end
   
    -- If it has a single non-array value, try to convert it to an array
     if count == 1 and next(value) and type(next(value)) ~= "number" then
        local k, v = next(value)
        if type(v) == "string" then
            return {v}
        end
    end
   
    -- Return the original table if it seems to be an array
    return value
end


if not jsonLoaded or not json then
-- Use MediaWiki's built-in JSON functions directly
     json = { decode = function() return nil end }
local function jsonDecode(jsonString)
     debugLog('WARNING: Module:JSON not available, achievement features will be limited')
    if not jsonString then return nil end
      
    if mw.text and mw.text.jsonDecode then
        local success, result = pcall(function()
            -- Use WITHOUT PRESERVE_KEYS flag to ensure proper array handling
            return mw.text.jsonDecode(jsonString)
        end)
       
        if success and result then
            return result
        end
    end
      
    return nil
end
end


Line 52: Line 84:
-- Configuration, Default Data, and Cache
-- Configuration, Default Data, and Cache
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
local ACHIEVEMENT_DATA_PAGE = 'MediaWiki:AchievementData.json'
local ACHIEVEMENT_DATA_PAGE = 'MediaWiki:AchievementData.json'
local ACHIEVEMENT_LIST_PAGE = 'MediaWiki:AchievementList.json'
local dataCache = nil
local dataCache = nil
local typesCache = nil


local DEFAULT_DATA = {
local DEFAULT_DATA = {
     schema_version = 1,
     schema_version = 2,
     last_updated = os.date('!%Y-%m-%dT%H:%M:%SZ'),
     last_updated = os.date('!%Y-%m-%dT%H:%M:%SZ'),
     achievement_types = {},
     achievement_types = {},
     user_achievements = {},
     user_achievements = {},
    cache_control = { version = 0 }
}
}


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Configuration
-- Load achievement types from the JSON page
-- @param frame - The Scribunto frame object for preprocessing
-- @return Array of achievement type definitions
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- This array maps legacy achievement IDs to standardized ones
function Achievements.loadTypes(frame)
local ACHIEVEMENT_TYPE_MAPPING = {
    -- Use the request-level cache if we already loaded data once
    ["title-test"] = "dev-role",
    if typesCache then
    ["jedi"]      = "ach1",
        return typesCache
    ["champion"]  = "ach2",
    end
    ["sponsor"]  = "ach3"
 
}
    local success, types = pcall(function()
        -- Get the JSON content using frame:preprocess if available
        local jsonText
        if frame and type(frame) == "table" and frame.preprocess then
            -- Make sure frame is valid and has preprocess method
            local preprocessSuccess, preprocessResult = pcall(function()
                return frame:preprocess('{{MediaWiki:AchievementList.json}}')
            end)
           
            if preprocessSuccess and preprocessResult then
                jsonText = preprocessResult
            end
        end
       
        -- If we couldn't get JSON from frame:preprocess, fall back to direct content loading
        if not jsonText then
            -- Try using mw.loadJsonData first (preferred method)
            if mw.loadJsonData then
                local loadJsonSuccess, jsonData = pcall(function()
                    return mw.loadJsonData(ACHIEVEMENT_LIST_PAGE)
                end)
               
                if loadJsonSuccess and jsonData and type(jsonData) == 'table' and jsonData.achievement_types then
                    return jsonData.achievement_types
                end
            end
           
            -- Direct content loading approach as fallback
            local pageTitle = mw.title.new(ACHIEVEMENT_LIST_PAGE)
            if pageTitle and pageTitle.exists then
                -- Get raw content from the wiki page
                local contentSuccess, content = pcall(function()
                    return pageTitle:getContent()
                end)
               
                if contentSuccess and content and content ~= "" then
                    -- Remove any BOM or leading whitespace that might cause issues
                    content = content:gsub("^%s+", "")
                    if content:byte(1) == 239 and content:byte(2) == 187 and content:byte(3) == 191 then
                        content = content:sub(4)
                    end
                   
                    jsonText = content
                   
                    -- Try different JSON decode approaches
                    if jsonText and mw.text and mw.text.jsonDecode then
                        -- First try WITHOUT PRESERVE_KEYS flag (standard approach)
                        local jsonDecodeSuccess, jsonData = pcall(function()
                            return mw.text.jsonDecode(jsonText)
                        end)
                       
                        if jsonDecodeSuccess and jsonData and jsonData.achievement_types then
                            return jsonData.achievement_types
                        end
                       
                        -- If that failed, try with JSON_TRY_FIXING flag
                        jsonDecodeSuccess, jsonData = pcall(function()
                            return mw.text.jsonDecode(jsonText, mw.text.JSON_TRY_FIXING)
                        end)
                       
                        if jsonDecodeSuccess and jsonData and jsonData.achievement_types then
                            return jsonData.achievement_types
                        end
                    end
                end
            end
           
            -- If we couldn't load from AchievementList.json, fall back to AchievementData.json
            local data = Achievements.loadData(frame)
            if data and data.achievement_types then
                return data.achievement_types
            end
        else
            -- We have jsonText from frame:preprocess, try to decode it
            if jsonText and mw.text and mw.text.jsonDecode then
                -- First try WITHOUT PRESERVE_KEYS flag (standard approach)
                local jsonDecodeSuccess, jsonData = pcall(function()
                    return mw.text.jsonDecode(jsonText)
                end)
               
                if jsonDecodeSuccess and jsonData and jsonData.achievement_types then
                    return jsonData.achievement_types
                end
               
                -- If that failed, try with JSON_TRY_FIXING flag
                jsonDecodeSuccess, jsonData = pcall(function()
                    return mw.text.jsonDecode(jsonText, mw.text.JSON_TRY_FIXING)
                end)
               
                if jsonDecodeSuccess and jsonData and jsonData.achievement_types then
                    return jsonData.achievement_types
                end
            end
           
            -- If we couldn't decode the JSON, fall back to AchievementData.json
            local data = Achievements.loadData(frame)
            if data and data.achievement_types then
                return data.achievement_types
            end
        end
       
        -- As an absolute last resort, return an empty array
        return {}
    end)


-- Normalizes achievement type to handle variants or legacy types
     if not success or not types then
local function normalizeAchievementType(achievementType)
        -- If there was an error, fall back to AchievementData.json
     if not achievementType then return nil end
        local data = Achievements.loadData(frame)
   
        if data and data.achievement_types then
    -- If it's already a standard type, return it directly
            typesCache = data.achievement_types
    if achievementType == "dev-role" or
            return typesCache
      achievementType == "ach1" or
        end
      achievementType == "ach2" or
         types = {}
      achievementType == "ach3" then
         return achievementType
     end
     end
   
 
     -- Otherwise check the mapping table
     typesCache = types
     return ACHIEVEMENT_TYPE_MAPPING[achievementType] or achievementType
     return types
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Load achievement data from the JSON page
-- Load achievement data from the JSON page
-- @param frame - The Scribunto frame object for preprocessing
-- @return Table containing the full achievement data
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.loadData()
function Achievements.loadData(frame)
    mw.log("JSON-DEBUG: Starting to load achievement data")
 
     -- Use the request-level cache if we already loaded data once
     -- Use the request-level cache if we already loaded data once
     if dataCache then
     if dataCache then
        mw.log("JSON-DEBUG: Using request-level cached data")
         return dataCache
         return dataCache
     end
     end


     local success, data = pcall(function()
     local success, data = pcall(function()
         -- Try using the specialized JSON data loader - this is the correct MediaWiki way
         -- Get the JSON content using frame:preprocess if available
         -- to load JSON from wiki pages
         local jsonText
         mw.log("JSON-DEBUG: ===== LOAD JSON DATA ATTEMPT START =====")
         if frame and type(frame) == "table" and frame.preprocess then
        mw.log("JSON-DEBUG: Attempting to use mw.loadJsonData for " .. ACHIEVEMENT_DATA_PAGE)
            -- Make sure frame is valid and has preprocess method
       
             local preprocessSuccess, preprocessResult = pcall(function()
        -- Check if mw.loadJsonData is available
                return frame:preprocess('{{MediaWiki:AchievementData.json}}')
        if not mw.loadJsonData then
             end)
             mw.log("JSON-DEBUG: CRITICAL ERROR: mw.loadJsonData function does not exist!")
           
             mw.log("JSON-DEBUG: This indicates the MediaWiki version may be too old or misconfigured")
            if preprocessSuccess and preprocessResult then
        else
                jsonText = preprocessResult
             mw.log("JSON-DEBUG: mw.loadJsonData function exists, attempting to use it")
             end
         end
         end
          
          
         local loadJsonSuccess, jsonData = pcall(function()
         -- If we couldn't get JSON from frame:preprocess, fall back to direct content loading
            return mw.loadJsonData(ACHIEVEMENT_DATA_PAGE)
         if not jsonText then
        end)
             -- Try using mw.loadJsonData first (preferred method)
 
             if mw.loadJsonData then
         if loadJsonSuccess and jsonData then
                 local loadJsonSuccess, jsonData = pcall(function()
             mw.log("JSON-DEBUG: Successfully loaded data with mw.loadJsonData")
                     return mw.loadJsonData(ACHIEVEMENT_DATA_PAGE)
             mw.log("JSON-DEBUG: JSON data type: " .. type(jsonData))
                 end)
           
            -- Check if we got a table as expected
            if type(jsonData) == 'table' then
                 -- Check some expected fields to confirm it's valid
                if jsonData.achievement_types then
                    mw.log("JSON-DEBUG: ✓ Found achievement_types array with " ..
                          #(jsonData.achievement_types or {}) .. " entries")
                else
                     mw.log("JSON-DEBUG: ✗ Missing achievement_types array in loaded data!")
                 end
                  
                  
                 if jsonData.user_achievements then
                 if loadJsonSuccess and jsonData and type(jsonData) == 'table' then
                    local userCount = 0
                     return jsonData
                    for _, _ in pairs(jsonData.user_achievements) do
                        userCount = userCount + 1
                     end
                    mw.log("JSON-DEBUG: ✓ Found user_achievements for " .. userCount .. " users")
                else
                    mw.log("JSON-DEBUG: ✗ Missing user_achievements in loaded data!")
                 end
                 end
             end
             end
              
              
             return jsonData
             -- Direct content loading approach as fallback
        else
             local pageTitle = mw.title.new(ACHIEVEMENT_DATA_PAGE)
             mw.log("JSON-DEBUG: mw.loadJsonData failed: " .. tostring(jsonData or 'unknown error'))
            if not pageTitle or not pageTitle.exists then
                return DEFAULT_DATA
            end
           
            -- Get raw content from the wiki page
            local contentSuccess, content = pcall(function()
                return pageTitle:getContent()
            end)
              
              
            -- Try to categorize the error
             if contentSuccess and content and content ~= "" then
            local errorMsg = tostring(jsonData or '')
                 -- Remove any BOM or leading whitespace that might cause issues
             if errorMsg:match("content model") then
                 content = content:gsub("^%s+", "")
                mw.log("JSON-DEBUG: ERROR CAUSE: Content model issue - page must be set to 'json' model")
                if content:byte(1) == 239 and content:byte(2) == 187 and content:byte(3) == 191 then
            elseif errorMsg:match("JSON decode") or errorMsg:match("syntax") then
                     content = content:sub(4)
                 mw.log("JSON-DEBUG: ERROR CAUSE: JSON syntax error - check for invalid JSON formatting")
            elseif errorMsg:match("permission") or errorMsg:match("access") then
                 mw.log("JSON-DEBUG: ERROR CAUSE: Permission/access error - check page permissions")
            end
        end
       
        -- Try to fetch the raw content to see what's being received
        local rawContent = nil
        pcall(function()
            local title = mw.title.new(ACHIEVEMENT_DATA_PAGE)
            if title and title.exists then
                rawContent = title:getContent()
                if rawContent and #rawContent > 0 then
                    mw.log("JSON-DEBUG: Raw content first 100 chars: " ..
                          rawContent:sub(1, 100):gsub("\n", "\\n"):gsub("\t", "\\t"))
                         
                    -- Check if it starts with a curly brace
                    if rawContent:match("^%s*{") then
                        mw.log("JSON-DEBUG: ✓ Content starts with { (possibly with whitespace)")
                    else
                        mw.log("JSON-DEBUG: ✗ Content does NOT start with {")
                    end
                   
                    -- Check for common issues
                    if rawContent:match("^<!DOCTYPE") or rawContent:match("^<[Hh][Tt][Mm][Ll]") then
                        mw.log("JSON-DEBUG: ERROR: Content appears to be HTML, not JSON!")
                    elseif rawContent:match("^%s*<") then
                        mw.log("JSON-DEBUG: ERROR: Content appears to have XML/HTML markup!")
                    end
                else
                     mw.log("JSON-DEBUG: Could not get raw content or content is empty")
                 end
                 end
               
                jsonText = content
             else
             else
                 mw.log("JSON-DEBUG: Could not create title object or page doesn't exist")
                 return DEFAULT_DATA
             end
             end
        end)
       
        mw.log("JSON-DEBUG: ===== LOAD JSON DATA ATTEMPT END =====")
       
        -- GET RAW CONTENT DIRECTLY APPROACH - likely the most reliable method
        mw.log("JSON-DEBUG: ===== DIRECT RAW CONTENT METHOD START =====")
       
        -- Try to fetch the raw content directly with proper error handling
        local pageTitle = mw.title.new(ACHIEVEMENT_DATA_PAGE)
        if not pageTitle or not pageTitle.exists then
            mw.log("JSON-DEBUG: " .. ACHIEVEMENT_DATA_PAGE .. " does not exist or title creation failed")
            return DEFAULT_DATA
         end
         end
          
          
         -- Get raw content from the wiki page
         -- Try different JSON decode approaches
         local content = nil
         if jsonText and mw.text and mw.text.jsonDecode then
        local contentSuccess, contentResult = pcall(function()
            -- First try WITHOUT PRESERVE_KEYS flag (standard approach)
            return pageTitle:getContent()
            local jsonDecodeSuccess, jsonData = pcall(function()
        end)
                return mw.text.jsonDecode(jsonText)
       
            end)
        if contentSuccess and contentResult and contentResult ~= "" then
            content = contentResult
            mw.log("JSON-DEBUG: Successfully retrieved raw content, length: " .. #content)
              
              
             -- Log the first part of content for debugging
             if jsonDecodeSuccess and jsonData then
            local contentPreview = content:sub(1, 100):gsub("\n", "\\n"):gsub("\t", "\\t")
                return jsonData
             mw.log("JSON-DEBUG: Content preview: " .. contentPreview)
             end
              
              
             -- Remove any BOM or leading whitespace that might cause issues
             -- If that failed, try with JSON_TRY_FIXING flag
             content = content:gsub("^%s+", "")
             jsonDecodeSuccess, jsonData = pcall(function()
            if content:byte(1) == 239 and content:byte(2) == 187 and content:byte(3) == 191 then
                 return mw.text.jsonDecode(jsonText, mw.text.JSON_TRY_FIXING)
                 mw.log("JSON-DEBUG: Removing UTF-8 BOM from content")
             end)
                content = content:sub(4)
             end
              
              
             -- Check if content starts with { or [
             if jsonDecodeSuccess and jsonData then
            if content:match("^%s*[{%[]") then
                return jsonData
                mw.log("JSON-DEBUG: Content appears to be valid JSON")
               
                -- Use mw.text.jsonDecode for parsing
                if mw.text and mw.text.jsonDecode then
                    local jsonDecodeSuccess, jsonData = pcall(function()
                        mw.log("JSON-DEBUG: Using mw.text.jsonDecode on raw content")
                        return mw.text.jsonDecode(content)
                    end)
                   
                    if jsonDecodeSuccess and jsonData then
                        mw.log("JSON-DEBUG: ✓ Successfully decoded content with mw.text.jsonDecode")
                       
                        -- Validate the structure
                        if jsonData.achievement_types and jsonData.user_achievements then
                            mw.log("JSON-DEBUG: ✓ Parsed JSON has required fields")
                            mw.log("JSON-DEBUG: ===== DIRECT RAW CONTENT METHOD SUCCESS =====")
                            return jsonData
                        else
                            mw.log("JSON-DEBUG: ✗ Parsed JSON missing critical fields")
                        end
                    else
                        mw.log("JSON-DEBUG: ✗ mw.text.jsonDecode failed: " .. tostring(jsonData or 'unknown error'))
                    end
                else
                    mw.log("JSON-DEBUG: ✗ mw.text.jsonDecode not available")
                end
               
                -- Fallback to Module:JSON if available
                if json and json.decode then
                    local parseSuccess, parsedData = pcall(function()
                        mw.log("JSON-DEBUG: Using Module:JSON's json.decode as fallback")
                        return json.decode(content)
                    end)
                   
                    if parseSuccess and parsedData then
                        mw.log("JSON-DEBUG: ✓ Successfully decoded with Module:JSON")
                        mw.log("JSON-DEBUG: ===== DIRECT RAW CONTENT METHOD SUCCESS =====")
                        return parsedData
                    else
                        mw.log("JSON-DEBUG: ✗ Module:JSON decode failed: " .. tostring(parsedData or 'unknown error'))
                    end
                end
            else
                mw.log("JSON-DEBUG: ✗ Content does not appear to be valid JSON")
                mw.log("JSON-DEBUG: First 10 characters: " .. content:sub(1, 10):gsub("\n", "\\n"):gsub("\t", "\\t"))
             end
             end
        else
            mw.log("JSON-DEBUG: ✗ Failed to get content: " .. tostring(contentResult or 'unknown error'))
        end
       
        mw.log("JSON-DEBUG: ===== DIRECT RAW CONTENT METHOD FAILED =====")
       
        -- FALLBACK SAFETY APPROACHES
       
        -- Try parser cache as fallback
        local loadDataSuccess, cachedData = pcall(function()
            mw.log("JSON-DEBUG: Attempting mw.loadData fallback")
            return mw.loadData('Module:AchievementSystem')
        end)
        if loadDataSuccess and cachedData then
            mw.log("JSON-DEBUG: Using mw.loadData cached data")
            return cachedData
        else
            mw.log("JSON-DEBUG: mw.loadData failed, using default data")
         end
         end
       
         -- As an absolute last resort, use local default data
         -- As absolute last resort, use local default data
         return DEFAULT_DATA
         mw.log("JSON-DEBUG: All JSON loading approaches failed, using default data")
     end)
     end)


     if not success or not data then
     if not success or not data then
        mw.log("JSON-DEBUG: Critical error in load process: " .. tostring(data or 'unknown error'))
         data = DEFAULT_DATA
         data = DEFAULT_DATA
     end
     end


     -- Show success source in log
     dataCache = data
     if data ~= DEFAULT_DATA then
    return data
         mw.log("JSON-DEBUG: Successfully loaded JSON data with " .. tostring(#(data.achievement_types or {})) .. " achievement types")
end
       
 
        -- Log actual achievement types if DEBUG_MODE
--------------------------------------------------------------------------------
        if DEBUG_MODE and data.achievement_types then
-- Get user achievements
            for i, type in ipairs(data.achievement_types) do
-- @param pageId - The page ID to get achievements for
                mw.log("JSON-DEBUG: Type[" .. i .. "]: id=" .. (type.id or "nil") .. ", name=" .. (type.name or "nil"))
-- @return Array of achievement objects for the specified page
             end
--------------------------------------------------------------------------------
local userAchievementsCache = {}
 
---@return UserAchievement[]
function Achievements.getUserAchievements(pageId)
     if not pageId or pageId == '' then
         return {}
    end
   
    -- Check cache first
    local cacheKey = tostring(pageId)
    if userAchievementsCache[cacheKey] then
        return userAchievementsCache[cacheKey]
    end
 
    local data = Achievements.loadData()
    if not data or not data.user_achievements then
        return {}
    end
 
    local key = cacheKey
    local userEntry = data.user_achievements[key]
   
    -- If found with string key, return achievements
    if userEntry and userEntry.achievements then
        local achievements = ensureArray(userEntry.achievements)
        userAchievementsCache[cacheKey] = achievements
        return achievements
    end
   
    -- Try numeric key as fallback
    local numKey = tonumber(key)
    if numKey then
        userEntry = data.user_achievements[numKey]
        if userEntry and userEntry.achievements then
            local achievements = ensureArray(userEntry.achievements)
             userAchievementsCache[cacheKey] = achievements
            return achievements
         end
         end
     end
     end
 
   
     dataCache = data
    -- Cache empty result to avoid repeated lookups
     return data
     userAchievementsCache[cacheKey] = {}
     return {}
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Check if a page/user has any achievements
-- Check if a page/user has any achievements
-- @param pageId - The page ID to check
-- @return Boolean indicating if the page has any achievements
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.hasAchievements(pageId)
function Achievements.hasAchievements(pageId)
Line 327: Line 380:
     end
     end


     local data = Achievements.loadData()
     local userAchievements = Achievements.getUserAchievements(pageId)
     if not data or not data.user_achievements then
    return #userAchievements > 0
         return false
end
 
--------------------------------------------------------------------------------
-- Get all badge-type achievements for a user
-- @param pageId - The page ID to check
-- @param frame - The Scribunto frame object for preprocessing
-- @return Array of badge achievement objects
--------------------------------------------------------------------------------
function Achievements.getBadgeAchievements(pageId, frame)
     if not pageId or pageId == '' then
         return {}
     end
     end


     local key = tostring(pageId)
     local userAchievements = Achievements.getUserAchievements(pageId)
     if data.user_achievements[key] and #data.user_achievements[key] > 0 then
     if #userAchievements == 0 then
         return true
         return {}
     end
     end


     -- Check for legacy "n123" style
    local types = Achievements.loadTypes(frame)
     if key:match("^%d+$") then
   
         local alt = "n" .. key
     -- Build a lookup table for achievement types for efficient access
         if data.user_achievements[alt] and #data.user_achievements[alt] > 0 then
    local typeDefinitions = {}
             return true
     for _, typeData in ipairs(types) do
        if typeData.id and typeData.type then
            typeDefinitions[typeData.id] = typeData
        end
    end
   
    local badgeAchievements = {}
    -- Filter user achievements to only include badge types
    for _, achievementTbl in ipairs(userAchievements) do
         local achType = achievementTbl['type']
         if achType and typeDefinitions[achType] and typeDefinitions[achType]['type'] == "badge" then
                local newAchievement = {
                    type = achType,
                    date = achievementTbl['date'] or '',
                    name = typeDefinitions[achType].name or achType,
                    category = typeDefinitions[achType].category
                }
             table.insert(badgeAchievements, newAchievement)
         end
         end
     end
     end


    -- We removed the forced "true" for test pages to avoid dev-role injection
     return badgeAchievements
     return false
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Get a user-friendly name for a given achievement type
-- Get a user-friendly name for a given achievement type
-- @param achievementType - The achievement type ID
-- @param frame - The Scribunto frame object for preprocessing
-- @return String containing the user-friendly name
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.getAchievementName(achievementType)
function Achievements.getAchievementName(achievementType, frame)
     if not achievementType or achievementType == '' then
     if not achievementType or achievementType == '' then
        debugLog("Empty achievement type provided to getAchievementName")
        mw.log("ACHIEVEMENT-NAME-ERROR: Received empty achievementType")
         return 'Unknown'
         return 'Unknown'
     end
     end


    debugLog("Looking up achievement name for type: '" .. tostring(achievementType) .. "'")
     local types = Achievements.loadTypes(frame)
 
     local data = Achievements.loadData()
    if not data or not data.achievement_types then
        mw.log("ACHIEVEMENT-NAME-ERROR: No achievement data or achievement_types missing")
        return achievementType
    end
      
      
    -- Display available achievement types in the log
    mw.log("ACHIEVEMENT-NAME-DEBUG: Searching achievement types for: " .. achievementType)
    mw.log("ACHIEVEMENT-NAME-DEBUG: Available achievement types:")
    for i, typeData in ipairs(data.achievement_types) do
        mw.log("  " .. i .. ": id=" .. (typeData.id or "nil") ..
              ", name=" .. (typeData.name or "nil") ..
              ", tier=" .. (typeData.tier or "nil"))
    end
     -- Try to match achievement ID
     -- Try to match achievement ID
     for i, typeData in ipairs(data.achievement_types) do
     for _, typeData in ipairs(types) do
         if typeData.id == achievementType then
         if typeData.id == achievementType then
             if typeData.name and typeData.name ~= "" then
             if typeData.name and typeData.name ~= "" then
                mw.log("ACHIEVEMENT-NAME-SUCCESS: Found achievement: " .. typeData.id .. " with name: " .. typeData.name)
                 return typeData.name
                 return typeData.name
             else
             else
                mw.log("ACHIEVEMENT-NAME-WARNING: '" .. typeData.id .. "' has no name; using ID")
                 return achievementType
                 return achievementType
             end
             end
Line 389: Line 452:
     end
     end


    -- Special case for dev-role lookup - always show details
    if achievementType == "dev-role" then
        mw.log("ACHIEVEMENT-NAME-WARNING: Could not find dev-role in achievement_types!")
        mw.log("ACHIEVEMENT-NAME-DEBUG: Raw achievement_types:")
       
        -- Try to log the raw JSON for debugging
        pcall(function()
            if json and json.encode then
                mw.log(json.encode(data.achievement_types))
            end
        end)
    end
    mw.log("ACHIEVEMENT-NAME-ERROR: No achievement found with type '" .. achievementType .. "'; using ID fallback")
     return achievementType
     return achievementType
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Find the top-tier achievement for the user (lowest tier number)
-- Find the top-tier Title achievement for the user (lowest tier number)
-- Return the CSS class and the readable achievement name
-- Return the CSS class and the readable achievement name
-- @param pageId - The page ID to get the title achievement for
-- @param frame - The Scribunto frame object for preprocessing
-- @return CSS class, display name
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.getTitleClass(pageId)
function Achievements.getTitleClass(pageId, frame)
     if not pageId or pageId == '' then
     if not pageId or pageId == '' then
        debugLog("Empty page ID provided to getTitleClass")
         return '', ''
         return '', ''
     end
     end


     local data = Achievements.loadData()
     local userAchievements = Achievements.getUserAchievements(pageId)
    if not data or not data.user_achievements then
     if #userAchievements == 0 then
        debugLog("No achievement data available in getTitleClass")
        return '', ''
    end
 
    local key = tostring(pageId)
    debugLog("Looking up achievements for ID: " .. key)
   
    -- Debug logging to show available achievements in JSON
    if data.user_achievements then
        local availableIds = {}
        for k, _ in pairs(data.user_achievements) do
            table.insert(availableIds, k)
        end
        debugLog("Available user IDs in JSON: " .. table.concat(availableIds, ", "))
    end
 
    -- Try to fetch achievements for this pageId
    local userAchievements = data.user_achievements[key] or {}
   
    -- If no achievements found under normal ID, try alternative format
     if #userAchievements == 0 and key:match("^%d+$") then
        local altKey = "n" .. key
        debugLog("No achievements under ID '" .. key .. "', trying alternative ID: '" .. altKey .. "'")
        userAchievements = data.user_achievements[altKey] or {}
    end
 
    -- Special handling for test page ID 18451
    if key == "18451" then
        -- Verify if the dev-role achievement exists
        local devRoleFound = false
        for _, ach in ipairs(userAchievements) do
            if ach.type == "dev-role" then
                devRoleFound = true
                debugLog("FOUND DEV-ROLE for page 18451!")
                break
            end
        end
       
        -- If no achievements found for test page, this is concerning
        if #userAchievements == 0 then
            debugLog("WARNING: Test page ID 18451 has no achievements!")
        end
       
        -- If achievements exist but dev-role is missing, also concerning
        if #userAchievements > 0 and not devRoleFound then
            debugLog("WARNING: Test page ID 18451 has achievements but missing dev-role!")
        end
    end
 
    -- Log found achievements for debugging
    if #userAchievements > 0 then
        debugLog("Found " .. #userAchievements .. " achievements for user " .. key)
        for i, ach in ipairs(userAchievements) do
            debugLog("  Achievement " .. i .. ": type=" .. (ach.type or "nil"))
        end
    else
        debugLog("No achievements found for user " .. key)
         return '', ''
         return '', ''
     end
     end


    local types = Achievements.loadTypes(frame)
     local highestTier = 999
     local highestTier = 999
     local highestAchievement = nil
     local highestAchievement = nil


     for _, achievement in ipairs(userAchievements) do
     for _, achievement in ipairs(userAchievements) do
         local achType = achievement.type
         local achType = achievement["type"]
        debugLog("Processing achievement type: " .. (achType or "nil"))
          
          
         for _, typeData in ipairs(data.achievement_types) do
         for _, typeData in ipairs(types) do
             if typeData.id == achType then
             if typeData.id == achType then
                 local tier = typeData.tier or 999
                 local tier = typeData.tier or 999
                debugLog("  Found type '" .. typeData.id .. "' with tier " .. tier .. " and name '" .. (typeData.name or "nil") .. "'")
                 if tier < highestTier then
                 if tier < highestTier then
                     highestTier = tier
                     highestTier = tier
                     highestAchievement = typeData
                     highestAchievement = typeData
                    debugLog("  New highest tier achievement: " .. typeData.id)
                 end
                 end
             end
             end
Line 499: Line 491:


     if not highestAchievement or not highestAchievement.id then
     if not highestAchievement or not highestAchievement.id then
        debugLog("No valid top-tier achievement found for user " .. key)
         return '', ''
         return '', ''
     end
     end
Line 505: Line 496:
     local cssClass = "achievement-" .. highestAchievement.id
     local cssClass = "achievement-" .. highestAchievement.id
     local displayName = highestAchievement.name or highestAchievement.id or "Award"
     local displayName = highestAchievement.name or highestAchievement.id or "Award"
   
    debugLog("Using top-tier achievement: " .. cssClass .. " with name: " .. displayName)
      
      
     return cssClass, displayName
     return cssClass, displayName
Line 512: Line 501:


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Renders a simple "box" with the top-tier achievement for the user
-- Renders a box with the top-tier achievement for the user
-- @param pageId - The page ID to render the achievement box for
-- @param frame - The Scribunto frame object for preprocessing
-- @return HTML string containing the achievement box
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.renderAchievementBox(pageId)
function Achievements.renderAchievementBox(pageId, frame)
     if not pageId or pageId == '' then
     if not pageId or pageId == '' then
         return ''
         return ''
     end
     end


     local data = Achievements.loadData()
     local userAchievements = Achievements.getUserAchievements(pageId)
    if not data or not data.user_achievements then
     if #userAchievements == 0 then
        return ''
    end
 
    local key = tostring(pageId)
    local userAchievements = data.user_achievements[key]
    if (not userAchievements or #userAchievements == 0) and key:match("^%d+$") then
        userAchievements = data.user_achievements["n" .. key]
    end
 
     if not userAchievements or #userAchievements == 0 then
         return ''
         return ''
     end
     end
   
    local types = Achievements.loadTypes(frame)
      
      
     -- Build a lookup table for achievement type definitions
     -- Build a lookup table for achievement type definitions
     local typeDefinitions = {}
     local typeDefinitions = {}
     if data and data.achievement_types then
     for _, typeData in ipairs(types) do
        for _, typeData in ipairs(data.achievement_types) do
        if typeData.id and typeData.name then
            if typeData.id and typeData.name then
            typeDefinitions[typeData.id] = {
                typeDefinitions[typeData.id] = {
                name = typeData.name,
                    name = typeData.name,
                tier = typeData.tier or 999
                    tier = typeData.tier or 999
            }
                }
            end
         end
         end
     end
     end


     -- Look for the highest-tier achievement (lowest tier number)
     -- Look for the highest-tier Title achievement (lowest tier number)
     local highestTier = 999
     local highestTier = 999
     local topAchType = nil
     local topAchType = nil
Line 574: Line 556:


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Simple pass-through to track pages (for future expansions)
-- Get page name for a given page ID
-- @param pageId - The page ID to get the name for
-- @return String containing the page name
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.trackPage(pageId, pageName)
function Achievements.getPageName(pageId)
     return true
    if not pageId or pageId == '' then
        return ''
    end
   
    local data = Achievements.loadData()
    if not data or not data.user_achievements then
        return ''
    end
   
    local key = tostring(pageId)
    local userEntry = data.user_achievements[key]
   
    -- Check if entry exists with string key
    if userEntry and userEntry.page_name then
        return userEntry.page_name
    end
   
    -- Try numeric key as fallback
    local numKey = tonumber(key)
    if numKey then
        userEntry = data.user_achievements[numKey]
        if userEntry and userEntry.page_name then
            return userEntry.page_name
        end
    end
   
     return ''
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Retrieve a specific achievement if present, by type
-- Retrieve a specific achievement if present, by type
-- @param pageId - The page ID to get the achievement for
-- @param achievementType - The achievement type ID to look for
-- @return Achievement object or nil if not found
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.getSpecificAchievement(pageId, achievementType)
function Achievements.getSpecificAchievement(pageId, achievementType)
    debugLog("ACHIEVEMENT-DEBUG: Looking for '" .. tostring(achievementType) ..
            "' in page ID: " .. tostring(pageId))
     if not pageId or not achievementType or pageId == '' then
     if not pageId or not achievementType or pageId == '' then
        debugLog("ACHIEVEMENT-DEBUG: Invalid arguments for getSpecificAchievement")
         return nil
         return nil
     end
     end


     local data = Achievements.loadData()
     local userAchievements = Achievements.getUserAchievements(pageId)
    if not data or not data.user_achievements then
        debugLog("ACHIEVEMENT-DEBUG: No achievement data loaded")
        return nil
    end
 
    local key = tostring(pageId)
    local userAchievements = data.user_achievements[key] or {}
   
    -- If no achievements found under normal ID, try alternative format
    if #userAchievements == 0 and key:match("^%d+$") then
        local altKey = "n" .. key
        debugLog("No achievements under ID '" .. key .. "', trying alternative ID: '" .. altKey .. "'")
        userAchievements = data.user_achievements[altKey] or {}
    end
      
      
     -- Direct lookup for the requested achievement type
     -- Direct lookup for the requested achievement type
     for _, achievement in ipairs(userAchievements) do
     for _, achievementTbl in ipairs(userAchievements) do
         if achievement.type == achievementType then
         if achievementTbl["type"] == achievementType then
            debugLog("FOUND ACHIEVEMENT: " .. achievementType .. " for user " .. key)
local def = Achievements.getAchievementDefinition(achievementType)
             return achievement
            return {
                type    = achievementTbl.type,
                date    = achievementTbl.date or '',
                name    = def and def.name or achievementType,
                category = def and def.category
             }
         end
         end
     end
     end


    debugLog("ACHIEVEMENT-DEBUG: No match found for achievement type: " .. achievementType)
     return nil
     return nil
end
end
Line 622: Line 621:
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Get achievement definition directly from JSON data
-- Get achievement definition directly from JSON data
-- @param achievementType - The achievement type ID to get the definition for
-- @param frame - The Scribunto frame object for preprocessing
-- @return Achievement type definition or nil if not found
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.getAchievementDefinition(achievementType)
function Achievements.getAchievementDefinition(achievementType, frame)
     if not achievementType or achievementType == '' then
     if not achievementType or achievementType == '' then
        debugLog("ACHIEVEMENT-DEF: Empty achievement type")
         return nil
         return nil
     end
     end
      
      
     local data = Achievements.loadData()
     local types = Achievements.loadTypes(frame)
    if not data or not data.achievement_types then
        debugLog("ACHIEVEMENT-DEF: No achievement data loaded")
        return nil
    end
      
      
     -- Direct lookup in achievement_types array
     -- Direct lookup in achievement_types array
     for _, typeData in ipairs(data.achievement_types) do
     for _, typeData in ipairs(types) do
         if typeData.id == achievementType then
         if typeData.id == achievementType then
            debugLog("ACHIEVEMENT-DEF: Found definition for " .. achievementType)
             return typeData
             return typeData
         end
         end
     end
     end
      
      
    debugLog("ACHIEVEMENT-DEF: No definition found for " .. achievementType)
     return nil
     return nil
end
--------------------------------------------------------------------------------
-- Diagnostic Function: List all badges for a page with details
--------------------------------------------------------------------------------
function Achievements.debugBadgesForPage(pageId)
    if not pageId or pageId == '' then
        mw.log("BADGE-DEBUG: Empty page ID")
        return "ERROR: No page ID provided"
    end
    local data = Achievements.loadData()
    if not data then
        mw.log("BADGE-DEBUG: Failed to load achievement data")
        return "ERROR: Failed to load achievement data"
    end
    local key = tostring(pageId)
    local userAchievements = data.user_achievements[key] or {}
   
    -- Check alternate keys if needed
    if #userAchievements == 0 and key:match("^%d+$") then
        local altKey = "n" .. key
        userAchievements = data.user_achievements[altKey] or {}
        if #userAchievements > 0 then
            mw.log("BADGE-DEBUG: Found achievements under alternate key: " .. altKey)
        end
    end
    if #userAchievements == 0 then
        mw.log("BADGE-DEBUG: No achievements found for page ID " .. pageId)
        return "No achievements found for page ID " .. pageId
    end
    -- Build debug report
    local output = {}
    table.insert(output, "=== BADGE DEBUG FOR PAGE " .. pageId .. " ===")
    table.insert(output, "Found " .. #userAchievements .. " achievements")
   
    -- Check each achievement in detail
    for i, achievement in ipairs(userAchievements) do
        local achType = achievement.type or "nil"
        local typeDef = Achievements.getAchievementDefinition(achType)
       
        table.insert(output, "\nACHIEVEMENT " .. i .. ":")
        table.insert(output, "  Type: " .. achType)
       
        if typeDef then
            table.insert(output, "  Name: " .. (typeDef.name or "unnamed"))
            table.insert(output, "  Definition Type: " .. (typeDef.type or "unspecified"))
            table.insert(output, "  Description: " .. (typeDef.description or "none"))
            if typeDef.tier then
                table.insert(output, "  Tier: " .. typeDef.tier)
            end
        else
            table.insert(output, "  WARNING: No type definition found!")
        end
    end
   
    return table.concat(output, "\n")
end
end


Line 711: Line 646:
-- This specifically looks for achievements with type="title"
-- This specifically looks for achievements with type="title"
-- Return the CSS class, readable achievement name, and achievement ID (or empty strings if none found)
-- Return the CSS class, readable achievement name, and achievement ID (or empty strings if none found)
-- @param pageId - The page ID to get the title achievement for
-- @param frame - The Scribunto frame object for preprocessing
-- @return achievementId, displayName, achievementId
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.getTitleAchievement(pageId)
function Achievements.getTitleAchievement(pageId, frame)
     if not pageId or pageId == '' then
     if not pageId or pageId == '' then
        debugLog("Empty page ID provided to getTitleAchievement")
         return nil
         return '', '', ''
     end
     end


     local data = Achievements.loadData()
     local userAchievements = Achievements.getUserAchievements(pageId)
     if not data or not data.user_achievements then
     if #userAchievements == 0 then
        debugLog("No achievement data available in getTitleAchievement")
         return nil
         return '', '', ''
     end
     end


     local key = tostring(pageId)
     local types = Achievements.loadTypes(frame)
    debugLog("Looking up title achievements for ID: " .. key)
   
    -- Try to fetch achievements for this pageId
    local userAchievements = data.user_achievements[key] or {}
      
      
    -- If no achievements found under normal ID, try alternative format
    if #userAchievements == 0 and key:match("^%d+$") then
        local altKey = "n" .. key
        debugLog("No achievements under ID '" .. key .. "', trying alternative ID: '" .. altKey .. "'")
        userAchievements = data.user_achievements[altKey] or {}
    end
    -- Special case for test page ID 18451
    if key == "18451" then
        mw.log("TITLE-ACHIEVEMENT-DEBUG: Processing test page 18451")
    end
    -- Log found achievements for debugging
    if #userAchievements > 0 then
        debugLog("Found " .. #userAchievements .. " achievements for user " .. key)
       
        -- Log each achievement for the test page
        if key == "18451" then
            for i, ach in ipairs(userAchievements) do
                mw.log("TITLE-ACHIEVEMENT-DEBUG: Test page achievement " .. i .. " type=" .. (ach.type or "nil"))
            end
        end
    else
        debugLog("No achievements found for user " .. key)
        return '', '', ''
    end
     -- Build a table of achievement definitions for quick lookup
     -- Build a table of achievement definitions for quick lookup
     local typeDefinitions = {}
     local typeDefinitions = {}
     for _, typeData in ipairs(data.achievement_types) do
     for _, typeData in ipairs(types) do
         typeDefinitions[typeData.id] = typeData
         typeDefinitions[typeData.id] = typeData
       
        -- Log definitions for test page
        if key == "18451" then
            mw.log("TITLE-ACHIEVEMENT-DEBUG: Definition [" .. typeData.id .. "]: type=" ..
                  (typeData.type or "nil") .. ", name=" .. (typeData.name or "nil"))
        end
     end
     end


Line 772: Line 671:
     local highestTier = 999
     local highestTier = 999
     local titleAchievement = nil
     local titleAchievement = nil
 
   
     for i, achievement in ipairs(userAchievements) do
     for _, achievement in ipairs(userAchievements) do
         local achType = achievement.type
         local achType = achievement["type"]
         if achType then
         if achType then
             local typeData = typeDefinitions[achType]
             local typeData = typeDefinitions[achType]
             if typeData then
             if typeData and typeData["type"] == "title" then
                -- Check if it's a title type
                local tier = typeData.tier or 999
                local achDefType = typeData.type
                if tier < highestTier then
               
                    highestTier = tier
                -- Log processing details for test page
                    titleAchievement = typeData
                if key == "18451" then
                    mw.log("TITLE-ACHIEVEMENT-DEBUG: Checking achievement " .. i .. ": type=" .. achType ..
                          ", definition type=" .. (achDefType or "nil"))
                end
               
                -- Only consider achievements with type="title"
                if achDefType == "title" then
                    debugLog("Found title achievement: " .. achType)
                    local tier = typeData.tier or 999
                    if tier < highestTier then
                        highestTier = tier
                        titleAchievement = typeData
                        debugLog("New highest tier title achievement: " .. typeData.id)
                    end
                 end
                 end
            else
                debugLog("No type definition found for achievement: " .. achType)
             end
             end
        else
            debugLog("Achievement missing type property")
         end
         end
     end
     end


     if not titleAchievement or not titleAchievement.id then
     return titleAchievement
        debugLog("No valid title achievement found for user " .. key)
end
        return '', '', ''
    end


    local cssClass = "achievement-" .. titleAchievement.id
-- Renders a title block with achievement integration
     local displayName = titleAchievement.name or titleAchievement.id or "Award"
function Achievements.renderTitleBlockWithAchievement(args, titleClass, titleText, achievementClass, achievementId, achievementName)
    local achievementId = titleAchievement.id
     titleClass = titleClass or "template-title"
      
      
     debugLog("Using title achievement: " .. cssClass .. " with name: " .. displayName)
     -- Only add achievement attributes if they exist
      
    if achievementClass and achievementClass ~= "" and achievementId and achievementId ~= "" then
    return cssClass, displayName, achievementId
        return string.format(
            '|-\n! colspan="2" class="%s %s" data-achievement-id="%s" data-achievement-name="%s" | %s',
            titleClass, achievementClass, achievementId, achievementName, titleText
        )
     else
        -- Clean row with no achievement data
        return string.format('|-\n! colspan="2" class="%s" | %s', titleClass, titleText)
    end
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Diagnostic function that can be directly called to troubleshoot JSON loading
-- Generate wikitext category links for a given list of achievements
-- @param achievements - An array of user achievement objects
-- @param frame - The Scribunto frame object
-- @return A string of wikitext category links, e.g., "[[Category:Cat1]][[Category:Cat2]]"
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function Achievements.diagnoseJsonLoading()
function Achievements.getCategoryLinks(achievements, frame)
    local output = {}
     if not achievements or #achievements == 0 then
    table.insert(output, "===== ACHIEVEMENT SYSTEM JSON DIAGNOSTICS =====")
         return ""
      
    -- Check MediaWiki version and capabilities
    table.insert(output, "\n== MEDIAWIKI CAPABILITIES ==")
    if mw.loadJsonData then
         table.insert(output, "✓ mw.loadJsonData: Available")
    else
        table.insert(output, "❌ mw.loadJsonData: Not available! MediaWiki may be too old or misconfigured")
     end
     end
   
 
     if mw.text and mw.text.jsonDecode then
     local types = Achievements.loadTypes(frame)
        table.insert(output, "✓ mw.text.jsonDecode: Available")
     local typeDefinitions = {}
     else
    for _, typeData in ipairs(types) do
         table.insert(output, "❌ mw.text.jsonDecode: Not available! This is a critical function")
         typeDefinitions[typeData.id] = typeData
     end
     end
   
 
     if json and json.decode then
     local categoryLinks = {}
        table.insert(output, "✓ Module:JSON: Available")
     local foundCategories = {} -- To prevent duplicate categories
    else
 
        table.insert(output, "❌ Module:JSON: Not available or failed to load")
     for _, ach in ipairs(achievements) do
    end
         local achType = ach['type']
   
         local definition = typeDefinitions[achType]
    -- Check the page configuration
    table.insert(output, "\n== JSON PAGE STATUS ==")
     local pageTitle = mw.title.new(ACHIEVEMENT_DATA_PAGE)
    if not pageTitle then
        table.insert(output, "❌ Could not create title object for: " .. ACHIEVEMENT_DATA_PAGE)
        return table.concat(output, "\n")
    end
   
    if not pageTitle.exists then
        table.insert(output, "❌ Page does not exist: " .. ACHIEVEMENT_DATA_PAGE)
        return table.concat(output, "\n")
    end
   
    table.insert(output, "✓ Page exists: " .. ACHIEVEMENT_DATA_PAGE)
   
    -- Check the content model
    if pageTitle.contentModel then
        table.insert(output, "Content model: " .. pageTitle.contentModel)
        if pageTitle.contentModel == "json" then
            table.insert(output, "✓ Page has correct content model: 'json'")
        else
            table.insert(output, "❌ Page has INCORRECT content model: '" .. pageTitle.contentModel .. "' (should be 'json')")
        end
     else
        table.insert(output, "⚠ Could not determine content model")
    end
   
    -- Try to fetch page content
    local content = nil
    local contentSuccess, contentResult = pcall(function()
         return pageTitle:getContent()
    end)
   
    if not contentSuccess or not contentResult or contentResult == "" then
        table.insert(output, "❌ Failed to get page content: " .. tostring(contentResult or "Unknown error"))
        return table.concat(output, "\n")
    end
   
    table.insert(output, "✓ Got page content, length: " .. #contentResult)
   
    -- Check page content
    content = contentResult
    local contentPreview = content:sub(1, 50):gsub("\n", "\\n"):gsub("\t", "\\t")
    table.insert(output, "Content preview: \"" .. contentPreview .. "...\"")
   
    if content:match("^%s*{") then
        table.insert(output, "✓ Content starts with { (correct)")
    else
        table.insert(output, "❌ Content does NOT start with { (INCORRECT)")
    end
   
    -- Check for common issues
    if content:match("^<!DOCTYPE") or content:match("^<[Hh][Tt][Mm][Ll]") then
        table.insert(output, "❌ CRITICAL ERROR: Content appears to be HTML, not JSON!")
    elseif content:match("^%s*<") then
         table.insert(output, "❌ CRITICAL ERROR: Content appears to have XML/HTML markup!")
    end
   
    -- Try mw.loadJsonData
    table.insert(output, "\n== TESTING mw.loadJsonData ==")
    local loadJsonSuccess, loadJsonResult = pcall(function()
        return mw.loadJsonData(ACHIEVEMENT_DATA_PAGE)
    end)
   
    if not loadJsonSuccess then
        table.insert(output, "❌ mw.loadJsonData failed: " .. tostring(loadJsonResult or "Unknown error"))
          
          
        -- Analyze error
         if definition and definition.category and definition.category ~= "" and not foundCategories[definition.category] then
        local errorMsg = tostring(loadJsonResult or "")
             table.insert(categoryLinks, "[[Category:" .. definition.category .. "]]")
         if errorMsg:match("content model") then
             foundCategories[definition.category] = true
            table.insert(output, "ERROR CAUSE: Content model issue - page must be set to 'json' model")
        elseif errorMsg:match("JSON decode") or errorMsg:match("syntax") then
            table.insert(output, "ERROR CAUSE: JSON syntax error - check for invalid JSON formatting")
        elseif errorMsg:match("permission") or errorMsg:match("access") then
            table.insert(output, "ERROR CAUSE: Permission/access error - check page permissions")
        end
    else
        table.insert(output, "✓ mw.loadJsonData SUCCESSFUL!")
        table.insert(output, "Data type: " .. type(loadJsonResult))
       
        if type(loadJsonResult) == "table" then
             local keysFound = {}
            for k, _ in pairs(loadJsonResult) do
                table.insert(keysFound, k)
            end
            table.insert(output, "Top-level keys: " .. table.concat(keysFound, ", "))
           
            if loadJsonResult.achievement_types then
                table.insert(output, "✓ Found " .. #loadJsonResult.achievement_types .. " achievement types")
             else
                table.insert(output, "❌ Missing 'achievement_types' array!")
            end
           
            if loadJsonResult.user_achievements then
                local userCount = 0
                for _, _ in pairs(loadJsonResult.user_achievements) do
                    userCount = userCount + 1
                end
                table.insert(output, "✓ Found user achievements for " .. userCount .. " users")
            else
                table.insert(output, "❌ Missing 'user_achievements' object!")
            end
         end
         end
     end
     end
   
 
    -- Try direct JSON decoding
     return table.concat(categoryLinks)
    table.insert(output, "\n== TESTING DIRECT JSON DECODING ==")
   
    -- Use mw.text.jsonDecode
    if mw.text and mw.text.jsonDecode then
        local jsonDecodeSuccess, jsonData = pcall(function()
            return mw.text.jsonDecode(content)
        end)
       
        if jsonDecodeSuccess and jsonData then
            table.insert(output, "✓ mw.text.jsonDecode SUCCESSFUL!")
           
            if jsonData.achievement_types then
                table.insert(output, "✓ Found " .. #jsonData.achievement_types .. " achievement types")
            else
                table.insert(output, "❌ Missing 'achievement_types' array in decoded data!")
            end
        else
            table.insert(output, "❌ mw.text.jsonDecode failed: " .. tostring(jsonData or "Unknown error"))
        end
    else
        table.insert(output, "⚠ Cannot test mw.text.jsonDecode (not available)")
    end
   
    -- Use Module:JSON if available
    if json and json.decode then
        local parseSuccess, parsedData = pcall(function()
            return json.decode(content)
        end)
       
        if parseSuccess and parsedData then
            table.insert(output, "✓ Module:JSON's json.decode SUCCESSFUL!")
           
            if parsedData.achievement_types then
                table.insert(output, "✓ Found " .. #parsedData.achievement_types .. " achievement types")
            else
                table.insert(output, "❌ Missing 'achievement_types' array in decoded data!")
            end
        else
            table.insert(output, "❌ Module:JSON's json.decode failed: " .. tostring(parsedData or "Unknown error"))
        end
    else
        table.insert(output, "⚠ Cannot test Module:JSON (not available)")
    end
   
    -- Add recommendations
    table.insert(output, "\n== RECOMMENDATIONS ==")
    if not loadJsonSuccess then
        table.insert(output, "1. Ensure '" .. ACHIEVEMENT_DATA_PAGE .. "' has content model set to 'json'")
        table.insert(output, "2. Verify the JSON is valid with no syntax errors")
        table.insert(output, "3. Check the page starts with { with no leading whitespace or comments")
    else
        table.insert(output, "✓ JSON loading appears to be working correctly!")
    end
   
     return table.concat(output, "\n")
end
end


return Achievements
return Achievements
Retrieved from "https://staging.icannwiki.org/Module:AchievementSystem"