/**
 * SillyTavern Integration Module
 * Handles all event listeners and integration with SillyTavern's event system
 */

import { getContext } from '../../../../../../extensions.js';
import { chat, chat_metadata, user_avatar, setExtensionPrompt, extension_prompt_types } from '../../../../../../../script.js';

// Core modules
import {
    extensionSettings,
    lastGeneratedData,
    committedTrackerData,
    lastActionWasSwipe,
    isPlotProgression,
    isAwaitingNewMessage,
    setLastActionWasSwipe,
    setIsPlotProgression,
    setIsGenerating,
    setIsAwaitingNewMessage,
    updateLastGeneratedData,
    updateCommittedTrackerData,
    $musicPlayerContainer,
    incrementSeparateGenerationId
} from '../../core/state.js';
import {
    saveChatData,
    loadChatData,
    autoSwitchPresetForEntity,
    getMessageSwipeTrackerData,
    getCurrentMessageSwipeTrackerData,
    restoreLatestTrackerStateFromChat,
    setMessageSwipeTrackerData,
    getSwipeData,
    commitTrackerDataFromPriorMessage,
    inheritSwipeDataFromPriorMessage
} from '../../core/persistence.js';
import { i18n } from '../../core/i18n.js';

// Generation & Parsing
import { parseResponse, parseUserStats } from '../generation/parser.js';
import { parseAndStoreSpotifyUrl, convertToEmbedUrl } from '../features/musicPlayer.js';
import { updateRPGData } from '../generation/apiClient.js';
import { removeLocks } from '../generation/lockManager.js';
import { onGenerationStarted, initHistoryInjectionListeners } from '../generation/injector.js';

// Rendering
import { renderUserStats } from '../rendering/userStats.js';
import { renderInfoBox } from '../rendering/infoBox.js';
import { renderThoughts, updateChatThoughts } from '../rendering/thoughts.js';
import { renderInventory } from '../rendering/inventory.js';
import { renderQuests } from '../rendering/quests.js';
import { renderMusicPlayer } from '../rendering/musicPlayer.js';

// Utils
import { getSafeThumbnailUrl } from '../../utils/avatars.js';

// UI
import { setFabLoadingState, updateFabWidgets } from '../ui/mobile.js';
import { updateStripWidgets } from '../ui/desktop.js';

// Chapter checkpoint
import { updateAllCheckpointIndicators } from '../ui/checkpointUI.js';
import { restoreCheckpointOnLoad } from '../features/chapterCheckpoint.js';

let chatStateRehydrateRunId = 0;

/**
 * Reads the swipe store of the last assistant message in `currentChat` and
 * writes its data into `lastGeneratedData`, including syncing stat bars via
 * `parseUserStats`.  If no assistant message exists, or none has stored swipe
 * data, `lastGeneratedData` is left unchanged.
 *
 * Use this wherever the displayed tracker state must be re-derived from the
 * authoritative swipe store rather than from chat_metadata (e.g. after a
 * CHAT_CHANGED caused by branching, or after a message deletion).
 *
 * @param {Array} currentChat - Live chat array from getContext().chat
 * @returns {boolean} True if swipe data was found and applied
 */
function syncLastGeneratedDataFromSwipeStore(currentChat) {
    for (let i = currentChat.length - 1; i >= 0; i--) {
        const msg = currentChat[i];
        if (!msg.is_user && !msg.is_system) {
            const swipeId = msg.swipe_id || 0;
            const swipeData = getSwipeData(msg, swipeId);
            if (swipeData) {
                lastGeneratedData.userStats = swipeData.userStats || null;
                lastGeneratedData.infoBox = swipeData.infoBox || null;
                // Normalize characterThoughts to string (backward compat with old object format).
                if (swipeData.characterThoughts && typeof swipeData.characterThoughts === 'object') {
                    lastGeneratedData.characterThoughts = JSON.stringify(swipeData.characterThoughts, null, 2);
                } else {
                    lastGeneratedData.characterThoughts = swipeData.characterThoughts || null;
                }
                if (swipeData.userStats) {
                    parseUserStats(swipeData.userStats);
                }
                return true;
            }
            return false; // Last assistant message exists but has no swipe data yet
        }
    }
    return false; // No assistant messages in chat
}

