import fs from 'node:fs/promises';
import path from 'node:path';
import ts from 'typescript';

const ROOT_DIR = process.cwd();
const PHP_ROOT = path.join(ROOT_DIR, 'legacy', 'hwe', 'sammo', 'Command');
const TS_ROOT = path.join(ROOT_DIR, 'packages', 'logic', 'src', 'actions');

const DEFAULT_MODE = 'action';

const ARG_HELP = `
Usage: node tools/compare-command-logs.mjs [options]

Options:
    --mode action|history|all   Compare action logs (default), history logs, or all logs.
    --include <regex>           Only include command keys matching regex.
    --strict                    Compare raw templates without normalization.
    --keep-date                 Keep <1>...</> date markers in normalized output.
    --json                      Output JSON report.
    --help                      Show this help.
`;

const args = process.argv.slice(2);
const modeArgIndex = args.indexOf('--mode');
const mode = modeArgIndex >= 0 ? args[modeArgIndex + 1] : DEFAULT_MODE;
const includeIndex = args.indexOf('--include');
const includePattern = includeIndex >= 0 ? args[includeIndex + 1] : null;
const strict = args.includes('--strict');
const keepDate = args.includes('--keep-date');
const asJson = args.includes('--json');

if (args.includes('--help')) {
    console.log(ARG_HELP.trim());
    process.exit(0);
}

if (!['action', 'history', 'all'].includes(mode)) {
    console.error(`Invalid --mode ${mode}`);
    console.error(ARG_HELP.trim());
    process.exit(1);
}

const includeRegex = includePattern ? new RegExp(includePattern) : null;

const collectFiles = async (dir) => {
    const entries = await fs.readdir(dir, { withFileTypes: true });
    const files = [];
    for (const entry of entries) {
        const fullPath = path.join(dir, entry.name);
        if (entry.isDirectory()) {
            files.push(...(await collectFiles(fullPath)));
        } else {
            files.push(fullPath);
        }
    }
    return files;
};

const buildLineIndex = (text) => {
    const lineStarts = [0];
    for (let i = 0; i < text.length; i += 1) {
        if (text[i] === '\n') {
            lineStarts.push(i + 1);
        }
    }
    return lineStarts;
};

