MediaWiki:Gadget-FormattingFixer.js

/**
 * FormattingFixer for MediaWiki
 * 
 * Fixes common reference citation issues in wikitext:
 * - Reorders refs so definitions come before reuses
 * - Standardizes chapter URLs to {{Cite chapter|url=...}} format
 * - Detects and helps fix undefined named refs
 * - Validates chapter URL format (must have /cXX/pXX)
 * 
 * Works with:
 * - VisualEditor (both visual and source modes)
 * - WikiEditor (legacy source editor)
 * 
 * Installation:
 * 1. Copy this code to MediaWiki:Gadget-FormattingFixer.js
 * 2. Add to MediaWiki:Gadgets-definition:
 *    * FormattingFixer[ResourceLoader|default]|Gadget-FormattingFixer.js
 * 3. All users get it by default; can disable in Special:Preferences > Gadgets
 */
(function() {
    'use strict';

    // Configuration - adjust this pattern if your wiki uses a different URL structure
    var config = {
        chapterUrlPattern: /https?:\/\/www\.bittersweetcandybowl\.com\/c(\d+(?:\.\d+)?)\/p(\d+)/,
        chapterUrlLoose: /https?:\/\/www\.bittersweetcandybowl\.com\/c(\d+(?:\.\d+)?)(\/(p\d+)?)?/,
        siteUrlPattern: /https?:\/\/www\.bittersweetcandybowl\.com\//
    };

    // Guard to prevent duplicate WikiEditor buttons
    var wikiEditorButtonsAdded = false;

    /**
     * Parse all references from wikitext
     */
    function parseRefs(wikitext) {
        var refs = {
            definitions: [],  // <ref name="X">content</ref>
            reuses: [],       // <ref name="X" />
            anonymous: []     // <ref>content</ref>
        };

        // Match named refs with content: <ref name="X">content</ref>
        var defined_refPattern = /<ref\s+name\s*=\s*["']([^"']+)["']\s*>([\s\S]*?)<\/ref>/gi;
        var match;
        while ((match = defined_refPattern.exec(wikitext)) !== null) {
            refs.definitions.push({
                fullMatch: match[0],
                name: match[1],
                content: match[2],
                index: match.index
            });
        }

        // Match named refs without content (reuses): <ref name="X" />
        var reusePattern = /<ref\s+name\s*=\s*["']([^"']+)["']\s*\/>/gi;
        while ((match = reusePattern.exec(wikitext)) !== null) {
            refs.reuses.push({
                fullMatch: match[0],
                name: match[1],
                index: match.index
            });
        }

        // Match anonymous refs: <ref>content</ref>
        // Need to be careful not to match named refs
        var anonPattern = /<ref\s*>([\s\S]*?)<\/ref>/gi;
        while ((match = anonPattern.exec(wikitext)) !== null) {
            // Double-check it's not a named ref that our pattern somehow caught
            if (!/<ref\s+name\s*=/.test(match[0])) {
                refs.anonymous.push({
                    fullMatch: match[0],
                    content: match[1],
                    index: match.index
                });
            }
        }

        return refs;
    }

    /**
     * Generate a ref name from a chapter URL (e.g., :c37p15 or :c37_1p15 for decimals)
     */
    function generateRefName(url) {
        var match = config.chapterUrlPattern.exec(url);
        if (!match) return null;
        var chapter = match[1];
        var page = match[2];
        // Replace decimal with underscore for valid ref names (37.1 -> 37_1)
        var safeChapter = chapter.replace('.', '_');
        return ':c' + safeChapter + 'p' + page;
    }

    /**
     * Extract URL from ref content
     */
    function extractUrl(content) {
        // Try {{Cite chapter|url=...}} format first
        var citeMatch = /\{\{Cite\s*chapter\s*\|\s*url\s*=\s*([^\s\}\|]+)/i.exec(content);
        if (citeMatch) {
            return citeMatch[1];
        }
        
        // Try {{Cite web|url=...}} format
        var webMatch = /\{\{Cite\s*web\s*\|\s*url\s*=\s*([^\s\}\|]+)/i.exec(content);
        if (webMatch) {
            return webMatch[1];
        }

        // Try raw URL
        var urlMatch = /(https?:\/\/[^\s\}<]+)/.exec(content);
        if (urlMatch) {
            return urlMatch[1];
        }

        return null;
    }

    /**
     * Format a URL as proper citation - ONLY for chapter URLs
     */
    function formatCitation(url) {
        if (!url) return null;
        
        // Only convert chapter URLs (must match /cXX/pXX pattern)
        if (config.chapterUrlPattern.test(url)) {
            return '{{Cite chapter|url=' + url + '}}';
        }
        
        // All other URLs are left unchanged
        return url;
    }

    /**
     * Validate a chapter URL has proper format
     */
    function validateChapterUrl(url) {
        if (!url) return { valid: false, error: 'No URL found' };
        
        var looseMatch = config.chapterUrlLoose.exec(url);
        if (!looseMatch) {
            return { valid: true, error: null }; // Not a chapter URL, skip validation
        }
        
        // It's a chapter URL - check if it has /pXX
        if (!looseMatch[2]) {
            return { 
                valid: false, 
                error: 'Chapter URL missing page number: ' + url + ' (needs /pXX)'
            };
        }
        
        return { valid: true, error: null };
    }

    /**
     * Find order issues - refs used before they're defined
     */
    function findOrderIssues(refs) {
        var issues = [];
        var definitionsByName = {};

        // Index definitions by name
        refs.definitions.forEach(function(def) {
            if (!definitionsByName[def.name]) {
                definitionsByName[def.name] = def;
            }
        });

        // Check each reuse
        refs.reuses.forEach(function(reuse) {
            var def = definitionsByName[reuse.name];
            if (def && reuse.index < def.index) {
                issues.push({
                    name: reuse.name,
                    reuseIndex: reuse.index,
                    definitionIndex: def.index,
                    definition: def,
                    reuse: reuse
                });
            }
        });

        return issues;
    }

    /**
     * Find undefined refs - names used but never defined
     */
    function findUndefinedRefs(refs) {
        var definedNames = new Set(refs.definitions.map(function(d) { return d.name; }));
        var undefinedRefs = [];

        refs.reuses.forEach(function(reuse) {
            if (!definedNames.has(reuse.name)) {
                // Check if we already logged this name
                if (!undefinedRefs.some(function(u) { return u.name === reuse.name; })) {
                    undefinedRefs.push({
                        name: reuse.name,
                        usages: refs.reuses.filter(function(r) { return r.name === reuse.name; })
                    });
                }
            }
        });

        return undefinedRefs;
    }

    /**
     * Find anonymous refs that could match undefined names
     */
    function findPotentialMatches(refs, undefinedRefs) {
        var matches = [];
        
        undefinedRefs.forEach(function(undef) {
            refs.anonymous.forEach(function(anon) {
                var url = extractUrl(anon.content);
                if (url) {
                    matches.push({
                        undefinedName: undef.name,
                        anonymousRef: anon,
                        url: url
                    });
                }
            });
        });

        return matches;
    }

    /**
     * Assign chapter-based names to anonymous refs with chapter URLs
     */
    function assignNamesToAnonymousRefs(wikitext, refs) {
        var usedNames = new Set(refs.definitions.map(function(d) { return d.name; }));
        var fixes = [];
        
        // Sort by index descending to preserve positions when replacing
        var anonsToName = refs.anonymous.filter(function(anon) {
            var url = extractUrl(anon.content);
            return url && config.chapterUrlPattern.test(url);
        }).sort(function(a, b) { return b.index - a.index; });
        
        anonsToName.forEach(function(anon) {
            var url = extractUrl(anon.content);
            var baseName = generateRefName(url);
            if (!baseName) return;
            
            // Ensure unique name
            var name = baseName;
            var suffix = 2;
            while (usedNames.has(name)) {
                name = baseName + '_' + suffix;
                suffix++;
            }
            usedNames.add(name);
            
            // Replace anonymous ref with named ref
            var namedRef = '<ref name="' + name + '">' + anon.content + '</ref>';
            wikitext = wikitext.substring(0, anon.index) + namedRef + wikitext.substring(anon.index + anon.fullMatch.length);
            fixes.push('Named anonymous ref as "' + name + '"');
        });
        
        return { wikitext: wikitext, fixes: fixes };
    }

    /**
     * Fix order issues in wikitext
     */
    function fixOrderIssues(wikitext, issues) {
        if (issues.length === 0) return wikitext;

        // Sort issues by definition index descending (fix from end to preserve indices)
        issues.sort(function(a, b) { return b.definitionIndex - a.definitionIndex; });

        issues.forEach(function(issue) {
            // Strategy: 
            // 1. Replace the definition with a reuse
            // 2. Replace the first reuse with the definition
            
            var def = issue.definition;
            var reuse = issue.reuse;
            
            // Build the replacement strings
            var reuseStr = '<ref name="' + def.name + '" />';
            var defStr = '<ref name="' + def.name + '">' + def.content + '</ref>';
            
            // Replace definition with reuse (do this first since it's later in the text)
            wikitext = wikitext.substring(0, def.index) + 
                       reuseStr + 
                       wikitext.substring(def.index + def.fullMatch.length);
            
            // Now replace the reuse with definition
            // Need to recalculate position since we changed the text
            var offset = reuseStr.length - def.fullMatch.length;
            var newReuseIndex = reuse.index; // reuse is before def, so no offset needed
            
            wikitext = wikitext.substring(0, newReuseIndex) + 
                       defStr + 
                       wikitext.substring(newReuseIndex + reuse.fullMatch.length);
        });

        return wikitext;
    }

    /**
     * Standardize citation format - ONLY for chapter URLs
     */
    function standardizeCitations(wikitext) {
        // Find all refs with raw URLs (not in Cite templates)
        var refPattern = /<ref(\s+name\s*=\s*["'][^"']+["'])?\s*>([\s\S]*?)<\/ref>/gi;
        
        wikitext = wikitext.replace(refPattern, function(match, nameAttr, content) {
            nameAttr = nameAttr || '';
            
            // Check if content is just a raw URL
            var trimmedContent = content.trim();
            
            // Skip if already in Cite template
            if (/\{\{Cite/i.test(trimmedContent)) {
                return match;
            }
            
            // Only process if it's a chapter URL (matches /cXX/pXX)
            if (config.chapterUrlPattern.test(trimmedContent)) {
                var formatted = formatCitation(trimmedContent);
                return '<ref' + nameAttr + '>' + formatted + '</ref>';
            }
            
            return match;
        });

        return wikitext;
    }

    /**
     * Auto-add links (stub for future implementation)
     */
    function autoAddLinks(wikitext) {
        var fixes = [];
        var warnings = [];
        
        // TODO: Future implementation will:
        // - Detect unlinked character names and link them
        // - Detect unlinked chapter names and link them
        // - Add other automatic linking improvements
        
        warnings.push('Auto Add Links is not yet implemented.');
        warnings.push('This feature will automatically add wiki links to character names, chapters, etc.');
        
        return {
            wikitext: wikitext,
            fixes: fixes,
            warnings: warnings
        };
    }

    /**
     * Run both Fix Citations and Auto Add Links
     */
    function fixAll(wikitext) {
        // Run Fix Citations first
        var citationResult = fixCitations(wikitext);
        
        // Then run Auto Add Links on the result
        var linkResult = autoAddLinks(citationResult.wikitext);
        
        // Combine results
        return {
            wikitext: linkResult.wikitext,
            fixes: citationResult.fixes.concat(linkResult.fixes),
            warnings: citationResult.warnings.concat(linkResult.warnings)
        };
    }

    /**
     * Restore linebreaks to collapsed infoboxes.
     * Parsoid may collapse {{Infobox ...|param=val|param2=val2}} onto one line.
     * This function expands them back to one parameter per line.
     */
    function restoreInfoboxLinebreaks(wikitext) {
        // Match infoboxes that are on a single line (collapsed)
        // Pattern: {{Infobox TYPE|param=val|param=val|...}}
        var infoboxPattern = /\{\{(Infobox[^|{}]*)\|([^{}]*(?:\{\{[^{}]*\}\}[^{}]*)*)\}\}/gi;
        
        return wikitext.replace(infoboxPattern, function(match, infoboxType, params) {
            // Check if already multi-line (has newlines between pipes)
            if (/\|\s*\n/.test(match)) {
                return match; // Already formatted, leave alone
            }
            
            // Split by | but be careful of nested templates and links
            var result = '{{' + infoboxType + '\n';
            var depth = 0;
            var currentParam = '';
            
            for (var i = 0; i < params.length; i++) {
                var char = params[i];
                
                if (char === '{' || char === '[') {
                    depth++;
                    currentParam += char;
                } else if (char === '}' || char === ']') {
                    depth--;
                    currentParam += char;
                } else if (char === '|' && depth === 0) {
                    // End of parameter
                    if (currentParam.trim()) {
                        result += '| ' + currentParam.trim() + '\n';
                    }
                    currentParam = '';
                } else {
                    currentParam += char;
                }
            }
            
            // Don't forget the last parameter
            if (currentParam.trim()) {
                result += '| ' + currentParam.trim() + '\n';
            }
            
            result += '}}';
            return result;
        });
    }

    /**
     * Main fix function
     */
    function fixCitations(wikitext) {
        var issues = [];
        var warnings = [];
        var fixes = [];

        // Parse all refs
        var refs = parseRefs(wikitext);

        // 1. Find and fix order issues
        var orderIssues = findOrderIssues(refs);
        if (orderIssues.length > 0) {
            wikitext = fixOrderIssues(wikitext, orderIssues);
            orderIssues.forEach(function(issue) {
                fixes.push('Fixed order: "' + issue.name + '" - moved definition before first usage');
            });
            // Re-parse after fixes
            refs = parseRefs(wikitext);
        }

        // 2. Standardize citation format
        var before = wikitext;
        wikitext = standardizeCitations(wikitext);
        if (wikitext !== before) {
            fixes.push('Standardized raw URLs to {{Cite chapter|url=...}} format');
            refs = parseRefs(wikitext);
        }

        // 3. Find undefined refs
        var undefinedRefs = findUndefinedRefs(refs);
        if (undefinedRefs.length > 0) {
            undefinedRefs.forEach(function(undef) {
                warnings.push('Undefined reference: "' + undef.name + '" is used ' + 
                             undef.usages.length + ' time(s) but never defined');
            });
        }

        // 4. Validate chapter URLs
        refs.definitions.forEach(function(def) {
            var url = extractUrl(def.content);
            var validation = validateChapterUrl(url);
            if (!validation.valid) {
                warnings.push('Invalid URL in "' + def.name + '": ' + validation.error);
            }
        });
        refs.anonymous.forEach(function(anon, i) {
            var url = extractUrl(anon.content);
            var validation = validateChapterUrl(url);
            if (!validation.valid) {
                warnings.push('Invalid URL in anonymous ref #' + (i+1) + ': ' + validation.error);
            }
        });

        // 5. Assign names to anonymous refs with chapter URLs
        var namingResult = assignNamesToAnonymousRefs(wikitext, refs);
        if (namingResult.fixes.length > 0) {
            wikitext = namingResult.wikitext;
            fixes = fixes.concat(namingResult.fixes);
            refs = parseRefs(wikitext);
        }

        // 6. Re-check undefined refs after naming
        undefinedRefs = findUndefinedRefs(refs);
        if (undefinedRefs.length > 0) {
            warnings.push('');
            warnings.push('=== Undefined references requiring manual attention ===');
            undefinedRefs.forEach(function(undef) {
                warnings.push('Reference "' + undef.name + '" is used ' + undef.usages.length + ' time(s) but never defined.');
                warnings.push('  → Find the correct source and add: <ref name="' + undef.name + '">{{Cite chapter|url=...}}</ref>');
            });
        }

        return {
            wikitext: wikitext,
            fixes: fixes,
            warnings: warnings
        };
    }


    /**
     * Show result message using mw.notify (nicer than alert)
     */
    function showResultMessage(result) {
        var message = '';
        if (result.fixes.length > 0) {
            message += 'FIXES APPLIED:\n' + result.fixes.join('\n') + '\n\n';
        }
        if (result.warnings.length > 0) {
            message += 'WARNINGS:\n' + result.warnings.join('\n');
        }
        if (result.fixes.length === 0 && result.warnings.length === 0) {
            message = 'No issues found! Citations look good.';
        }
        
        // Use mw.notify for a nicer notification, fall back to alert
        if (typeof mw !== 'undefined' && mw.notify) {
            mw.notify(message.replace(/\n/g, '<br>'), { 
                title: 'FormattingFixer', 
                autoHide: false,
                tag: 'formattingfixer'
            });
        } else {
            alert(message);
        }
    }

    // ========================================
    // VisualEditor Integration
    // ========================================

    function veIsAvailable() {
        return typeof ve !== 'undefined' && ve.init && ve.init.target;
    }

    function veGetSurface() {
        if ( !veIsAvailable() ) {
            return null;
        }
        return ve.init.target.getSurface && ve.init.target.getSurface();
    }

    function veGetMode() {
        var surface = veGetSurface();
        return surface && surface.getMode ? surface.getMode() : null;
    }

    function veGetFullWikitextFromSourceSurface( surface ) {
        var model = surface.getModel();
        var doc = model.getDocument();
        var range = new ve.Range( 0, doc.data.getLength() );
        return doc.data.getSourceText( range );
    }

    function veReplaceAllWikitextInSourceSurface( surface, newWikitext ) {
        var model = surface.getModel();
        model.getLinearFragment( new ve.Range( 0 ), true )
            .expandLinearSelection( 'root' )
            .insertContent( newWikitext );
    }

    function veCreateDmDocumentFromWikitext( wikitext, targetDoc ) {
        return ve.init.target.parseWikitextFragment( wikitext, false, targetDoc ).then( function ( response ) {
            if ( ve.getProp( response, 'visualeditor', 'result' ) !== 'success' ) {
                return $.Deferred().reject( response ).promise();
            }

            var html = response.visualeditor.content;
            var htmlDoc = ve.createDocumentFromHtml( html );

            // Mirror VE's own clipboard importer flow for Parsoid HTML
            if ( mw.libs && mw.libs.ve && mw.libs.ve.stripRestbaseIds ) {
                mw.libs.ve.stripRestbaseIds( htmlDoc );
            }
            if ( mw.libs && mw.libs.ve && mw.libs.ve.stripParsoidFallbackIds ) {
                mw.libs.ve.stripParsoidFallbackIds( htmlDoc.body );
            }

            // Pass an empty object for importRules to enable clipboard mode
            var newDoc = targetDoc.newFromHtml( htmlDoc, {} );
            var data = newDoc.data.data;
            var surface = new ve.dm.Surface( newDoc );

            // Filter out auto-generated items (e.g. reference lists)
            for ( var i = data.length - 1; i >= 0; i-- ) {
                if ( ve.getProp( data[ i ], 'attributes', 'mw', 'autoGenerated' ) ) {
                    surface.change(
                        ve.dm.TransactionBuilder.static.newFromRemoval(
                            newDoc,
                            surface.getDocument().getDocumentNode().getNodeFromOffset( i + 1 ).getOuterRange()
                        )
                    );
                }
            }

            // Avoid about attribute conflicts
            newDoc.data.cloneElements( true );
            return newDoc;
        } );
    }

    function veReplaceAllContentWithDocument( uiSurface, newDoc ) {
        var surfaceModel = uiSurface.getModel();
        surfaceModel.getLinearFragment( new ve.Range( 0 ), true )
            .expandLinearSelection( 'root' )
            .insertDocument( newDoc );
    }

    function veEnsureSourceMode() {
        var target = ve.init.target;
        var surface = veGetSurface();
        if ( surface && surface.getMode && surface.getMode() === 'source' ) {
            return $.Deferred().resolve().promise();
        }

        // Switch to the VisualEditor wikitext mode. This is the only reliable
        // way to apply whole-document wikitext transforms.
        try {
            return target.switchToWikitextEditor( true );
        } catch ( e ) {
            return $.Deferred().reject( e ).promise();
        }
    }

    /**
     * Process a single ref's body content and return the fixed version
     */
    function processRefBody( bodyWikitext ) {
        if ( !bodyWikitext ) return { changed: false, wikitext: bodyWikitext };
        
        var trimmed = bodyWikitext.trim();
        
        // Skip if already in Cite template
        if ( /\{\{Cite/i.test( trimmed ) ) {
            return { changed: false, wikitext: bodyWikitext };
        }
        
        // Only process chapter URLs (must match /cXX/pXX pattern)
        if ( config.chapterUrlPattern.test( trimmed ) ) {
            var formatted = '{{Cite chapter|url=' + trimmed + '}}';
            return { changed: true, wikitext: formatted };
        }
        
        return { changed: false, wikitext: bodyWikitext };
    }

    /**
     * Surgically update refs in VisualEditor without touching other content.
     * This modifies ref nodes directly in VE's internal list, avoiding Parsoid round-trip.
     */
    function veUpdateRefsInPlace( surface, mode ) {
        var doc = surface.getModel().getDocument();
        var internalList = doc.getInternalList();
        var refGroups = internalList.getNodeGroups();
        var fixes = [];
        var warnings = [];
        var transactions = [];

        // Iterate through all reference groups
        for ( var groupName in refGroups ) {
            if ( !refGroups.hasOwnProperty( groupName ) ) continue;
            if ( groupName.indexOf( 'mwReference/' ) !== 0 ) continue;

            var group = refGroups[ groupName ];
            var indexOrder = group.indexOrder;

            for ( var i = 0; i < indexOrder.length; i++ ) {
                var itemIndex = indexOrder[ i ];
                var itemNode = internalList.getItemNode( itemIndex );
                if ( !itemNode ) continue;

                // Get the ref content node
                var refContentRange = itemNode.getRange();
                var refContent = doc.data.getText( refContentRange );
                
                // Also try to get the raw mw body if available
                var listNode = itemNode.children && itemNode.children[ 0 ];
                if ( !listNode ) continue;

                // Get the wikitext body from the mw attribute
                var mwData = null;
                try {
                    // Find the actual ref node that uses this internal list item
                    var nodes = group.firstNodes;
                    if ( nodes && nodes[ i ] ) {
                        var refNode = nodes[ i ];
                        var refNodeData = doc.data.getData( refNode.getOffset() );
                        if ( refNodeData && refNodeData.attributes && refNodeData.attributes.mw ) {
                            mwData = refNodeData.attributes.mw;
                        }
                    }
                } catch ( e ) {
                    // Ignore errors accessing node data
                }

                // Get body content - try mw.body.html first, then plain text
                var bodyWikitext = '';
                if ( mwData && mwData.body && mwData.body.html ) {
                    // Parse HTML to get text content (simple case)
                    var tempDiv = document.createElement( 'div' );
                    tempDiv.innerHTML = mwData.body.html;
                    bodyWikitext = tempDiv.textContent || tempDiv.innerText || '';
                } else {
                    bodyWikitext = refContent;
                }

                // Process this ref
                var result = processRefBody( bodyWikitext );
                if ( result.changed ) {
                    // Build a transaction to update this ref's content
                    // We need to update the mw attribute of the ref node
                    if ( mwData && group.firstNodes && group.firstNodes[ i ] ) {
                        var refNode = group.firstNodes[ i ];
                        var offset = refNode.getOffset();
                        
                        // Clone mwData and update body
                        var newMwData = ve.copy( mwData );
                        newMwData.body = { html: result.wikitext };
                        
                        // Create attribute change transaction
                        var tx = ve.dm.TransactionBuilder.static.newFromAttributeChanges(
                            doc,
                            offset,
                            { mw: newMwData }
                        );
                        transactions.push( tx );
                        fixes.push( 'Wrapped raw URL in {{Cite chapter}}' );
                    }
                }
            }
        }

        // Apply all transactions
        if ( transactions.length > 0 ) {
            var surfaceModel = surface.getModel();
            for ( var t = 0; t < transactions.length; t++ ) {
                surfaceModel.change( transactions[ t ] );
            }
        }

        // Also check for name generation on anonymous refs
        // (This is harder to do surgically, so we'll just warn)
        if ( mode !== 'links' ) {
            // TODO: Implement surgical name assignment for anonymous refs
        }

        return {
            fixes: fixes,
            warnings: warnings,
            changed: transactions.length > 0
        };
    }

    /**
     * Alternative: Use VE's built-in wikitext serialization and re-parse only changed refs
     */
    function veProcessRefsViaApi( surface, processFunc ) {
        var target = ve.init.target;
        var doc = surface.getModel().getDocument();
        
        return target.getWikitextFragment( doc ).then( function ( wikitext ) {
            var result = processFunc( wikitext );
            
            if ( result.wikitext === wikitext ) {
                // No changes needed
                showResultMessage( result );
                return $.Deferred().resolve().promise();
            }

            // Use VE's own mechanism to apply wikitext changes
            // This parses the new wikitext through the API but we're only
            // changing refs, not templates, so normalization should be minimal
            return veCreateDmDocumentFromWikitext( result.wikitext, doc ).then( function ( newDoc ) {
                veReplaceAllContentWithDocument( surface, newDoc );
                showResultMessage( result );
            }, function () {
                // If that fails, show results and offer copy option
                mw.notify( $( '<div>' ).append(
                    $( '<p>' ).text( 'Could not apply changes automatically.' ),
                    $( '<p>' ).text( 'Fixes: ' + result.fixes.join( ', ' ) ),
                    $( '<button>' ).text( 'Copy fixed wikitext' ).on( 'click', function () {
                        navigator.clipboard.writeText( result.wikitext );
                        mw.notify( 'Copied!' );
                    } )
                ), { autoHide: false, tag: 'formattingfixer' } );
            } );
        } );
    }

    function runFormattingFixerInVE( mode ) {
        if ( !veIsAvailable() ) {
            mw.notify( 'FormattingFixer: VisualEditor is not available yet.', { type: 'error' } );
            return;
        }

        var target = ve.init.target;
        var surface = veGetSurface();
        if ( !surface ) {
            mw.notify( 'FormattingFixer: Could not access the editor surface.', { type: 'error' } );
            return;
        }

        // Select the appropriate processing function
        var processFunc;
        if ( mode === 'links' ) {
            processFunc = autoAddLinks;
        } else if ( mode === 'all' ) {
            processFunc = fixAll;
        } else {
            processFunc = fixCitations;
        }

        var currentMode = veGetMode();

        // In source mode, we can read/write directly.
        if ( currentMode === 'source' ) {
            var sourceWikitext = veGetFullWikitextFromSourceSurface( surface );
            var result = processFunc( sourceWikitext );
            if ( result.wikitext !== sourceWikitext ) {
                veReplaceAllWikitextInSourceSurface( surface, result.wikitext );
                // Trigger preview refresh
                setTimeout( function () {
                    if ( surface && surface.getModel ) {
                        surface.getModel().emit( 'history' );
                    }
                }, 100 );
            }
            showResultMessage( result );
            return;
        }

        // In visual mode, use Parsoid but post-process to restore infobox formatting
        var doc = surface.getModel().getDocument();
        target.getWikitextFragment( doc ).then( function ( wikitext ) {
            var result = processFunc( wikitext );
            
            if ( result.wikitext === wikitext ) {
                showResultMessage( result );
                return;
            }

            // Parse new wikitext through Parsoid
            veCreateDmDocumentFromWikitext( result.wikitext, doc ).then( function ( newDoc ) {
                veReplaceAllContentWithDocument( surface, newDoc );
                
                // After Parsoid, get the wikitext again and fix any collapsed infoboxes
                setTimeout( function () {
                    // Re-serialize to check for collapsed infoboxes
                    target.getWikitextFragment( surface.getModel().getDocument() ).then( function ( newWikitext ) {
                        var fixed = restoreInfoboxLinebreaks( newWikitext );
                        if ( fixed !== newWikitext ) {
                            // Infoboxes were collapsed, need to re-apply with fixes
                            veCreateDmDocumentFromWikitext( fixed, surface.getModel().getDocument() ).then( function ( fixedDoc ) {
                                veReplaceAllContentWithDocument( surface, fixedDoc );
                                result.fixes.push( 'Restored infobox formatting' );
                                showResultMessage( result );
                            } );
                        } else {
                            showResultMessage( result );
                        }
                    } );
                }, 500 );
            }, function () {
                mw.notify( 'FormattingFixer: Could not apply changes. Try using source mode.', { type: 'error' } );
            } );
        } );
    }

    /**
     * Add toolbar buttons to VisualEditor
     */
    function addVisualEditorButtons() {
        function registerTools() {
            // Define and register tools. Use the documented pattern:
            // register tools via ve.ui.toolFactory, and add a toolbar group
            // via target.static.toolbarGroups (early) or toolbar.addItems (late).

            if ( !veIsAvailable() ) {
                return;
            }

            var toolFactory = ve.ui.toolFactory;

            // Tool 1: Fix Citations
            if ( !toolFactory.lookup( 'formattingFixerFix' ) ) {
                function FormattingFixerFixTool() {
                    FormattingFixerFixTool.super.apply( this, arguments );
                }
                OO.inheritClass( FormattingFixerFixTool, OO.ui.Tool );
                FormattingFixerFixTool.static.name = 'formattingFixerFix';
                FormattingFixerFixTool.static.group = 'formattingfixer';
                FormattingFixerFixTool.static.title = 'Fix Citations';
                FormattingFixerFixTool.static.icon = 'check';
                FormattingFixerFixTool.static.autoAddToCatchall = false;
                FormattingFixerFixTool.static.autoAddToGroup = true;
                FormattingFixerFixTool.prototype.onSelect = function () {
                    runFormattingFixerInVE( 'citations' );
                    this.setActive( false );
                };
                FormattingFixerFixTool.prototype.onUpdateState = function () {
                    this.setDisabled( false );
                };
                toolFactory.register( FormattingFixerFixTool );
            }

            // Tool 2: Auto Add Links
            if ( !toolFactory.lookup( 'formattingFixerLinks' ) ) {
                function FormattingFixerLinksTool() {
                    FormattingFixerLinksTool.super.apply( this, arguments );
                }
                OO.inheritClass( FormattingFixerLinksTool, OO.ui.Tool );
                FormattingFixerLinksTool.static.name = 'formattingFixerLinks';
                FormattingFixerLinksTool.static.group = 'formattingfixer';
                FormattingFixerLinksTool.static.title = 'Auto Add Links';
                FormattingFixerLinksTool.static.icon = 'link';
                FormattingFixerLinksTool.static.autoAddToCatchall = false;
                FormattingFixerLinksTool.static.autoAddToGroup = true;
                FormattingFixerLinksTool.prototype.onSelect = function () {
                    runFormattingFixerInVE( 'links' );
                    this.setActive( false );
                };
                FormattingFixerLinksTool.prototype.onUpdateState = function () {
                    this.setDisabled( false );
                };
                toolFactory.register( FormattingFixerLinksTool );
            }

            // Tool 3: Fix All (Citations + Links)
            if ( !toolFactory.lookup( 'formattingFixerAll' ) ) {
                function FormattingFixerAllTool() {
                    FormattingFixerAllTool.super.apply( this, arguments );
                }
                OO.inheritClass( FormattingFixerAllTool, OO.ui.Tool );
                FormattingFixerAllTool.static.name = 'formattingFixerAll';
                FormattingFixerAllTool.static.group = 'formattingfixer';
                FormattingFixerAllTool.static.title = 'Fix Citations + Auto Add Links';
                FormattingFixerAllTool.static.icon = 'wikiText';
                FormattingFixerAllTool.static.autoAddToCatchall = false;
                FormattingFixerAllTool.static.autoAddToGroup = true;
                FormattingFixerAllTool.prototype.onSelect = function () {
                    runFormattingFixerInVE( 'all' );
                    this.setActive( false );
                };
                FormattingFixerAllTool.prototype.onUpdateState = function () {
                    this.setDisabled( false );
                };
                toolFactory.register( FormattingFixerAllTool );
            }
        }

        // Ensure our tool group is available in the toolbar (early-load path).
        function addGroupToTarget( targetClass ) {
            if ( !targetClass.static.toolbarGroups ) {
                return;
            }
            var exists = targetClass.static.toolbarGroups.some( function ( g ) {
                return g && g.name === 'formattingfixer';
            } );
            if ( exists ) {
                return;
            }

            targetClass.static.toolbarGroups.push( {
                name: 'formattingfixer',
                label: 'FormattingFixer',
                type: 'list',
                indicator: 'down',
                include: [ { group: 'formattingfixer' } ]
            } );
        }

        // Preferred: integrate during VE module loading.
        mw.hook( 've.loadModules' ).add( function ( addPlugin ) {
            addPlugin( function () {
                registerTools();
                mw.loader.using( [ 'ext.visualEditor.mediawiki' ] ).then( function () {
                    for ( var n in ve.init.mw.targetFactory.registry ) {
                        addGroupToTarget( ve.init.mw.targetFactory.lookup( n ) );
                    }
                    ve.init.mw.targetFactory.on( 'register', function ( name, targetClass ) {
                        addGroupToTarget( targetClass );
                    } );
                } );
            } );
        } );

        // Fallback: if VE is already active, add a toolgroup to the existing toolbar.
        mw.hook( 've.activationComplete' ).add( function () {
            if ( !veIsAvailable() ) {
                return;
            }
            registerTools();

            var toolbar = ve.init.target.getToolbar && ve.init.target.getToolbar();
            if ( !toolbar ) {
                toolbar = ve.init.target.toolbar;
            }
            if ( !toolbar || toolbar.$element.find( '.formattingfixer-toolgroup' ).length ) {
                return;
            }

            var myToolGroup = new OO.ui.ListToolGroup( toolbar, {
                label: 'FormattingFixer',
                include: [ 'formattingFixerFix', 'formattingFixerLinks', 'formattingFixerAll' ]
            } );
            myToolGroup.$element.addClass( 'formattingfixer-toolgroup' );
            toolbar.addItems( [ myToolGroup ] );
        } );
    }


    // ========================================
    // WikiEditor Integration (Legacy)
    // ========================================

    /**
     * Add toolbar button for WikiEditor
     */
    function addWikiEditorButtons() {
        // Guard against duplicate button creation
        if (wikiEditorButtonsAdded) {
            return true;
        }

        if (typeof $ === 'undefined' || !$.fn.wikiEditor) {
            console.log('FormattingFixer: WikiEditor not available');
            return false;
        }

        var $textarea = $('#wpTextbox1');
        if ($textarea.length === 0) {
            console.log('FormattingFixer: No textarea found');
            return false;
        }

        // Check if button already exists in DOM
        if ($('.tool[rel="formattingfixer-fix"]').length > 0) {
            wikiEditorButtonsAdded = true;
            return true;
        }

        try {
            $textarea.wikiEditor('addToToolbar', {
                section: 'advanced',
                group: 'format',
                tools: {
                    'formattingfixer-fix': {
                        label: 'Fix Citations',
                        type: 'button',
                        oouiIcon: 'check',
                        action: {
                            type: 'callback',
                            execute: function() {
                                var textarea = document.getElementById('wpTextbox1');
                                var result = fixCitations(textarea.value);
                                textarea.value = result.wikitext;
                                showResultMessage(result);
                            }
                        }
                    },
                    'formattingfixer-links': {
                        label: 'Auto Add Links',
                        type: 'button',
                        oouiIcon: 'link',
                        action: {
                            type: 'callback',
                            execute: function() {
                                var textarea = document.getElementById('wpTextbox1');
                                var result = autoAddLinks(textarea.value);
                                textarea.value = result.wikitext;
                                showResultMessage(result);
                            }
                        }
                    },
                    'formattingfixer-all': {
                        label: 'Fix Citations + Auto Add Links',
                        type: 'button',
                        oouiIcon: 'wikiText',
                        action: {
                            type: 'callback',
                            execute: function() {
                                var textarea = document.getElementById('wpTextbox1');
                                var result = fixAll(textarea.value);
                                textarea.value = result.wikitext;
                                showResultMessage(result);
                            }
                        }
                    }
                }
            });
            wikiEditorButtonsAdded = true;
            console.log('FormattingFixer: WikiEditor buttons added');
            return true;
        } catch (e) {
            console.log('FormattingFixer: Error adding WikiEditor buttons:', e);
            return false;
        }
    }

    // ========================================
    // Fallback: Simple Buttons
    // ========================================

    /**
     * Add simple HTML buttons as fallback
     */
    function addSimpleButtons() {
        var textbox = document.getElementById('wpTextbox1');
        if (!textbox) return false;

        // Don't attach to VisualEditor's hidden dummy textbox
        if (textbox.classList && textbox.classList.contains('ve-dummyTextbox')) {
            return false;
        }

        // Check if buttons already exist
        if (document.getElementById('formattingfixer-buttons')) return true;

        var container = document.createElement('div');
        container.id = 'formattingfixer-buttons';
        container.style.cssText = 'margin: 5px 0; padding: 8px; background: #f8f9fa; border: 1px solid #a2a9b1; border-radius: 2px; display: flex; gap: 10px; align-items: center;';
        
        var label = document.createElement('span');
        label.textContent = 'FormattingFixer:';
        label.style.fontWeight = 'bold';
        container.appendChild(label);

        var fixBtn = document.createElement('button');
        fixBtn.textContent = 'Fix Citations';
        fixBtn.style.cssText = 'padding: 5px 10px; cursor: pointer; border: 1px solid #a2a9b1; border-radius: 2px; background: #fff;';
        fixBtn.type = 'button';
        fixBtn.onclick = function() {
            var result = fixCitations(textbox.value);
            textbox.value = result.wikitext;
            showResultMessage(result);
        };
        container.appendChild(fixBtn);

        var linksBtn = document.createElement('button');
        linksBtn.textContent = 'Auto Add Links';
        linksBtn.style.cssText = 'padding: 5px 10px; cursor: pointer; border: 1px solid #a2a9b1; border-radius: 2px; background: #fff;';
        linksBtn.type = 'button';
        linksBtn.onclick = function() {
            var result = autoAddLinks(textbox.value);
            textbox.value = result.wikitext;
            showResultMessage(result);
        };
        container.appendChild(linksBtn);

        var allBtn = document.createElement('button');
        allBtn.textContent = 'Fix All';
        allBtn.style.cssText = 'padding: 5px 10px; cursor: pointer; border: 1px solid #a2a9b1; border-radius: 2px; background: #36c; color: #fff;';
        allBtn.type = 'button';
        allBtn.onclick = function() {
            var result = fixAll(textbox.value);
            textbox.value = result.wikitext;
            showResultMessage(result);
        };
        container.appendChild(allBtn);

        textbox.parentNode.insertBefore(container, textbox);
        console.log('FormattingFixer: Simple buttons added');
        return true;
    }

    // ========================================
    // Initialization
    // ========================================

    function init() {
        var action = mw.config.get('wgAction');
        var veLoaded = mw.config.get('wgVisualEditor');

        console.log('FormattingFixer: Initializing, action=' + action);

        // For VisualEditor
        if (typeof ve !== 'undefined' || (veLoaded && veLoaded.pageLanguageDir)) {
            console.log('FormattingFixer: Setting up VisualEditor hooks');
            addVisualEditorButtons();
        }

        // Hook for when VE loads later
        mw.hook('ve.activationComplete').add(function() {
            console.log('FormattingFixer: VE activation complete');
            addVisualEditorButtons();
        });

        // For source editing (action=edit without VE)
        if (action === 'edit' || action === 'submit') {
            // Try WikiEditor first
            mw.hook('wikiEditor.toolbarReady').add(function($textarea) {
                console.log('FormattingFixer: WikiEditor toolbar ready');
                addWikiEditorButtons();
            });

            // If this is the classic source editor, try loading WikiEditor explicitly.
            // (If the user doesn't have it enabled, we'll fall back to simple buttons.)
            setTimeout(function() {
                var textbox = document.getElementById('wpTextbox1');
                if (!textbox) {
                    return;
                }
                if (textbox.classList && textbox.classList.contains('ve-dummyTextbox')) {
                    return;
                }

                mw.loader.using(['ext.wikiEditor']).then(function() {
                    addWikiEditorButtons();
                }, function() {
                    addSimpleButtons();
                });
            }, 0);

            // If WikiEditor isn't present, ensure the user still gets controls
            // in the classic source editor.
            setTimeout(function() {
                var textbox = document.getElementById('wpTextbox1');
                if (textbox && !document.getElementById('formattingfixer-buttons')) {
                    if (textbox.classList && textbox.classList.contains('ve-dummyTextbox')) {
                        return;
                    }
                    if (typeof $ !== 'undefined' && $.fn && $.fn.wikiEditor) {
                        // WikiEditor exists but may not be initialized yet.
                        if (!addWikiEditorButtons()) {
                            addSimpleButtons();
                        }
                    } else {
                        addSimpleButtons();
                    }
                }
            }, 250);

            // Fallback after delay
            setTimeout(function() {
                var textbox = document.getElementById('wpTextbox1');
                if (textbox && !document.getElementById('formattingfixer-buttons')) {
                    if (textbox.classList && textbox.classList.contains('ve-dummyTextbox')) {
                        return;
                    }
                    // Check if WikiEditor toolbar exists
                    if ($('.wikiEditor-ui-toolbar').length > 0) {
                        if (!addWikiEditorButtons()) {
                            addSimpleButtons();
                        }
                    } else {
                        addSimpleButtons();
                    }
                }
            }, 1500);
        }
    }

    // Run when ready
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', function() {
            mw.loader.using(['mediawiki.util']).then(init);
        });
    } else {
        mw.loader.using(['mediawiki.util']).then(init);
    }

    // Expose for testing
    window.FormattingFixer = {
        fixCitations: fixCitations,
        autoAddLinks: autoAddLinks,
        fixAll: fixAll,
        parseRefs: parseRefs,
        generateRefName: generateRefName
    };

})();