/**
 * Commits the tracker data from the last assistant message to be used as source for next generation.
 * This should be called when the user has replied to a message, ensuring all swipes of the next
 * response use the same committed context.
 */
export function commitTrackerData() {
    const chat = getContext().chat;
    if (!chat || chat.length === 0) {
        return;
    }

    // Find the last assistant message
    for (let i = chat.length - 1; i >= 0; i--) {
        const message = chat[i];
        if (!message.is_user && !message.is_system) {
            // Found last assistant message - commit its tracker data
            const swipeId = message.swipe_id || 0;
            const swipeData = getSwipeData(message, swipeId);

            if (swipeData) {
                // console.log('[RPG Companion] Committing tracker data from assistant message at index', i, 'swipe', swipeId);
                committedTrackerData.userStats = swipeData.userStats || null;
                committedTrackerData.infoBox = swipeData.infoBox || null;
                const rawCharacterThoughts = swipeData.characterThoughts;
                if (rawCharacterThoughts == null) {
                    committedTrackerData.characterThoughts = null;
                } else if (typeof rawCharacterThoughts === 'object') {
                    committedTrackerData.characterThoughts = JSON.stringify(rawCharacterThoughts);
                } else {
                    committedTrackerData.characterThoughts = String(rawCharacterThoughts);
                }
            } else {
                // No saved swipe data — treat as empty (e.g. first message, no prior generation)
                committedTrackerData.userStats = null;
                committedTrackerData.infoBox = null;
                committedTrackerData.characterThoughts = null;
            }
            break;
        }
    }
}

function getSwipeTrackerData(message) {
    return getMessageSwipeTrackerData(message);
}

function getCurrentSwipeTrackerData(message) {
    return getCurrentMessageSwipeTrackerData(message);
}

function hasAssistantMessageBody() {
    const $messages = $('#chat .mes');

    for (let i = $messages.length - 1; i >= 0; i--) {
        const $message = $messages.eq(i);
        if ($message.attr('is_user') === 'true') continue;
        if ($message.find('.mes_text').length > 0) {
            return true;
        }
    }

    return false;
}

function hasAnyTrackerStateInChat() {
    const chatMessages = getContext()?.chat || [];

    for (let i = chatMessages.length - 1; i >= 0; i--) {
        const swipeData = getSwipeTrackerData(chatMessages[i]);
        if (swipeData?.userStats || swipeData?.infoBox || swipeData?.characterThoughts) {
            return true;
        }
    }

    return false;
}

function hasAssistantMessagesInChat() {
    const chatMessages = getContext()?.chat || [];
    return chatMessages.some(message => message && !message.is_user && !message.is_system);
}

function hasPotentialTrackerSourceInChat() {
    const chatMessages = getContext()?.chat || [];

    for (const message of chatMessages) {
        if (!message || message.is_user || message.is_system) {
            continue;
        }

        if (message.extra?.rpg_companion_swipes) {
            return true;
        }

        if (Array.isArray(message.swipe_info) && message.swipe_info.some(info => info?.extra?.rpg_companion_swipes)) {
            return true;
        }

        if (Array.isArray(message.swipes) && message.swipes.length > 1) {
            return true;
        }
    }

    return false;
}

function maybeRehydrateUserStatsFromDisplayData() {
    const hasSavedUserStats = !!chat_metadata?.rpg_companion?.userStats;
    if (!hasSavedUserStats && lastGeneratedData.userStats) {
        try {
            parseUserStats(lastGeneratedData.userStats);
        } catch (error) {
            console.warn('[RPG Companion] Failed to rebuild user stats from display data:', error);
        }
    }
}

function getCurrentSwipeText(message) {
    const swipeId = Number(message?.swipe_id ?? 0);

    if (Array.isArray(message?.swipes) && typeof message.swipes[swipeId] === 'string' && message.swipes[swipeId].trim()) {
        return message.swipes[swipeId];
    }

    return typeof message?.mes === 'string' ? message.mes : '';
}

