Pull YAML properties from a diverged content collection, and merge them.

import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';

// Derive __dirname for ES module
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// --- Configuration ---
const MONOREPO_ROOT = path.resolve(__dirname, '../../'); // Adjust based on script location
const CURRENT_TOOLING_DIR = path.join(MONOREPO_ROOT, 'content', 'tooling');
const OLD_TOOLING_DIR = path.join(MONOREPO_ROOT, 'temp_old_repo', 'tooling'); // Path to the cloned old repo's tooling dir

// List of relative file paths missing 'url:' (from previous `find` command output)
// NOTE: Manually copy the list from the previous step's output here.
// Ensure paths are relative to CURRENT_TOOLING_DIR (e.g., './Hardware/CM5.md')


// --- Helper Functions ---

/**
 * Extracts the URL from the frontmatter of a given file content string.
 * Manually searches for 'url:' line without parsing YAML.
 * @param {string} fileContent - The full content of the file.
 * @returns {string|null} - The extracted URL or null if not found.
 */
function extractUrlManually(fileContent) {
    const lines = fileContent.split('\n');
    let inFrontmatter = false;
    for (const line of lines) {
        if (line.trim() === '---') {
            // Toggle frontmatter flag, but stop if we hit the second '---'
            if (inFrontmatter) {
                return null; // Reached end of frontmatter without finding url
            }
            inFrontmatter = true;
            continue;
        }
        if (inFrontmatter) {
            const trimmedLine = line.trim();
            // Look for 'url:' specifically (case-sensitive, at start of line in frontmatter)
            if (trimmedLine.startsWith('url:')) {
                // Extract value after 'url:'
                return trimmedLine.substring(4).trim();
            }
        }
    }
    return null; // No url found or no frontmatter
}

/**
 * Inserts the urlLine into the frontmatter of the target file content.
 * Inserts just before the closing '---'.
 * @param {string} targetContent - The content of the file to modify.
 * @param {string} urlLine - The full 'url: <value>' line to insert.
 * @returns {string|null} - The modified content or null if frontmatter markers aren't found.
 */
function insertUrlManually(targetContent, urlLine) {
    const lines = targetContent.split('\n');
    let firstMarkerIndex = -1;
    let secondMarkerIndex = -1;

    // Find frontmatter delimiters
    for (let i = 0; i < lines.length; i++) {
        if (lines[i].trim() === '---') {
            if (firstMarkerIndex === -1) {
                firstMarkerIndex = i;
            } else {
                secondMarkerIndex = i;
                break;
            }
        }
    }

    // Ensure frontmatter block exists
    if (firstMarkerIndex === -1 || secondMarkerIndex === -1) {
        console.warn("Could not find frontmatter delimiters (---).");
        return null;
    }

    // Insert the urlLine just before the closing delimiter
    lines.splice(secondMarkerIndex, 0, urlLine);

    return lines.join('\n');
}

// --- Main Processing Logic ---

async function processFiles() {
    console.log(`Starting URL restoration process...`);
    let processedCount = 0;
    let addedCount = 0;
    let notFoundInOldRepoCount = 0;
    let urlMissingInOldFileCount = 0;
    let writeErrorCount = 0;
    let frontmatterErrorCount = 0;

    for (const relativePath of filesMissingUrl) {
        processedCount++;
        const currentFilePath = path.join(CURRENT_TOOLING_DIR, relativePath);
        const oldFilePath = path.join(OLD_TOOLING_DIR, relativePath);

        try {
            // 1. Check if old file exists
            await fs.access(oldFilePath); // Throws error if doesn't exist

            // 2. Read old file and extract URL
            const oldContent = await fs.readFile(oldFilePath, 'utf-8');
            const extractedUrlValue = extractUrlManually(oldContent);

            if (!extractedUrlValue) {
                console.warn(`[WARN] No 'url:' found in old file: ${relativePath}`);
                urlMissingInOldFileCount++;
                continue; // Skip to next file
            }

            // Construct the full url line
            const urlLineToInsert = `url: ${extractedUrlValue}`;

            // 3. Read current file
            const currentContent = await fs.readFile(currentFilePath, 'utf-8');

            // Check if URL already exists somehow (safety check)
            if (currentContent.includes('\nurl:')) {
                 console.log(`[SKIP] 'url:' already exists in current file: ${relativePath}`);
                 continue;
            }

            // 4. Insert URL into current file content
            const updatedContent = insertUrlManually(currentContent, urlLineToInsert);

            if (!updatedContent) {
                 console.error(`[ERROR] Failed to insert URL due to missing frontmatter markers in: ${relativePath}`);
                 frontmatterErrorCount++;
                 continue; // Skip to next file
            }

            // 5. Write updated content back to current file
            await fs.writeFile(currentFilePath, updatedContent, 'utf-8');
            console.log(`[SUCCESS] Added URL to: ${relativePath}`);
            addedCount++;

        } catch (error) {
            if (error.code === 'ENOENT') {
                console.warn(`[WARN] Old file not found: ${relativePath}`);
                notFoundInOldRepoCount++;
            } else {
                console.error(`[ERROR] Processing ${relativePath}: ${error.message}`);
                writeErrorCount++; // Assume other errors are write related for now
            }
        }
    }

    console.log(`\n--- Processing Summary ---`);
    console.log(`Total files checked: ${processedCount}`);
    console.log(`URLs successfully added: ${addedCount}`);
    console.log(`Files not found in old repo: ${notFoundInOldRepoCount}`);
    console.log(`'url:' missing in old file: ${urlMissingInOldFileCount}`);
    console.log(`Errors finding frontmatter: ${frontmatterErrorCount}`);
    console.log(`Other errors (read/write): ${writeErrorCount}`);
    console.log(`--------------------------`);
}

processFiles();