import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import tv.tivilux.nativeplayer.data.PlaybackBufferBudget;
import tv.tivilux.nativeplayer.data.VisibleCatalogCache;

/** Standalone JVM checks; these do not substitute for Android/device playback tests. */
public final class PerformancePolicyCheck {
    private static void check(boolean ok, String message) {
        if (!ok) throw new AssertionError(message);
    }

    public static void main(String[] args) {
        VisibleCatalogCache<Integer> cache = new VisibleCatalogCache<>();
        AtomicInteger calls = new AtomicInteger();
        List<Integer> source = new ArrayList<>();
        for (int i = 0; i < 50000; i++) source.add(i);
        VisibleCatalogCache.Filter<Integer> even = item -> {
            calls.incrementAndGet();
            return item % 2 == 0;
        };
        List<Integer> first = cache.get(source, 1, even);
        check(first.size() == 25000 && first.get(24999) == 49998, "complete ordered result");
        for (int i = 1; i < 300; i++) {
            check(cache.get(source, 1, even) == first, "same published input reuses result");
        }
        check(calls.get() == 50000, "cache hit performs no filtering");
        System.out.println("300 reads of 50,000 items: 50,000 filter calls; uncached path requires 15,000,000.");

        List<Integer> changed = cache.get(source, 2, item -> item < 3);
        check(changed.equals(Arrays.asList(0, 1, 2)), "visibility/profile revision invalidation");
        List<Integer> replacement = new ArrayList<>(Arrays.asList(8, 4, 6));
        check(cache.get(replacement, 2, item -> true).equals(replacement), "category/source replacement");
        calls.set(0);
        List<Integer> equalButNew = new ArrayList<>(replacement);
        cache.get(equalButNew, 2, even);
        check(calls.get() == 3, "equal new source must invalidate by identity");
        cache.clear();
        cache.get(equalButNew, 2, even);
        check(calls.get() == 6, "clear releases and invalidates entry");
        check(cache.get(new ArrayList<>(), 3, even).isEmpty(), "empty catalog");
        boolean immutable = false;
        try { first.add(1); } catch (UnsupportedOperationException expected) { immutable = true; }
        check(immutable, "cached output cannot be mutated");

        int mb = 1024 * 1024;
        for (int heap : new int[] {0, 64, 128, 192, 256, 512, 1024, Integer.MAX_VALUE}) {
            for (boolean lowRam : new boolean[] {false, true}) {
                int live = PlaybackBufferBudget.targetBytes(false, heap, lowRam);
                int vod = PlaybackBufferBudget.targetBytes(true, heap, lowRam);
                check(live >= 8 * mb && live <= (lowRam ? 12 : 24) * mb, "live budget bounds");
                check(vod >= 24 * mb && vod <= (lowRam ? 32 : 96) * mb, "VOD budget bounds");
            }
        }
        check(PlaybackBufferBudget.targetBytes(true, 128, true) == 32 * mb, "128 MiB VOD budget");
        check(PlaybackBufferBudget.targetBytes(false, 128, true) == 8 * mb, "128 MiB live budget");
        System.out.println("PASS: cache reuse/invalidation/order/completeness/clear/immutability; buffer policy bounds.");
    }
}