/**
 * Resolves the currently active swipe index for a message.
 * Some ST flows can briefly expose a stale message.swipe_id during swipe transitions,
 * so we also match against message.mes in the swipes array when possible.
 *
 * @param {Object} message - Assistant message object
 * @returns {number} Active swipe index
 */
function resolveActiveSwipeId(message) {
    const fallbackSwipeId = Number(message?.swipe_id ?? 0);
    const swipes = Array.isArray(message?.swipes) ? message.swipes : null;

    if (!swipes || swipes.length === 0) {
        return Math.max(0, fallbackSwipeId);
    }

    const currentText = typeof message?.mes === 'string' ? message.mes : '';
    if (currentText) {
        for (let i = swipes.length - 1; i >= 0; i--) {
            if (typeof swipes[i] === 'string' && swipes[i] === currentText) {
                return i;
            }
        }
    }

    if (fallbackSwipeId < 0) {
        return 0;
    }

    return Math.min(fallbackSwipeId, swipes.length - 1);
}

function repairLatestTrackerStateFromCurrentSwipeContent(chatMessages = getContext()?.chat || []) {
    for (let i = chatMessages.length - 1; i >= 0; i--) {
        const message = chatMessages[i];
        if (!message || message.is_user || message.is_system) {
            continue;
        }

        const swipeId = Number(message.swipe_id ?? 0);
        if (getCurrentSwipeTrackerData(message)) {
            continue;
        }

        const currentSwipeText = getCurrentSwipeText(message);
        if (!currentSwipeText) {
            continue;
        }

        const parsedData = parseResponse(currentSwipeText);
        if (parsedData.userStats) {
            parsedData.userStats = removeLocks(parsedData.userStats);
        }
        if (parsedData.infoBox) {
            parsedData.infoBox = removeLocks(parsedData.infoBox);
        }
        if (parsedData.characterThoughts) {
            parsedData.characterThoughts = removeLocks(parsedData.characterThoughts);
        }

        if (!parsedData.userStats && !parsedData.infoBox && !parsedData.characterThoughts) {
            continue;
        }

        setMessageSwipeTrackerData(message, swipeId, {
            userStats: parsedData.userStats || null,
            infoBox: parsedData.infoBox || null,
            characterThoughts: parsedData.characterThoughts || null
        });

        return true;
    }

    return false;
}

function restoreOrRepairLatestTrackerState() {
    const chatMessages = getContext()?.chat || [];
    let restored = restoreLatestTrackerStateFromChat(chatMessages);

    if (!restored) {
        const repaired = repairLatestTrackerStateFromCurrentSwipeContent(chatMessages);
        if (repaired) {
            restored = restoreLatestTrackerStateFromChat(chatMessages);
        }
    }

    return restored;
}

function rerenderRpgState() {
    renderUserStats();
    renderInfoBox();
    renderThoughts();
    renderInventory();
    renderQuests();
    renderMusicPlayer($musicPlayerContainer[0]);
    updateFabWidgets();
    updateStripWidgets();
}

export function scheduleChatStateRehydration() {
    chatStateRehydrateRunId++;
    const runId = chatStateRehydrateRunId;
    let attempts = 0;
    const maxAttempts = 15;
    const eagerRetryAttempts = 4;

    const tryRestoreState = () => {
        if (runId !== chatStateRehydrateRunId) {
            return;
        }

        attempts++;

        loadChatData();
        restoreOrRepairLatestTrackerState();
        maybeRehydrateUserStatsFromDisplayData();
        rerenderRpgState();

        const hasRestoredTrackerState = !!(
            lastGeneratedData.userStats
            || lastGeneratedData.infoBox
            || lastGeneratedData.characterThoughts
            || committedTrackerData.userStats
            || committedTrackerData.infoBox
            || committedTrackerData.characterThoughts
        );
        const hasStoredTrackerState = !!chat_metadata?.rpg_companion || hasAnyTrackerStateInChat();
        const hasAssistantMessages = hasAssistantMessagesInChat();
        const hasPotentialTrackerSource = hasPotentialTrackerSourceInChat();
        const chatBodyReady = hasAssistantMessageBody();

        if (chatBodyReady) {
            updateChatThoughts();
        }

        const shouldRetryForRestore = !hasRestoredTrackerState && (
            hasStoredTrackerState
            || (hasAssistantMessages && attempts < eagerRetryAttempts)
            || (hasPotentialTrackerSource && attempts < maxAttempts)
        );

        const shouldRetryForDom = !chatBodyReady && hasAssistantMessages;

        if ((shouldRetryForRestore || shouldRetryForDom) && attempts < maxAttempts) {
            setTimeout(tryRestoreState, 200);
        }
    };

    setTimeout(tryRestoreState, 200);
}

