Datasets:

FrontierCS
/

Frontier-CS

import fs from 'fs/promises';
import path from 'path';
import YAML from 'js-yaml';
import unzipper from 'unzipper';
import tar from 'tar';
import { GoJudgeClient } from './gojudge.js';

import { dirExists, ensureDir, parseProblemConf, fileExists, findTestCases} from './utils.js';

export class ProblemConfig {
    constructor(pdir = null) {
        this.config = null;
        this.pdir = pdir;
        this.cases = [];
        this.checker = null;
        this.filename = null;
    }

    async loadConfig(configPath) {
        try{
            this.config = YAML.load(await fs.readFile(configPath, 'utf8'));
        } catch (error) {
            throw new Error(`Failed to load config: ${error.message}`);
        }
        
        // Validate configuration type
        const type = this.config.type || 'default';

        // Validate that subtasks exist
        if (!this.config.subtasks || !Array.isArray(this.config.subtasks)) {
            throw new Error('config.yaml must define subtasks');
        }
        return this.config;
    }

    async loadSubtasks() {
        const cfg = this.config;
        const cases = [];
        
        // Get global default values
        const globalTime = cfg.time_limit || cfg.time || '1s';
        const globalMemory = cfg.memory_limit || cfg.memory || '256m';
        const inputPrefix = cfg.input_prefix || '';
        const outputPrefix = cfg.output_prefix || '';
        const inputSuffix = cfg.input_suffix || '.in';
        const outputSuffix = cfg.output_suffix || '.ans';

        // Iterate through each subtask
        let curCase = 1;
        for (let si = 0; si < cfg.subtasks.length; si++) {
            const st = cfg.subtasks[si];
            const subtaskTime = st.time_limit || st.time || globalTime;
            const subtaskMemory = st.memory_limit || st.memory || globalMemory;

            // Determine which method to use for loading test cases
            if (st.n_cases !== undefined) {
                // Use n_cases to automatically generate filenames
                for (let i = 0; i < st.n_cases; i++) {
                    cases.push({
                        subtask: si,
                        input: `${inputPrefix}${curCase + i}${inputSuffix}`,
                        output: `${outputPrefix}${curCase + i}${outputSuffix}`,
                        time: subtaskTime,
                        memory: subtaskMemory
                    });
                }
                curCase += st.n_cases;
            } else if (st.cases && Array.isArray(st.cases)) {
                // Use explicitly specified cases
                st.cases.forEach(c => {
                    cases.push({
                        subtask: si,
                        input: c.input,
                        output: c.output,
                        time: c.time || subtaskTime,
                        memory: c.memory || subtaskMemory
                    });
                });
            } else {
                throw new Error(`Subtask ${si} must define either 'n_cases' or 'cases'`);
            }
        }
        
        this.cases = cases;
    }

    async loadClassic() {
        // Classic mode: load subtasks
        await this.loadSubtasks();

        // Set checker and filename
        this.checker = this.config.checker || 'chk.cc';
        this.filename = this.config.filename || null;
        
    }

    async loadLeetcode() {
        throw new Error('LeetCode problems are not supported for now.');
    }

    async loadInteractive() {
        //throw new Error('Interactive problems are not supported for now.');

         // Interactive mode: load subtasks
        await this.loadSubtasks();
        this.checker = this.config.checker || 'chk.cc';
        this.interactor = this.config.interactor || 'interactor.cc';
        //console.log('Loading interactive problem, the interactor is:', this.config.interactor);
        this.filename = this.config.filename || null;
    }
    
    async loadProblem(pdir) {
        // Load configuration file
        this.pdir = pdir;
        await this.loadConfig(path.join(this.pdir, 'config.yaml'));

        // Load based on problem type
        const type = this.config.type || 'default';
        
        switch (type) {
            case 'default':
                await this.loadClassic();
                break;
            case 'leetcode':
                await this.loadLeetcode();
                break;
            case 'interactive':
                await this.loadInteractive();
                break;
            default:
                throw new Error(`Unknown problem type: ${type}`);
        }

        // Return format compatible with original code
        return {
            pdir: this.pdir,
            cfg: this.config,
            cases: this.cases,
            checker: this.checker,
            interactor: this.interactor,
            filename: this.filename
        };
    }
}

