package unit;
import java.util.*;

/**
 * CWE-407 scan result for signalapp/Signal-Server — CLEAN
 *
 * All hot-path membership checks in Signal-Server use hash-backed collections
 * (HashSet, EnumSet, Set<>) rather than List.contains().  No O(n²) membership
 * test was found.  This test documents the key clean patterns and verifies
 * that the data structures chosen (Set vs List) have the expected O(1) vs
 * O(n) lookup behaviour.
 *
 * Compile: javac -d . SignalServerTest.java && java -ea unit.SignalServerTest
 */
public class SignalServerTest {

    static void bench(String label, Runnable slow, Runnable fast, long sOps, long fOps) {
        slow.run(); fast.run(); // warm up
        long t0 = System.nanoTime(); slow.run(); long sMs = (System.nanoTime() - t0) / 1_000_000;
        long t1 = System.nanoTime(); fast.run(); long fMs = (System.nanoTime() - t1) / 1_000_000;
        double r = fOps > 0 ? (double) sOps / fOps : 0;
        System.out.printf("  %-52s  slow:%4dms (%,d ops)  fast:%4dms (%,d ops)  speedup:%.0fx%n",
                label, sMs, sOps, fMs, fOps, r);
    }

    // Verify ExperimentEnrollmentManager pattern: Set<UUID>.contains() is O(1)
    // (Signal uses Set<UUID> for excludedUuids, uuidSelector.uuids, etc.)
    static long simulateListContains(List<UUID> candidates, List<UUID> haystack) {
        long ops = 0;
        for (UUID candidate : candidates) {
            for (UUID h : haystack) {
                ops++;
                if (candidate.equals(h)) break;
            }
        }
        return ops;
    }

    static long simulateSetContains(List<UUID> candidates, Set<UUID> haystackSet) {
        long ops = 0;
        for (UUID candidate : candidates) {
            ops++;
            haystackSet.contains(candidate); // O(1)
        }
        return ops;
    }

    // Verify Device.capabilities pattern: EnumSet.contains() is O(1)
    enum DeviceCapability { STORAGE, TRANSFER, PAYMENT, PNI_REGISTRATION, DELETE_SYNC }

    static long simulateListContains_cap(List<DeviceCapability> checks, List<DeviceCapability> capList) {
        long ops = 0;
        for (DeviceCapability cap : checks) {
            for (DeviceCapability c : capList) {
                ops++;
                if (c == cap) break;
            }
        }
        return ops;
    }

    static long simulateEnumSetContains(List<DeviceCapability> checks, Set<DeviceCapability> caps) {
        long ops = 0;
        for (DeviceCapability cap : checks) {
            ops++;
            caps.contains(cap); // O(1) EnumSet
        }
        return ops;
    }

    public static void main(String[] args) {
        System.out.println("signal-server CWE-407 scan — CLEAN (reference benchmarks)");
        System.out.println("=".repeat(80));
        System.out.println("Signal-Server uses Set<>/HashSet/EnumSet for all hot-path membership.");
        System.out.println("No O(n^2) defect found. Benchmarks below confirm O(1) vs O(n) contrast.");
        System.out.println();

        // Show what O(n^2) would look like vs Signal's actual O(1) approach
        int N = 1000;
        List<UUID> uuids = new ArrayList<>(N);
        for (int i = 0; i < N; i++) uuids.add(UUID.randomUUID());
        Set<UUID> uuidSet = new HashSet<>(uuids);

        long sOps = simulateListContains(uuids, uuids);
        long fOps = simulateSetContains(uuids, uuidSet);

        bench(String.format("ExperimentEnrollment UUID lookup N=%d", N),
                () -> simulateListContains(uuids, uuids),
                () -> simulateSetContains(uuids, uuidSet),
                sOps, fOps);

        // EnumSet is even faster than HashSet
        List<DeviceCapability> allCaps = Arrays.asList(DeviceCapability.values());
        Set<DeviceCapability> enumSet = EnumSet.allOf(DeviceCapability.class);
        int REPS = 200_000;
        List<DeviceCapability> checks = new ArrayList<>(REPS);
        for (int i = 0; i < REPS; i++) checks.add(allCaps.get(i % allCaps.size()));

        long eOps = simulateEnumSetContains(checks, enumSet);
        // For "slow" side, simulate linear scan with a list-backed check
        long eListOps = simulateListContains_cap(checks, new ArrayList<>(allCaps));
        bench(String.format("Device.capabilities EnumSet N=%d", REPS),
                () -> simulateListContains_cap(checks, new ArrayList<>(allCaps)),
                () -> simulateEnumSetContains(checks, enumSet),
                eListOps, eOps);

        System.out.println();
        System.out.println("VERDICT: signal-server CLEAN — no CWE-407 defects found.");
        System.out.println("=".repeat(80));

        // Sanity: O(n^2) ops >> O(n) ops
        assert sOps >= fOps * 100 : "UUID list scan should be >> set lookup at N=" + N;
        System.out.println("All assertions passed.");
    }
}