ATLYSS TechPendium

const Utils = await require("Utils");
const Wiki = await require("Wiki");
const Game = await require("Game");
const Cache = await require("Cache");
const { latest: latestVersion } = await requireData("Versions");
const { TooltipBuilder } = await require("Tooltip_Builder");
const { InfoboxBuilder } = await require("Infobox_Builder");

async function buildConsumableTooltipHtml(itemData, itemId, version = latestVersion) {
    const tooltip = new TooltipBuilder(`Consumable:Item:${itemId}`);

    const name = itemData.name || itemId;
    const description = itemData.description || "";

    const sanitizedDescription = description
        .replace(/\n{2,}/g, "\n")
        .replace(/<color=(.*?)>(.*?)<\/color>/g,
            "<span style='color:$1;'>$2</span>");

    tooltip.addLine(
        `<div style="display:flex;justify-content:space-between;">` +
        `<div>'''${name}'''</div>` +
        `<div>[[File:${itemData.id}_icon.png|26px|inline|alt=${name}]]</div>` +
        `</div>`
    );

    if (sanitizedDescription) {
        tooltip.addLine(sanitizedDescription.replace(/\n/g, "<br>"));
    }

    tooltip.addLine(`<div>Rarity: ${Wiki.wikiRarity(itemData.rarity)}</div>`);
    tooltip.addLine(`<div>Stack Size: ${itemData.stack?.max ?? "N/A"}</div>`);

    switch (itemData.category) {
        case "classtome":
            const { data: classData } = await Utils.resolveData("Classes", false, version);

            const classInfo = Utils.findByProperty(classData, "guid", itemData.unlocks?.classGuid);

            if (itemData.unlocks?.tierIndex) {
                tooltip.addLine(`<div>Unlocks Class: ${classInfo?.name ?? itemData.unlocks?.classGuid ?? "N/A"} (Tier: ${classInfo?.tiers[itemData.unlocks.tierIndex]?.name ?? "N/A"})</div>`);
            } else {
                tooltip.addLine(`<div>Unlocks Class: ${classInfo?.name ?? itemData.unlocks?.classGuid ?? "N/A"}</div>`);
            }

            tooltip.addLine(`<div>Level Requirement: ${itemData.unlocks?.levelRequirement ?? "N/A"}</div>`);
            break;
        case "dye":
            tooltip.addLine(`<div>Buy Price: ${itemData.buyPrice} Crowns</div>`);
            tooltip.addLine(`<div>Sell Price: ${Game.getSellPrice(itemData.buyPrice)} Crowns</div>`);
            tooltip.addLine(`<span>Dye Color:</span><span class="dye-box" style="background-color: ${itemId.replace("_dye", "")};"></span>`);
            break;
        case "skillscroll":
            const { data: skillData } = await Utils.resolveData("Skills", false, version);
            const skillInfo = Utils.findByProperty(skillData, "guid", itemData.unlocks?.skillGuid);

            tooltip.addLine(`<div>Buy Price: ${itemData.buyPrice} Crowns</div>`);
            tooltip.addLine(`<div>Sell Price: ${Game.getSellPrice(itemData.buyPrice)} Crowns</div>`);
            tooltip.addLine(`<div>Unlocks Skill: ${skillInfo?.name ?? itemData.unlocks?.skillGuid ?? "N/A"}</div>`);
            tooltip.addLine(`<div>Level Requirement: ${itemData.unlocks?.levelRequirement ?? "N/A"}</div>`);
            break;
        case "instant":
            tooltip.addLine(`<div>Buy Price: ${itemData.buyPrice} Crowns</div>`);
            tooltip.addLine(`<div>Sell Price: ${Game.getSellPrice(itemData.buyPrice)} Crowns</div>`);
            
            if (itemData.effects.instant?.health) {
                tooltip.addLine(`<div>Restores Health: ${itemData.effects.instant.health}</div>`);
            }

            if (itemData.effects.instant?.mana) {
                tooltip.addLine(`<div>Restores Mana: ${itemData.effects.instant.mana}</div>`);
            }

            if (itemData.effects.instant?.stamina) {
                tooltip.addLine(`<div>Restores Stamina: ${itemData.effects.instant.stamina}</div>`);
            }

            if (itemData.effects.instant?.experience) {
                tooltip.addLine(`<div>Restores Experience: ${itemData.effects.instant.experience}</div>`);
            }

            if (itemData.effects.instant?.resetSkillPoints) {
                tooltip.addLine(`<div>Resets Skill Points</div>`);
            }

            if (itemData.effects.instant?.resetAttributePoints) {
                tooltip.addLine(`<div>Resets Attribute Points</div>`);
            }
            break;
        case "status":
            tooltip.addLine(`<div>Buy Price: ${itemData.buyPrice} Crowns</div>`);
            tooltip.addLine(`<div>Sell Price: ${Game.getSellPrice(itemData.buyPrice)} Crowns</div>`);

            if (itemData.effects.statusCondition?.conditionGuid) {
                const { data: conditionData } = await Utils.resolveData("Conditions", false, version);
                const conditionInfo = Utils.findByProperty(conditionData, "guid", itemData.effects.statusCondition.conditionGuid);

                tooltip.addLine(`<div>Applies Status Condition: ${conditionInfo?.name ?? itemData.effects.statusCondition.conditionGuid ?? "N/A"}</div>`);
            }
            break;
        case "tool":
            tooltip.addLine(`<div>Buy Price: ${itemData.buyPrice} Crowns</div>`);
            tooltip.addLine(`<div>Sell Price: ${Game.getSellPrice(itemData.buyPrice)} Crowns</div>`);
            break;
    }

    return tooltip.build();
}

