//custom-eslint-rules/run-eslint-tests.ts
import { readdirSync } from "fs";

console.log("Running all ESLint rule tests...\n");

// Find all test files in the current directory
const testFiles = readdirSync(".")
    .filter((file) => file.endsWith(".test.ts"))
    .map((file) => "./" + file.replace(".ts", ".js"));

// Import and run test files
await Promise.all(testFiles.map((file) => import(file)));

export {};


//custom-eslint-rules/test-utils/eslint-rule-tester.ts
import { RuleTester } from "@typescript-eslint/rule-tester";
import parser from "@typescript-eslint/parser";

// Console colors
const colors = {
    green: "\x1b[32m",
    red: "\x1b[31m",
    yellow: "\x1b[33m",
    blue: "\x1b[34m",
    reset: "\x1b[0m",
    bold: "\x1b[1m",
};

interface TestStats {
    passedTests: number;
    failedTests: number;
    totalTests: number;
}

export class ESLintRuleTestRunner {
    private stats: TestStats = {
        passedTests: 0,
        failedTests: 0,
        totalTests: 0,
    };

    private ruleTester: RuleTester;

    constructor() {
        // Setup test runner
        RuleTester.afterAll = () => {};
        RuleTester.describe = (_name, fn) => fn();
        RuleTester.it = (name, fn) => {
            this.stats.totalTests++;
            try {
                fn();
                console.log(`${colors.green}✓${colors.reset} ${name}`);
                this.stats.passedTests++;
            } catch (error: any) {
                console.log(`${colors.red}✗${colors.reset} ${name}`);
                console.log(`${colors.red}Error: ${error.message}${colors.reset}\n`);
                this.stats.failedTests++;
                throw error;
            }
        };

        // Create RuleTester instance
        this.ruleTester = new RuleTester({
            languageOptions: {
                parser,
                parserOptions: {
                    ecmaVersion: 2022,
                    sourceType: "module",
                },
            },
        });
    }

    runTests(
        ruleName: string,
        rule: any,
        testCases: {
            valid?: { code: string }[];
            invalid?: {
                code: string;
                errors: { messageId: string }[];
                output?: string;
            }[];
        }[],
    ) {
        console.log(`\n${colors.bold}Testing ESLint rule: ${colors.blue}${ruleName}${colors.reset}\n`);

        // Run valid cases
        if (testCases.some((cases) => cases.valid?.length)) {
            console.log(`${colors.bold}Testing Valid Cases (Should Pass):${colors.reset}`);
            this.ruleTester.run(`${ruleName}-valid`, rule, {
                valid: testCases.flatMap((cases) => cases.valid || []),
                invalid: [],
            });
        }

        // Run invalid cases
        if (testCases.some((cases) => cases.invalid?.length)) {
            console.log(`\n${colors.bold}Testing Invalid Cases (Should Fail):${colors.reset}`);
            this.ruleTester.run(`${ruleName}-invalid`, rule, {
                valid: [],
                invalid: testCases.flatMap((cases) => cases.invalid || []),
            });
        }

        // Print summary
        this.printSummary();
    }

    private printSummary() {
        console.log(`\n${colors.bold}Test Summary:${colors.reset}`);
        console.log(`${colors.green}✓${colors.reset} ${this.stats.passedTests} tests passed`);
        console.log(`${colors.red}✗${colors.reset} ${this.stats.failedTests} tests failed`);
        console.log(`${colors.blue}Total:${colors.reset} ${this.stats.totalTests} tests`);

        if (this.stats.failedTests > 0) {
            console.log(`\n${colors.bold}${colors.red}Some tests failed!${colors.reset}\n`);
            process.exit(1);
        } else {
            console.log(`\n${colors.bold}${colors.green}All tests passed successfully!${colors.reset}\n`);
        }
    }
}