Module:DataTableParserV2

Documentation for this module may be created at Module:DataTableParserV2/doc

-- Module:DataTableParserV2
-- Handles display and formatting of building data for Templates using External Data.
-- Data is fetched from your SQL tables (data_buildings and data_refining_recipes)
-- via the ExternalData extension rather than from a wiki table page.

local p = {}

--------------------------------------------------
-- Helper: Get icon file reference for a resource
--------------------------------------------------
local function getResourceIcon(resourceName)
    if not resourceName or resourceName == "" then
        return ""
    end
    local fileName = resourceName:gsub("%s+", "_") .. "_-_Icon.png"
    local fileTitle = mw.title.new("File:" .. fileName)
    if fileTitle and fileTitle.exists then
        return "[[File:" .. fileName .. "|20px]]"
    else
        return ""
    end
end

---------------------------------------------
-- Function: iconize
-- Adds icons to resource links in text
---------------------------------------------
function p.iconize(frame)
    local text = frame.args[1] or ""
    text = text:gsub("%[%[([^%]]+)%]%]", function(resourceName)
        local icon = getResourceIcon(resourceName)
        if icon ~= "" then
            return icon .. " [[" .. resourceName .. "]]"
        else
            return "[[" .. resourceName .. "]]"
        end
    end)
    return text
end

------------------------------------------------------
-- Function: formatComponent
-- Formats a recipe component by adding icons to resource links.
------------------------------------------------------
function p.formatComponent(text)
    if not text or text == "" then
        return ""
    end
    local components = mw.text.split(text, ";")
    local formatted = {}
    for i, component in ipairs(components) do
        component = mw.text.trim(component)
        local itemName, quantity = component:match("%[%[([^%]]+)%]%] x (%d+)")
        if itemName and quantity then
            local icon = getResourceIcon(itemName)
            table.insert(formatted, icon .. " [[" .. itemName .. "]] x " .. quantity)
        else
            table.insert(formatted, component)
        end
    end
    return table.concat(formatted, "<br>")
end

--------------------------------------------------------------------------------
-- Function: loadBuildingData
-- Uses externaldata to fetch building data from data_buildings as a structured table.
--------------------------------------------------------------------------------
local function loadBuildingData(frame)
    local buildingName = frame.args[1] or frame.args.name or mw.title.getCurrentTitle().text
    
    -- Create a direct query that returns field-value pairs instead of trying to parse a wikitable
    local edQuery = string.format([[
        {{#get_external_data: source=externaldb
         |from=data_buildings
         |data=ID=id,
               BuildingType=building_type,
               Name=name,
               Description=description,
               PowerCost=power_cost,
               GeneratesPower=generates_power,
               StorageSlots=storage_slots,
               StorageCapacity=storage_capacity,
               SchematicRequirement=schematic_requirement,
               JourneyRequirement=journey_requirement,
               Health=health,
               PlacedWith=placed_with,
               AdditionalNotes=additional_notes,
               RecipeToBuild=recipe_to_build,
               ImageFile=image_file,
               IconFile=icon_file,
               Category1=category_1,
               Category2=category_2,
               Category3=category_3,
               Gallery1=gallery_1,
               Gallery2=gallery_2,
               Gallery3=gallery_3,
               Gallery4=gallery_4,
               YoutubeVideoLink=youtube_video_link
         |cache=yes
         |where=name='%s'
         |limit=1
        }}
    ]], buildingName)
    
    local result = frame:preprocess(edQuery)
    
    -- Create a structure to hold our building data
    local buildingData = {}
    local colMap = {}
    local fieldValues = {}
    
    -- Parse field values directly from ExternalData variables
    local fields = {
        "ID", "BuildingType", "Name", "Description", "PowerCost", "GeneratesPower",
        "StorageSlots", "StorageCapacity", "SchematicRequirement", "JourneyRequirement",
        "Health", "PlacedWith", "AdditionalNotes", "RecipeToBuild", "ImageFile",
        "IconFile", "Category1", "Category2", "Category3", "Gallery1", "Gallery2",
        "Gallery3", "Gallery4", "YoutubeVideoLink"
    }
    
    for i, field in ipairs(fields) do
        colMap[field] = i
        local value = frame:preprocess("{{{" .. field .. "}}}")
        if value and value ~= "" and value ~= "{{{" .. field .. "}}}" then
            fieldValues[i] = value
        else
            fieldValues[i] = ""
        end
    end
    
    -- Check if we got any data
    local hasData = false
    for _, v in ipairs(fieldValues) do
        if v ~= "" then
            hasData = true
            break
        end
    end
    
    if not hasData then
        return nil, "No data found for building: " .. buildingName
    end
    
    -- Create the structure expected by the rest of the code
    buildingData.colMap = colMap
    buildingData.rows = {fieldValues}
    
    return buildingData, nil