export class ProblemSetter {
    constructor(dataDir, tarDir) {
        this.dataDir = dataDir;
        this.tarDir = tarDir;
    }

    // Copy file
    async copyFile(src, dest) {
        await ensureDir(path.dirname(dest));
        await fs.copyFile(src, dest);
    }

    // Move all files
    async moveAllFiles(srcDir, destDir) {
        await ensureDir(destDir);
        const files = await fs.readdir(srcDir);
        
        for (const file of files) {
            const srcPath = path.join(srcDir, file);
            const destPath = path.join(destDir, file);
            const stat = await fs.stat(srcPath);
            
            if (stat.isFile()) {
                await this.copyFile(srcPath, destPath);
            } else if (stat.isDirectory()) {
                await this.moveAllFiles(srcPath, destPath);
            }
        }
    }

    // Easy mode: directly copy all files
    async setEasyMode() {
        // Use ProblemConfig to validate configuration
        const loader = new ProblemConfig(this.dataDir);

        try {
            // Verify if configuration is correct
            await loader.loadProblem(this.dataDir);
            console.log(`Configuration validated`);
        } catch (err) {
            throw new Error(`Configuration validation failed: ${err.message}`);
        }

        // Validation passed, move all files to target directory
        await this.moveAllFiles(this.dataDir, this.tarDir);
        
        console.log(`Problem set successfully in EASY mode`);
        return { mode: 'easy', targetDir: this.tarDir };
    }

    // Free mode: generate configuration and organize files
    async setFreeMode() {
        console.log(`Setting problem in FREE mode`);

        // Default configuration
        let timeLimit = '2s';
        let memoryLimit = '512m';
        let mode = 'default';

        // Try to read problem.conf
        const confPath = path.join(this.dataDir, 'problem.conf');
        if (await fileExists(confPath)) {
            console.log('Found problem.conf, parsing...');
            const conf = await parseProblemConf(confPath);
            if (conf.interaction_mode === 'on') {
                mode = 'interactive';
            }

            if (conf.time_limit || conf.timelimit) {
                const timeSec = conf.time_limit || conf.timelimit;
                timeLimit = `${timeSec}s`;
            }
            
            if (conf.memory_limit || conf.memorylimit || conf.memory) {
                const memMB = conf.memory_limit || conf.memorylimit || conf.memory;
                memoryLimit = `${memMB}m`;
            }

        }

        let checker_name;
        const candidates = ['checker.cpp', 'checker.cc', 'chk.cpp', 'chk.cc'];

        for (const fname of candidates) {
            const fpath = path.join(this.dataDir, fname);
            if (await fileExists(fpath)) {
                checker_name = fname;
                break; 
            }
        }
        if (!checker_name && mode === 'default') {
            throw new Error('No checker source file found (expected one of: ' + candidates.join(', ') + ')');
        }

        let interactor_name;
        const interactorCandidates = ['interactor.cpp', 'interactor.cc'];

        for (const fname of interactorCandidates) {
            const fpath = path.join(this.dataDir, fname);
            if (await fileExists(fpath)) {
                interactor_name = fname;
                break;
            }
        }
        if (mode === 'interactive' && !interactor_name) {
            throw new Error('Interactive mode requires an interactor source file (expected one of: ' + interactorCandidates.join(', ') + ')');
        }

        // Find test case pairs
        const testCases = await findTestCases(this.dataDir);
        if (testCases.length === 0) {
            throw new Error('No matching test case pairs found');
        }
        
        console.log(`Found ${testCases.length} test case pairs`);
        
        const testdataDir = path.join(this.tarDir, 'testdata');
        await ensureDir(testdataDir);

        // Copy and rename test cases
        const cases = [];
        for (let i = 0; i < testCases.length; i++) {
            const testCase = testCases[i];
            const newIndex = i + 1;

            // Copy input file
            await this.copyFile(
                path.join(this.dataDir, testCase.input),
                path.join(testdataDir, `${newIndex}.in`)
            );

            // Copy output file
            await this.copyFile(
                path.join(this.dataDir, testCase.output),
                path.join(testdataDir, `${newIndex}.ans`)
            );
            
            cases.push({
                input: `${newIndex}.in`,
                output: `${newIndex}.ans`
            });
        }

        // Generate config.yaml
        const config = {
            type: mode,
            time_limit: timeLimit,
            memory_limit: memoryLimit,
            checker: checker_name,
            interactor: interactor_name,
            input_prefix: '',
            output_prefix: '',
            input_suffix: '.in',
            output_suffix: '.ans',
            subtasks: [
                {
                    score: 100,
                    n_cases: testCases.length
                }
            ]
        };

        // Write configuration file
        const configPath = path.join(this.tarDir, 'config.yaml');
        await fs.writeFile(configPath, YAML.dump(config), 'utf8');

        // Copy other necessary files (e.g., checker.cpp, statement.txt, etc.)
        const otherFiles = ['checker.cpp', 'statement.txt', config.checker, config.interactor].filter(f => f);
        for (const file of otherFiles) {
            const srcPath = path.join(this.dataDir, file);
            if (await fileExists(srcPath)) {
                await this.copyFile(srcPath, path.join(this.tarDir, file));
            }
        }

        console.log(`Problem set successfully in FREE mode`);
        console.log(`Generated config with ${testCases.length} test cases`);
        
        return {
            mode: 'free',
            targetDir: this.tarDir,
            testCases: testCases.length,
            timeLimit,
            memoryLimit
        };
    }