const getLineNumber = (lineStarts, index) => {
    let low = 0;
    let high = lineStarts.length - 1;
    while (low <= high) {
        const mid = Math.floor((low + high) / 2);
        if (lineStarts[mid] <= index && (mid === lineStarts.length - 1 || lineStarts[mid + 1] > index)) {
            return mid + 1;
        }
        if (lineStarts[mid] > index) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return 1;
};

const scanToDelimiter = (text, startIndex, delimiter) => {
    let i = startIndex;
    let depth = 0;
    let quote = null;
    let escaped = false;
    while (i < text.length) {
        const ch = text[i];
        if (quote) {
            if (escaped) {
                escaped = false;
            } else if (ch === '\\') {
                escaped = true;
            } else if (ch === quote) {
                quote = null;
            }
            i += 1;
            continue;
        }

        if (ch === '\'' || ch === '"') {
            quote = ch;
            i += 1;
            continue;
        }

        if (ch === '(' || ch === '[' || ch === '{') {
            depth += 1;
        } else if (ch === ')' || ch === ']' || ch === '}') {
            if (depth > 0) {
                depth -= 1;
            }
        } else if (ch === delimiter && depth === 0) {
            return { value: text.slice(startIndex, i), endIndex: i + 1 };
        }
        i += 1;
    }
    return { value: text.slice(startIndex), endIndex: text.length };
};

const scanToFirstArgumentEnd = (text, startIndex) => {
    let i = startIndex;
    let depth = 0;
    let quote = null;
    let escaped = false;
    while (i < text.length) {
        const ch = text[i];
        if (quote) {
            if (escaped) {
                escaped = false;
            } else if (ch === '\\\\') {
                escaped = true;
            } else if (ch === quote) {
                quote = null;
            }
            i += 1;
            continue;
        }

        if (ch === '\'' || ch === '"') {
            quote = ch;
            i += 1;
            continue;
        }

        if (ch === '(' || ch === '[' || ch === '{') {
            depth += 1;
        } else if (ch === ')' || ch === ']' || ch === '}') {
            if (depth > 0) {
                depth -= 1;
            } else if (ch === ')') {
                return { value: text.slice(startIndex, i), endIndex: i + 1 };
            }
        } else if (ch === ',' && depth === 0) {
            return { value: text.slice(startIndex, i), endIndex: i + 1 };
        }

        i += 1;
    }
    return { value: text.slice(startIndex), endIndex: text.length };
};

const splitTopLevel = (text, delimiter) => {
    const parts = [];
    let current = '';
    let depth = 0;
    let quote = null;
    let escaped = false;
    for (let i = 0; i < text.length; i += 1) {
        const ch = text[i];
        if (quote) {
            current += ch;
            if (escaped) {
                escaped = false;
            } else if (ch === '\\') {
                escaped = true;
            } else if (ch === quote) {
                quote = null;
            }
            continue;
        }

        if (ch === '\'' || ch === '"') {
            quote = ch;
            current += ch;
            continue;
        }

        if (ch === '(' || ch === '[' || ch === '{') {
            depth += 1;
        } else if (ch === ')' || ch === ']' || ch === '}') {
            if (depth > 0) {
                depth -= 1;
            }
        }

        if (ch === delimiter && depth === 0) {
            parts.push(current);
            current = '';
            continue;
        }

        current += ch;
    }
    if (current) {
        parts.push(current);
    }
    return parts;
};

const parsePhpStringLiteral = (segment) => {
    const trimmed = segment.trim();
    const quote = trimmed[0];
    if (quote !== '\'' && quote !== '"') {
        return null;
    }

    let result = '';
    let escaped = false;
    for (let i = 1; i < trimmed.length; i += 1) {
        const ch = trimmed[i];
        if (escaped) {
            result += ch;
            escaped = false;
            continue;
        }
        if (ch === '\\') {
            escaped = true;
            continue;
        }
        if (ch === quote) {
            break;
        }
        result += ch;
    }

    if (quote === '"') {
        result = result.replace(/\{\$[A-Za-z_][A-Za-z0-9_]*\}/g, '${}');
        result = result.replace(/\$[A-Za-z_][A-Za-z0-9_]*\b/g, '${}');
    }

    return result;
};

const parsePhpExprToTemplate = (expr, assignments, callPos) => {
    const segments = splitTopLevel(expr, '.');
    const parts = [];
    let hasLiteral = false;

    for (const rawSegment of segments) {
        let segment = rawSegment.trim();
        while (segment.startsWith('(') && segment.endsWith(')')) {
            segment = segment.slice(1, -1).trim();
        }
        if (!segment) {
            continue;
        }

        const stringLiteral = parsePhpStringLiteral(segment);
        if (stringLiteral !== null) {
            parts.push(stringLiteral);
            hasLiteral = true;
            continue;
        }

        const varMatch = segment.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
        if (varMatch) {
            const varName = varMatch[1];
            const assignment = resolveAssignment(assignments, varName, callPos);
            if (assignment) {
                parts.push(assignment.template);
                hasLiteral = hasLiteral || assignment.hasLiteral;
            } else {
                parts.push('${}');
            }
            continue;
        }

        parts.push('${}');
    }

    return {
        template: parts.join(''),
        hasLiteral,
    };
};

const resolveAssignment = (assignments, name, callPos) => {
    const list = assignments.get(name);
    if (!list) {
        return null;
    }
    let candidate = null;
    for (const entry of list) {
        if (entry.pos <= callPos) {
            if (!candidate || entry.pos > candidate.pos) {
                candidate = entry;
            }
        }
    }
    return candidate;
};

const findPhpAssignments = (text) => {
    const assignments = new Map();
    const regex = /\$([A-Za-z_][A-Za-z0-9_]*)\s*=/g;
    while (true) {
        const match = regex.exec(text);
        if (!match) {
            break;
        }
        const varName = match[1];
        const afterIndex = match.index + match[0].length;
        const afterChar = text[afterIndex] ?? '';
        if (afterChar === '=' || afterChar === '>') {
            continue;
        }
        const { value, endIndex } = scanToDelimiter(text, afterIndex, ';');
        const parsed = parsePhpExprToTemplate(value, new Map(), match.index);
        if (!parsed.hasLiteral) {
            regex.lastIndex = endIndex;
            continue;
        }
        const list = assignments.get(varName) ?? [];
        list.push({
            pos: match.index,
            template: parsed.template,
            hasLiteral: parsed.hasLiteral,
        });
        assignments.set(varName, list);
        regex.lastIndex = endIndex;
    }
    return assignments;
};

const extractPhpLogCalls = (text, assignments) => {
    const results = [];
    const regex = /pushGeneralActionLog\s*\(/g;
    const lineStarts = buildLineIndex(text);

    while (true) {
        const match = regex.exec(text);
        if (!match) {
            break;
        }
        const startIndex = match.index + match[0].length;
        const { value } = scanToFirstArgumentEnd(text, startIndex);
        const parsed = parsePhpExprToTemplate(value, assignments, match.index);
        results.push({
            pos: match.index,
            raw: value.trim(),
            template: parsed.template,
            line: getLineNumber(lineStarts, match.index),
        });
    }

    return results;
};

const tsEnumValue = (node, enumName) => {
    if (!node) {
        return null;
    }
    if (ts.isPropertyAccessExpression(node)) {
        const left = node.expression.getText();
        if (left === enumName) {
            return node.name.text;
        }
    }
    return null;
};

const readOptionsInfo = (node) => {
    if (!node || !ts.isObjectLiteralExpression(node)) {
        return { category: null, scope: null };
    }

    let category = null;
    let scope = null;

    for (const prop of node.properties) {
        if (!ts.isPropertyAssignment(prop)) {
            continue;
        }
        const key = ts.isIdentifier(prop.name) ? prop.name.text : null;
        if (!key) {
            continue;
        }
        if (key === 'category') {
            category = tsEnumValue(prop.initializer, 'LogCategory');
        }
        if (key === 'scope') {
            scope = tsEnumValue(prop.initializer, 'LogScope');
        }
    }

    return { category, scope };
};

const renderTsExpr = (expr) => {
    if (!expr) {
        return '${}';
    }
    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
        return expr.text;
    }
    if (ts.isTemplateExpression(expr)) {
        let out = expr.head.text;
        for (const span of expr.templateSpans) {
            out += '${}';
            out += span.literal.text;
        }
        return out;
    }
    if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) {
        return `${renderTsExpr(expr.left)}${renderTsExpr(expr.right)}`;
    }
    if (ts.isParenthesizedExpression(expr)) {
        return renderTsExpr(expr.expression);
    }
    return '${}';
};

