disappear.js

// ==UserScript==
// @name         Disappear
// @namespace    https://github.com/vil/disappear
// @version      1.0
// @description  Delete all your messages in specified Discord DMs, groups, and servers.
// @author       Vili (https://vili.dev)
// @match        https://discord.com/*
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_addStyle
// ==/UserScript==

(function() {
    'use strict';

    // Helper to parse header string to Headers object
    function createHeadersFromString(headerStr) {
        const headers = new Headers();
        if (headerStr) {
            const headerPairs = headerStr.split('\r\n');
            headerPairs.forEach(headerPair => {
                const P = headerPair.indexOf(':');
                if (P > 0) {
                    const key = headerPair.substring(0, P).trim();
                    const value = headerPair.substring(P + 1).trim();
                    if (key && value) { // Ensure key and value are not empty
                        try {
                            headers.append(key, value);
                        } catch (e) {
                            console.warn(`[Disappear] Could not append header: ${key}: ${value}`, e);
                            // Some headers might be problematic for the Headers object if they are not valid
                        }
                    }
                }
            });
        }
        return headers;
    }

    // --- Configuration ---
    const SCRIPT_PREFIX = 'disappear'; // Used for CSS classes and local storage
    const API_BASE_URL = 'https://discord.com/api/v9';
    const MESSAGE_FETCH_LIMIT = 100; // Max messages to fetch per request (Discord limit)
    let MIN_DELAY_MS = 1000; // Minimum delay between delete operations
    let MAX_DELAY_MS = 3000; // Maximum delay
    const MAX_MESSAGE_DELETE_ATTEMPTS = 3; // Max attempts to delete a single message
    const MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES = 3; // Max consecutive full fetches with no user messages before stopping channel scan

    // --- State ---
    let authToken = '';
    let currentUserId = null;
    let isDeleting = false; // To control the deletion loop
    let isExporting = false; // To control the export loop

    // --- UI Elements ---
    let controlButton;
    let modalContainer;
    let statusDiv;

    // --- Helper Function for Control Button State ---
    function updateControlButtonIndicator(isWorking) {
        if (!controlButton) return;
        const workingClassName = `${SCRIPT_PREFIX}-working-indicator`;
        if (isWorking) {
            controlButton.innerHTML = '🗑️ Disappear (Working...)';
            controlButton.classList.add(workingClassName);
        } else {
            controlButton.innerHTML = '🗑️ Disappear';
            controlButton.classList.remove(workingClassName);
        }
    }

    // --- API Interaction ---
    function discordApiRequest(method, endpoint, data) {
        return new Promise((resolve, reject) => {
            if (!authToken) {
                updateStatus('<span style="color: red;">Auth Token is not set!</span>', true);
                return reject({ message: 'Auth Token is not set!', status: 0, responseText: null });
            }
            GM_xmlhttpRequest({
                method: method,
                url: `${API_BASE_URL}${endpoint}`,
                headers: {
                    "Authorization": authToken,
                    "Content-Type": "application/json"
                },
                data: data ? JSON.stringify(data) : null,
                onload: function(response) {
                    const responseHeaders = createHeadersFromString(response.responseHeaders);
                    if (response.status >= 200 && response.status < 300) {
                        try {
                            resolve({ data: JSON.parse(response.responseText), headers: responseHeaders });
                        } catch (e) { // Handle cases where response might not be JSON (e.g., 204 No Content for DELETE)
                            resolve({ data: null, headers: responseHeaders });
                        }
                    } else if (response.status === 401) {
                        updateStatus('<span style="color: red;">Invalid Auth Token! Please check and re-enter.</span>', true);
                        reject({
                            message: `API Error ${response.status}: Unauthorized. Invalid token?`,
                            status: response.status,
                            responseText: response.responseText,
                            headers: responseHeaders
                        });
                    } else if (response.status === 429) { // Rate limit
                        updateStatus('<span style="color: orange;">Rate limited by Discord.</span>', true);
                        reject({
                            message: 'Rate limited by Discord API.',
                            status: response.status,
                            headers: responseHeaders,
                            responseText: response.responseText
                        });
                    }
                    else { // Other errors (e.g. 403, 404, 500)
                        updateStatus(`<span style="color: red;">API Error ${response.status}. Check console.</span>`, true);
                        console.error('[Disappear] API Error Response:', response);
                        reject({
                            message: `API Error ${response.status}: ${response.statusText}`,
                            status: response.status,
                            responseText: response.responseText,
                            headers: responseHeaders // Also pass headers for other errors if available
                        });
                    }
                },
                onerror: function(error) {
                    updateStatus('<span style="color: red;">Network error. Check console.</span>', true);
                    console.error('[Disappear] Network Error:', error);
                    reject({
                        message: 'Network error during API request.',
                        status: 0, // Or some other indicator for network error
                        responseText: null,
                        networkError: true,
                        headers: new Headers() // Provide empty headers for network errors
                    });
                }
            });
        });
    }

    async function fetchAuthenticatedUser() {
        if (currentUserId) return currentUserId;
        try {
            updateStatus('Fetching user ID...');
            const { data } = await discordApiRequest('GET', '/users/@me');
            if (data && data.id) {
                currentUserId = data.id;
                updateStatus('User ID fetched successfully.');
                console.log('[Disappear] Current User ID:', currentUserId);
                return currentUserId;
            } else {
                throw new Error('Could not retrieve user ID.');
            }
        } catch (error) {
            console.error('[Disappear] Error fetching user ID:', error);
            updateStatus('<span style="color: red;">Failed to fetch User ID. Token might be invalid.</span>', true);
            throw error;
        }
    }


    async function fetchChannels() {
        updateStatus('Fetching channels...');
        console.log('[Disappear]', 'Fetching channels...');
        try {
            // Fetch DMs (includes user DMs and group DMs)
            const { data: dmChannels } = await discordApiRequest('GET', '/users/@me/channels');
            const channels = dmChannels.map(ch => ({
                id: ch.id,
                name: ch.recipients && ch.recipients.length > 0 ? ch.recipients.map(r => r.username).join(', ') : (ch.name || 'Unnamed Group DM'),
                type: ch.type === 1 ? 'DM' : (ch.type === 3 ? 'Group DM' : 'Unknown DM Type') // 1: DM, 3: Group DM
            }));

            // Fetch Guilds (servers)
            const { data: guilds } = await discordApiRequest('GET', '/users/@me/guilds');
            for (const guild of guilds) {
                // For each guild, fetch its channels
                // Note: This can be a lot of requests if the user is in many servers.
                // @TODO Consider adding an option to only fetch channels for selected servers later.
                try {
                    const { data: guildChannels } = await discordApiRequest('GET', `/guilds/${guild.id}/channels`);
                    guildChannels.forEach(gc => {
                        // We are primarily interested in text channels where messages can be sent
                        if (gc.type === 0 || gc.type === 2 || gc.type === 5 || gc.type === 10 || gc.type === 11 || gc.type === 12) { // Text, Voice (text), Announcement, Thread types
                             channels.push({
                                id: gc.id,
                                name: `${gc.name} (${guild.name})`,
                                type: 'Server Channel'
                            });
                        }
                    });
                } catch (guildChannelError) {
                    console.warn(`[Disappear] Could not fetch channels for guild ${guild.name} (ID: ${guild.id}):`, guildChannelError);
                }
            }
            updateStatus('Channels fetched.');
            console.log('[Disappear] Fetched channels:', channels);
            return channels;
        } catch (error) {
            console.error('[Disappear] Error fetching channels:', error);
            updateStatus('<span style="color: red;">Failed to fetch channels.</span>', true);
            throw error;
        }
    }

    async function fetchMessages(channelId, authorId, beforeMessageId = null) {
        const logMessage = beforeMessageId ? 
            `Scanning for messages (before ${beforeMessageId}) in channel ${channelId}...` :
            `Scanning for initial messages in channel ${channelId}...`;
        updateStatus(logMessage, true); // Append this specific log
        console.log('[Disappear]', `Fetching messages for channel ${channelId}, author ${authorId}, before ${beforeMessageId || 'latest'}`);
        let endpoint = `/channels/${channelId}/messages?limit=${MESSAGE_FETCH_LIMIT}`;
        if (beforeMessageId) {
            endpoint += `&before=${beforeMessageId}`;
        }

        try {
            const { data: allMessages, headers } = await discordApiRequest('GET', endpoint);
            
            if (!allMessages || allMessages.length === 0) {
                // No messages returned at all from the API for this segment
                return { userMessages: [], oldestMessageIdInBatch: null, hasMore: false, headers, skipped: false };
            }

            // Filter messages by the current user
            const userMessages = allMessages.filter(msg => msg.author.id === authorId);
            const oldestMessageIdInBatch = allMessages[allMessages.length - 1].id;
            const hasMoreMessagesInChannel = allMessages.length === MESSAGE_FETCH_LIMIT;

            console.log('[Disappear]', `Fetched ${allMessages.length} raw messages, ${userMessages.length} by user ${authorId}. Oldest in batch: ${oldestMessageIdInBatch}`);
            return { userMessages, oldestMessageIdInBatch, hasMore: hasMoreMessagesInChannel, headers, skipped: false };
        } catch (error) {
            if (error.status === 429) { // Rate limit
                await handleRateLimit(new Headers(Object.entries(error.headers).map(([k,v]) => [k, Array.isArray(v) ? v[0] : v]))); // GM_xmlhttpRequest headers are different
                 // After handling rate limit, throw a specific error or return a value indicating a retry is needed for the fetch itself
                 // This allows the calling function (processChannel) to decide to retry fetching this same segment.
                 throw { ...error, needsRetryFetch: true }; 
            }
            console.error('[Disappear] Error fetching messages:', error);
            updateStatus(`<span style="color: red;">Failed to fetch messages for channel ${channelId}.</span>`, true);
            if (error.message && (error.message.includes('403') || error.message.includes('Missing Access'))) {
                 console.warn(`[Disappear] Missing access to channel ${channelId}. Skipping.`);
                 return { userMessages: [], oldestMessageIdInBatch: null, hasMore: false, headers: null, skipped: true };
            }
            throw error; // Re-throw other errors
        }
    }

    async function deleteMessage(channelId, messageId) {
        console.log('[Disappear]', `Attempting delete for message ${messageId} in channel ${channelId}...`);
        try {
            const { headers } = await discordApiRequest('DELETE', `/channels/${channelId}/messages/${messageId}`);
            // Handle rate limits after successful delete too, as the limit might be hit on the NEXT request
            if (headers && headers.get('x-ratelimit-remaining') === '0') {
                 const delay = (parseFloat(headers.get('x-ratelimit-reset-after')) || (MIN_DELAY_MS/1000) + Math.random() * (MAX_DELAY_MS - MIN_DELAY_MS)/1000) * 1000;
                 console.warn(`[Disappear] Approaching rate limit (on success), waiting ${delay.toFixed(0)}ms`);
                 await new Promise(resolve => setTimeout(resolve, delay));
            } else {
                // Normal delay
                const delay = MIN_DELAY_MS + Math.random() * (MAX_DELAY_MS - MIN_DELAY_MS);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
            return { success: true, headers };
        } catch (error) {
            // Check for system message error (Discord code 50021)
            if (error.status === 403 && error.responseText) {
                try {
                    const errorData = JSON.parse(error.responseText);
                    if (errorData.code === 50021 && errorData.message === "Cannot execute action on a system message") {
                        console.warn(`[Disappear] System message (${messageId}). Code 50021. Skipping.`);
                        updateStatus(`<span style="color: #ccaa00;">System msg ${messageId}. Skipping.</span>`, true);
                        return { success: false, systemMessage: true };
                    }
                } catch (parseError) {
                    console.warn('[Disappear] Could not parse error.responseText for 403 error:', parseError, error.responseText);
                }
            }

            // Handle "Unknown Message" error (Discord code 10008)
            if (error.status === 404 && error.responseText) {
                try {
                    const errorData = JSON.parse(error.responseText);
                    if (errorData.code === 10008) {
                        console.warn(`[Disappear] Unknown Message (${messageId}). Code 10008. Already deleted or inaccessible. Skipping.`);
                        updateStatus(`<span style="color: #ccaa00;">Msg ${messageId} not found (10008). Already deleted or inaccessible. Skipping.</span>`, true);
                        return { success: false, unknownMessage: true }; // Special flag for this case
                    }
                } catch (parseError) {
                    console.warn('[Disappear] Could not parse error.responseText for 404 error:', parseError, error.responseText);
                }
            }

            if (error.status === 429) { // Rate limit
                 await handleRateLimit(new Headers(Object.entries(error.headers || {}).map(([k,v]) => [k, Array.isArray(v) ? v[0] : v])));
                 return { success: false, rateLimited: true }; // Indicate retry is needed by processChannel
            }

            // For other errors, log and re-throw to be handled by processChannel's retry logic
            console.error(`[Disappear] Error deleting message ${messageId}:`, error.status, error.message, error.responseText);
            // Status update for this will be in processChannel's catch block
            throw error; // This error will be caught by the `catch (deleteError)` in `processChannel`
        }
    }

    async function fetchAllUserMessagesForExport(channelId, authorId, channelName) {
        if (!isExporting) {
            updateStatus(`Export stopped for channel ${channelId}.`);
            return { messages: [], skipped: false, error: false };
        }
        // Set initial status for the channel export, subsequent logs from fetchMessages will append.
        updateStatus(`Preparing to export messages from channel ${channelName} (${channelId})...`, false);
        console.log('[Disappear]', `Fetching all messages for export from channel ${channelId} (${channelName}) for author ${authorId}`);

        let allUserMessagesInChannel = [];
        let lastFetchedMessageId = null;
        let consecutiveFetchFailures = 0;
        let consecutiveEmptyUserMessageFetches = 0;

        while (isExporting) {
            try {
                const {
                    userMessages,
                    oldestMessageIdInBatch,
                    hasMore,
                    headers,
                    skipped
                } = await fetchMessages(channelId, authorId, lastFetchedMessageId);

                if (skipped) {
                    updateStatus(`Skipped channel ${channelName} (${channelId}) for export due to missing access.`);
                    return { messages: [], skipped: true, error: false };
                }
                consecutiveFetchFailures = 0;

                if (userMessages && userMessages.length > 0) {
                    consecutiveEmptyUserMessageFetches = 0;
                    userMessages.forEach(msg => {
                        allUserMessagesInChannel.push({
                            message_id: msg.id,
                            timestamp: msg.timestamp,
                            edited_timestamp: msg.edited_timestamp || null,
                            content: msg.content,
                            attachments: msg.attachments,
                            embeds: msg.embeds,
                            author_id: msg.author.id,
                            author_username: msg.author.username,
                            channel_id: channelId,
                            channel_name: channelName
                        });
                    });
                    updateStatus(`Fetched ${userMessages.length} more messages from ${channelName}. Total for channel: ${allUserMessagesInChannel.length}. Scanning older...`, true);
                } else {
                    if (hasMore) {
                        consecutiveEmptyUserMessageFetches++;
                        updateStatus(`No user messages in this segment of ${channelName} (Scan ${consecutiveEmptyUserMessageFetches}/${MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES}). Scanning older...`, true);
                        if (consecutiveEmptyUserMessageFetches >= MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES) {
                            updateStatus(`No user messages found after ${MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES} scans in ${channelName}. Assuming all user messages fetched.`, true);
                            break;
                        }
                    }
                }

                if (!hasMore) {
                    updateStatus(`All user messages likely fetched from ${channelName}. Total: ${allUserMessagesInChannel.length}.`, true);
                    break;
                }

                if (!oldestMessageIdInBatch) {
                    updateStatus(`No oldest message ID to paginate with in ${channelName} for export. Stopping channel scan.`, true);
                    break;
                }
                lastFetchedMessageId = oldestMessageIdInBatch;

                const delay = (MIN_DELAY_MS / 2 + Math.random() * (MAX_DELAY_MS - MIN_DELAY_MS) / 2);
                await new Promise(resolve => setTimeout(resolve, Math.max(250, delay / 2))); // Shorter delay for fetching

            } catch (fetchError) {
                consecutiveFetchFailures++;
                console.error(`[Disappear] Error during message export fetch for ${channelName} (Attempt ${consecutiveFetchFailures}):`, fetchError);

                if (fetchError.needsRetryFetch) {
                    updateStatus(`<span style="color: orange;">Rate limited fetching messages for ${channelName} (export). Retrying...</span>`, true);
                    if (!fetchError.status || fetchError.status !== 429) {
                        await new Promise(resolve => setTimeout(resolve, MIN_DELAY_MS));
                    }
                    continue;
                }

                if (fetchError.status === 429) {
                    await handleRateLimit(new Headers(Object.entries(fetchError.headers || {}).map(([k,v]) => [k, Array.isArray(v) ? v[0] : v])));
                } else if (consecutiveFetchFailures >= 3) {
                    updateStatus(`<span style="color: red;">Too many errors exporting from ${channelName}. Skipping channel.</span>`, true);
                    return { messages: allUserMessagesInChannel, skipped: true, error: true };
                } else {
                    updateStatus(`<span style="color: orange;">Error exporting from ${channelName}. Retrying... (Attempt ${consecutiveFetchFailures})</span>`, true);
                    await new Promise(resolve => setTimeout(resolve, (MAX_DELAY_MS / 2) * consecutiveFetchFailures));
                }
            }
        }
        if (!isExporting) {
            updateStatus(`Export stopped by user during scan of ${channelName}.`, true);
        }
        return { messages: allUserMessagesInChannel, skipped: false, error: false };
    }

    async function processChannel(channelId, settings) {
        if (!isDeleting) {
            updateStatus(`Deletion stopped for channel ${channelId}.`);
            return;
        }
        // Set initial status for the channel, subsequent logs from fetchMessages will append.
        updateStatus(`Processing channel ${channelId}... (This may take a while, fetching message segments)`, false);
        console.log('[Disappear]', `Processing channel ${channelId}...`);

        if (!currentUserId) {
            updateStatus('<span style="color: red;">User ID not available. Cannot process channel.</span>', true);
            return;
        }

        let lastProcessedMessageId = null; // This will be the ID of the oldest message from the *previous* successful fetch operation
        let messagesDeletedInChannel = 0;
        let consecutiveFetchFailures = 0;
        let consecutiveEmptyUserMessageFetches = 0; // New counter

        while (isDeleting) {
            try {
                const { userMessages, oldestMessageIdInBatch, hasMore, headers, skipped } = await fetchMessages(channelId, currentUserId, lastProcessedMessageId);

                if (skipped) {
                    updateStatus(`Skipped channel ${channelId} due to missing access.`);
                    return; // Stop processing this channel
                }
                consecutiveFetchFailures = 0; // Reset on successful fetch (even if no user messages)

                if (userMessages && userMessages.length > 0) {
                    consecutiveEmptyUserMessageFetches = 0; // Reset if we found user messages
                    for (const message of userMessages) {
                        if (!isDeleting) {
                            updateStatus('Deletion process stopped globally.');
                            return;
                        }

                        // Proactively skip non-standard message types, even if authored by the user
                        const userDeletableTypes = [0, 19, 20, 21, 23]; // 0:Default, 19:Reply, 20:ChatInputCommand, 21:ThreadStarterMessage, 23:ContextMenuCommand
                        if (!userDeletableTypes.includes(message.type)) {
                            console.log(`[Disappear] Skipping message ${message.id} (type ${message.type}) in channel ${channelId}: Authored by user, but not a standard deletable message type.`);
                            updateStatus(`Skipping your msg ${message.id} (type ${message.type}) as it's not a standard deletable type.`, true);
                            continue; // Move to the next message
                        }

                        let attempts = 0;
                        let processedSuccessfully = false; // True if deleted or intentionally skipped (e.g. system message)

                        while (attempts < MAX_MESSAGE_DELETE_ATTEMPTS && !processedSuccessfully && isDeleting) {
                            try {
                                updateStatus(`Deleting msg ${message.id} (Ch:${channelId}) (Attempt ${attempts + 1}/${MAX_MESSAGE_DELETE_ATTEMPTS}, Total Ch Del: ${messagesDeletedInChannel})`);
                                const deleteResult = await deleteMessage(channelId, message.id);

                                if (deleteResult.success) {
                                    messagesDeletedInChannel++;
                                    updateStatus(`Deleted msg ${message.id} (Total Ch Del: ${messagesDeletedInChannel}). Waiting...`, true);
                                    processedSuccessfully = true;
                                } else if (deleteResult.systemMessage) {
                                    // Status already updated by deleteMessage
                                    processedSuccessfully = true; // Mark as "handled" to exit the retry loop
                                } else if (deleteResult.unknownMessage) { // Handle Unknown Message (10008)
                                    // Status already updated by deleteMessage
                                    processedSuccessfully = true; // Mark as "handled" to exit the retry loop
                                } else if (deleteResult.rateLimited) {
                                    updateStatus(`Rate limited on msg ${message.id}. Retrying after pause...`, true);
                                    // deleteMessage already paused. Loop will retry this message.
                                    // Do not increment attempts here.
                                } else {
                                    // This case should ideally not be reached if deleteMessage covers all returns or throws.
                                    attempts++;
                                    console.warn(`[Disappear] Unknown outcome from deleteMessage for ${message.id}. Attempt ${attempts}.`);
                                    if (attempts >= MAX_MESSAGE_DELETE_ATTEMPTS) {
                                        updateStatus(`<span style="color: red;">Unknown issue, msg ${message.id} skipped after ${attempts} attempts.</span>`, true);
                                        processedSuccessfully = true; // Give up
                                    } else if (isDeleting) {
                                        updateStatus(`<span style="color: orange;">Unknown issue with msg ${message.id}. Retrying (Att ${attempts + 1})...</span>`, true);
                                        await new Promise(resolve => setTimeout(resolve, MIN_DELAY_MS)); // Small delay
                                    }
                                }
                            } catch (deleteError) { // Catches errors THROWN by deleteMessage
                                attempts++;
                                const errStatus = deleteError.status || 'N/A';
                                const errMsg = deleteError.message || 'Unknown error';
                                console.warn(`[Disappear] Error deleting message ${message.id} (Attempt ${attempts}/${MAX_MESSAGE_DELETE_ATTEMPTS}): Status ${errStatus}, ${errMsg}`, deleteError.responseText || '');
                                
                                if (attempts >= MAX_MESSAGE_DELETE_ATTEMPTS) {
                                    updateStatus(`<span style="color: red;">Failed to delete msg ${message.id} after ${attempts} attempts (Status: ${errStatus}). Skipping.</span>`, true);
                                    processedSuccessfully = true; // Give up on this message
                                } else if (isDeleting) {
                                    updateStatus(`<span style="color: orange;">Error on msg ${message.id} (Status: ${errStatus}). Retrying (Att ${attempts + 1}/${MAX_MESSAGE_DELETE_ATTEMPTS})...</span>`, true);
                                    // Escalating delay for retries on the same message
                                    await new Promise(resolve => setTimeout(resolve, (MIN_DELAY_MS / 2 + Math.random() * (MAX_DELAY_MS - MIN_DELAY_MS)/2) * attempts));
                                }
                            }
                        } // End of while-retry loop for a single message

                        if (!processedSuccessfully && isDeleting) {
                             // This primarily catches cases where loop exited due to !isDeleting during retries
                             console.log(`[Disappear] Message ${message.id} in channel ${channelId} was not successfully processed.`);
                        } else if (!processedSuccessfully && !isDeleting) {
                            updateStatus(`Stopped while trying to process message ${message.id}.`, true);
                        }
                    } // End of for-loop for messages in current batch
                } else { // No user messages in this batch
                    if (hasMore) { // Batch was full, but no user messages
                        consecutiveEmptyUserMessageFetches++;
                        updateStatus(`No user messages in this segment of ${channelId} (Attempt ${consecutiveEmptyUserMessageFetches}/${MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES}). Scanning older...`, true);
                        if (consecutiveEmptyUserMessageFetches >= MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES) {
                            updateStatus(`No user messages found after ${MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES} consecutive empty scans in ${channelId}. Assuming all user messages are processed.`, true);
                            console.log(`[Disappear] Stopping channel ${channelId} after ${MAX_CONSECUTIVE_EMPTY_USER_MESSAGE_FETCHES} consecutive empty user message fetches.`);
                            break; // Exit while loop for this channel
                        }
                    } else {
                        // If !hasMore and userMessages.length is 0, the condition below will catch it.
                        // No need to increment consecutiveEmptyUserMessageFetches here.
                    }
                }

                if (!hasMore) { // No more messages in the channel according to API (current batch was not full)
                    updateStatus(`All your messages likely deleted in channel ${channelId}. Total for channel: ${messagesDeletedInChannel}`);
                    console.log(`[Disappear] No more messages (hasMore=false) or oldestMessageIdInBatch is null for channel ${channelId}.`);
                    break; // Exit while loop for this channel
                }

                if (!oldestMessageIdInBatch) {
                    // This case should ideally be covered by !hasMore if API returns empty and it's the end.
                    // If oldestMessageIdInBatch is null but hasMore was somehow true, it's an issue.
                    updateStatus(`No oldest message ID to paginate with in ${channelId}, but API indicated more. Stopping channel to be safe.`);
                    console.warn(`[Disappear] Inconsistent state: hasMore is true but no oldestMessageIdInBatch for channel ${channelId}.`);
                    break;
                }

                // Prepare for the next fetch iteration
                lastProcessedMessageId = oldestMessageIdInBatch;

            } catch (fetchOrProcessError) {
                consecutiveFetchFailures++;
                console.error(`[Disappear] Error during fetch/process for channel ${channelId} (Attempt ${consecutiveFetchFailures}):`, fetchOrProcessError);

                if (fetchOrProcessError.needsRetryFetch) { // Specific error from fetchMessages indicating a rate limit retry for the fetch itself
                    updateStatus(`<span style="color: orange;">Rate limited on fetching messages for ${channelId}. Automatic retry after pause...</span>`, true);
                    // fetchMessages already paused due to GM_xmlhttpRequest 429, or its internal handleRateLimit on other errors.
                    // We just continue the loop, and it will try fetching the same segment (using same lastProcessedMessageId).
                    // No need for additional manual pause here as handleRateLimit in fetchMessages should have done it.
                    // If fetchMessages didn't pause (e.g. error was not 429 but some other retryable), ensure a small delay.
                     if (!fetchOrProcessError.status || fetchOrProcessError.status !== 429) {
                         await new Promise(resolve => setTimeout(resolve, MIN_DELAY_MS)); // Small safety delay if not a 429
                     }
                    continue; // Retry fetching this segment
                }

                if (fetchOrProcessError.status === 429) { // General rate limit (e.g. from delete that propagated)
                    await handleRateLimit(new Headers(Object.entries(fetchOrProcessError.headers || {}).map(([k,v]) => [k, Array.isArray(v) ? v[0] : v])));
                } else if (consecutiveFetchFailures >= 3) {
                    updateStatus(`<span style="color: red;">Too many errors for channel ${channelId}. Skipping this channel.</span>`, true);
                    console.error(`[Disappear] Too many consecutive errors for channel ${channelId}. Skipping this channel.`);
                    break; // Stop processing this channel
                } else {
                    updateStatus(`<span style="color: orange;">Error in channel ${channelId}. Retrying after a delay... (Attempt ${consecutiveFetchFailures})</span>`, true);
                    await new Promise(resolve => setTimeout(resolve, MAX_DELAY_MS * consecutiveFetchFailures));
                }
            }
        }
        if (isDeleting) { // Only log as completed if deletion wasn't stopped globally
            console.log(`[Disappear] Finished processing channel ${channelId}. Deleted ${messagesDeletedInChannel} messages.`);
            updateStatus(`Finished scan for channel ${channelId}. Total messages deleted in this channel: ${messagesDeletedInChannel}.`, true);
        }
    }

    function handleRateLimit(responseHeaders) { // Changed to accept responseHeaders object
        let retryAfter = 1; // Default retry after 1 second
        if (responseHeaders) {
            // Try to get from 'retry-after' (standard HTTP header, in seconds)
            const httpRetryAfter = responseHeaders.get('retry-after');
            if (httpRetryAfter) {
                retryAfter = parseFloat(httpRetryAfter);
            } else {
                // Try to get from 'x-ratelimit-reset-after' (Discord specific, in seconds with fractional)
                const discordRetryAfter = responseHeaders.get('x-ratelimit-reset-after');
                if (discordRetryAfter) {
                    retryAfter = parseFloat(discordRetryAfter);
                }
            }
        }
        // Ensure retryAfter is a sensible number, not NaN, and add a small buffer
        retryAfter = isNaN(retryAfter) ? 1 : Math.max(0.5, retryAfter) + 0.25; // Minimum 0.5s + buffer

        const waitMs = retryAfter * 1000;
        updateStatus(`<span style="color: orange;">Rate limited. Waiting ${retryAfter.toFixed(2)}s...</span>`, true);
        console.warn(`[Disappear] Rate limited. Waiting ${waitMs}ms (derived from headers: retry-after or x-ratelimit-reset-after)`);
        return new Promise(resolve => setTimeout(resolve, waitMs));
    }

    function convertToCSV(dataArray) {
        if (!dataArray || dataArray.length === 0) {
            return "";
        }
        const headers = Object.keys(dataArray[0]);
        const csvRows = [];
        csvRows.push(headers.join(',')); // Add header row

        for (const row of dataArray) {
            const values = headers.map(header => {
                let cell = row[header];
                if (cell === null || cell === undefined) {
                    cell = "";
                } else if (typeof cell === 'object') {
                    cell = JSON.stringify(cell); // Stringify arrays/objects like attachments/embeds
                } else {
                    cell = String(cell);
                }
                // Escape double quotes by doubling them, and wrap if it contains comma, double quote, or newline
                if (cell.includes('"') || cell.includes(',') || cell.includes('\n') || cell.includes('\r')) {
                    cell = `"${cell.replace(/"/g, '""')}"`;
                }
                return cell;
            });
            csvRows.push(values.join(','));
        }
        return csvRows.join('\n');
    }

    function triggerDownload(data, format, filename) {
        let mimeType;
        let fileExtension;
        let content;

        if (format === 'json') {
            mimeType = 'application/json';
            fileExtension = 'json';
            content = JSON.stringify(data, null, 2);
        } else if (format === 'csv') {
            mimeType = 'text/csv';
            fileExtension = 'csv';
            content = convertToCSV(data);
        } else {
            console.error("[Disappear] Unsupported download format:", format);
            updateStatus(`<span style="color: red;">Unsupported download format: ${format}</span>`, true);
            return;
        }

        const blob = new Blob([content], { type: mimeType });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = `${filename}.${fileExtension}`;
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
        updateStatus(`Download started for ${filename}.${fileExtension}`, true);
    }

    // --- UI Creation and Management ---
    function updateStatus(message, append = false) {
        if (statusDiv) {
            if (append) {
                const timestamp = new Date().toLocaleTimeString();
                statusDiv.innerHTML += `<div>[${timestamp}] ${message}</div>`;
                statusDiv.scrollTop = statusDiv.scrollHeight; // Scroll to bottom
            } else {
                statusDiv.innerHTML = message;
            }
        }
        console.log('[Disappear Status]', message.replace(/<[^>]*>?/gm, '')); // Log cleaned message
    }

    function addControlButton() {
        controlButton = document.createElement('button');
        controlButton.innerHTML = '🗑️ Disappear';
        controlButton.id = `${SCRIPT_PREFIX}-control-button`;
        // Basic styling
        controlButton.style.position = 'fixed';
        controlButton.style.top = '15px';
        controlButton.style.right = '15px';
        controlButton.style.zIndex = '9999';
        controlButton.style.backgroundColor = '#7289da'; // Discord blurple
        controlButton.style.color = 'white';
        controlButton.style.border = 'none';
        controlButton.style.padding = '10px 15px';
        controlButton.style.borderRadius = '5px';
        controlButton.style.cursor = 'pointer';
        controlButton.title = 'Open Disappear Options'; // Tooltip

        controlButton.onclick = showModal;
        document.body.appendChild(controlButton);
    }

    function createModalUI(channels) {
        if (modalContainer) modalContainer.remove();

        modalContainer = document.createElement('div');
        modalContainer.id = `${SCRIPT_PREFIX}-modal`;
        // Basic styling (can be improved with GM_addStyle)
        modalContainer.style.position = 'fixed';
        modalContainer.style.top = '50%';
        modalContainer.style.left = '50%';
        modalContainer.style.transform = 'translate(-50%, -50%)';
        modalContainer.style.backgroundColor = '#36393f'; // Discord's dark theme color
        modalContainer.style.padding = '20px';
        modalContainer.style.borderRadius = '8px';
        modalContainer.style.zIndex = '10000';
        modalContainer.style.color = 'white';
        modalContainer.style.maxHeight = '80vh';
        modalContainer.style.overflowY = 'auto';
        modalContainer.style.border = '1px solid #202225';


        modalContainer.innerHTML = `
            <h2 style="margin-top:0; border-bottom: 1px solid #4f545c; padding-bottom:10px;">Disappear by Vili (vili.dev)</h2>
            <p><strong>Warning:</strong> This tool permanently deletes messages. Use with caution. Sharing your auth token is risky.</p>
            
            <div style="margin-bottom: 15px;">
                <label for="${SCRIPT_PREFIX}-auth-token">Auth Token (Required):</label>
                <input type="password" id="${SCRIPT_PREFIX}-auth-token" value="${authToken || ''}" style="width: 100%; padding: 8px; background-color: #202225; border: 1px solid #000; color: white; border-radius: 3px; margin-top:5px;">
                <small>Find this via Inspect Element -> Application -> Local Storage, find discord.com, look for 'token'. Be careful!</small>
            </div>

            <div style="margin-bottom: 15px;">
                <label for="${SCRIPT_PREFIX}-min-delay">Min Delay (ms):</label>
                <input type="number" id="${SCRIPT_PREFIX}-min-delay" value="${MIN_DELAY_MS}" style="width: 80px; padding: 8px; background-color: #202225; border: 1px solid #000; color: white; border-radius: 3px;">
                <label for="${SCRIPT_PREFIX}-max-delay" style="margin-left:10px;">Max Delay (ms):</label>
                <input type="number" id="${SCRIPT_PREFIX}-max-delay" value="${MAX_DELAY_MS}" style="width: 80px; padding: 8px; background-color: #202225; border: 1px solid #000; color: white; border-radius: 3px;">
            </div>

            <p>Select channels/DMs/groups to process:</p>
            <button id="${SCRIPT_PREFIX}-select-all" style="margin-bottom:5px;">Select All</button>
            <button id="${SCRIPT_PREFIX}-deselect-all" style="margin-bottom:5px; margin-left:5px;">Deselect All</button>

            <div id="${SCRIPT_PREFIX}-channel-list" style="max-height: 200px; overflow-y: auto; border: 1px solid #4f545c; padding: 10px; background-color: #2f3136; border-radius:3px;">
                ${channels.length > 0 ? channels.map(ch => `
                    <div style="margin-bottom: 5px;">
                        <input type="checkbox" id="${SCRIPT_PREFIX}-ch-${ch.id}" data-channel-id="${ch.id}" data-channel-name="${ch.name}" checked style="margin-right:5px;">
                        <label for="${SCRIPT_PREFIX}-ch-${ch.id}" title="${ch.id}">${ch.name} (${ch.type})</label>
                    </div>
                `).join('') : '<p>No channels loaded yet. Click "Refresh Channels" or ensure token is valid.</p>'}
            </div>
            <br>
            <button id="${SCRIPT_PREFIX}-refresh-channels" style="margin-right: 10px;">Refresh Channels</button>
            <button id="${SCRIPT_PREFIX}-start-button" class="danger ${SCRIPT_PREFIX}-action-button">Start Deletion</button>
            <button id="${SCRIPT_PREFIX}-stop-button" class="${SCRIPT_PREFIX}-action-button" style="display: none;">Stop Process</button>
            <button id="${SCRIPT_PREFIX}-export-button" class="${SCRIPT_PREFIX}-action-button">Export Messages</button>
            <select id="${SCRIPT_PREFIX}-export-format" style="background-color: #202225; color: white; border: 1px solid #000; border-radius:3px;">
                <option value="json">JSON</option>
                <option value="csv">CSV</option>
            </select>
            <button id="${SCRIPT_PREFIX}-close-button" class="${SCRIPT_PREFIX}-action-button" style="float:right;">Close</button>
            <button id="${SCRIPT_PREFIX}-hide-button" class="${SCRIPT_PREFIX}-action-button" style="float:right;">Hide</button>
            <div id="${SCRIPT_PREFIX}-status-container" style="margin-top: 15px; padding:10px; background-color: #2f3136; border-radius:3px; min-height: 50px; max-height:250px; overflow-y:auto; border: 1px solid #000;">
                 <div id="${SCRIPT_PREFIX}-status">Enter Auth Token and click "Refresh Channels".</div>
            </div>
        `;

        document.body.appendChild(modalContainer);
        statusDiv = document.getElementById(`${SCRIPT_PREFIX}-status`); // Initialize statusDiv

        document.getElementById(`${SCRIPT_PREFIX}-hide-button`).onclick = () => {
            if (modalContainer) {
                modalContainer.style.display = 'none';
            }
        };

        document.getElementById(`${SCRIPT_PREFIX}-close-button`).onclick = () => {
            if (isDeleting || isExporting) {
                const processName = isDeleting ? "Deletion" : "Export";
                if (!confirm(`${processName} is in progress. Are you sure you want to close? This will stop the current process.`)) {
                    return;
                }
                stopCurrentOperation(); // This will set the appropriate flag to false
            }
            if (modalContainer) {
                modalContainer.remove();
                modalContainer = null; // Explicitly nullify to ensure fresh creation next time
            }
        };
        document.getElementById(`${SCRIPT_PREFIX}-start-button`).onclick = startDeletionProcess;
        document.getElementById(`${SCRIPT_PREFIX}-stop-button`).onclick = stopCurrentOperation;
        document.getElementById(`${SCRIPT_PREFIX}-export-button`).onclick = startExportProcess;
        document.getElementById(`${SCRIPT_PREFIX}-refresh-channels`).onclick = async () => {
            authToken = document.getElementById(`${SCRIPT_PREFIX}-auth-token`).value.trim();
             if (!authToken) {
                updateStatus('<span style="color: red;">Please enter Auth Token first!</span>', true);
                return;
            }
            localStorage.setItem(`${SCRIPT_PREFIX}_authToken`, authToken);
            try {
                await fetchAuthenticatedUser(); // Fetch user ID first
                const fetchedChannels = await fetchChannels();
                // Re-render the channel list part of the modal
                const channelListDiv = document.getElementById(`${SCRIPT_PREFIX}-channel-list`);
                if (channelListDiv) {
                    channelListDiv.innerHTML = fetchedChannels.length > 0 ? fetchedChannels.map(ch => `
                        <div style="margin-bottom: 5px;">
                            <input type="checkbox" id="${SCRIPT_PREFIX}-ch-${ch.id}" data-channel-id="${ch.id}" data-channel-name="${ch.name}" checked style="margin-right:5px;">
                            <label for="${SCRIPT_PREFIX}-ch-${ch.id}" title="${ch.id}">${ch.name} (${ch.type})</label>
                        </div>
                    `).join('') : '<p>No channels found or unable to fetch.</p>';
                }
                 updateStatus(`Fetched ${fetchedChannels.length} channels. Ready to select and start.`, true);
            } catch (error) {
                updateStatus(`<span style="color: red;">Error refreshing channels: ${error.message}</span>`, true);
            }
        };

        document.getElementById(`${SCRIPT_PREFIX}-select-all`).onclick = () => {
            document.querySelectorAll(`#${SCRIPT_PREFIX}-channel-list input[type="checkbox"]`).forEach(cb => cb.checked = true);
        };
        document.getElementById(`${SCRIPT_PREFIX}-deselect-all`).onclick = () => {
            document.querySelectorAll(`#${SCRIPT_PREFIX}-channel-list input[type="checkbox"]`).forEach(cb => cb.checked = false);
        };


        // Load saved token if available
        const savedToken = localStorage.getItem(`${SCRIPT_PREFIX}_authToken`);
        if (savedToken) {
            document.getElementById(`${SCRIPT_PREFIX}-auth-token`).value = savedToken;
            authToken = savedToken; // Update global authToken
        }
         // Load saved delays
        MIN_DELAY_MS = parseInt(localStorage.getItem(`${SCRIPT_PREFIX}_minDelay`) || MIN_DELAY_MS);
        MAX_DELAY_MS = parseInt(localStorage.getItem(`${SCRIPT_PREFIX}_maxDelay`) || MAX_DELAY_MS);
        document.getElementById(`${SCRIPT_PREFIX}-min-delay`).value = MIN_DELAY_MS;
        document.getElementById(`${SCRIPT_PREFIX}-max-delay`).value = MAX_DELAY_MS;
    }

    function showModal() {
        if (modalContainer && document.body.contains(modalContainer)) {
            modalContainer.style.display = 'block';
            // Ensure statusDiv is valid if the modal is being reshown
            if (!statusDiv) {
                statusDiv = document.getElementById(`${SCRIPT_PREFIX}-status`);
            }
        } else {
            // If modalContainer was removed (by close button or never created)
            // or if it exists in variable but not in DOM (e.g., edge case)
            if (modalContainer) { // Clean up if it exists but isn't in DOM, or to be certain
                modalContainer.remove();
            }
            createModalUI([]); // Create it fresh, this also initializes statusDiv
            // createModalUI already sets an initial status message.
            // If a different one is needed here, it can be set.
            // For now, createModalUI's default is fine.
        }
    }

    async function startDeletionProcess() {
        if (isDeleting) {
            updateStatus('<span style="color: orange;">Deletion is already in progress.</span>', true);
            return;
        }

        authToken = document.getElementById(`${SCRIPT_PREFIX}-auth-token`).value.trim();
        if (!authToken) {
            updateStatus('<span style="color: red;">Auth Token is required!</span>', true);
            return;
        }
        localStorage.setItem(`${SCRIPT_PREFIX}_authToken`, authToken);

        MIN_DELAY_MS = parseInt(document.getElementById(`${SCRIPT_PREFIX}-min-delay`).value) || 1000;
        MAX_DELAY_MS = parseInt(document.getElementById(`${SCRIPT_PREFIX}-max-delay`).value) || 3000;
        if (MIN_DELAY_MS < 200) MIN_DELAY_MS = 200; // Safety floor
        if (MAX_DELAY_MS < MIN_DELAY_MS) MAX_DELAY_MS = MIN_DELAY_MS + 200;
        localStorage.setItem(`${SCRIPT_PREFIX}_minDelay`, MIN_DELAY_MS);
        localStorage.setItem(`${SCRIPT_PREFIX}_maxDelay`, MAX_DELAY_MS);

        const selectedChannelElements = Array.from(document.querySelectorAll(`#${SCRIPT_PREFIX}-channel-list input[type="checkbox"]:checked`));
        const channelsToProcess = selectedChannelElements.map(el => ({
            id: el.dataset.channelId,
            name: el.dataset.channelName
        }));

        if (channelsToProcess.length === 0) {
            updateStatus('<span style="color: orange;">No channels selected for deletion.</span>', true);
            return;
        }

        if (!confirm(`Are you sure you want to delete ALL YOUR MESSAGES in ${channelsToProcess.length} selected channel(s)/DM(s)? This action is IRREVERSIBLE.`)) {
            updateStatus('Deletion cancelled by user.', true);
            return;
        }

        isDeleting = true;
        updateControlButtonIndicator(true); // Indicate working
        document.getElementById(`${SCRIPT_PREFIX}-start-button`).disabled = true;
        document.getElementById(`${SCRIPT_PREFIX}-stop-button`).style.display = 'inline-block';
        document.getElementById(`${SCRIPT_PREFIX}-refresh-channels`).disabled = true;
        document.getElementById(`${SCRIPT_PREFIX}-export-button`).disabled = true;

        // Clear previous logs and start fresh for this operation session
        if (statusDiv) statusDiv.innerHTML = '';
        updateStatus(`Starting deletion process for ${channelsToProcess.length} channel(s)...`, true);
        console.log('[Disappear]', 'Selected channels for deletion:', channelsToProcess.map(c => c.name));

        try {
            if (!currentUserId) {
                await fetchAuthenticatedUser();
            }
            if (!currentUserId) {
                 throw new Error("Could not obtain User ID. Cannot proceed.");
            }

            for (const channel of channelsToProcess) {
                if (!isDeleting) {
                    updateStatus('Deletion stopped by user during channel iteration.', true);
                    break;
                }
                updateStatus(`--- Starting channel: ${channel.name} (ID: ${channel.id}) ---`, true);
                await processChannel(channel.id, {});
                if (isDeleting) {
                    updateStatus(`--- Finished channel: ${channel.name} ---`, true);
                }
            }
        } catch (error) {
            console.error('[Disappear] Critical error during deletion process:', error);
            updateStatus(`<span style="color: red;">A critical error occurred: ${error.message}. Process halted. Check console.</span>`, true);
        } finally {
            if (isDeleting) { // This means it ran to completion or an error occurred while still 'isDeleting'
                updateStatus('Deletion process run completed. Check logs for details on each channel.', true);
            } else if (!isDeleting && channelsToProcess.length > 0) { // This means it was stopped by user
                 updateStatus('Deletion process was stopped by user or an early error. Check logs.', true);
            }
            isDeleting = false;
            updateControlButtonIndicator(false); // Revert indicator
            const startButton = document.getElementById(`${SCRIPT_PREFIX}-start-button`);
            if (startButton) startButton.disabled = false;
            const stopButton = document.getElementById(`${SCRIPT_PREFIX}-stop-button`);
            if (stopButton) stopButton.style.display = 'none';
            const refreshButton = document.getElementById(`${SCRIPT_PREFIX}-refresh-channels`);
            if (refreshButton) refreshButton.disabled = false;
            const exportButton = document.getElementById(`${SCRIPT_PREFIX}-export-button`);
            if (exportButton) exportButton.disabled = false;
        }
    }

    function stopCurrentOperation() {
        if (isDeleting) {
            isDeleting = false;
            updateStatus('<span style="color: orange;">Stopping deletion process... Please wait for current operations to finish.</span>', true);
            console.log('[Disappear] Stop command received for DELETION. Process will halt after the current message/batch.');
        } else if (isExporting) {
            isExporting = false;
            updateStatus('<span style="color: orange;">Stopping export process... Please wait for current fetch to finish.</span>', true);
            console.log('[Disappear] Stop command received for EXPORT. Process will halt after the current fetch segment.');
        } else {
            updateStatus('No process is currently running.');
        }
        // UI updates for buttons are primarily handled in the finally blocks of startDeletionProcess/startExportProcess
        // However, we can ensure the stop button is hidden if no process was found to be running.
        if (!isDeleting && !isExporting) {
            const stopButton = document.getElementById(`${SCRIPT_PREFIX}-stop-button`);
            if (stopButton) stopButton.style.display = 'none';
            // Also ensure other buttons are enabled if modal is open
            const startButton = document.getElementById(`${SCRIPT_PREFIX}-start-button`);
            if (startButton) startButton.disabled = false;
            const exportButton = document.getElementById(`${SCRIPT_PREFIX}-export-button`);
            if (exportButton) exportButton.disabled = false;
            const refreshButton = document.getElementById(`${SCRIPT_PREFIX}-refresh-channels`);
            if (refreshButton) refreshButton.disabled = false;
        }
    }

    async function startExportProcess() {
        if (isDeleting) {
            updateStatus('<span style="color: orange;">Deletion is in progress. Please stop it before exporting.</span>', true);
            return;
        }
        if (isExporting) {
            updateStatus('<span style="color: orange;">Export is already in progress.</span>', true);
            return;
        }

        authToken = document.getElementById(`${SCRIPT_PREFIX}-auth-token`).value.trim();
        if (!authToken) {
            updateStatus('<span style="color: red;">Auth Token is required!</span>', true);
            return;
        }
        localStorage.setItem(`${SCRIPT_PREFIX}_authToken`, authToken);

        MIN_DELAY_MS = parseInt(document.getElementById(`${SCRIPT_PREFIX}-min-delay`).value) || 1000;
        MAX_DELAY_MS = parseInt(document.getElementById(`${SCRIPT_PREFIX}-max-delay`).value) || 3000;
        localStorage.setItem(`${SCRIPT_PREFIX}_minDelay`, MIN_DELAY_MS);
        localStorage.setItem(`${SCRIPT_PREFIX}_maxDelay`, MAX_DELAY_MS);

        const selectedChannelElements = Array.from(document.querySelectorAll(`#${SCRIPT_PREFIX}-channel-list input[type="checkbox"]:checked`));
        const channelsToExport = selectedChannelElements.map(el => ({
            id: el.dataset.channelId,
            name: el.dataset.channelName
        }));

        if (channelsToExport.length === 0) {
            updateStatus('<span style="color: orange;">No channels selected for export.</span>', true);
            return;
        }

        const exportFormat = document.getElementById(`${SCRIPT_PREFIX}-export-format`).value;

        if (!confirm(`Are you sure you want to fetch and export ALL YOUR MESSAGES from ${channelsToExport.length} selected channel(s)/DM(s) as ${exportFormat.toUpperCase()}? This might take a while and generate many API requests.`)) {
            updateStatus('Export cancelled by user.', true);
            return;
        }

        isExporting = true;
        updateControlButtonIndicator(true); // Indicate working
        document.getElementById(`${SCRIPT_PREFIX}-start-button`).disabled = true;
        document.getElementById(`${SCRIPT_PREFIX}-export-button`).disabled = true;
        document.getElementById(`${SCRIPT_PREFIX}-stop-button`).style.display = 'inline-block';
        document.getElementById(`${SCRIPT_PREFIX}-refresh-channels`).disabled = true;

        // Clear previous logs and start fresh for this operation session
        if (statusDiv) statusDiv.innerHTML = '';
        updateStatus(`Starting export process for ${channelsToExport.length} channel(s) as ${exportFormat.toUpperCase()}...`, true);
        console.log('[Disappear]', 'Selected channels for export:', channelsToExport.map(c => c.name));

        let allExportedMessages = [];

        try {
            if (!currentUserId) {
                await fetchAuthenticatedUser();
            }
            if (!currentUserId) {
                throw new Error("Could not obtain User ID. Cannot proceed with export.");
            }

            for (const channel of channelsToExport) {
                if (!isExporting) {
                    updateStatus('Export stopped by user during channel iteration.', true);
                    break;
                }
                updateStatus(`--- Starting export for channel: ${channel.name} (ID: ${channel.id}) ---`, true);
                const { messages: channelMessages, skipped, error: channelError } = await fetchAllUserMessagesForExport(channel.id, currentUserId, channel.name);

                if (skipped && channelError) {
                    updateStatus(`<span style="color: red;">--- Skipped channel ${channel.name} due to errors during export. ---</span>`, true);
                } else if (skipped) {
                    updateStatus(`--- Channel ${channel.name} was skipped (e.g. no access or stopped). ---`, true);
                } else if (channelMessages.length > 0) {
                    allExportedMessages.push(...channelMessages);
                    updateStatus(`--- Finished export for channel: ${channel.name}. Fetched ${channelMessages.length} messages. Total: ${allExportedMessages.length} ---`, true);
                } else if (isExporting) {
                    updateStatus(`--- Finished export for channel: ${channel.name}. No new messages found or fetched for this channel. ---`, true);
                }
            }

            if (isExporting && allExportedMessages.length > 0) {
                updateStatus(`Total messages fetched from all selected channels: ${allExportedMessages.length}. Preparing download...`, true);
                const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, -5);
                triggerDownload(allExportedMessages, exportFormat, `discord_messages_export_${timestamp}`);
            } else if (isExporting) {
                updateStatus('No messages found to export from any of the selected channels after processing all.', true);
            }

        } catch (error) {
            console.error('[Disappear] Critical error during export process:', error);
            updateStatus(`<span style="color: red;">A critical error occurred during export: ${error.message}. Process halted. Check console.</span>`, true);
        } finally {
            if (isExporting) {
                updateStatus('Export process run completed. Check logs for details.', true);
            } else if (!isExporting && channelsToExport.length > 0) {
                updateStatus('Export process was stopped by user or an early error. Check logs.', true);
            }
            isExporting = false;
            updateControlButtonIndicator(false); // Revert indicator
            const startButton = document.getElementById(`${SCRIPT_PREFIX}-start-button`);
            if (startButton) startButton.disabled = false;
            const exportButton = document.getElementById(`${SCRIPT_PREFIX}-export-button`);
            if (exportButton) exportButton.disabled = false;
            const stopButton = document.getElementById(`${SCRIPT_PREFIX}-stop-button`);
            if (stopButton) stopButton.style.display = 'none';
            const refreshButton = document.getElementById(`${SCRIPT_PREFIX}-refresh-channels`);
            if (refreshButton) refreshButton.disabled = false;
        }
    }

    // --- Initialization ---
    function init() {
        console.log('[Disappear]', 'Script loaded.');
        addControlButton();

        // We need a way to get the user's own ID for message filtering.
        // This often involves listening to network requests or inspecting internal Discord objects.
        // For Undiscord, it seems to get it from an API endpoint or a global variable.
        // We'll need to investigate how to reliably get the current user's ID.
        // We will try to fetch this when the user clicks "Refresh Channels" or "Start Deletion" after providing token.

        GM_addStyle(`
            #${SCRIPT_PREFIX}-modal button.danger { background-color: #f04747; color: white; } /* Default, will be more specific below */
            #${SCRIPT_PREFIX}-modal button.danger:hover { background-color: #d84040; } /* Default, will be more specific below */
            #${SCRIPT_PREFIX}-modal input[type="checkbox"] { transform: scale(1.2); margin-right: 8px; vertical-align: middle;}
            #${SCRIPT_PREFIX}-status-container div { margin-bottom: 4px; font-size: 0.9em;}
            #${SCRIPT_PREFIX}-status-container div:last-child { margin-bottom: 0;}
            
            @keyframes disappearPulse {
                0% { box-shadow: 0 0 0 0 rgba(114, 137, 218, 0.7); }
                70% { box-shadow: 0 0 0 10px rgba(114, 137, 218, 0); }
                100% { box-shadow: 0 0 0 0 rgba(114, 137, 218, 0); }
            }
            .${SCRIPT_PREFIX}-working-indicator {
                animation: disappearPulse 2s infinite;
            }

            /* Base style for main action buttons in the modal */
            #${SCRIPT_PREFIX}-modal .${SCRIPT_PREFIX}-action-button {
                padding: 7px 14px; /* Uniform padding */
                border-radius: 3px;
                border: 1px solid transparent;
                cursor: pointer;
                margin-left: 8px; /* Uniform margin */
                min-width: 110px; /* Minimum width for consistency */
                box-sizing: border-box;
                text-align: center;
                vertical-align: middle;
                font-size: 14px;
            }

            /* Start Deletion Button (uses .danger class) */
            #${SCRIPT_PREFIX}-modal button.danger.${SCRIPT_PREFIX}-action-button {
                background-color: #f04747;
                color: white;
                border-color: #f04747;
            }
            #${SCRIPT_PREFIX}-modal button.danger.${SCRIPT_PREFIX}-action-button:hover {
                background-color: #d84040;
                border-color: #d84040;
            }
            #${SCRIPT_PREFIX}-modal button.danger.${SCRIPT_PREFIX}-action-button:disabled {
                background-color: #747f8d; /* Discord's disabled button grey */
                color: #dcddde;       /* Discord's disabled button text color */
                border-color: #747f8d;
                cursor: not-allowed;
            }

            /* Stop Button */
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-stop-button.${SCRIPT_PREFIX}-action-button {
                background-color: #faa61a; /* Orange/Warning */
                color: white;
                border-color: #faa61a;
            }
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-stop-button.${SCRIPT_PREFIX}-action-button:hover {
                background-color: #e79817;
                border-color: #e79817;
            }

            /* Export Button */
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-export-button.${SCRIPT_PREFIX}-action-button {
                background-color: #43b581; /* Green */
                color: white;
                border-color: #43b581;
            }
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-export-button.${SCRIPT_PREFIX}-action-button:hover {
                background-color: #3aa873;
                border-color: #3aa873;
            }
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-export-button.${SCRIPT_PREFIX}-action-button:disabled {
                background-color: #3a7056; /* Muted green for disabled */
                color: #a0c3b0;
                border-color: #3a7056;
                cursor: not-allowed;
            }

            /* Hide Button */
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-hide-button.${SCRIPT_PREFIX}-action-button {
                background-color: #5865f2; /* Blurple */
                color: white;
                border-color: #5865f2;
            }
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-hide-button.${SCRIPT_PREFIX}-action-button:hover {
                background-color: #4a55cf;
                border-color: #4a55cf;
            }

            /* Close Button */
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-close-button.${SCRIPT_PREFIX}-action-button {
                background-color: #72767d; /* Discord's secondary/grey button */
                color: white;
                border-color: #72767d;
            }
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-close-button.${SCRIPT_PREFIX}-action-button:hover {
                background-color: #686c72;
                border-color: #686c72;
            }
            
            /* Styling for the export format select element */
            #${SCRIPT_PREFIX}-modal #${SCRIPT_PREFIX}-export-format {
                padding: 7px;
                background-color: #202225;
                color: white;
                border: 1px solid #000;
                border-radius: 3px;
                vertical-align: middle;
                margin-left: 8px;
                font-size: 14px;
            }
        `);
    }

    // Wait for Discord to load before initializing
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', init);
    } else {
        init();
    }

})();