    // Main entry point
    async setProblem() {
        // Check if problem directory exists
        if (!(await fileExists(this.dataDir))) {
            throw new Error(`Problem directory not found: ${this.dataDir}`);
        }

        // Check if config.yaml exists (Easy mode)
        const configPath = path.join(this.dataDir, 'config.yaml');
        if (await fileExists(configPath)) {
            return await this.setEasyMode();
        } else {
            // Free mode
            return await this.setFreeMode();
        }
    }
}

export class ProblemManager {
    constructor(config) {
        this.problemsRoot = config.problemsRoot;
        this.gjAddr = config.gjAddr || 'http://localhost:8080';
        this.testlibPath = config.testlibPath || '/lib/testlib';

        this.goJudge = new GoJudgeClient(config.gjAddr);
    }

    // Load a single problem
    async loadProblem(pid) {
        const pdir = path.join(this.problemsRoot, pid);
        return new ProblemConfig().loadProblem(pdir);
    }

    // Get problem statement
    async getStatement(pid) {
        const fp = path.join(this.problemsRoot, pid, 'statement.txt');
        return await fs.readFile(fp, 'utf8');
    }

    // Get list of all problems
    async listProblems(includeStatement = false) {
        const problems = [];
        
        const folders = await fs.readdir(this.problemsRoot, { withFileTypes: true });
        const problemFolders = folders
            .filter(dirent => dirent.isDirectory())
            .map(dirent => dirent.name)
            .sort();

        for (const folder of problemFolders) {
            const problemPath = path.join(this.problemsRoot, folder);
            const configPath = path.join(problemPath, 'config.yaml');

            try {
                // Check if config.yaml exists
                await fs.access(configPath);

                const problemInfo = { id: folder };

                // If statement needs to be included
                if (includeStatement) {
                    try {
                        const statement = await this.getStatement(folder);
                        problemInfo.statement = statement;
                    } catch {
                        // statement file doesn't exist, don't add this field
                    }
                }

                problems.push(problemInfo);
            } catch {
                // config.yaml doesn't exist, skip this folder
            }
        }

        return problems;
    }

    // Read test data file
    async readTestFile(pid, filename) {
        const filePath = path.join(this.problemsRoot, pid, 'testdata', filename);
        return await fs.readFile(filePath, 'utf8');
    }

    // Read checker source code
    async readCheckerSource(pid, checkerFile = 'chk.cc') {
        const filePath = path.join(this.problemsRoot, pid, checkerFile);
        return await fs.readFile(filePath, 'utf8');
    }

    // Read interactor source code
    async readInteractorSource(pid, interactorFile = 'interactor.cpp') {
        const filePath = path.join(this.problemsRoot, pid, interactorFile);
        return await fs.readFile(filePath, 'utf8');
    }