const extractTsLogs = (filePath, text) => {
    const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
    const results = [];

    const visit = (node) => {
        if (ts.isCallExpression(node)) {
            let calleeName = null;
            let isProperty = false;
            if (ts.isPropertyAccessExpression(node.expression)) {
                calleeName = node.expression.name.text;
                isProperty = true;
            } else if (ts.isIdentifier(node.expression)) {
                calleeName = node.expression.text;
            }

            if (calleeName === 'addLog' || calleeName === 'createLogEffect') {
                const [firstArg, secondArg] = node.arguments;
                const info = readOptionsInfo(secondArg);
                const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
                results.push({
                    kind: calleeName,
                    template: renderTsExpr(firstArg),
                    raw: firstArg ? firstArg.getText(sourceFile) : '',
                    line: line + 1,
                    category: info.category,
                    scope: info.scope,
                    isProperty,
                });
            }
        }
        ts.forEachChild(node, visit);
    };

    visit(sourceFile);
    return results;
};

const normalizeTemplate = (text) => {
    if (strict) {
        return text.trim();
    }
    let out = text;
    if (!keepDate) {
        out = out.replace(/<1>.*?<\/>/g, '');
    }
    out = out.replace(/\$\{[^}]*\}/g, '${}');
    out = out.replace(/\{\$[A-Za-z_][A-Za-z0-9_]*\}/g, '${}');
    out = out.replace(/\$[A-Za-z_][A-Za-z0-9_]*\b/g, '${}');
    out = out.replace(/\s+/g, ' ').trim();
    return out;
};