export function onChatLoaded() {
    loadChatData();
    restoreOrRepairLatestTrackerState();
    maybeRehydrateUserStatsFromDisplayData();
    rerenderRpgState();
    scheduleChatStateRehydration();
    updateAllCheckpointIndicators();
}

function syncDisplayedTrackerStateFromChat() {
    const restored = restoreOrRepairLatestTrackerState();

    if (!restored) {
        lastGeneratedData.userStats = null;
        lastGeneratedData.infoBox = null;
        lastGeneratedData.characterThoughts = null;
        committedTrackerData.userStats = null;
        committedTrackerData.infoBox = null;
        committedTrackerData.characterThoughts = null;
    }

    rerenderRpgState();
    updateChatThoughts();
}

/**
 * Event handler for when the user sends a message.
 * Sets the flag to indicate this is NOT a swipe.
 * In together mode, commits displayed data (only for real messages, not streaming placeholders).
 */
export function onMessageSent() {
    if (!extensionSettings.enabled) return;

    // console.log('[RPG Companion] 🟢 EVENT: onMessageSent - lastActionWasSwipe =', lastActionWasSwipe);

    // Check if this is a streaming placeholder message (content = "...")
    // When streaming is on, ST sends a "..." placeholder before generation starts
    const context = getContext();
    const chat = context.chat;
    const lastMessage = chat && chat.length > 0 ? chat[chat.length - 1] : null;


    if (lastMessage && lastMessage.mes === '...') {
        // console.log('[RPG Companion] 🟢 Ignoring onMessageSent: streaming placeholder message');
        return;
    }

    // console.log('[RPG Companion] 🟢 EVENT: onMessageSent (after placeholder check)');
    // console.log('[RPG Companion] 🟢 NOTE: lastActionWasSwipe will be reset in onMessageReceived after generation completes');

    // Set flag to indicate we're expecting a new message from generation
    // This allows auto-update to distinguish between new generations and loading chat history
    setIsAwaitingNewMessage(true);




    // Note: FAB spinning is NOT shown for together mode since no extra API request is made
    // The RPG data comes embedded in the main response
    // FAB spinning is handled by apiClient.js for separate/external modes when updateRPGData() is called
}

/**
 * Event handler for when a message is generated.
 */
