import * as acorn from 'acorn';
import fs from 'fs';

// Parse command line arguments
const args = process.argv.slice(2);
let file = 'main.js';
let target = 2018;
let ios = null;

// Help menu
if (args.includes('--help') || args.includes('-h')) {
    console.log(`Usage: node utils/check-compatibility.js [options]
Options:
  --file <path>                  Path to the bundle file to check (default: main.js)
  --target <year>                Target ECMAScript version (default: 2018)
  --ios <version>                Target iOS version (e.g. 14, 15, 16.4). Sets defaults automatically.
  --[no-]allow-dynamic-import    Allow dynamic import() expressions
  --[no-]allow-bigint            Allow BigInt literals
  --[no-]allow-numeric-separator  Allow numeric separators (e.g. 1_000)
  --[no-]allow-class-fields      Allow public/private/static class fields
  --[no-]allow-class-static-blocks Allow class static initialization blocks
  --[no-]allow-regexp-lookbehind Allow RegExp lookbehind assertions ((?<=...) / (?<!...))
  --[no-]allow-regexp-indices    Allow RegExp 'd' (indices) flag
  --[no-]allow-regexp-v-flag     Allow RegExp 'v' (Unicode properties) flag
`);
    process.exit(0);
}

for (let i = 0; i < args.length; i++) {
    if (args[i] === '--file' && args[i + 1]) {
        file = args[i + 1];
        i++;
    } else if (args[i] === '--target' && args[i + 1]) {
        target = parseInt(args[i + 1], 10);
        i++;
    } else if (args[i] === '--ios' && args[i + 1]) {
        ios = parseFloat(args[i + 1]);
        i++;
    }
}

// Default feature flags based on target ECMA version
let allowDynamicImport = target >= 2020;
let allowBigInt = target >= 2020;
let allowNumericSeparator = target >= 2021;
let allowClassFields = target >= 2022;
let allowClassStaticBlocks = target >= 2022;
let allowRegexpLookbehind = target >= 2023;
let allowRegexpIndices = target >= 2022;
let allowRegexpVFlag = target >= 2024;

// Override feature flags if target iOS version is specified
if (ios !== null) {
    // Determine a general baseline ECMA version for parser reports
    if (ios >= 16.4) target = 2022;
    else if (ios >= 15.0) target = 2021;
    else if (ios >= 14.0) target = 2020;
    else target = 2018;

    allowDynamicImport = ios >= 11.3;
    allowBigInt = ios >= 14.0;
    allowNumericSeparator = ios >= 14.0;
    allowClassFields = ios >= 14.5;
    allowRegexpIndices = ios >= 15.0;
    allowClassStaticBlocks = ios >= 16.4;
    allowRegexpLookbehind = ios >= 16.4;
    allowRegexpVFlag = ios >= 17.0;
}

// Override defaults with explicit command line options if specified
for (let i = 0; i < args.length; i++) {
    if (args[i] === '--allow-dynamic-import') allowDynamicImport = true;
    else if (args[i] === '--no-allow-dynamic-import') allowDynamicImport = false;
    else if (args[i] === '--allow-bigint') allowBigInt = true;
    else if (args[i] === '--no-allow-bigint') allowBigInt = false;
    else if (args[i] === '--allow-numeric-separator') allowNumericSeparator = true;
    else if (args[i] === '--no-allow-numeric-separator') allowNumericSeparator = false;
    else if (args[i] === '--allow-class-fields') allowClassFields = true;
    else if (args[i] === '--no-allow-class-fields') allowClassFields = false;
    else if (args[i] === '--allow-class-static-blocks') allowClassStaticBlocks = true;
    else if (args[i] === '--no-allow-class-static-blocks') allowClassStaticBlocks = false;
    else if (args[i] === '--allow-regexp-lookbehind') allowRegexpLookbehind = true;
    else if (args[i] === '--no-allow-regexp-lookbehind') allowRegexpLookbehind = false;
    else if (args[i] === '--allow-regexp-indices') allowRegexpIndices = true;
    else if (args[i] === '--no-allow-regexp-indices') allowRegexpIndices = false;
    else if (args[i] === '--allow-regexp-v-flag') allowRegexpVFlag = true;
    else if (args[i] === '--no-allow-regexp-v-flag') allowRegexpVFlag = false;
}

if (!fs.existsSync(file)) {
    console.error(`Error: File '${file}' does not exist.`);
    process.exit(1);
}

const code = fs.readFileSync(file, 'utf8');
let ast;

