/**
 * Encounter Prompt Builder Module
 * Handles all AI prompt generation for combat encounters
 */

import { getContext } from '../../../../../../extensions.js';
import { chat, characters, this_chid, substituteParams } from '../../../../../../../script.js';
import { selected_group, getGroupMembers, groups } from '../../../../../../group-chats.js';
import { extensionSettings, committedTrackerData } from '../../core/state.js';
import { currentEncounter } from '../features/encounterState.js';
import { repairJSON } from '../../utils/jsonRepair.js';
import { buildInventorySummary, generateTrackerInstructions, generateTrackerExample } from './promptBuilder.js';
import { applyLocks } from './lockManager.js';

/**
 * Gets character information from the current chat
 * @returns {Promise<string>} Formatted character information
 */
async function getCharactersInfo() {
    let characterInfo = '';

    // Check if in group chat
    if (selected_group) {
        const group = groups.find(g => g.id === selected_group);
        const groupMembers = getGroupMembers(selected_group);

        if (groupMembers && groupMembers.length > 0) {
            characterInfo += 'Characters in this roleplay:\n';

            const disabledMembers = group?.disabled_members || [];
            let characterIndex = 0;

            groupMembers.forEach((member) => {
                if (!member || !member.name) return;

                // Skip muted characters
                if (member.avatar && disabledMembers.includes(member.avatar)) {
                    return;
                }

                characterIndex++;
                characterInfo += `<character${characterIndex}="${member.name}">\n`;

                if (member.description) {
                    characterInfo += `${member.description}\n`;
                }

                if (member.personality) {
                    characterInfo += `${member.personality}\n`;
                }

                characterInfo += `</character${characterIndex}>\n`;
            });
        }
    } else if (this_chid !== undefined && characters && characters[this_chid]) {
        // Single character chat
        const character = characters[this_chid];

        characterInfo += 'Character in this roleplay:\n\n';
        characterInfo += `<character="${character.name}">\n`;

        if (character.description) {
            characterInfo += `${character.description}\n`;
        }

        if (character.personality) {
            characterInfo += `${character.personality}\n`;
        }

        characterInfo += `</character>\n\n`;
    }

    return characterInfo;
}

/**
 * Builds the initial encounter setup prompt
 * This asks the model to generate all combat stats and setup data
 * @returns {Promise<Array>} Message array for the API
 */