end

--------------------------------------------------------------------------------
-- Function: loadRefiningData
-- Uses externaldata to fetch refining recipes from data_refining_recipes.
--------------------------------------------------------------------------------
local function loadRefiningData(frame)
    local buildingName = frame.args[1] or frame.args.name or mw.title.getCurrentTitle().text
    
    local edQuery = string.format([[
        {{#get_external_data: source=externaldb
         |from=data_refining_recipes
         |data=Refiner=Refiner,Output=Output,Ingredients=Ingredients,Time=Time,Recipe=Recipe
         |cache=yes
         |where=Refiner='%s'
        }}
    ]], buildingName)
    
    local result = frame:preprocess(edQuery)
    
    -- Create structure to hold refining data
    local refiningData = {}
    local colMap = {}
    local rows = {}
    
    -- Parse field values directly from ExternalData variables
    local fields = {"Refiner", "Output", "Ingredients", "Time", "Recipe"}
    
    -- Check if we have multiple rows by trying to access {{{Refiner_1}}}
    local rowCount = 0
    local hasMultipleRows = false
    
    -- Check first row
    local firstRow = {}
    for i, field in ipairs(fields) do
        colMap[field] = i
        local value = frame:preprocess("{{{" .. field .. "}}}")
        if value and value ~= "" and value ~= "{{{" .. field .. "}}}" then
            firstRow[i] = value
            rowCount = 1
        else
            firstRow[i] = ""
        end
    end
    
    -- Check if we have data in first row
    local hasFirstRow = false
    for _, v in pairs(firstRow) do
        if v ~= "" then
            hasFirstRow = true
            break
        end
    end
    
    if hasFirstRow then
        table.insert(rows, firstRow)
    end
    
    -- Check if we have multiple rows
    for i = 1, 50 do -- Limit to 50 rows max for safety
        local testValue = frame:preprocess("{{{Refiner_" .. i .. "}}}")
        if testValue and testValue ~= "" and testValue ~= "{{{Refiner_" .. i .. "}}}" then
            hasMultipleRows = true
            break
        end
    end
    
    -- If we have multiple rows, process them
    if hasMultipleRows then
        for i = 1, 50 do -- Limit to 50 rows max for safety
            local rowData = {}
            local hasData = false
            
            for j, field in ipairs(fields) do
                local value = frame:preprocess("{{{" .. field .. "_" .. i .. "}}}")
                if value and value ~= "" and value ~= "{{{" .. field .. "_" .. i .. "}}}" then
                    rowData[j] = value
                    hasData = true
                else
                    rowData[j] = ""
                end
            end
            
            if hasData then
                table.insert(rows, rowData)
            else
                break -- No more rows
            end
        end
    end
    
    if #rows == 0 then
        return nil, "No refining recipes found for building: " .. buildingName
    end
    
    refiningData.colMap = colMap
    refiningData.rows = rows
    
    return refiningData, nil
end

--------------------------------------------------------------------------------
-- Function: getBuildingData
-- Returns the row (and colMap) for a given building name from external data.
--------------------------------------------------------------------------------
function p.getBuildingData(buildingName, frame)
    -- Simply pass through to loadBuildingData
    local buildingData, err = loadBuildingData(frame)
    if not buildingData or #buildingData.rows == 0 then
        return nil, err or "Building not found"
    end
    
    -- Return the first row and column map for compatibility
    return buildingData.rows[1], buildingData.colMap
