package unit;

import java.util.*;

/**
 * Perl5Test -- CWE-407 benchmark for perl5-0001
 *
 * Models S_pad_findlex() O(M*N) linear pad-name scan per lexical lookup
 * vs. O(M) HashMap-based offset index.
 *
 * Real code (pad.c ~1168):
 *   for (offset = PadnamelistMAXNAMED(names); offset > 0; offset--)   // O(N)
 *       if (PadnameLEN(name)==namelen && memEQ(PadnamePV(name), namepv, namelen))
 *           ...
 *
 * Fix: hash map (padname_string -> pad_offset) in PADNAMELIST, O(1) lookup.
 */
public class Perl5Test {

    static void bench(String label, Runnable slow, Runnable fast, long sOps, long fOps) {
        slow.run(); fast.run();
        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 speedup = fMs > 0 ? (double) sMs / fMs : 0;
        System.out.printf("  %-54s  slow:%4dms (%,d ops)  fast:%4dms (%,d ops)  speedup:%.0fx%n",
                label, sMs, sOps, fMs, fOps, speedup);
    }

    static long slowPadFindLex(int N, int M) {
        String[] padNames = new String[N];
        for (int i = 0; i < N; i++) padNames[i] = "$var_" + i;
        String target = padNames[N / 2]; // middle of pad
        long ops = 0;
        for (int ref = 0; ref < M; ref++) {
            // reverse scan from MAXNAMED down to 0
            for (int offset = N - 1; offset >= 0; offset--) {
                ops++;
                if (padNames[offset].equals(target)) break;
            }
        }
        return ops;
    }

    static long fastPadFindLex(int N, int M) {
        Map<String, Integer> padIndex = new HashMap<>(N * 2);
        for (int i = 0; i < N; i++) padIndex.put("$var_" + i, i);
        String target = "$var_" + (N / 2);
        long ops = 0;
        for (int ref = 0; ref < M; ref++) {
            ops++; // O(1) map lookup
            padIndex.get(target);
        }
        return ops;
    }

    public static void main(String[] args) {
        System.out.println("Perl5Test -- perl5-0001: S_pad_findlex() linear scan -> HashMap index");
        System.out.println();
        System.out.println("  [pad.c ~1168 S_pad_findlex() -- O(N) per lexical variable lookup]");
        int[][] cases = {{100, 1000, 50000}, {300, 2000, 20000}, {500, 5000, 5000}};
        for (int[] c : cases) {
            int N = c[0], M = c[1], R = c[2];
            bench(
                String.format("N=%d pad vars, M=%d refs/unit, %,d compile units", N, M, R),
                () -> { for (int i = 0; i < R; i++) slowPadFindLex(N, M); },
                () -> { for (int i = 0; i < R; i++) fastPadFindLex(N, M); },
                (long) N * M * R,
                (long) M * R
            );
        }
        System.out.println();
        System.out.println("Defect : pad.c ~1168 -- S_pad_findlex() O(N) reverse scan per lexical reference");
        System.out.println("Fix    : PADNAMELIST hash map (padname_string -> offset) -- O(1) lookup");
        System.out.println("Ticket : perl5-0001-pad-findlex-linear-scan-per-lexical-lookup.md");
        System.out.println();
        int pass = 0;
        long s0 = slowPadFindLex(500, 5000), f0 = fastPadFindLex(500, 5000);
        assert s0 > f0 * 50 : "perl5-0001 expected >50x; slow=" + s0 + " fast=" + f0; pass++;
        System.out.printf("%d/1 PASS -- perl5-0001: CWE-407 in Perl5 S_pad_findlex() lexical lookup%n", pass);
        System.out.printf("Hotpath: every variable reference at compile time in ORM/template-heavy code%n");
    }
}