const shouldIncludeTsEntry = (entry) => {
    if (mode === 'all') {
        return true;
    }
    const category = entry.category;
    const scope = entry.scope;
    if (mode === 'action') {
        if (category && category !== 'ACTION') {
            return false;
        }
        if (scope && scope !== 'GENERAL') {
            return false;
        }
        return true;
    }
    if (mode === 'history') {
        if (category && category !== 'HISTORY') {
            return false;
        }
        if (scope && scope !== 'GENERAL') {
            return false;
        }
        return true;
    }
    return true;
};

const filterCommandKey = (key) => {
    if (!includeRegex) {
        return true;
    }
    return includeRegex.test(key);
};

const formatEntries = (entries) => {
    const map = new Map();
    for (const entry of entries) {
        const key = normalizeTemplate(entry.template);
        const list = map.get(key) ?? [];
        list.push(entry);
        map.set(key, list);
    }
    const lines = [];
    for (const [template, list] of map.entries()) {
        const first = list[0];
        const extra = list.length > 1 ? ` (+${list.length - 1} more)` : '';
        lines.push(`${first.file}:${first.line}${extra} | ${normalizeTemplate(template)}`);
    }
    return lines;
};

const loadPhpLogs = async () => {
    const files = (await collectFiles(PHP_ROOT)).filter((file) => file.endsWith('.php'));
    const logsByKey = new Map();

    for (const file of files) {
        const baseName = path.basename(file, '.php');
        if (['BaseCommand', 'GeneralCommand', 'NationCommand'].includes(baseName)) {
            continue;
        }
        const relPath = path.relative(PHP_ROOT, file);
        const dirName = relPath.split(path.sep)[0];
        const key = dirName === 'General' || dirName === 'Nation' ? `${dirName}/${baseName}` : baseName;
        if (!filterCommandKey(key)) {
            continue;
        }
        const text = await fs.readFile(file, 'utf-8');
        const assignments = findPhpAssignments(text);
        const logs = extractPhpLogCalls(text, assignments);
        if (logs.length === 0) {
            continue;
        }
        const normalized = logs.map((log) => ({
            file: path.relative(ROOT_DIR, file),
            line: log.line,
            template: log.template,
            raw: log.raw,
        }));
        logsByKey.set(key, normalized);
    }

    return logsByKey;
};

const loadTsLogs = async () => {
    const files = (await collectFiles(TS_ROOT)).filter((file) => file.endsWith('.ts'));
    const logsByKey = new Map();

    for (const file of files) {
        const baseName = path.basename(file, '.ts');
        if (!/^che_|^cr_|^event_|^휴식$/.test(baseName)) {
            continue;
        }
        const relPath = path.relative(TS_ROOT, file).split(path.sep).join('/');
        let key = baseName;
        if (relPath.startsWith('turn/general/') || relPath.startsWith('instant/general/')) {
            key = `General/${baseName}`;
        } else if (relPath.startsWith('turn/nation/') || relPath.startsWith('instant/nation/')) {
            key = `Nation/${baseName}`;
        }
        if (!filterCommandKey(key)) {
            continue;
        }
        const text = await fs.readFile(file, 'utf-8');
        const entries = extractTsLogs(file, text);
        const filtered = entries
            .filter((entry) => shouldIncludeTsEntry(entry))
            .map((entry) => ({
                file: path.relative(ROOT_DIR, file),
                line: entry.line,
                template: entry.template,
                raw: entry.raw,
                category: entry.category,
                scope: entry.scope,
            }));

        if (filtered.length === 0) {
            continue;
        }
        logsByKey.set(key, filtered);
    }

    return logsByKey;
};

