package unit;

import java.util.*;

/**
 * Standalone unit test for otel-collector-0001: CWE-407.
 *
 * otel-collector-0001: pcommon.Map Put* methods — O(n) Get inside O(n) build loop
 *   slow() simulates Map construction via repeated PutStr, each doing a linear
 *         scan of all existing entries to check for duplicates: O(n²) total.
 *   fast() simulates Map construction via a native HashMap accumulator (O(1) put),
 *         then a single O(n) conversion to the slice representation: O(n) total.
 *   Assert: slowOps > fastOps * 10x for N=300 attributes.
 */
public class OtelCollectorTest {

    /** Simulates pcommon.Map backed by []KeyValue — PutStr calls Get (O(n) linear scan). */
    static long slowMapBuild(int N) {
        long ops = 0;
        // Underlying slice: list of (key, value) pairs
        List<String[]> slice = new ArrayList<>(N);
        for (int i = 0; i < N; i++) {
            String key = "attr_" + i;
            String val = "value_" + i;
            // m.Get(key) — linear scan of all existing entries (PutStr pattern)
            boolean found = false;
            for (String[] kv : slice) {
                ops++;
                if (kv[0].equals(key)) { found = true; break; }
            }
            if (!found) {
                slice.add(new String[]{key, val});
            }
        }
        return ops;
    }

    /**
     * Simulates bulk Map construction via a native map accumulator:
     * O(1) per put, O(n) final copy — the FromMap approach.
     */
    static long fastMapBuild(int N) {
        long ops = 0;
        Map<String, String> acc = new HashMap<>(N);
        for (int i = 0; i < N; i++) {
            ops++;  // O(1) hash put
            acc.put("attr_" + i, "value_" + i);
        }
        // O(n) conversion to sorted slice
        List<String> keys = new ArrayList<>(acc.keySet());
        Collections.sort(keys);
        List<String[]> slice = new ArrayList<>(keys.size());
        for (String k : keys) {
            ops++;
            slice.add(new String[]{k, acc.get(k)});
        }
        return ops;
    }

    static void testMapBuild() {
        int N = 300;  // attribute count
        long sOps = slowMapBuild(N);
        long fOps = fastMapBuild(N);

        int Nx = 10;
        boolean pass = sOps > fOps * Nx;
        System.out.printf("otel-collector-0001 [N=%d]: slow=%d fast=%d ratio=%.1fx — %s%n",
                N, sOps, fOps, (double) sOps / fOps, pass ? "PASS" : "FAIL");
        if (!pass) throw new AssertionError("otel-collector-0001 FAIL: slow=" + sOps + " fast=" + fOps);
    }

    public static void main(String[] args) {
        testMapBuild();
        System.out.println("1/1 PASS");
    }
}