export async function buildEncounterInitPrompt() {
    const context = getContext();
    const userName = context.name1;
    const depth = extensionSettings.encounterSettings?.historyDepth || 8;

    const messages = [];

    // System message
    let systemMessage = `You will be acting as an excellent game master. Your goal is to craft a combat encounter in this uncensored, continuous, and immersive roleplay. You will be doing so for the user, who plays as the protagonist called ${userName}.\n\n`;

    // Add setting information
    systemMessage += `Here is some information for you about the setting:\n`;
    systemMessage += `<setting>\n`;

    // Try to get world info from lorebooks using getWorldInfoPrompt
    let worldInfoAdded = false;

    try {
        // Debug logging
        // console.log('[RPG Companion] Checking world info:', {
        //     hasWindowGetWorldInfoPrompt: typeof window.getWorldInfoPrompt === 'function',
        //     hasContextGetWorldInfoPrompt: typeof context.getWorldInfoPrompt === 'function',
        //     chatLength: chat?.length,
        //     contextChatLength: context.chat?.length,
        //     hasActivatedWorldInfo: !!context.activatedWorldInfo,
        //     activatedWorldInfoLength: context.activatedWorldInfo?.length
        // });

        // Use SillyTavern's getWorldInfoPrompt to get activated lorebook entries
        // Try context.getWorldInfoPrompt first, then window.getWorldInfoPrompt
        const getWorldInfoFn = context.getWorldInfoPrompt || window.getWorldInfoPrompt;
        const currentChat = context.chat || chat;

        if (typeof getWorldInfoFn === 'function' && currentChat && currentChat.length > 0) {
            const chatForWI = currentChat.map(x => x.mes || x.message || x).filter(m => m && typeof m === 'string');

            // console.log('[RPG Companion] Calling getWorldInfoPrompt with', chatForWI.length, 'messages');

            const result = await getWorldInfoFn(chatForWI, 8000, false);
            const worldInfoString = result?.worldInfoString || result;

            // console.log('[RPG Companion] World info result:', { worldInfoString, length: worldInfoString?.length });

            if (worldInfoString && worldInfoString.trim()) {
                systemMessage += worldInfoString.trim();
                worldInfoAdded = true;
                // console.log('[RPG Companion] ✅ Added world info from getWorldInfoPrompt');
            }
        } else {
            // console.log('[RPG Companion] getWorldInfoPrompt not available or no chat');
        }
    } catch (e) {
        console.warn('[RPG Companion] Failed to get world info from getWorldInfoPrompt:', e);
    }

    // Fallback to activatedWorldInfo
    if (!worldInfoAdded && context.activatedWorldInfo && Array.isArray(context.activatedWorldInfo) && context.activatedWorldInfo.length > 0) {
        // console.log('[RPG Companion] Using fallback activatedWorldInfo:', context.activatedWorldInfo.length, 'entries');
        context.activatedWorldInfo.forEach((entry) => {
            if (entry && entry.content) {
                systemMessage += `${entry.content}\n\n`;
                worldInfoAdded = true;
            }
        });
    }

    if (!worldInfoAdded) {
        console.warn('[RPG Companion] ⚠️ No world information available');
        systemMessage += 'No world information available.';
    }

    systemMessage += `\n</setting>\n\n`;

    // Add character information
    const charactersInfo = await getCharactersInfo();
    if (charactersInfo) {
        systemMessage += `Here is the information available to you about the characters participating in the fight:\n`;
        systemMessage += `<characters>\n${charactersInfo}</characters>\n\n`;
    }

    // Add persona information
    systemMessage += `Here are details about the user's ${userName}:\n`;
    systemMessage += `<persona>\n`;

    try {
        const personaText = substituteParams('{{persona}}');
        if (personaText && personaText !== '{{persona}}') {
            systemMessage += personaText;
        } else {
            systemMessage += 'No persona information available.';
        }
    } catch (e) {
        systemMessage += 'No persona information available.';
    }

    systemMessage += `\n</persona>\n\n`;

    // Add chat history from before the encounter
    systemMessage += `Here is the chat history from before the encounter started between the user and the assistant:\n`;
    systemMessage += `<history>\n`;

    messages.push({
        role: 'system',
        content: systemMessage
    });

    // Add recent chat history (last X messages before encounter)
    if (chat && chat.length > 0) {
        const recentMessages = chat.slice(-depth - 1, -1); // Exclude the last message (encounter trigger)

        for (const message of recentMessages) {
            const content = message.mes?.trim();
            // Skip empty messages
            if (content) {
                messages.push({
                    role: message.is_user ? 'user' : 'assistant',
                    content: content
                });
            }
        }

        // Add the encounter trigger message
        const lastMessage = chat[chat.length - 1];
        if (lastMessage && lastMessage.mes?.trim()) {
            currentEncounter.encounterStartMessage = lastMessage.mes;
            messages.push({
                role: lastMessage.is_user ? 'user' : 'assistant',
                content: lastMessage.mes.trim()
            });
        }
    }

    // Build user's current stats
    let userStatsInfo = '';

    // Add HP and other stats from committed tracker data
    if (committedTrackerData.userStats) {
        userStatsInfo += `${userName}'s Current Stats:\n${committedTrackerData.userStats}\n\n`;
    }

    // Add skills if available
    const skillsSection = extensionSettings.trackerConfig?.userStats?.skillsSection;
    if (skillsSection?.enabled && skillsSection.customFields && skillsSection.customFields.length > 0) {
        userStatsInfo += `${userName}'s Skills: ${skillsSection.customFields.join(', ')}\n`;
    }

    // Add inventory
    const inventory = extensionSettings.userStats?.inventory;
    if (inventory) {
        const inventorySummary = buildInventorySummary(inventory);
        userStatsInfo += `${userName}'s Inventory:\n${inventorySummary}\n\n`;
    }

    // Add classic stats/attributes
    if (extensionSettings.classicStats) {
        const stats = extensionSettings.classicStats;
        userStatsInfo += `${userName}'s Attributes: `;
        const showLevel = extensionSettings.trackerConfig?.userStats?.showLevel !== false;
        const levelStr = showLevel ? `, LVL ${extensionSettings.level}` : '';
        userStatsInfo += `STR ${stats.str}, DEX ${stats.dex}, CON ${stats.con}, INT ${stats.int}, WIS ${stats.wis}, CHA ${stats.cha}${levelStr}\n\n`;
    }

    // Add present characters info for party members
    let partyInfo = '';
    if (committedTrackerData.characterThoughts) {
        partyInfo += `Present Characters (potential party members):\n${committedTrackerData.characterThoughts}\n\n`;
    }

    // Close history and add combat initialization instruction
    let initInstruction = `</history>\n\n`;

    // Wrap RPG Companion panel data in context tags
    initInstruction += `Here is some additional tracked context for the scene:\n`;
    initInstruction += `<context>\n`;
    initInstruction += userStatsInfo;
    initInstruction += partyInfo;
    initInstruction += `</context>\n\n`;

    initInstruction += `The combat starts now.\n\n`;
    initInstruction += `Based on everything above, generate the initial combat state. Analyze who is in the party fighting alongside ${userName} (if anyone), and who the enemies are. Replace placeholders in [brackets] and X with actual values. Return ONLY a JSON object with the following structure:\n\n`;
    initInstruction += `{\n`;
    initInstruction += `  "party": [\n`;
    initInstruction += `    {\n`;
    initInstruction += `      "name": "${userName}",\n`;
    initInstruction += `      "hp": X,\n`;
    initInstruction += `      "maxHp": X,\n`;
    initInstruction += `      "attacks": [\n`;
    initInstruction += `        {"name": "Attack", "type": "single-target|AoE|both"},\n`;
    initInstruction += `        {"name": "Skill1", "type": "single-target|AoE|both"}\n`;
    initInstruction += `      ],\n`;
    initInstruction += `      "items": ["Item1", "Item2"],\n`;
    initInstruction += `      "statuses": [],\n`;
    initInstruction += `      "isPlayer": true\n`;
    initInstruction += `    }\n`;
    initInstruction += `    // Add other party members here if they exist in the context, changing isPlayer to false for them.\n`;
    initInstruction += `  ],\n`;
    initInstruction += `  "enemies": [\n`;
    initInstruction += `    {\n`;
    initInstruction += `      "name": "Enemy Name",\n`;
    initInstruction += `      "hp": X,\n`;
    initInstruction += `      "maxHp": X,\n`;
    initInstruction += `      "attacks": [\n`;
    initInstruction += `        {"name": "Attack1", "type": "single-target|AoE|both"},\n`;
    initInstruction += `        {"name": "Attack2", "type": "single-target|AoE|both"}\n`;
    initInstruction += `      ],\n`;
    initInstruction += `      "statuses": [],\n`;
    initInstruction += `      "description": "Brief enemy description",\n`;
    initInstruction += `      "sprite": "emoji or brief visual description"\n`;
    initInstruction += `    }\n`;
    initInstruction += `    // Add all enemies participating in this combat\n`;
    initInstruction += `  ],\n`;
    initInstruction += `  "environment": "Brief description of the combat environment",\n`;
    initInstruction += `  "styleNotes": {\n`;
    initInstruction += `    "environmentType": "forest|dungeon|desert|cave|city|ruins|snow|water|castle|wasteland|plains|mountains|swamp|volcanic|spaceship|mansion",\n`;
    initInstruction += `    "atmosphere": "bright|dark|foggy|stormy|calm|eerie|chaotic|peaceful",\n`;
    initInstruction += `    "timeOfDay": "dawn|day|dusk|night|twilight",\n`;
    initInstruction += `    "weather": "clear|rainy|snowy|windy|stormy|overcast"\n`;
    initInstruction += `  }\n`;
    initInstruction += `}\n\n`;
    initInstruction += `IMPORTANT NOTES:\n`;
    initInstruction += `- For attacks array: Each attack must be an object with "name" and "type" properties\n`;
    initInstruction += `  - "single-target": Can only target one character (enemy or ally)\n`;
    initInstruction += `  - "AoE": Area of Effect - targets all enemies, but some AoE attacks (like storms, explosions) can also harm allies if the attack is indiscriminate\n`;
    initInstruction += `  - "both": Player can choose to target a single enemy OR use as AoE\n`;
    initInstruction += `- Statuses array: May start empty, but don't have to if characters applied them before the combat\n`;
    initInstruction += `  - Each status has a format: {"name": "Status Name", "emoji": "💀", "duration": X}\n`;
    initInstruction += `  - Examples: Poisoned (🧪), Burning (🔥), Blessed (✨), Stunned (💫), Weakened (⬇️), Strengthened (⬆️)\n\n`;
    initInstruction += `The styleNotes object will be used to visually style the combat window - choose ONE value from each category that best fits the environment described in the chat history.\n\n`;
    initInstruction += `Use the user's current stats, inventory, and skills to populate the party data. For ${userName}'s attacks array, include their available skills. For items, include usable items from their inventory. Set HP based on their current Health stat if available.\n\n`;
    initInstruction += `Ensure all party members and enemies have realistic HP values based on the setting and their descriptions. Return ONLY the JSON object, no other text.`;

    // Only add the instruction if it has meaningful content
    if (initInstruction.trim()) {
        messages.push({
            role: 'user',
            content: initInstruction.trim()
        });
    }

    // Validate that we have at least one message with content
    if (messages.length === 0 || messages.every(m => !m.content || !m.content.trim())) {
        throw new Error('Unable to build encounter prompt - no valid content available');
    }

    return messages;
}