const buildReport = (phpLogs, tsLogs) => {
    const keys = new Set([...phpLogs.keys(), ...tsLogs.keys()]);
    const sortedKeys = [...keys].sort();

    const missingInTs = [];
    const missingInPhp = [];
    const mismatches = [];
    const matches = [];

    for (const key of sortedKeys) {
        const phpEntries = phpLogs.get(key) ?? [];
        const tsEntries = tsLogs.get(key) ?? [];
        if (phpEntries.length === 0) {
            missingInPhp.push(key);
            continue;
        }
        if (tsEntries.length === 0) {
            missingInTs.push(key);
            continue;
        }

        const phpSet = new Set(phpEntries.map((entry) => normalizeTemplate(entry.template)));
        const tsSet = new Set(tsEntries.map((entry) => normalizeTemplate(entry.template)));

        const missing = [...phpSet].filter((item) => !tsSet.has(item));
        const extra = [...tsSet].filter((item) => !phpSet.has(item));
        if (missing.length === 0 && extra.length === 0) {
            matches.push(key);
        } else {
            mismatches.push({ key, phpEntries, tsEntries, missing, extra });
        }
    }

    return {
        totals: {
            phpCommands: phpLogs.size,
            tsCommands: tsLogs.size,
            sharedCommands: keys.size - missingInPhp.length - missingInTs.length,
            matches: matches.length,
            mismatches: mismatches.length,
        },
        missingInTs,
        missingInPhp,
        mismatches,
    };
};

const main = async () => {
    const phpLogs = await loadPhpLogs();
    const tsLogs = await loadTsLogs();
    const report = buildReport(phpLogs, tsLogs);

    if (asJson) {
        console.log(JSON.stringify(report, null, 2));
        return;
    }

    console.log(`Compare command logs (mode: ${mode}, strict: ${strict ? 'on' : 'off'}, keepDate: ${keepDate ? 'on' : 'off'})`);
    console.log(`PHP commands: ${report.totals.phpCommands}`);
    console.log(`TS commands: ${report.totals.tsCommands}`);
    console.log(`Matched commands: ${report.totals.matches}`);
    console.log(`Mismatched commands: ${report.totals.mismatches}`);
    console.log(`Missing in TS: ${report.missingInTs.length}`);
    console.log(`Missing in PHP: ${report.missingInPhp.length}`);

    if (report.missingInTs.length > 0) {
        console.log('\nMissing in TS:');
        for (const key of report.missingInTs) {
            console.log(`- ${key}`);
        }
    }

    if (report.missingInPhp.length > 0) {
        console.log('\nMissing in PHP:');
        for (const key of report.missingInPhp) {
            console.log(`- ${key}`);
        }
    }

    if (report.mismatches.length > 0) {
        console.log('\nMismatch Details:');
        for (const mismatch of report.mismatches) {
            console.log(`\n== ${mismatch.key} ==`);
            const phpLines = formatEntries(mismatch.phpEntries);
            const tsLines = formatEntries(mismatch.tsEntries);

            console.log('PHP:');
            for (const line of phpLines) {
                console.log(line);
            }
            console.log('TS:');
            for (const line of tsLines) {
                console.log(line);
            }
        }
    }
};

main().catch((error) => {
    console.error(error);
    process.exit(1);
});