package main.rice.parse;

// TODO: implement the ConfigFile class here

package main.rice;

import main.rice.basegen.BaseSetGenerator;
import main.rice.concisegen.ConciseSetGenerator;
import main.rice.parse.ConfigFile;
import main.rice.parse.ConfigFileParser;
import main.rice.parse.InvalidConfigException;
import main.rice.test.TestCase;
import main.rice.test.Tester;
import main.rice.test.TestResults;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.Set;

/**
 * Main entry point for the testing framework that ties together all components.
 */
public class Main {

    /**
     * Generates a minimal set of test cases that can distinguish between correct
     * and incorrect implementations.
     *
     * @param args command line arguments:
     *            args[0] = path to config file
     *            args[1] = path to solution file
     *            args[2] = path to implementations directory
     * @return a set of test cases that forms a minimal test suite
     * @throws InvalidConfigException if the config file is invalid
     * @throws IOException if there are file I/O errors
     * @throws InterruptedException if the testing process is interrupted
     */
    public static Set<TestCase> generateTests(String[] args) throws InvalidConfigException, IOException, InterruptedException {
        if (args.length < 3) {
            throw new IllegalArgumentException("Usage: Main <config_file> <solution_file> <impl_dir>");
        }

        String configPath = args[0];
        String solutionPath = args[1];
        String implDirPath = args[2];

        // Step 1: Parse the config file
        String configContent = Files.readString(Paths.get(configPath));
        ConfigFileParser parser = new ConfigFileParser();
        ConfigFile config = parser.parse(configContent);

        // Step 2: Generate test cases using BaseSetGenerator
        BaseSetGenerator baseGen = new BaseSetGenerator(config.getNodes(), config.getNumRand());
        List<TestCase> baseSet = baseGen.genBaseSet();

        // Step 3: Run tests using Tester
        Tester tester = new Tester(config.getFuncName(), solutionPath, implDirPath, baseSet);

        // Compute expected results from the solution
        tester.computeExpectedResults();

        // Run all tests on implementations
        TestResults results = tester.runTests();

        // Step 4: Select minimal test set using ConciseSetGenerator
        Set<TestCase> minimalSet = ConciseSetGenerator.setCover(results);

        return minimalSet;
    }

    /**
     * Main method for command-line invocation.
     *
     * @param args command line arguments (config file, solution file, implementations directory)
     */
    public static void main(String[] args) {
        try {
            Set<TestCase> minimalSet = generateTests(args);
            System.out.println("Generated minimal test set with " + minimalSet.size() + " test cases:");
            for (TestCase tc : minimalSet) {
                System.out.println("  " + tc);
            }
        } catch (InvalidConfigException e) {
            System.err.println("Invalid configuration: " + e.getMessage());
            System.exit(1);
        } catch (IOException e) {
            System.err.println("I/O error: " + e.getMessage());
            System.exit(1);
        } catch (InterruptedException e) {
            System.err.println("Test execution interrupted: " + e.getMessage());
            System.exit(1);
        }
    }
}