/**
 * Builds a combat action prompt
 * This is sent when the user takes an action in combat
 * @param {string} action - The action taken by the user
 * @param {object} combatStats - Current combat statistics
 * @returns {Array} Message array for the API
 */
export async function buildCombatActionPrompt(action, combatStats) {
    const context = getContext();
    const userName = context.name1;
    const depth = extensionSettings.encounterSettings?.historyDepth || 8;

    // Get narrative style from settings
    const narrativeStyle = extensionSettings.encounterSettings?.combatNarrative || {};
    const tense = narrativeStyle.tense || 'present';
    const person = narrativeStyle.person || 'third';
    const narration = narrativeStyle.narration || 'omniscient';
    const pov = narrativeStyle.pov || 'narrator';

    const messages = [];

    // Build system message with setting info
    let systemMessage = `You are the game master managing this combat encounter. You must not play as ${userName} - only describe what happens as a result of their actions/dialogues and control NPCs/enemies.\n\n`;

    // Add setting information
    systemMessage += `Here is some information for you about the setting:\n`;
    systemMessage += `<setting>\n`;

    // Get world info
    let worldInfoAdded = false;
    try {
        const getWorldInfoFn = context.getWorldInfoPrompt || window.getWorldInfoPrompt;
        const currentChat = context.chat || chat;

        if (typeof getWorldInfoFn === 'function' && currentChat && currentChat.length > 0) {
            const chatForWI = currentChat.map(x => x.mes || x.message || x).filter(m => m && typeof m === 'string');
            const result = await getWorldInfoFn(chatForWI, 8000, false);
            const worldInfoString = result?.worldInfoString || result;

            if (worldInfoString && worldInfoString.trim()) {
                systemMessage += worldInfoString.trim();
                worldInfoAdded = true;
            }
        }
    } catch (e) {
        console.warn('[RPG Companion] Failed to get world info for combat action:', e);
    }

    if (!worldInfoAdded && context.activatedWorldInfo && Array.isArray(context.activatedWorldInfo) && context.activatedWorldInfo.length > 0) {
        context.activatedWorldInfo.forEach((entry) => {
            if (entry && entry.content) {
                systemMessage += `${entry.content}\n\n`;
                worldInfoAdded = true;
            }
        });
    }

    if (!worldInfoAdded) {
        systemMessage += 'No world information available.';
    }

    systemMessage += `\n</setting>\n\n`;

    // Add character information
    const charactersInfo = await getCharactersInfo();
    if (charactersInfo) {
        systemMessage += `Here is the information available to you about the characters:\n`;
        systemMessage += `<characters>\n${charactersInfo}</characters>\n\n`;
    }

    // Add persona info
    if (context.name1) {
        systemMessage += `The protagonist is:\n`;
        systemMessage += `<persona>\n`;

        // Use substituteParams to get {{persona}} like in initial encounter
        try {
            const personaText = substituteParams('{{persona}}');
            if (personaText && personaText !== '{{persona}}') {
                systemMessage += personaText;
            } else {
                systemMessage += `Name: ${context.name1}\n`;
                if (extensionSettings.userStats?.personaDescription) {
                    systemMessage += `${extensionSettings.userStats.personaDescription}\n`;
                }
            }
        } catch (e) {
            systemMessage += `Name: ${context.name1}\n`;
            if (extensionSettings.userStats?.personaDescription) {
                systemMessage += `${extensionSettings.userStats.personaDescription}\n`;
            }
        }

        // Add ONLY classic stats/attributes if enabled
        if (extensionSettings.classicStats) {
            const stats = extensionSettings.classicStats;
            const config = extensionSettings.trackerConfig?.userStats;
            const rpgAttributes = (config?.rpgAttributes && config.rpgAttributes.length > 0) ? config.rpgAttributes : [
                { id: 'str', name: 'STR', enabled: true },
                { id: 'dex', name: 'DEX', enabled: true },
                { id: 'con', name: 'CON', enabled: true },
                { id: 'int', name: 'INT', enabled: true },
                { id: 'wis', name: 'WIS', enabled: true },
                { id: 'cha', name: 'CHA', enabled: true }
            ];
            const enabledAttributes = rpgAttributes.filter(attr => attr && attr.enabled && attr.name && attr.id);
            const attributeStrings = enabledAttributes.map(attr => `${attr.name} ${stats[attr.id] || 10}`);
            systemMessage += `\nAttributes: ${attributeStrings.join(', ')}, LVL ${extensionSettings.level}\n`;
        }

        systemMessage += `</persona>\n\n`;
    }

    messages.push({
        role: 'system',
        content: systemMessage
    });

    // Add recent chat history for context - append as user/assistant messages like initial encounter
    const currentChat = context.chat || chat;
    if (currentChat && currentChat.length > 0) {
        const recentMessages = currentChat.slice(-depth);

        for (const message of recentMessages) {
            const content = message.mes?.trim();
            // Skip empty messages
            if (content) {
                messages.push({
                    role: message.is_user ? 'user' : 'assistant',
                    content: content
                });
            }
        }
    }

    // Add combat log as plain text (previous actions)
    if (currentEncounter.encounterLog && currentEncounter.encounterLog.length > 0) {
        let combatHistory = 'Previous Combat Actions:\n';
        currentEncounter.encounterLog.forEach(entry => {
            combatHistory += `- ${entry.action}\n`;
            if (entry.result) {
                combatHistory += `  ${entry.result}\n`;
            }
        });

        messages.push({
            role: 'user',
            content: combatHistory
        });
    }

    // Add current combat state with FULL information (but tell AI not to regenerate static parts)
    let stateMessage = `Current Combat State:\n`;
    stateMessage += `Environment: ${combatStats.environment || 'Unknown location'}\n\n`;

    stateMessage += `Party Members:\n`;
    combatStats.party.forEach(member => {
        stateMessage += `- ${member.name}${member.isPlayer ? ' (Player)' : ''}: ${member.hp}/${member.maxHp} HP\n`;
        if (member.attacks && member.attacks.length > 0) {
            stateMessage += `  Attacks: ${member.attacks.map(a => typeof a === 'string' ? a : a.name).join(', ')}\n`;
        }
        if (member.items && member.items.length > 0) {
            stateMessage += `  Items: ${member.items.join(', ')}\n`;
        }
        if (member.statuses && member.statuses.length > 0) {
            const validStatuses = member.statuses.filter(s => s && (s.emoji || s.name));
            if (validStatuses.length > 0) {
                stateMessage += `  Status Effects: ${validStatuses.map(s => `${s.emoji || ''} ${s.name || ''}`.trim()).join(', ')}\n`;
            }
        }
    });

    stateMessage += `\nEnemies:\n`;
    combatStats.enemies.forEach(enemy => {
        stateMessage += `- ${enemy.name} (${enemy.sprite || ''}): ${enemy.hp}/${enemy.maxHp} HP\n`;
        if (enemy.description) {
            stateMessage += `  ${enemy.description}\n`;
        }
        if (enemy.attacks && enemy.attacks.length > 0) {
            stateMessage += `  Attacks: ${enemy.attacks.map(a => typeof a === 'string' ? a : a.name).join(', ')}\n`;
        }
        if (enemy.statuses && enemy.statuses.length > 0) {
            const validStatuses = enemy.statuses.filter(s => s && (s.emoji || s.name));
            if (validStatuses.length > 0) {
                stateMessage += `  Status Effects: ${validStatuses.map(s => `${s.emoji || ''} ${s.name || ''}`.trim()).join(', ')}\n`;
            }
        }
    });

    stateMessage += `\n${userName}'s Action: ${action}\n\n`;
    stateMessage += `Respond with the exact JSON object as below, containing ONLY these specified values. Remember to consider the user's party and their moves. DO NOT regenerate character descriptions, sprites, or environment:\n`;
    stateMessage += `{\n`;
    stateMessage += `  "combatStats": {\n`;
    stateMessage += `    "party": [{ "name": "Name", "hp": X, "maxHp": X, "statuses": [...] }],\n`;
    stateMessage += `    "enemies": [{ "name": "Name", "hp": X, "maxHp": X, "statuses": [...] }]\n`;
    stateMessage += `  },\n`;
    stateMessage += `  "enemyActions": [{ "enemyName": "Name", "action": "what they do", "target": "target" }],\n`;
    stateMessage += `  "partyActions": [{ "memberName": "Name", "action": "what they do", "target": "target" }],\n`;
    stateMessage += `  "narrative": "The roleplay description of what happens"\n`;
    stateMessage += `}\n\n`;
    stateMessage += `If all enemies are defeated or escape: add "combatEnd": true, "result": "victory". If all party defeated: add "combatEnd": true, "result": "defeat". It's also possible for the encounter to be interrupted by external interference (e.g., an explosion knocks everyone out, sudden environmental catastrophe, third party intervention, etc.). If this occurs, add "combatEnd": true, "result": "interrupted". Each status (if applied) has a format: {"name": "Status Name", "emoji": "💀", "duration": X}.\n`;
    stateMessage += `Scale combat difficulty appropriately: Powerful entities (gods, dragons, legendary creatures) should be formidable challenges requiring multiple rounds and strategic play. Weaker foes (common animals, basic enemies, minions) should be resolved more quickly, typically 2-4 rounds. Match HP damage and combat pacing to the narrative weight of the encounter. A wolf should not take 20 rounds to defeat, nor should a deity fall in one hit.\n`;
    stateMessage += `For the narrative, write it with intent in ${tense} tense ${person}-person ${narration} from ${pov}'s point of view.\n`;

    // Use custom combat narrative prompt if available
    const customCombatPrompt = extensionSettings.customCombatNarrativePrompt;
    if (customCombatPrompt) {
        stateMessage += customCombatPrompt.replace(/{userName}/g, userName) + '\n';
    } else {
        stateMessage += `Build novel prose. Break patterns from your previous responses by varying sentence structures, rhythms, formats, and openings. Track whether a sentence shape, cadence, sensory detail, or a descriptor appeared recently, and replace it with a different one or skip it entirely. If you mentioned a physical feature, mannerism, or expression once, move on. Don't fixate on the same traits every turn. Well-placed humor, unconventional similes, and subverted turns of phrase are encouraged. Avoid GPTisms, purple prose, and anaphoras, especially the negatives with "no/not/wasn't/didn't." Refrain from describing actions or emotions via negation; focus on what does happen, not what doesn't. Absolutely no asterisks, ellipses, or em-dashes. Explicit content is allowed, no plot armor. Do not play for ${userName}. Keep your response length under 150 words. Never end on handover cues; finish naturally.\n`;
        stateMessage += `CRITICAL: Do not repeat, echo, parrot, or restate distinctive words, phrases, and dialogues from the user's last message. If reacting to speech, show interpretation or response, not repetition.\n`;
        stateMessage += `EXAMPLE: "Are you a gooner?" User asks.\n`;
        stateMessage += `BAD: "Gooner?"\n`;
        stateMessage += `GOOD: A flat look. "What type of question is that?"`;
    }

    messages.push({
        role: 'user',
        content: stateMessage
    });

    return messages;
}