const targetInfo = ios !== null ? `iOS ${ios}` : `ES${target}`;
console.log(`Parsing '${file}' to inspect compatibility (target ${targetInfo})...`);
console.log(`Rules:
  Dynamic Import:     ${allowDynamicImport ? 'Allowed' : 'Prohibited'}
  BigInt:             ${allowBigInt ? 'Allowed' : 'Prohibited'}
  Numeric Separators: ${allowNumericSeparator ? 'Allowed' : 'Prohibited'}
  Class Fields:       ${allowClassFields ? 'Allowed' : 'Prohibited'}
  Class Static Block: ${allowClassStaticBlocks ? 'Allowed' : 'Prohibited'}
  RegExp Lookbehind:  ${allowRegexpLookbehind ? 'Allowed' : 'Prohibited'}
  RegExp Indices (d): ${allowRegexpIndices ? 'Allowed' : 'Prohibited'}
  RegExp Unicode (v): ${allowRegexpVFlag ? 'Allowed' : 'Prohibited'}
`);

try {
    ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: 'script' });
} catch (err) {
    console.error(`Syntax Error: Failed to parse '${file}' due to a syntax issue:`);
    console.error(err.message);
    if (err.pos !== undefined) {
        const line = code.substring(0, err.pos).split('\n').length;
        console.error(`Location: line ${line}, character ${err.pos}`);
        const start = Math.max(0, err.pos - 50);
        const end = Math.min(code.length, err.pos + 50);
        console.error('Context around error:');
        console.error(code.substring(start, end));
        console.error(' '.repeat(err.pos - start) + '^');
    }
    process.exit(1);
}

// Violations list
const violations = [];

function hasLookbehind(pattern) {
    let index = 0;
    while (true) {
        const match = pattern.indexOf('(?<=', index);
        const match2 = pattern.indexOf('(?<!', index);
        const pos = (match !== -1 && match2 !== -1) ? Math.min(match, match2) : (match !== -1 ? match : match2);
        if (pos === -1) break;
        
        let backslashes = 0;
        for (let i = pos - 1; i >= 0; i--) {
            if (pattern[i] === '\\') backslashes++;
            else break;
        }
        if (backslashes % 2 === 0) {
            return true;
        }
        index = pos + 4;
    }
    return false;
}