export async function onMessageReceived(data) {
    // console.log('[RPG Companion] onMessageReceived called, lastActionWasSwipe:', lastActionWasSwipe);

    if (!extensionSettings.enabled) {
        return;
    }

    // Reset swipe flag after generation completes
    // This ensures next user message (whether from original or swipe) triggers commit
    setLastActionWasSwipe(false);
    // console.log('[RPG Companion] 🟢 Reset lastActionWasSwipe = false (generation completed)');

    if (extensionSettings.generationMode === 'together') {
        // In together mode, parse the response to extract RPG data
        // Commit happens in onMessageSent (when user sends message, before generation)
        const lastMessage = chat[chat.length - 1];
        if (lastMessage && !lastMessage.is_user) {
            const rawSwipeId = Number(lastMessage.swipe_id ?? 0);
            const responseText = lastMessage.mes;
            const parsedData = parseResponse(responseText);

            // Note: Don't show parsing error here - this event fires when loading chat history too
            // Error notification is handled in apiClient.js for fresh generations only

            // Remove locks from parsed data (JSON format only, text format is unaffected)
            if (parsedData.userStats) {
                parsedData.userStats = removeLocks(parsedData.userStats);
            }
            if (parsedData.infoBox) {
                parsedData.infoBox = removeLocks(parsedData.infoBox);
            }
            if (parsedData.characterThoughts) {
                parsedData.characterThoughts = removeLocks(parsedData.characterThoughts);
            }

            // Parse and store Spotify URL if feature is enabled
            parseAndStoreSpotifyUrl(responseText);

            // Update display data with newly parsed response
            // console.log('[RPG Companion] 📝 TOGETHER MODE: Updating lastGeneratedData with parsed response');
            if (parsedData.userStats) {
                lastGeneratedData.userStats = parsedData.userStats;
                parseUserStats(parsedData.userStats);
            }
            if (parsedData.infoBox) {
                lastGeneratedData.infoBox = parsedData.infoBox;
            }
            if (parsedData.characterThoughts) {
                lastGeneratedData.characterThoughts = parsedData.characterThoughts;
            }

            // Store RPG data for this specific swipe in the message's extra field
            if (!lastMessage.extra) {
                lastMessage.extra = {};
            }
            if (!lastMessage.extra.rpg_companion_swipes) {
                lastMessage.extra.rpg_companion_swipes = {};
            }

            const currentSwipeId = resolveActiveSwipeId(lastMessage);

            setMessageSwipeTrackerData(lastMessage, currentSwipeId, {
                userStats: parsedData.userStats,
                infoBox: parsedData.infoBox,
                characterThoughts: parsedData.characterThoughts
            });

            // console.log('[RPG Companion] Stored RPG data for swipe', currentSwipeId);

            // Remove the tracker code blocks from the visible message
            let cleanedMessage = responseText;

            // Note: JSON code blocks are hidden from display by regex script (but preserved in message data)

            // Remove old text format code blocks (legacy support)
            cleanedMessage = cleanedMessage.replace(/```[^`]*?Stats\s*\n\s*---[^`]*?```\s*/gi, '');
            cleanedMessage = cleanedMessage.replace(/```[^`]*?Info Box\s*\n\s*---[^`]*?```\s*/gi, '');
            cleanedMessage = cleanedMessage.replace(/```[^`]*?Present Characters\s*\n\s*---[^`]*?```\s*/gi, '');
            // Remove any stray "---" dividers that might appear after the code blocks
            cleanedMessage = cleanedMessage.replace(/^\s*---\s*$/gm, '');
            // Clean up multiple consecutive newlines
            cleanedMessage = cleanedMessage.replace(/\n{3,}/g, '\n\n');
            // Note: <trackers> XML tags are automatically hidden by SillyTavern
            // Note: <Song - Artist/> tags are also automatically hidden by SillyTavern

            // Update the message in chat history
            lastMessage.mes = cleanedMessage.trim();

            // Update the swipe text as well
            if (lastMessage.swipes && lastMessage.swipes[currentSwipeId] !== undefined) {
                lastMessage.swipes[currentSwipeId] = cleanedMessage.trim();
            }

            // Render the updated data FIRST (before cleaning DOM)
            renderUserStats();
            renderInfoBox();
            renderThoughts();
            renderInventory();
            renderQuests();
            renderMusicPlayer($musicPlayerContainer[0]);

            // Update FAB widgets and strip widgets with newly parsed data
            updateFabWidgets();
            updateStripWidgets();

            // Then update the DOM to reflect the cleaned message
            // Using updateMessageBlock to perform macro substitutions + regex formatting
            const messageId = chat.length - 1;
            updateMessageBlock(messageId, lastMessage, { rerenderMessage: true });

            // console.log('[RPG Companion] Cleaned message, removed tracker code blocks from DOM');

            // Re-insert chat thoughts after SillyTavern finishes rerendering the cleaned message DOM.
            if (parsedData.characterThoughts) {
                setTimeout(() => updateChatThoughts(), 100);
            }

            // Save to chat metadata
            saveChatData();
        }
    } else if (extensionSettings.generationMode === 'separate' || extensionSettings.generationMode === 'external') {
        // In separate/external mode, also parse Spotify URLs from the main roleplay response
        const lastMessage = chat[chat.length - 1];
        if (lastMessage && !lastMessage.is_user) {
            const responseText = lastMessage.mes;

            // Parse and store Spotify URL
            const foundSpotifyUrl = parseAndStoreSpotifyUrl(responseText);

            // No need to clean message - SillyTavern auto-hides <Song - Artist/> tags
            if (foundSpotifyUrl && extensionSettings.enableSpotifyMusic) {
                // Just render the music player
                renderMusicPlayer($musicPlayerContainer[0]);
            }

            // When auto-update is disabled, no tracker API call will run for this message.
            // Inherit the prior assistant message's tracker data into this swipe slot so that
            // commitTrackerDataFromPriorMessage can find a valid state next turn instead of nulling everything.
            // Inheritance does not overwrite existing data, so it's safe to call even if the condition misses an edge case.
            if (!extensionSettings.autoUpdate || !isAwaitingNewMessage) {
                inheritSwipeDataFromPriorMessage(lastMessage, chat.length - 1);
            }
        }

        // Trigger auto-update if enabled (for both separate and external modes)
        // Only trigger if this is a newly generated message, not loading chat history
        if (extensionSettings.autoUpdate && isAwaitingNewMessage) {
            // Capture the current generation ID before the async gap so that any
            // message deletion (or a newer generation) that increments the counter
            // while the 500ms timer or the API call is in-flight will cause
            // updateRPGData to discard its result rather than stomping the UI.
            const genId = incrementSeparateGenerationId();
            setTimeout(async () => {
                await updateRPGData(renderUserStats, renderInfoBox, renderThoughts, renderInventory, genId);
                // Update FAB widgets and strip widgets after separate/external mode update completes
                setFabLoadingState(false);
                updateFabWidgets();
                updateStripWidgets();
            }, 500);
        }
    }

    // Reset the awaiting flag after processing the message
    setIsAwaitingNewMessage(false);

    // Reset the swipe flag after generation completes
    // This ensures that if the user swiped → auto-reply generated → flag is now cleared
    // so the next user message will be treated as a new message (not a swipe)
    if (lastActionWasSwipe) {
        // console.log('[RPG Companion] 🔄 Generation complete after swipe - resetting lastActionWasSwipe to false');
        setLastActionWasSwipe(false);
    }

    // Clear plot progression flag if this was a plot progression generation
    // Note: No need to clear extension prompt since we used quiet_prompt option
    if (isPlotProgression) {
        setIsPlotProgression(false);
        // console.log('[RPG Companion] Plot progression generation completed');
    }

    // Stop FAB loading state and update widgets
    setFabLoadingState(false);
    updateFabWidgets();
    updateStripWidgets();

    // Re-apply checkpoint in case SillyTavern unhid messages during generation
    await restoreCheckpointOnLoad();
}