/**
 * Builds the final summary prompt
 * This is sent when combat ends to get a narrative summary
 * @param {Array} combatLog - Full combat log
 * @param {string} result - Combat result ('victory', 'defeat', or 'fled')
 * @returns {Promise<Array>} Message array for the API
 */
export async function buildCombatSummaryPrompt(combatLog, result) {
    const context = getContext();
    const userName = context.name1;

    const messages = [];

    // Get narrative style from settings (use summary narrative settings)
    const narrativeStyle = extensionSettings.encounterSettings?.summaryNarrative || {};
    const tense = narrativeStyle.tense || 'past';
    const person = narrativeStyle.person || 'third';
    const narration = narrativeStyle.narration || 'omniscient';
    const pov = narrativeStyle.pov || 'narrator';

    // Build system message with setting info
    let systemMessage = `You are summarizing a combat encounter that just concluded.\n\n`;

    // Add setting information
    systemMessage += `Here is some information for you about the setting:\n`;
    systemMessage += `<setting>\n`;

    // Get world info using the same method as encounter init
    let worldInfoAdded = false;
    try {
        const getWorldInfoFn = context.getWorldInfoPrompt || window.getWorldInfoPrompt;
        const currentChat = context.chat || chat;

        if (typeof getWorldInfoFn === 'function' && currentChat && currentChat.length > 0) {
            const chatForWI = currentChat.map(x => x.mes || x.message || x).filter(m => m && typeof m === 'string');
            const result = await getWorldInfoFn(chatForWI, 8000, false);
            const worldInfoString = result?.worldInfoString || result;

            if (worldInfoString && worldInfoString.trim()) {
                systemMessage += worldInfoString.trim();
                worldInfoAdded = true;
            }
        }
    } catch (e) {
        console.warn('[RPG Companion] Failed to get world info for summary:', e);
    }

    // Fallback to activatedWorldInfo
    if (!worldInfoAdded && context.activatedWorldInfo && Array.isArray(context.activatedWorldInfo) && context.activatedWorldInfo.length > 0) {
        context.activatedWorldInfo.forEach((entry) => {
            if (entry && entry.content) {
                systemMessage += `${entry.content}\n\n`;
                worldInfoAdded = true;
            }
        });
    }

    if (!worldInfoAdded) {
        systemMessage += 'No world information available.';
    }

    systemMessage += `\n</setting>\n\n`;

    // Add character information
    const charactersInfo = await getCharactersInfo();
    if (charactersInfo) {
        systemMessage += `Here is the information available to you about the characters:\n`;
        systemMessage += `<characters>\n${charactersInfo}</characters>\n\n`;
    }

    // Add persona information
    systemMessage += `Here are details about ${userName}:\n`;
    systemMessage += `<persona>\n`;

    try {
        const personaText = substituteParams('{{persona}}');
        if (personaText && personaText !== '{{persona}}') {
            systemMessage += personaText;
        } else {
            systemMessage += 'No persona information available.';
        }
    } catch (e) {
        systemMessage += 'No persona information available.';
    }

    systemMessage += `\n</persona>\n\n`;

    // Add the message that triggered the encounter
    if (currentEncounter.encounterStartMessage) {
        systemMessage += `Here is the last message before combat started:\n`;
        systemMessage += `<trigger>\n${currentEncounter.encounterStartMessage}\n</trigger>\n\n`;
    }

    messages.push({
        role: 'system',
        content: systemMessage
    });

    let summaryMessage = `Combat has ended with result: ${result}\n\n`;
    summaryMessage += `Full Combat Log:\n`;

    combatLog.forEach((entry, index) => {
        summaryMessage += `\nRound ${index + 1}:\n`;
        summaryMessage += `${entry.action}\n`;
        summaryMessage += `${entry.result}\n`;
    });

    summaryMessage += `\n\nProvide a narrative summary of the entire fight in a way that fits the style from the chat history. Start with [FIGHT CONCLUDED] on the first line, then provide the description.\n\n`;
    summaryMessage += `Write with intent in ${tense} tense ${person}-person ${narration} from ${pov}'s point of view.\n`;
    summaryMessage += `Build novel prose. Break patterns from your previous responses by varying sentence structures, rhythms, formats, and openings. If you last started with a narration, begin this one with dialogue; if with an action, switch to an internal thought. Track whether a sentence shape, cadence, sensory detail, or a descriptor appeared recently, and replace it with a different one or skip it entirely. If you mentioned a physical feature, mannerism, or expression once, move on. Don't fixate on the same traits every turn. Well-placed humor, unconventional similes, and subverted turns of phrase are encouraged. Avoid GPTisms, purple prose, and anaphoras, especially the negatives with "no/not/wasn't/didn't." Refrain from describing actions or emotions via negation; focus on what does happen, not what doesn't. Minimize asterisks, ellipses, and em-dashes. Explicit content is allowed. Never end on handover cues; finish naturally.\n\n`;
    summaryMessage += `Express ${userName}'s actions and dialogue using indirect speech (e.g., "${userName} swung their sword" or "${userName} asked for help"). The summary should be 2-4 paragraphs and capture the essence of the battle.\n\n`;

    // If in Together mode and trackers are enabled, add tracker update instructions
    if (extensionSettings.generationMode === 'together' && (extensionSettings.showUserStats || extensionSettings.showInfoBox || extensionSettings.showCharacterThoughts)) {
        summaryMessage += `\n--- TRACKER UPDATE ---\n\n`;
        summaryMessage += `After the [FIGHT CONCLUDED] summary, update the RPG trackers to reflect ${userName}'s state AFTER the combat encounter. `;
        summaryMessage += `Account for any injuries sustained, resources used, emotional state changes, or other consequences of the battle.\n\n`;

        // Include pre-combat tracker state if available
        if (committedTrackerData.userStats || committedTrackerData.infoBox || committedTrackerData.characterThoughts) {
            summaryMessage += `Pre-combat tracker state:\n`;
            summaryMessage += `<previous>\n`;

            if (committedTrackerData.userStats) {
                const statsJSON = typeof committedTrackerData.userStats === 'object'
                    ? JSON.stringify(committedTrackerData.userStats, null, 2)
                    : committedTrackerData.userStats;
                summaryMessage += statsJSON + '\n';
            }

            if (committedTrackerData.infoBox) {
                const infoBoxJSON = typeof committedTrackerData.infoBox === 'object'
                    ? JSON.stringify(committedTrackerData.infoBox, null, 2)
                    : committedTrackerData.infoBox;
                summaryMessage += infoBoxJSON + '\n';
            }

            if (committedTrackerData.characterThoughts) {
                const charactersJSON = typeof committedTrackerData.characterThoughts === 'object'
                    ? JSON.stringify(committedTrackerData.characterThoughts, null, 2)
                    : committedTrackerData.characterThoughts;
                summaryMessage += charactersJSON + '\n';
            }

            summaryMessage += `</previous>\n\n`;
        }

        // Add tracker instructions and example
        const trackerInstructions = generateTrackerInstructions(false, false, true);
        summaryMessage += trackerInstructions;

        const trackerExample = generateTrackerExample();
        if (trackerExample) {
            summaryMessage += `\n${trackerExample}`;
        }
    }

    messages.push({
        role: 'user',
        content: summaryMessage
    });

    return messages;
}