end

--------------------------------------------------------------------------------
-- Function: getRefiningRecipes
-- Returns a table of refining recipes matching the building name.
--------------------------------------------------------------------------------
function p.getRefiningRecipes(frame)
    local buildingName = frame.args[1] or mw.title.getCurrentTitle().text
    local refiningData, err = loadRefiningData(frame)
    
    if not refiningData then
        return '<tr><td colspan="3" style="text-align:center;">No refining recipes found for this building.</td></tr>'
    end
    
    local rows = refiningData.rows
    local colMap = refiningData.colMap
    
    if #rows == 0 then
        return '<tr><td colspan="3" style="text-align:center;">No refining recipes found for this building.</td></tr>'
    end
    
    local output = "<tr>\n" ..
                   "<th style=\"text-align:left;\">Output</th>\n" ..
                   "<th style=\"text-align:left;\">Ingredients</th>\n" ..
                   "<th style=\"text-align:left;\">Craft Time</th>\n" ..
                   "</tr>\n"
                   
    for _, recipe in ipairs(rows) do
        local outputItem = recipe[colMap["Output"]] or ""
        local ingredients = recipe[colMap["Ingredients"]] or ""
        local time = recipe[colMap["Time"]] or ""
        local recipeQty = recipe[colMap["Recipe"]] or ""
        
        local qty = "1"
        if recipeQty ~= "" then
            local extractQty = recipeQty:match("x%s*(%d+)")
            if extractQty then
                qty = extractQty
            end
        end
        
        local formattedOutput = p.iconize({args = {[1] = outputItem}})
        if qty ~= "1" then
            formattedOutput = formattedOutput .. " × " .. qty
        end
        
        local formattedIngredients = ""
        if ingredients ~= "" then
            local ingredientsList = mw.text.split(ingredients, ";")
            for i, ingredient in ipairs(ingredientsList) do
                local trimmedIngredient = mw.text.trim(ingredient)
                if trimmedIngredient ~= "" then
                    local formattedIngredient = p.iconize({args = {[1] = trimmedIngredient}})
                    if i > 1 then
                        formattedIngredients = formattedIngredients .. "<br>"
                    end
                    formattedIngredients = formattedIngredients .. formattedIngredient
                end
            end
        end
        
        output = output .. "<tr>\n" ..
                 "<td style=\"text-align:left;\">" .. formattedOutput .. "</td>\n" ..
                 "<td style=\"text-align:left;\">" .. formattedIngredients .. "</td>\n" ..
                 "<td style=\"text-align:left;\">" .. time .. "</td>\n" ..
                 "</tr>\n"
    end
    
    return output
end