/**
 * Event handler for character change.
 */
export function onCharacterChanged() {
    // Remove thought panel and icon when changing characters
    $('#rpg-thought-panel').remove();
    $('#rpg-thought-icon').remove();
    $('.rpg-inline-thoughts, .rpg-inline-thought').remove();
    $('#chat').off('scroll.thoughtPanel');
    $(window).off('resize.thoughtPanel');
    $(document).off('click.thoughtPanel');

    // Auto-switch to the preset associated with this character/group (if any)
    const presetSwitched = autoSwitchPresetForEntity();
    // if (presetSwitched) {
    //     console.log('[RPG Companion] Auto-switched preset for character');
    // }

    // Load chat-specific data when switching chats
    loadChatData();

    // chat_metadata may not reflect the actual chat tail for branches, so
    // loadChatData() may have just restored stale data from the parent chat.
    // Override lastGeneratedData from the swipe store of the last assistant message.
    // The message objects in the branch already carry their full swipe stores, making this authoritative.
    // If no swipe data exists (e.g. branching at message 0, or a chat with no generations yet),
    // null out lastGeneratedData and committedTrackerData so we don't display stale values from the parent chat.
    const hadSwipeData = syncLastGeneratedDataFromSwipeStore(getContext().chat);
    if (!hadSwipeData) {
        lastGeneratedData.userStats = null;
        lastGeneratedData.infoBox = null;
        lastGeneratedData.characterThoughts = null;
        committedTrackerData.userStats = null;
        committedTrackerData.infoBox = null;
        committedTrackerData.characterThoughts = null;
    }

    // Don't call commitTrackerData() here - it would overwrite the loaded committedTrackerData
    // with data from the last message, which may be null/empty. The loaded committedTrackerData
    // already contains the committed state from when we last left this chat.
    // commitTrackerData() will be called naturally when new messages arrive.

    // Re-render with the loaded data and retry once SillyTavern finishes restoring chat state.
    rerenderRpgState();
    scheduleChatStateRehydration();

    // Update checkpoint indicators for the loaded chat
    updateAllCheckpointIndicators();
}