async function wikiTable(props) {
    const args = Utils.resolveArgs(props);
    const selectedVersion = args["version"] || args[0];

    const { data, version } = await Utils.resolveData("Consumables", false, selectedVersion);

    if (Utils.isModuleEmpty(data)) {
        return `<div id="Consumables-wikiTable">⚠️ Consumable data is unavailable for version ${version}.${Wiki.versionSelector(version, "Consumables", "wikiTable")}</div>`;
    }

    const sortedData = Utils.sortObjectByKey(data);

    let table = "";
    let tooltips = "";

    table += `{| class="wiki-table" style="width:auto;"\n`;
    table += `! colspan="5" | :Version: ${Wiki.versionSelector(version, "Consumables", "wikiTable")}\n`;
    table += `|-\n`;
    table += `! Name !! Rarity !! Max Stack !! Buy Price !! Sell Price\n`;

    for (const id in sortedData) {
        const item = sortedData[id];
        const itemId = item.id || id;

        table += `|-\n`;

        const tooltipId = `Consumable:Item:${itemId}`;

        table += `| <span data-tooltip-id="${tooltipId}">${availablePages.has(`File:${item.id}_icon.png`) ? `[[File:${item.id}_icon.png|16px|inline|alt=${item.name}|link=Consumables/${item.name}]]` : ""}[[Consumables/${item.name}|${item.name}]]</span>\n`;
        table += `| ${Wiki.wikiRarity(item.rarity)}\n`;
        table += `| ${item.stack?.max ?? "N/A"}\n`;
        
        if (item.buyPrice) {
            table += `| ${item.buyPrice} Crowns\n`;
            table += `| ${Game.getSellPrice(item.buyPrice)} Crowns\n`;
        } else {
            table += `| N/A\n`;
            table += `| N/A\n`;
        }

        if (!Cache.has("ConsumableTooltips", tooltipId)) {
            Cache.set("ConsumableTooltips", tooltipId, await buildConsumableTooltipHtml(item, itemId, version));
            tooltips += Cache.get("ConsumableTooltips", tooltipId);
        }
    }

    table += `|}\n`;

    return `<div id="Consumables-wikiTable">${table}${tooltips}</div>`;
}

async function wikiNavbox() {
    const { data, version } = await Utils.resolveData("Consumables", false);

    if (Utils.isModuleEmpty(data)) {
        return `<div id="Consumables-wikiNavbox">⚠️ Consumable data is unavailable for version ${version}.${Wiki.versionSelector(version, "Consumables", "wikiNavbox")}</div>`;
    }

    const sortedData = Utils.sortObjectByKey(data);

    let navbox = "";
    let tooltips = "";

    const versionTooltip = new TooltipBuilder(`Consumables:Version:${version.replace(/\./g, '_')}`);
    versionTooltip.addLine(
        `Data version: '''${version}''' <span class="${version === latestVersion ? 'latest' : 'outdated'}">(${version === latestVersion ? 'latest' : 'outdated'})</span>`
    );

    navbox += `{| class="wiki-table navbox"\n`;
    navbox += `! :Version: ${Wiki.versionCode(version, versionTooltip)}\n`;
    navbox += `|-\n`;
    navbox += `! Consumables Navigation\n`;
    navbox += `|-\n| `;

    const itemLinks = [];

    for (const id in sortedData) {
        const item = sortedData[id];
        const itemId = item.id || id;
        const tooltipId = `Consumable:Item:${itemId}`;

        itemLinks.push(`<span data-tooltip-id="${tooltipId}">${availablePages.has(`File:${item.id}_icon.png`) ? `[[File:${item.id}_icon.png|16px|inline|alt=${item.name}|link=Consumables/${item.name}]]` : ""}[[Consumables/${item.name}|${item.name}]]</span>`);

        if (!Cache.has("ConsumableTooltips", tooltipId)) {
            Cache.set("ConsumableTooltips", tooltipId, await buildConsumableTooltipHtml(item, itemId, version));
            tooltips += Cache.get("ConsumableTooltips", tooltipId);
        }
    }

    navbox += itemLinks.join(" • ") + `\n`;
    navbox += `|}\n`;

    return `<div id="Consumables-wikiNavbox">${navbox}${tooltips}</div>`;
}

async function wikiTooltip(props) {
    const args = Utils.resolveArgs(props);
    const itemArg = args["item"] || args[0];
    if (!itemArg) return "";

    const itemId = itemArg.toLowerCase().replace(/\s+|\'/g, '_').split("/").pop();

    const tooltipId = `Consumable:Item:${itemId}`;

    if (Cache.has("ConsumableTooltips", tooltipId)) {
        return Cache.get("ConsumableTooltips", tooltipId);
    }

    const { data } = await Utils.resolveData("Consumables", false);

    if (Utils.isModuleEmpty(data)) {
        return `⚠️ Consumable data is unavailable.`;
    }

    const itemData = data[itemId];

    if (!itemData) {
        return `⚠️ Consumable '${itemId}' not found.`;
    }

    const tooltipHtml = await buildConsumableTooltipHtml(itemData, itemId);

    const linkHtml = 
        `<span data-tooltip-id="${tooltipId}">` +
        `[[Consumables/${itemData.name}|${itemData.name}]]` +
        `</span>`;

    const result = linkHtml + tooltipHtml;

    Cache.set("ConsumableTooltips", tooltipId, result);

    return result;
}

async function wikiInfobox(props) {
    return "Not yet implemented"
}

exports = {
    wikiTable,
    wikiNavbox,
    wikiTooltip,
    wikiInfobox
}