/**
 * Parses JSON response from the AI, handling code blocks
 * @param {string} response - The AI response
 * @returns {object|null} Parsed JSON object or null if parsing fails
 */
export function parseEncounterJSON(response) {
    try {
        // Remove code blocks if present
        let cleaned = response.trim();

        // Remove ```json, ```markdown, and ``` markers (more comprehensive)
        cleaned = cleaned.replace(/```(?:json|markdown)?\s*/gi, '');

        // Remove any remaining backticks
        cleaned = cleaned.replace(/`/g, '');

        // Find the first { and last }
        const firstBrace = cleaned.indexOf('{');
        const lastBrace = cleaned.lastIndexOf('}');

        if (firstBrace !== -1 && lastBrace !== -1) {
            cleaned = cleaned.substring(firstBrace, lastBrace + 1);
        }

        // Try to parse directly first
        try {
            return JSON.parse(cleaned);
        } catch (initialError) {
            // If direct parsing fails, try JSON repair
            console.warn('[RPG Companion] Initial parse failed, attempting JSON repair...');
            const repaired = repairJSON(cleaned);

            if (repaired) {
                // console.log('[RPG Companion] ✓ Successfully repaired encounter JSON');
                return repaired;
            }

            // If repair also failed, throw the original error
            throw initialError;
        }
    } catch (error) {
        console.error('[RPG Companion] Failed to parse encounter JSON:', error);
        console.error('[RPG Companion] Response was:', response);
        return null;
    }
}