function checkNode(node) {
    if (!node || typeof node !== 'object') return;

    if (node.type) {
        // 1. Optional catch binding (ES2019 / iOS 11.3+)
        if (node.type === 'CatchClause' && !node.param) {
            if (target < 2019 && ios === null) {
                violations.push({
                    feature: 'Optional catch binding (ES2019 / iOS 11.3+)',
                    pos: node.start,
                    node
                });
            } else if (ios !== null && ios < 11.3) {
                violations.push({
                    feature: 'Optional catch binding (iOS 11.3+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 2. Dynamic import (ES2020 / iOS 11.3+)
        if (node.type === 'ImportExpression') {
            if (!allowDynamicImport) {
                violations.push({
                    feature: 'Dynamic import (ES2020 / iOS 11.3+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 3. import.meta (ES2020 / iOS 11.3+)
        if (node.type === 'MetaProperty' && node.meta && node.meta.name === 'import') {
            if (!allowDynamicImport) {
                violations.push({
                    feature: 'import.meta (ES2020 / iOS 11.3+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 4. Optional chaining (ES2020 / iOS 13.4+)
        if (node.type === 'ChainExpression') {
            const isProhibited = ios !== null ? ios < 13.4 : target < 2020;
            if (isProhibited) {
                violations.push({
                    feature: 'Optional chaining (ES2020 / iOS 13.4+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 5. Nullish coalescing (ES2020 / iOS 13.4+)
        if (node.type === 'LogicalExpression' && node.operator === '??') {
            const isProhibited = ios !== null ? ios < 13.4 : target < 2020;
            if (isProhibited) {
                violations.push({
                    feature: 'Nullish coalescing (ES2020 / iOS 13.4+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 6. BigInt literal (ES2020 / iOS 14.0+)
        if (node.type === 'Literal' && node.bigint !== undefined) {
            if (!allowBigInt) {
                violations.push({
                    feature: 'BigInt literal (ES2020 / iOS 14.0+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 7. Logical assignment (ES2021 / iOS 14.0+)
        if (node.type === 'AssignmentExpression' && ['||=', '&&=', '??='].includes(node.operator)) {
            const isProhibited = ios !== null ? ios < 14.0 : target < 2021;
            if (isProhibited) {
                violations.push({
                    feature: `Logical assignment operator '${node.operator}' (ES2021 / iOS 14.0+)`,
                    pos: node.start,
                    node
                });
            }
        }

        // 8. Numeric separators (ES2021 / iOS 14.0+)
        if (node.type === 'Literal' && typeof node.value === 'number' && node.raw && node.raw.includes('_')) {
            if (!allowNumericSeparator) {
                violations.push({
                    feature: 'Numeric separator (ES2021 / iOS 14.0+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 9. Class Fields (ES2022 / iOS 14.0+ public, iOS 14.5+ private/static)
        if (node.type === 'PropertyDefinition') {
            if (!allowClassFields) {
                const requiredVersion = node.key.type === 'PrivateIdentifier' || node.static ? 'iOS 14.5+' : 'iOS 14.0+';
                violations.push({
                    feature: `Class field definition '${node.key.name || node.key.value || '#private'}' (ES2022 / ${requiredVersion})`,
                    pos: node.start,
                    node
                });
            }
        }

        // 10. Class Static Initialization Blocks (ES2022 / iOS 16.4+)
        if (node.type === 'StaticBlock') {
            if (!allowClassStaticBlocks) {
                violations.push({
                    feature: 'Class static initialization block (ES2022 / iOS 16.4+)',
                    pos: node.start,
                    node
                });
            }
        }

        // 11. RegExp lookbehind assertions (ES2018 / iOS 16.4+)
        if (node.type === 'Literal' && node.regex) {
            if (!allowRegexpLookbehind && hasLookbehind(node.regex.pattern)) {
                violations.push({
                    feature: 'RegExp Lookbehind assertion (iOS 16.4+)',
                    pos: node.start,
                    node
                });
            }
            if (!allowRegexpIndices && node.regex.flags.includes('d')) {
                violations.push({
                    feature: "RegExp 'd' (indices) flag (ES2022 / iOS 15.0+)",
                    pos: node.start,
                    node
                });
            }
            if (!allowRegexpVFlag && node.regex.flags.includes('v')) {
                violations.push({
                    feature: "RegExp 'v' (Unicode properties) flag (ES2024 / iOS 17.0+)",
                    pos: node.start,
                    node
                });
            }
        }

        if ((node.type === 'NewExpression' || node.type === 'CallExpression') && node.callee && node.callee.name === 'RegExp') {
            if (!allowRegexpLookbehind && node.arguments[0] && node.arguments[0].type === 'Literal' && typeof node.arguments[0].value === 'string') {
                if (hasLookbehind(node.arguments[0].value)) {
                    violations.push({
                        feature: 'RegExp Lookbehind assertion (iOS 16.4+)',
                        pos: node.start,
                        node
                    });
                }
            }
            if (node.arguments[1] && node.arguments[1].type === 'Literal' && typeof node.arguments[1].value === 'string') {
                const flags = node.arguments[1].value;
                if (!allowRegexpIndices && flags.includes('d')) {
                    violations.push({
                        feature: "RegExp 'd' (indices) flag (ES2022 / iOS 15.0+)",
                        pos: node.start,
                        node
                    });
                }
                if (!allowRegexpVFlag && flags.includes('v')) {
                    violations.push({
                        feature: "RegExp 'v' (Unicode properties) flag (ES2024 / iOS 17.0+)",
                        pos: node.start,
                        node
                    });
                }
            }
        }
    }

    for (const key in node) {
        if (key === 'loc' || key === 'start' || key === 'end') continue;
        const val = node[key];
        if (Array.isArray(val)) {
            for (const child of val) {
                checkNode(child);
            }
        } else if (val && typeof val === 'object') {
            checkNode(val);
        }
    }
}

// Run compatibility checks on the AST
checkNode(ast);

if (violations.length > 0) {
    console.error(`\nCompatibility Check Failed: Found ${violations.length} prohibited features.`);
    violations.forEach((v, index) => {
        const line = code.substring(0, v.pos).split('\n').length;
        console.error(`\n[${index + 1}] Prohibited feature: ${v.feature}`);
        console.error(`Location: line ${line}, character ${v.pos}`);
        const start = Math.max(0, v.pos - 50);
        const end = Math.min(code.length, v.pos + 50);
        console.error('Context around feature:');
        console.error(code.substring(start, end));
        console.error(' '.repeat(v.pos - start) + '^');
    });
    process.exit(1);
}

console.log(`\nCompatibility Check Passed: '${file}' matches the compatibility rules.`);
process.exit(0);