LegendaryActionTracker

on("ready", () => {
    let legendaryActionTracker = {};  // Changed from const to let
    const legendaryActionSetupComplete = new Set();
    let ownerId = null;

    on("change:campaign:turnorder", () => {
        const turnOrder = JSON.parse(Campaign().get("turnorder") || "[]");

        if (turnOrder.length > 0) {
            const currentTurn = turnOrder[0];
            const tokenId = currentTurn.id;
            const token = getObj("graphic", tokenId);

            if (token && token.get("represents")) {
                const characterId = token.get("represents");
                const character = getObj("character", characterId);

                if (!character) return;

                if (!legendaryActionSetupComplete.has(tokenId)) {
                    setupLegendaryActions(tokenId, characterId);
                    legendaryActionSetupComplete.add(tokenId);
                }

                if (ownerId && ownerId !== tokenId && legendaryActionTracker[ownerId]?.remaining > 0) {
                    displayLegendaryActions(ownerId);
                }

                if (tokenId === ownerId) refreshLegendaryActions(ownerId);
            }
        }
    });

    function setupLegendaryActions(tokenId, characterId) {
        const legendaryActions = findObjs({
            _type: "ability",
            _characterid: characterId
        }).filter(ability => ability.get("name").startsWith("L-"));

        if (legendaryActions.length > 0) {
            legendaryActionTracker[tokenId] = {
                max: legendaryActions.length,
                remaining: legendaryActions.length,
                actions: {}
            };

            legendaryActions.forEach(action => {
                let actionName = action.get("name").replace(/^L-/, "").replace(/-\([\w-]*\d+a\)$/i, "").trim();
                const cost = parseCostFromAbilityName(action.get("name"));
                legendaryActionTracker[tokenId].actions[action.id] = {
                    name: capitalizeFirstLetter(actionName),
                    cost: cost,
                    abilityId: action.id
                };
            });
            ownerId = tokenId;
        }
    }

    function parseCostFromAbilityName(name) {
        const match = name.match(/-\((?:\w*-)?(\d+)a\)/i);
        return match ? parseInt(match[1]) : 1;
    }

    function refreshLegendaryActions(tokenId) {
        if (legendaryActionTracker[tokenId]) {
            legendaryActionTracker[tokenId].remaining = legendaryActionTracker[tokenId].max;
        }
    }

    function displayLegendaryActions(tokenId) {
        const characterId = getObj("graphic", tokenId)?.get("represents");
        const character = getObj("character", characterId);
        if (!character) return;

        const characterName = character.get("name");
        const remainingActions = legendaryActionTracker[tokenId].remaining;
        let message = `&{template:default} {{name=${characterName} Legendary Actions}} {{Remaining=${remainingActions}}}`;

        for (const actionId in legendaryActionTracker[tokenId].actions) {
            const action = legendaryActionTracker[tokenId].actions[actionId];
            if (action.cost <= remainingActions) {
                message += ` {{${action.name} (Cost: ${action.cost})=[Use](~${character.id}|${action.abilityId})}}`;
            }
        }

        sendChat("Legendary Action Tracker", `/w gm ${message}`);
    }

    on("chat:message", (msg) => {
        if (msg.type === "general" && ownerId) {
            detectAbilityUsageFromChat(msg.content, ownerId);
        } else if (msg.type === "api" && msg.content.toLowerCase() === "!endcombat") {
            resetCombat();
        }
    });

    function detectAbilityUsageFromChat(content, tokenId) {
        const cleanedContent = content.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim().toLowerCase();
        const tracker = legendaryActionTracker[tokenId];

        if (!tracker) return;

        const characterId = getObj("graphic", tokenId)?.get("represents");
        const legendaryActions = tracker.actions;

        for (const actionId in legendaryActions) {
            const action = legendaryActions[actionId];
            const actionName = action.name.toLowerCase();

            if (cleanedContent.includes(actionName) && tracker.remaining >= action.cost) {
                tracker.remaining -= action.cost;  // Deduct full action cost
                sendRemainingActionsPrompt(getObj("character", characterId), tokenId);
                break;
            }
        }
    }

    function sendRemainingActionsPrompt(character, tokenId) {
        const remainingActions = legendaryActionTracker[tokenId].remaining;
        const message = `&{template:default} {{name=${character.get("name")} Legendary Actions}} {{Remaining=${remainingActions}}}`;
        sendChat("Legendary Action Tracker", `/w gm ${message}`);
    }

    function capitalizeFirstLetter(string) {
        return string.charAt(0).toUpperCase() + string.slice(1);
    }

    function resetCombat() {
        for (let key in legendaryActionTracker) delete legendaryActionTracker[key];
        legendaryActionSetupComplete.clear();
        ownerId = null;
    }
});