--------------------------------------------------------------------------------
-- Function: formatBuilding
-- Formats building data as a template call to BuildingRefinerDisplayV2.
--------------------------------------------------------------------------------
function p.formatBuilding(frame)
    local buildingName = frame.args[1] or frame.args.name or mw.title.getCurrentTitle().text
    if not buildingName then
        return "Error: No building name provided"
    end

    -- Add debug information if debug flag is set
    if frame.args.debug then
        return p.debugBuildingData(frame)
    end

    local buildingData, err = loadBuildingData(frame)
    if not buildingData then
        return "Error: " .. (err or "Building '" .. buildingName .. "' not found")
    end
    
    local colMap = buildingData.colMap
    local building = buildingData.rows[1]
    
    if not building then
        return "Error: No data row found for building '" .. buildingName .. "'"
    end

    -- Prepare params with default values and better error handling
    local params = {
        Name = building[colMap["Name"]] or buildingName,
        Tier = building[colMap["BuildingType"]] or "Unknown",
        Description = building[colMap["Description"]] or "",
        JourneyRequirement = building[colMap["JourneyRequirement"]] or "",
        Health = building[colMap["Health"]] or "0",
        EnergyConsumption = building[colMap["PowerCost"]] or "0",
        GeneratesPower = building[colMap["GeneratesPower"]] or "0",
        StorageSlots = building[colMap["StorageSlots"]] or "0",
        StorageVolume = building[colMap["StorageCapacity"]] or "0",
        Components = building[colMap["RecipeToBuild"]] or "",
        PlacedWith = building[colMap["PlacedWith"]] or "",
        AdditionalNotes = building[colMap["AdditionalNotes"]] or "",
        ImageFile = building[colMap["ImageFile"]] or "",
        PrimarySource = "Crafting"
    }
    
    -- Process fields that need special formatting
    if params.Description ~= "" then
        params.Description = p.iconize({args = {[1] = params.Description}})
    end
    
    if params.JourneyRequirement ~= "" then
        params.JourneyRequirement = p.iconize({args = {[1] = params.JourneyRequirement}})
    end
    
    if params.Components ~= "" then
        params.Components = p.formatComponent(params.Components)
    end
    
    if params.PlacedWith ~= "" then
        params.PlacedWith = p.iconize({args = {[1] = params.PlacedWith}})
    end
    
    if params.AdditionalNotes ~= "" then
        params.AdditionalNotes = p.iconize({args = {[1] = params.AdditionalNotes}})
    end

    -- Add YouTube video if available
    if colMap["YoutubeVideoLink"] and building[colMap["YoutubeVideoLink"]] and building[colMap["YoutubeVideoLink"]] ~= "" then
        params.YoutubeEmbed = p.getYoutubeEmbed(frame)
    else
        params.YoutubeEmbed = "Coming Soon"
    end
    
    -- Add refining recipes
    params.RefiningRecipes = p.getRefiningRecipes(frame)
    
    -- Add category and related buildings
    if colMap["Category3"] and building[colMap["Category3"]] and building[colMap["Category3"]] ~= "" then
        params.Category3 = building[colMap["Category3"]]
    else
        params.Category3 = "Buildings"
    end
    
    params.RelatedBuildings = p.relatedBuildings(frame)
    
    -- Construct the template call
    local templateCall = "{{BuildingRefinerDisplayV2"
    for key, value in pairs(params) do
        if value and value ~= "" then
            templateCall = templateCall .. "\n|" .. key .. "=" .. value
        end
    end
    templateCall = templateCall .. "\n}}"
    
    -- Process the template
    return frame:preprocess(templateCall)
end

--------------------------------------------------------------------------------
-- Function: getYoutubeEmbed
-- Returns a processed YouTube embed tag.
--------------------------------------------------------------------------------
function p.getYoutubeEmbed(frame)
    local buildingName = frame.args[1] or mw.title.getCurrentTitle().text
    local width = frame.args.width or 400
    local height = frame.args.height or 300
    local dimensions = width .. "x" .. height

    local building, colMap = p.getBuildingData(buildingName, frame)
    if not building then
        return "Error loading data"
    end

    local youtubeUrl = building[colMap["YoutubeVideoLink"]] or ""
    if youtubeUrl == "" or youtubeUrl == "-" then
        return "Coming Soon"
    end

    local videoId = youtubeUrl:match("v=([%w-_]+)")
    if not videoId then
        return "Coming Soon"
    end

    local ytMarkup = string.format('<youtube dimensions="%s" alignment="center">%s</youtube>', dimensions, videoId)
    return frame:preprocess(ytMarkup)
end


--------------------------------------------------------------------------------
-- Function: getCategory3
-- Returns the Category3 field for the current building.
--------------------------------------------------------------------------------
function p.getCategory3(frame)
    local buildingName = frame.args[1] or mw.title.getCurrentTitle().text
    local building, colMap = p.getBuildingData(buildingName, frame)
    if not building then
        return "Buildings"
    end
    local cat3 = building[colMap["Category3"]] or ""
    if cat3 == "-" or cat3 == "" then
        return "Buildings"
    end
    if cat3:find("%[%[") then
        cat3 = cat3:match("%[%[(.-)%]%]")
    end
    return mw.text.trim(cat3)
end