/**
 * Event handler for when a message is swiped.
 * Loads the RPG data for the swipe the user navigated to.
 */
export function onMessageSwiped(messageIndex) {
    if (!extensionSettings.enabled) {
        return;
    }

    // console.log('[RPG Companion] 🔵 EVENT: onMessageSwiped at index:', messageIndex);

    // Get the message that was swiped
    const message = chat[messageIndex];
    if (!message || message.is_user) {
        // console.log('[RPG Companion] 🔵 Ignoring swipe - message is user or undefined');
        return;
    }

    const currentSwipeId = resolveActiveSwipeId(message);
    const swipeCount = Array.isArray(message.swipes) ? message.swipes.length : 0;

    // Only set flag to true if this swipe will trigger a NEW generation
    // Check if the swipe already exists (has content in the swipes array)
    const isExistingSwipe = message.swipes &&
        message.swipes[currentSwipeId] !== undefined &&
        message.swipes[currentSwipeId] !== null &&
        message.swipes[currentSwipeId].length > 0;
    const swipeData = getSwipeData(message, currentSwipeId);
    const isPendingNewSwipe = currentSwipeId >= swipeCount;

    if (!isExistingSwipe) {
        // This is a NEW swipe that will trigger generation
        setLastActionWasSwipe(true);
        setIsAwaitingNewMessage(true);
        // Immediately commit context from the prior assistant message (N-1) so generation
        // uses the world state before this message, not the last-viewed sibling swipe.
        commitTrackerDataFromPriorMessage(messageIndex);
        // console.log('[RPG Companion] 🔵 NEW swipe detected - Set lastActionWasSwipe = true');
    } else {
        // This is navigating to an EXISTING swipe - don't change the flag
        // console.log('[RPG Companion] 🔵 EXISTING swipe navigation - lastActionWasSwipe unchanged =', lastActionWasSwipe);
    }

    if (isPendingNewSwipe) {
        lastGeneratedData.characterThoughts = null;
    }

    // console.log('[RPG Companion] Loading data for swipe', currentSwipeId);

    // Load saved swipe data for the active swipe only.
    // Using the current-swipe helper here avoids falling back to another
    // stored swipe payload and showing stale tracker state.
    if (swipeData) {
        // Load swipe data into lastGeneratedData for display (both modes)
        lastGeneratedData.userStats = swipeData.userStats || null;
        lastGeneratedData.infoBox = swipeData.infoBox || null;

        // Normalize characterThoughts to string format (for backward compatibility with old object format)
        if (swipeData.characterThoughts && typeof swipeData.characterThoughts === 'object') {
            lastGeneratedData.characterThoughts = JSON.stringify(swipeData.characterThoughts, null, 2);
        } else {
            lastGeneratedData.characterThoughts = swipeData.characterThoughts || null;
        }

        // Sync extensionSettings.userStats so stat bars reflect this swipe
        if (swipeData.userStats) {
            parseUserStats(swipeData.userStats);
        }

        // console.log('[RPG Companion] 🔄 Loaded swipe data for swipe:', currentSwipeId);
    } else {
        // console.log('[RPG Companion] ℹ️ No stored data for swipe:', currentSwipeId);
    }

    // Re-render the panels
    renderUserStats();
    renderInfoBox();
    renderThoughts();
    renderInventory();
    renderQuests();
    renderMusicPlayer($musicPlayerContainer[0]);

    // Update widget strips with the newly loaded swipe data
    updateFabWidgets();
    updateStripWidgets();

    // Update chat thought overlays
    updateChatThoughts();
}