    async setupProblem(pid, zipfile) {
        const pdir = path.join(this.problemsRoot, pid);
        if (!await dirExists(pdir)) {
            throw new Error(`Problem ${pid} does not exist`);
        }

        if (!zipfile) {
            throw new Error('No zip file provided');
        }

        if (typeof zipfile === 'string') {
            // Handle string path
            const zipPath = path.resolve(zipfile);
            if (!await dirExists(zipPath)) {
                throw new Error(`Zip file ${zipPath} does not exist`);
            }
            const tmpDir = path.join(pdir, "tmp_" + pid);
            try {
                const directory = await unzipper.Open.file(zipPath);
                await directory.extract({ path: tmpDir })   ;
                const files = await fs.readdir(tmpDir, { recursive: true });
            } catch (error) {
                throw new Error(`Failed to unzip file: ${error.message}`);
            }
            await fs.unlink(zipPath);
            let Setter = new ProblemSetter(tmpDir, pdir);
            try {
                await Setter.setProblem();
            } catch (error) {
                await fs.rm(tmpDir, { recursive: true, force: true });
                throw new Error(`Failed to set problem: ${error.message}`);
            }
            await fs.rm(tmpDir, { recursive: true, force: true });
        }

        let config;
        try {
            config = await new ProblemConfig(pdir).loadConfig(path.join(pdir, 'config.yaml'));
        } catch (error) {
            throw new Error(`Failed to load problem config: ${error.message}`);
        }
        const checker_name = config.checker || undefined;
        if (checker_name) {
            const checker_source = await this.readCheckerSource(pid, checker_name);
            try {
                const checkerBin = await this.goJudge.getCheckerBin(checker_source, config.testlibPath);
                const checkerBinPath = path.join(pdir, `${checker_name}.bin`);
                await fs.writeFile(checkerBinPath, checkerBin);
            } catch (error) {
                throw new Error(`Failed to get checker binary: ${error.message}`);
            }
        }
        const interactor_name = config.interactor || undefined;
        if (interactor_name) {
            const interactor_source = await this.readInteractorSource(pid, interactor_name);
            try {
                const interactorBin = await this.goJudge.getCheckerBin(interactor_source, config.testlibPath);
                const interactorBinPath = path.join(pdir, `${interactor_name}.bin`);
                await fs.writeFile(interactorBinPath, interactorBin);
            } catch (error) {
                throw new Error(`Failed to get interactor binary: ${error.message}`);
            }
        }

        await tar.c({
            gzip: true,
            file: path.join(pdir, `${pid}.tar.gz`)  // Output location
        },
        [pdir]
        );
        return { message: 'Problem setup completed successfully', pid };
    }

    // Add new problem
    async addProblem(pid, zipfile) {
        const pdir = path.join(this.problemsRoot, pid);
        // Check if already exists
        if (await dirExists(pdir)) {
            throw new Error(`Problem ${pid} already exists`);
        }
        await fs.mkdir(pdir, { recursive: true });

        if (zipfile) {
            try{
                await this.setupProblem(pid, zipfile);
            } catch (error) {
                throw new Error(`Failed to setup problem: ${error.message}`);
            }
            return { message: 'Problem added and setup successfully', pid };
        }
        return { message: 'Problem added successfully', pid };
    }

    async deleteProblem(pid) {
        const pdir = path.join(this.problemsRoot, pid);
        if (!await dirExists(pdir)) {
            throw new Error(`Problem ${pid} does not exist`);
        }

        // Delete entire directory
        await fs.rm(pdir, { recursive: true, force: true });
        return { message: 'Problem deleted successfully', pid };
    }