--------------------------------------------------------------------------------
-- Function: relatedBuildings
-- Finds and formats related buildings based on Category3.
--------------------------------------------------------------------------------
function p.relatedBuildings(frame)
    local buildingName = frame.args[1] or mw.title.getCurrentTitle().text
    local building, colMap = p.getBuildingData(buildingName, frame)
    if not building then
        return "Error loading building data"
    end
    local targetCategory = building[colMap["Category3"]] or ""
    if targetCategory == "-" or targetCategory == "" then
        return "No related buildings found"
    end
    if targetCategory:find("%[%[") then
        targetCategory = targetCategory:match("%[%[(.-)%]%]")
    end
    targetCategory = mw.text.trim(targetCategory)

    -- Load all building rows (assuming the externaldata query returns all rows)
    local allData, err = loadBuildingData(frame)
    if not allData then
        return "Error loading building data"
    end
    local rows = allData.rows

    local relatedBuildings = {}
    for _, row in ipairs(rows) do
        if row[colMap["Name"]] ~= buildingName then
            local category = row[colMap["Category3"]] or ""
            if category ~= "-" and category ~= "" then
                if category:find("%[%[") then
                    category = category:match("%[%[(.-)%]%]")
                end
                category = mw.text.trim(category)
                if category == targetCategory then
                    table.insert(relatedBuildings, row)
                end
            end
        end
    end

    if #relatedBuildings == 0 then
        return "No other " .. targetCategory .. " found"
    end

    local output = '<table class="infobox-dune" style="width:100%">\n'
    output = output .. "<tr>\n"
    output = output .. "<th style=\"text-align:left;\">Name</th>\n"
    output = output .. "<th style=\"text-align:left;\">Tier</th>\n"
    output = output .. "<th style=\"text-align:left;\">Description</th>\n"
    output = output .. "</tr>\n"
    for _, b in ipairs(relatedBuildings) do
        local name = b[colMap["Name"]] or ""
        local tier = b[colMap["Tier"]] or ""
        local description = b[colMap["Description"]] or ""
        if tier == "-" then tier = "" end
        if description == "-" then description = "" end
        local nameWithIcon = "[[" .. name .. "]]"
        local iconFile = b[colMap["ImageFile"]] or ""
        if iconFile ~= "-" and iconFile ~= "" then
            nameWithIcon = "[[File:" .. iconFile .. "|20px]] [[" .. name .. "]]"
        end
        output = output .. "<tr>\n"
        output = output .. "<td>" .. nameWithIcon .. "</td>\n"
        output = output .. "<td>" .. tier .. "</td>\n"
        output = output .. "<td>" .. description .. "</td>\n"
        output = output .. "</tr>\n"
    end
    output = output .. "</table>"
    return output
end

--------------------------------------------------------------------------------
-- Function: debugBuildingData
-- Better error logging
--------------------------------------------------------------------------------

function p.debugBuildingData(frame)
    local buildingName = frame.args[1] or mw.title.getCurrentTitle().text
    local buildingData, err = loadBuildingData(frame)
    
    if not buildingData then
        return "Error: " .. (err or "Unknown error")
    end
    
    local output = "Debug information for '" .. buildingName .. "':\n\n"
    output = output .. "Raw data from database:\n"
    output = output .. "<pre>"
    
    -- Output column map
    output = output .. "Column mapping:\n"
    for name, idx in pairs(buildingData.colMap) do
        output = output .. name .. " => " .. idx .. "\n"
    end
    
    -- Output row data
    output = output .. "\nRows (" .. #buildingData.rows .. " found):\n"
    for i, row in ipairs(buildingData.rows) do
        output = output .. "Row " .. i .. ":\n"
        for j, cell in ipairs(row) do
            local colName = "Unknown"
            for name, idx in pairs(buildingData.colMap) do
                if idx == j then
                    colName = name
                    break
                end
            end
            output = output .. "  " .. colName .. " (" .. j .. "): '" .. cell .. "'\n"
        end
    end
    
    output = output .. "</pre>"
    return output
end


return p