export function onMessageDeleted() {
    if (!extensionSettings.enabled) {
        return;
    }

    // Invalidate any pending or in-flight separate-mode generation so
    // its result is not applied to the (now-changed) chat tail.
    incrementSeparateGenerationId();

    const currentChat = getContext().chat || [];
    let lastAssistantIndex = -1;
    for (let i = currentChat.length - 1; i >= 0; i--) {
        if (!currentChat[i].is_user && !currentChat[i].is_system) {
            lastAssistantIndex = i;
            break;
        }
    }

    syncDisplayedTrackerStateFromChat();

    // After the display state has been rebuilt, restore generation context from
    // the assistant message immediately before the new tail message so the next
    // generation uses the correct N-1 tracker state.
    if (lastAssistantIndex !== -1) {
        commitTrackerDataFromPriorMessage(lastAssistantIndex);
    }

    saveChatData();
}

/**
 * Update the persona avatar image when user switches personas
 */
export function updatePersonaAvatar() {
    const portraitImg = document.querySelector('.rpg-user-portrait');
    if (!portraitImg) {
        // console.log('[RPG Companion] Portrait image element not found in DOM');
        return;
    }

    // Get current user_avatar from context instead of using imported value
    const context = getContext();
    const currentUserAvatar = context.user_avatar || user_avatar;

    // console.log('[RPG Companion] Attempting to update persona avatar:', currentUserAvatar);

    // Try to get a valid thumbnail URL using our safe helper
    if (currentUserAvatar) {
        const thumbnailUrl = getSafeThumbnailUrl('persona', currentUserAvatar);

        if (thumbnailUrl) {
            // Only update the src if we got a valid URL
            portraitImg.src = thumbnailUrl;
            // console.log('[RPG Companion] Persona avatar updated successfully');
        } else {
            // Don't update the src if we couldn't get a valid URL
            // This prevents 400 errors and keeps the existing image
            // console.warn('[RPG Companion] Could not get valid thumbnail URL for persona avatar, keeping existing image');
        }
    } else {
        // console.log('[RPG Companion] No user avatar configured, keeping existing image');
    }
}

/**
 * Clears all extension prompts.
 */
export function clearExtensionPrompts() {
    setExtensionPrompt('rpg-companion-inject', '', extension_prompt_types.IN_CHAT, 0, false);
    setExtensionPrompt('rpg-companion-example', '', extension_prompt_types.IN_CHAT, 0, false);
    setExtensionPrompt('rpg-companion-html', '', extension_prompt_types.IN_CHAT, 0, false);
    setExtensionPrompt('rpg-companion-dialogue-coloring', '', extension_prompt_types.IN_CHAT, 0, false);
    setExtensionPrompt('rpg-companion-spotify', '', extension_prompt_types.IN_CHAT, 0, false);
    setExtensionPrompt('rpg-companion-context', '', extension_prompt_types.IN_CHAT, 1, false);
    // Note: rpg-companion-plot is not cleared here since it's passed via quiet_prompt option
    // console.log('[RPG Companion] Cleared all extension prompts');
}

/**
 * Event handler for when generation stops or ends
 * Re-applies checkpoint if SillyTavern unhid messages
 */
export async function onGenerationEnded() {
    // console.log('[RPG Companion] 🏁 onGenerationEnded called');

    // Note: isGenerating flag is cleared in onMessageReceived after parsing (together mode)
    // or in apiClient.js after separate generation completes (separate mode)

    // SillyTavern may auto-unhide messages when generation stops
    // Re-apply checkpoint if one exists
    await restoreCheckpointOnLoad();
}

/**
 * Initialize history injection event listeners.
 * Should be called once during extension initialization.
 */
export function initHistoryInjection() {
    initHistoryInjectionListeners();
}