package main.rice.node;

// TODO: implement the PyBoolNode class here

package main.rice.concisegen;

import main.rice.test.TestResults;
import main.rice.test.TestCase;
import java.util.HashSet;
import java.util.Set;

/**
 * A class that implements a greedy set cover algorithm to find a minimal set of test
 * cases that covers all buggy implementations.
 */
public class ConciseSetGenerator {

    /**
     * Finds a minimal set of test cases that covers all files in the wrongSet using a
     * greedy set cover algorithm. Does not mutate the input TestResults object.
     *
     * @param results the TestResults containing test cases and their coverage
     * @return a set of test cases that covers all buggy implementations
     */
    public static Set<TestCase> setCover(TestResults results) {
        // Create a set to track which files are still uncovered
        // We make a copy of wrongSet to avoid mutating the input
        Set<Integer> uncovered = new HashSet<>(results.getWrongSet());

        // The result set of test cases
        Set<TestCase> cover = new HashSet<>();

        // Keep going until all files are covered
        while (!uncovered.isEmpty()) {
            // Find the test case that covers the most uncovered files
            int bestTestIndex = -1;
            int maxCoverage = 0;

            // Iterate through all test cases
            for (int i = 0; i < results.getCaseToFiles().size(); i++) {
                // Count how many uncovered files this test case covers
                Set<Integer> filesForThisTest = results.getCaseToFiles().get(i);
                int coverage = 0;
                for (Integer file : filesForThisTest) {
                    if (uncovered.contains(file)) {
                        coverage++;
                    }
                }

                // Update best if this test case covers more files
                if (coverage > maxCoverage) {
                    maxCoverage = coverage;
                    bestTestIndex = i;
                }
            }

            // If no test case covers any uncovered files, we're done
            // (this shouldn't happen in valid inputs)
            if (bestTestIndex == -1) {
                break;
            }

            // Add the best test case to the cover
            TestCase bestTest = results.getTestCase(bestTestIndex);
            cover.add(bestTest);

            // Remove the covered files from uncovered
            Set<Integer> filesForBestTest = results.getCaseToFiles().get(bestTestIndex);
            for (Integer file : filesForBestTest) {
                uncovered.remove(file);
            }
        }

        return cover;
    }
}