rescue_codebase.js

const fs = require('fs');
const path = require('path');
const glob = require('glob'); // Assume simple Glob or use recursive file walker

const contextPath = path.join(__dirname, '..', 'src', 'contexts', 'LanguageContext.tsx');
const srcDir = path.join(__dirname, '..', 'src');

function getAllFiles(dirPath, arrayOfFiles) {
    const files = fs.readdirSync(dirPath);
    arrayOfFiles = arrayOfFiles || [];
    files.forEach(function (file) {
        if (fs.statSync(dirPath + "/" + file).isDirectory()) {
            arrayOfFiles = getAllFiles(dirPath + "/" + file, arrayOfFiles);
        } else {
            if (file.endsWith('.tsx') || file.endsWith('.ts')) {
                arrayOfFiles.push(path.join(dirPath, "/", file));
            }
        }
    });
    return arrayOfFiles;
}

try {
    const contextContent = fs.readFileSync(contextPath, 'utf8');
    const lines = contextContent.split('\n');

    // We need to parse keys and values, handling invalid multi-line strings
    const garbageKeys = new Map(); // Key -> Original Value

    let currentKey = null;
    let currentValue = '';
    let isMultiLine = false;

    // Regex for start of key: 'key': 'value...
    const keyStartRegex = /^\s*['"]([a-zA-Z0-9_.-]+)['"]:\s*['"](.*)/;

    for (let i = 0; i < lines.length; i++) {
        let line = lines[i];

        if (!isMultiLine) {
            const match = line.match(keyStartRegex);
            if (match) {
                const key = match[1];
                let rest = match[2];

                // Check if it ends on same line
                // Handle escaped quotes \'
                // Count unescaped quotes
                // If odd number of quotes at the end? (We started with one quote)
                // Actually `rest` starts after the opening quote.
                // We look for closing quote `'` or `',`

                // Check if rest ends with `',` or `'`
                if (rest.trim().endsWith("',") || (rest.trim().endsWith("'") && !rest.trim().endsWith("\\'"))) {
                    // Single line value
                    // Remove trailing comma/quote
                    let val = rest.trim();
                    if (val.endsWith("',")) val = val.slice(0, -2);
                    else if (val.endsWith("'")) val = val.slice(0, -1);

                    // Check if garbage
                    if (isGarbage(val)) {
                        garbageKeys.set(key, val);
                    }
                } else {
                    // Multi-line start
                    currentKey = key;
                    currentValue = rest + '\n'; // Add newline that was stripped by split
                    isMultiLine = true;
                }
            }
        } else {
            // Continuation of multi-line
            // Check for closing quote
            // It might be on a line by itself or at end of text
            if (line.trim().endsWith("',") || (line.trim().endsWith("'") && !line.trim().endsWith("\\'"))) {
                let val = line.trim();
                let literalPart = line; // preserve indentation for value?
                // split removes newline, so we add it back if not last line?

                if (val.endsWith("',")) literalPart = literalPart.substring(0, literalPart.lastIndexOf("',"));
                else if (val.endsWith("'")) literalPart = literalPart.substring(0, literalPart.lastIndexOf("'"));

                currentValue += literalPart;
                isMultiLine = false;

                if (isGarbage(currentValue)) {
                    garbageKeys.set(currentKey, currentValue);
                }
                currentKey = null;
                currentValue = '';
            } else {
                currentValue += line + '\n';
            }
        }
    }

    console.log(`Found ${garbageKeys.size} garbage keys.`);

    if (garbageKeys.size === 0) {
        console.log("No garbage keys found. Exiting.");
        return;
    }

    // List of files to scan
    const files = getAllFiles(srcDir);

    let restoredCount = 0;

    // Process files
    files.forEach(filePath => {
        // Optimization: Skip context file
        if (filePath.includes('LanguageContext')) return;

        let content = fs.readFileSync(filePath, 'utf8');
        let originalContent = content;

        // Naive search for each key? Expensive (400 files * N keys).
        // Better: Scan file for `t('key')` tokens, exclude good keys.

        // Regex for `t('key')`
        const tUsageRegex = /t\(['"]([a-zA-Z0-9_.-]+)['"]\)/g;
        let match;
        const matches = [];
        while ((match = tUsageRegex.exec(content)) !== null) {
            matches.push({ full: match[0], key: match[1], index: match.index });
        }

        // Iterate matches in reverse order to replace safely
        for (let i = matches.length - 1; i >= 0; i--) {
            const m = matches[i];
            if (garbageKeys.has(m.key)) {
                let originalCode = garbageKeys.get(m.key);
                // Unescape quotes
                originalCode = originalCode.replace(/\\'/g, "'");

                // Fix JSX context
                // If pattern is `>{t('key')}<`, replace `t('key')` matches code. `>{code}<`
                // But if code was `) : (`, then `>{) : (}<` is invalid JSX usually, 
                // UNLESS it was `>{t('key')}<` and we replace with `} ) : ( {` ??

                // Wait. 
                // If original was `) : (`, and I replaced it with `>{t('key')}<`
                // Then simply putting `) : (` back generates `> ) : ( <` which is text content ' ) : ( '.
                // BUT `) : (` usually implies TERNARY structure in code, not text.
                // Original: `condition ? (A) : (B)`
                // I matched ` : ` as text between `)` and `(`?
                // No, I match `>...<`.
                // Ternary: `<div> { cond ? ( <p>A</p> ) : ( <p>B</p> ) } </div>`

                // If I have `) : (` as text?
                // Ah, maybe usage was `<Comp prop={cond ? 'A' : 'B'} />`
                // My script handled ternaries too. `'A' -> t('key')`
                // If regex matched `) : (` inside `>`...`<`?
                // Maybe: `<div>{cond ? (A) : (B)}</div>`
                // `> {cond ? (A) : (B)} <`
                // Text matching `>...<` usually ignores `{}`? No.
                // `>([^<{]+)<`.
                // `{}` are not `<`.
                // so `{cond ? (A) : (B)}` matches `>...<`!
                // And if I extracted it and put it in a key...
                // Then I replaced `{cond ? (A) : (B)}` with `{t('key')}` (if inside JSX text).
                // So `<div>{t('key')}</div>`.
                // Value of key is `{cond ? (A) : (B)}`.
                // If I restore it: `<div>{cond ? (A) : (B)}</div>`.
                // This is correct!

                // However, I need to strip the wrapping `{t('...')}` if I am inside JSX text block `{...}` container?
                // My script usually output `>{t('key')}<`.
                // If source has `>{t('key')}<` and I restore value `CODE`, result `>CODE<`.
                // `>{cond ? A : B}<` -> invalid syntax if CODE contains `{}`?
                // No, `>{...}<` is valid.
                // But wait, `> { cond ... } <`
                // If code starts with `{`, then `>>{...}<` -> `>{...}<`?
                // My scanner matched `> TEXT <`.
                // If text was `{...}`, I replaced it with `{t(key)}`.
                // `>{t(key)}<`.
                // Restoration: `>{...}<`. Valid.

                // Only issue is if I added extra braces.
                // `>Text<` -> `>{t(key)}<`.
                // If Text was `) : (`, then `>{t(key)}<`.
                // Restoration `>) : (<`. 
                // This renders text string `) : (`.
                // It doesn't execute ternary.

                // UNLESS original was NOT `>{...}<` but just logic flow.
                // `apply_missing_translations.js`:
                // `>([^<{]+)<`
                // It only touches things between `>` and `<`.
                // If code was `return ( <div> { cond ? (A) : (B) } </div> )`
                // JSX Text is ` { cond ? (A) : (B) } `.
                // My script thinks this is text.
                // Replaces with ` {t(key)} `.
                // `return ( <div> {t(key)} </div> )`.
                // If key value is ` { cond ? (A) : (B) } `.
                // Then `t()` returns string "{ cond ? (A) : (B) }".
                // UI shows string.

                // I need to RESTORE the code to be executed, not stringified.
                // So I must remove `t('key')` wrappers?
                // Or rather replace `t('key')` with the raw CODE.

                // `<div>{t('key')}</div>` -> `<div>CODE</div>`.
                // If CODE is `{ cond ? A : B }`.
                // `<div>{ cond ? A : B }</div>`.
                // This works!

                // BUT `t('key')` call itself is JS code.
                // Usage: `... {t('key')} ...`
                // Replacement: `... CODE ...`
                // If usage was `>{t('key')}<`.
                // Replacement: `>CODE<`.
                // If CODE is `{...}`, result `>{...}<`. Correct.

                // What if improper replacement happened?
                // `attr={t('key')}`.
                // Replacement: `attr=CODE`.
                // If CODE is `cond ? 'A' : 'B'`.
                // `attr=cond ? 'A' : 'B'`. INVALID syntax (need braces).
                // My script put `{}` around `t(key)`. `attr={t('key')}`.
                // If I replace `t('key')` with `CODE`.
                // `attr={CODE}`.
                // `attr={cond ? 'A' : 'B'}`. Valid!

                // So, blindly replacing `t('key')` with `CODE` seems mostly safe IF `t('key')` is inside `{}` or similar boundary.
                // But regex `t\(['"]key['"]\)` matches just the function call.

                // Let's try replacing `t('key')` with `originalCode`.

                // There is one catch: Unescape quotes.
                // And if original code contained `"` and I am pasting it?
                // `t('key')` is expression. `CODE` is expression.
                // It should be fine.

                content = content.substring(0, m.index) + originalCode + content.substring(m.index + m.full.length);
                restoredCount++;
            }
        }

        if (content !== originalContent) {
            fs.writeFileSync(filePath, content, 'utf8');
            console.log(`Restored code in ${filePath}`);
        }
    });

    console.log(`Restored ${restoredCount} instances.`);

    // Now remove keys from LanguageContext
    // We filter `lines` array
    // This is hard because of multi-line values.
    // Better to filter `garbageKeys` from the file content we read earlier?
    // We can rewrite the file excluding the lines corresponding to garbage keys.
    // But line numbers match strict indices.
    // Let's filter line by line, but need to reconstruct proper structure.

    // Simpler: Read key/values again and build new file string.
    // Or iterate `lines` and skip those that start with garbage keys?
    // What about multiline values? We need to skip them too.

    // Pass 2 on LanguageContext to strip
    const newContextLines = [];
    isMultiLine = false;
    let skipMode = false;

    for (let i = 0; i < lines.length; i++) {
        let line = lines[i];
        if (!isMultiLine) {
            const match = line.match(keyStartRegex);
            if (match) {
                const key = match[1];
                if (garbageKeys.has(key)) {
                    // Skip this line
                    // Check if multiline
                    let rest = match[2];
                    if (!rest.trim().endsWith("',") && !(rest.trim().endsWith("'") && !rest.trim().endsWith("\\'"))) {
                        isMultiLine = true;
                        skipMode = true;
                    }
                    continue;
                }
            }
            newContextLines.push(line);
        } else {
            // In multi-line value
            // Check end
            if (line.trim().endsWith("',") || (line.trim().endsWith("'") && !line.trim().endsWith("\\'"))) {
                isMultiLine = false;
                if (skipMode) {
                    skipMode = false;
                    continue;
                }
                newContextLines.push(line);
            } else {
                if (skipMode) continue;
                newContextLines.push(line);
            }
        }
    }

    fs.writeFileSync(contextPath, newContextLines.join('\n'), 'utf8');
    console.log("LanguageContext cleaned.");

} catch (e) {
    console.error(e);
}

function isGarbage(text) {
    if (!text) return false;
    // Indicators of code
    if (text.includes(') : (') || text.includes('? (') || text.includes(') ?') || text.includes(' && ') || text.includes(' || ')) return true;
    if (text.trim().startsWith('//') || text.includes('/*')) return true;
    if (text.includes('=>') && text.includes('{')) return true;
    if (text.includes('</') && text.includes('>')) return true; // HTML tags
    if (text.endsWith('}') && text.includes('return ')) return true;
    if (text.includes('?.') || text.includes('!. ')) return true;

    // Specific garbage saw
    if (text.includes('setShowLocationPicker')) return true;
    if (text.includes('.current?.click()')) return true;

    return false;
}