    async getPackage(pid) {
        const pdir = path.join(this.problemsRoot, pid);
        if (!await dirExists(pdir)) {
            throw new Error(`Problem ${pid} does not exist`);
        }
        const packagePath = path.join(pdir, `${pid}.tar.gz`);
        try{
            await fs.access(packagePath);
        } catch {
            throw new Error(`Package ${packagePath} does not exist`);
        }
        return packagePath;
    }

}

	import fs from 'fs/promises';
	import path from 'path';
	import YAML from 'js-yaml';
	import unzipper from 'unzipper';
	import tar from 'tar';
	import { GoJudgeClient } from './gojudge.js';

	import { dirExists, ensureDir, parseProblemConf, fileExists, findTestCases} from './utils.js';

	export class ProblemConfig {
	constructor(pdir = null) {
	this.config = null;
	this.pdir = pdir;
	this.cases = [];
	this.checker = null;
	this.filename = null;
	}

	async loadConfig(configPath) {
	try{
	this.config = YAML.load(await fs.readFile(configPath, 'utf8'));
	} catch (error) {
	throw new Error(`Failed to load config: ${error.message}`);
	}

	// Validate configuration type
	const type = this.config.type \|\| 'default';

	// Validate that subtasks exist
	if (!this.config.subtasks \|\| !Array.isArray(this.config.subtasks)) {
	throw new Error('config.yaml must define subtasks');
	}
	return this.config;
	}

	async loadSubtasks() {
	const cfg = this.config;
	const cases = [];

	// Get global default values
	const globalTime = cfg.time_limit \|\| cfg.time \|\| '1s';
	const globalMemory = cfg.memory_limit \|\| cfg.memory \|\| '256m';
	const inputPrefix = cfg.input_prefix \|\| '';
	const outputPrefix = cfg.output_prefix \|\| '';
	const inputSuffix = cfg.input_suffix \|\| '.in';
	const outputSuffix = cfg.output_suffix \|\| '.ans';

	// Iterate through each subtask
	let curCase = 1;
	for (let si = 0; si < cfg.subtasks.length; si++) {
	const st = cfg.subtasks[si];
	const subtaskTime = st.time_limit \|\| st.time \|\| globalTime;
	const subtaskMemory = st.memory_limit \|\| st.memory \|\| globalMemory;

	// Determine which method to use for loading test cases
	if (st.n_cases !== undefined) {
	// Use n_cases to automatically generate filenames
	for (let i = 0; i < st.n_cases; i++) {
	cases.push({
	subtask: si,
	input: `${inputPrefix}${curCase + i}${inputSuffix}`,
	output: `${outputPrefix}${curCase + i}${outputSuffix}`,
	time: subtaskTime,
	memory: subtaskMemory
	});
	}
	curCase += st.n_cases;
	} else if (st.cases && Array.isArray(st.cases)) {
	// Use explicitly specified cases
	st.cases.forEach(c => {
	cases.push({
	subtask: si,
	input: c.input,
	output: c.output,
	time: c.time \|\| subtaskTime,
	memory: c.memory \|\| subtaskMemory
	});
	});
	} else {
	throw new Error(`Subtask ${si} must define either 'n_cases' or 'cases'`);
	}
	}

	this.cases = cases;
	}

	async loadClassic() {
	// Classic mode: load subtasks
	await this.loadSubtasks();

	// Set checker and filename
	this.checker = this.config.checker \|\| 'chk.cc';
	this.filename = this.config.filename \|\| null;

	}

	async loadLeetcode() {
	throw new Error('LeetCode problems are not supported for now.');
	}

	async loadInteractive() {
	//throw new Error('Interactive problems are not supported for now.');

	// Interactive mode: load subtasks
	await this.loadSubtasks();
	this.checker = this.config.checker \|\| 'chk.cc';
	this.interactor = this.config.interactor \|\| 'interactor.cc';
	//console.log('Loading interactive problem, the interactor is:', this.config.interactor);
	this.filename = this.config.filename \|\| null;
	}

	async loadProblem(pdir) {
	// Load configuration file
	this.pdir = pdir;
	await this.loadConfig(path.join(this.pdir, 'config.yaml'));

	// Load based on problem type
	const type = this.config.type \|\| 'default';

	switch (type) {
	case 'default':
	await this.loadClassic();
	break;
	case 'leetcode':
	await this.loadLeetcode();
	break;
	case 'interactive':
	await this.loadInteractive();
	break;
	default:
	throw new Error(`Unknown problem type: ${type}`);
	}

	// Return format compatible with original code
	return {
	pdir: this.pdir,
	cfg: this.config,
	cases: this.cases,
	checker: this.checker,
	interactor: this.interactor,
	filename: this.filename
	};
	}
	}

	export class ProblemSetter {
	constructor(dataDir, tarDir) {
	this.dataDir = dataDir;
	this.tarDir = tarDir;
	}

	// Copy file
	async copyFile(src, dest) {
	await ensureDir(path.dirname(dest));
	await fs.copyFile(src, dest);
	}

	// Move all files
	async moveAllFiles(srcDir, destDir) {
	await ensureDir(destDir);
	const files = await fs.readdir(srcDir);

	for (const file of files) {
	const srcPath = path.join(srcDir, file);
	const destPath = path.join(destDir, file);
	const stat = await fs.stat(srcPath);

	if (stat.isFile()) {
	await this.copyFile(srcPath, destPath);
	} else if (stat.isDirectory()) {
	await this.moveAllFiles(srcPath, destPath);
	}
	}
	}

	// Easy mode: directly copy all files
	async setEasyMode() {
	// Use ProblemConfig to validate configuration
	const loader = new ProblemConfig(this.dataDir);

	try {
	// Verify if configuration is correct
	await loader.loadProblem(this.dataDir);
	console.log(`Configuration validated`);
	} catch (err) {
	throw new Error(`Configuration validation failed: ${err.message}`);
	}

	// Validation passed, move all files to target directory
	await this.moveAllFiles(this.dataDir, this.tarDir);

	console.log(`Problem set successfully in EASY mode`);
	return { mode: 'easy', targetDir: this.tarDir };
	}

	// Free mode: generate configuration and organize files
	async setFreeMode() {
	console.log(`Setting problem in FREE mode`);

	// Default configuration
	let timeLimit = '2s';
	let memoryLimit = '512m';
	let mode = 'default';

	// Try to read problem.conf
	const confPath = path.join(this.dataDir, 'problem.conf');
	if (await fileExists(confPath)) {
	console.log('Found problem.conf, parsing...');
	const conf = await parseProblemConf(confPath);
	if (conf.interaction_mode === 'on') {
	mode = 'interactive';
	}

	if (conf.time_limit \|\| conf.timelimit) {
	const timeSec = conf.time_limit \|\| conf.timelimit;
	timeLimit = `${timeSec}s`;
	}

	if (conf.memory_limit \|\| conf.memorylimit \|\| conf.memory) {
	const memMB = conf.memory_limit \|\| conf.memorylimit \|\| conf.memory;
	memoryLimit = `${memMB}m`;
	}

	}

	let checker_name;
	const candidates = ['checker.cpp', 'checker.cc', 'chk.cpp', 'chk.cc'];

	for (const fname of candidates) {
	const fpath = path.join(this.dataDir, fname);
	if (await fileExists(fpath)) {
	checker_name = fname;
	break;
	}
	}
	if (!checker_name && mode === 'default') {
	throw new Error('No checker source file found (expected one of: ' + candidates.join(', ') + ')');
	}

	let interactor_name;
	const interactorCandidates = ['interactor.cpp', 'interactor.cc'];

	for (const fname of interactorCandidates) {
	const fpath = path.join(this.dataDir, fname);
	if (await fileExists(fpath)) {
	interactor_name = fname;
	break;
	}
	}
	if (mode === 'interactive' && !interactor_name) {
	throw new Error('Interactive mode requires an interactor source file (expected one of: ' + interactorCandidates.join(', ') + ')');
	}

	// Find test case pairs
	const testCases = await findTestCases(this.dataDir);
	if (testCases.length === 0) {
	throw new Error('No matching test case pairs found');
	}

	console.log(`Found ${testCases.length} test case pairs`);

	const testdataDir = path.join(this.tarDir, 'testdata');
	await ensureDir(testdataDir);

	// Copy and rename test cases
	const cases = [];
	for (let i = 0; i < testCases.length; i++) {
	const testCase = testCases[i];
	const newIndex = i + 1;

	// Copy input file
	await this.copyFile(
	path.join(this.dataDir, testCase.input),
	path.join(testdataDir, `${newIndex}.in`)
	);

	// Copy output file
	await this.copyFile(
	path.join(this.dataDir, testCase.output),
	path.join(testdataDir, `${newIndex}.ans`)
	);

	cases.push({
	input: `${newIndex}.in`,
	output: `${newIndex}.ans`
	});
	}

	// Generate config.yaml
	const config = {
	type: mode,
	time_limit: timeLimit,
	memory_limit: memoryLimit,
	checker: checker_name,
	interactor: interactor_name,
	input_prefix: '',
	output_prefix: '',
	input_suffix: '.in',
	output_suffix: '.ans',
	subtasks: [
	{
	score: 100,
	n_cases: testCases.length
	}
	]
	};

	// Write configuration file
	const configPath = path.join(this.tarDir, 'config.yaml');
	await fs.writeFile(configPath, YAML.dump(config), 'utf8');

	// Copy other necessary files (e.g., checker.cpp, statement.txt, etc.)
	const otherFiles = ['checker.cpp', 'statement.txt', config.checker, config.interactor].filter(f => f);
	for (const file of otherFiles) {
	const srcPath = path.join(this.dataDir, file);
	if (await fileExists(srcPath)) {
	await this.copyFile(srcPath, path.join(this.tarDir, file));
	}
	}

	console.log(`Problem set successfully in FREE mode`);
	console.log(`Generated config with ${testCases.length} test cases`);

	return {
	mode: 'free',
	targetDir: this.tarDir,
	testCases: testCases.length,
	timeLimit,
	memoryLimit
	};
	}

	// Main entry point
	async setProblem() {
	// Check if problem directory exists
	if (!(await fileExists(this.dataDir))) {
	throw new Error(`Problem directory not found: ${this.dataDir}`);
	}

	// Check if config.yaml exists (Easy mode)
	const configPath = path.join(this.dataDir, 'config.yaml');
	if (await fileExists(configPath)) {
	return await this.setEasyMode();
	} else {
	// Free mode
	return await this.setFreeMode();
	}
	}
	}

	export class ProblemManager {
	constructor(config) {
	this.problemsRoot = config.problemsRoot;
	this.gjAddr = config.gjAddr \|\| 'http://localhost:8080';
	this.testlibPath = config.testlibPath \|\| '/lib/testlib';

	this.goJudge = new GoJudgeClient(config.gjAddr);
	}

	// Load a single problem
	async loadProblem(pid) {
	const pdir = path.join(this.problemsRoot, pid);
	return new ProblemConfig().loadProblem(pdir);
	}

	// Get problem statement
	async getStatement(pid) {
	const fp = path.join(this.problemsRoot, pid, 'statement.txt');
	return await fs.readFile(fp, 'utf8');
	}

	// Get list of all problems
	async listProblems(includeStatement = false) {
	const problems = [];

	const folders = await fs.readdir(this.problemsRoot, { withFileTypes: true });
	const problemFolders = folders
	.filter(dirent => dirent.isDirectory())
	.map(dirent => dirent.name)
	.sort();

	for (const folder of problemFolders) {
	const problemPath = path.join(this.problemsRoot, folder);
	const configPath = path.join(problemPath, 'config.yaml');

	try {
	// Check if config.yaml exists
	await fs.access(configPath);

	const problemInfo = { id: folder };

	// If statement needs to be included
	if (includeStatement) {
	try {
	const statement = await this.getStatement(folder);
	problemInfo.statement = statement;
	} catch {
	// statement file doesn't exist, don't add this field
	}
	}

	problems.push(problemInfo);
	} catch {
	// config.yaml doesn't exist, skip this folder
	}
	}

	return problems;
	}

	// Read test data file
	async readTestFile(pid, filename) {
	const filePath = path.join(this.problemsRoot, pid, 'testdata', filename);
	return await fs.readFile(filePath, 'utf8');
	}

	// Read checker source code
	async readCheckerSource(pid, checkerFile = 'chk.cc') {
	const filePath = path.join(this.problemsRoot, pid, checkerFile);
	return await fs.readFile(filePath, 'utf8');
	}

	// Read interactor source code
	async readInteractorSource(pid, interactorFile = 'interactor.cpp') {
	const filePath = path.join(this.problemsRoot, pid, interactorFile);
	return await fs.readFile(filePath, 'utf8');
	}

	async setupProblem(pid, zipfile) {
	const pdir = path.join(this.problemsRoot, pid);
	if (!await dirExists(pdir)) {
	throw new Error(`Problem ${pid} does not exist`);
	}

	if (!zipfile) {
	throw new Error('No zip file provided');
	}

	if (typeof zipfile === 'string') {
	// Handle string path
	const zipPath = path.resolve(zipfile);
	if (!await dirExists(zipPath)) {
	throw new Error(`Zip file ${zipPath} does not exist`);
	}
	const tmpDir = path.join(pdir, "tmp_" + pid);
	try {
	const directory = await unzipper.Open.file(zipPath);
	await directory.extract({ path: tmpDir }) ;
	const files = await fs.readdir(tmpDir, { recursive: true });
	} catch (error) {
	throw new Error(`Failed to unzip file: ${error.message}`);
	}
	await fs.unlink(zipPath);
	let Setter = new ProblemSetter(tmpDir, pdir);
	try {
	await Setter.setProblem();
	} catch (error) {
	await fs.rm(tmpDir, { recursive: true, force: true });
	throw new Error(`Failed to set problem: ${error.message}`);
	}
	await fs.rm(tmpDir, { recursive: true, force: true });
	}

	let config;
	try {
	config = await new ProblemConfig(pdir).loadConfig(path.join(pdir, 'config.yaml'));
	} catch (error) {
	throw new Error(`Failed to load problem config: ${error.message}`);
	}
	const checker_name = config.checker \|\| undefined;
	if (checker_name) {
	const checker_source = await this.readCheckerSource(pid, checker_name);
	try {
	const checkerBin = await this.goJudge.getCheckerBin(checker_source, config.testlibPath);
	const checkerBinPath = path.join(pdir, `${checker_name}.bin`);
	await fs.writeFile(checkerBinPath, checkerBin);
	} catch (error) {
	throw new Error(`Failed to get checker binary: ${error.message}`);
	}
	}
	const interactor_name = config.interactor \|\| undefined;
	if (interactor_name) {
	const interactor_source = await this.readInteractorSource(pid, interactor_name);
	try {
	const interactorBin = await this.goJudge.getCheckerBin(interactor_source, config.testlibPath);
	const interactorBinPath = path.join(pdir, `${interactor_name}.bin`);
	await fs.writeFile(interactorBinPath, interactorBin);
	} catch (error) {
	throw new Error(`Failed to get interactor binary: ${error.message}`);
	}
	}

	await tar.c({
	gzip: true,
	file: path.join(pdir, `${pid}.tar.gz`) // Output location
	},
	[pdir]
	);
	return { message: 'Problem setup completed successfully', pid };
	}

	// Add new problem
	async addProblem(pid, zipfile) {
	const pdir = path.join(this.problemsRoot, pid);
	// Check if already exists
	if (await dirExists(pdir)) {
	throw new Error(`Problem ${pid} already exists`);
	}
	await fs.mkdir(pdir, { recursive: true });

	if (zipfile) {
	try{
	await this.setupProblem(pid, zipfile);
	} catch (error) {
	throw new Error(`Failed to setup problem: ${error.message}`);
	}
	return { message: 'Problem added and setup successfully', pid };
	}
	return { message: 'Problem added successfully', pid };
	}

	async deleteProblem(pid) {
	const pdir = path.join(this.problemsRoot, pid);
	if (!await dirExists(pdir)) {
	throw new Error(`Problem ${pid} does not exist`);
	}

	// Delete entire directory
	await fs.rm(pdir, { recursive: true, force: true });
	return { message: 'Problem deleted successfully', pid };
	}

	async getPackage(pid) {
	const pdir = path.join(this.problemsRoot, pid);
	if (!await dirExists(pdir)) {
	throw new Error(`Problem ${pid} does not exist`);
	}
	const packagePath = path.join(pdir, `${pid}.tar.gz`);
	try{
	await fs.access(packagePath);
	} catch {
	throw new Error(`Package ${packagePath} does not exist`);
	}
	return packagePath;
	}

	}