import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public final class StockExercise {
    static final class Stock {
        private int available;
        Stock(int initial) {
            if (initial < 0) throw new IllegalArgumentException("negative initial stock");
            available = initial;
        }
        synchronized boolean reserve(Integer quantity) {
            if (quantity == null || quantity <= 0)
                throw new IllegalArgumentException("positive quantity required");
            if (available < quantity) return false;
            available -= quantity;
            return true;
        }
        synchronized int available() { return available; }
    }
    static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
    }
    static void rejects(Runnable action) {
        try { action.run(); throw new AssertionError("exception expected"); }
        catch (IllegalArgumentException expected) { /* expected */ }
    }
    // Deliberately flawed: safe separate methods do not make a safe operation.
    static final class BrokenStock {
        private int available = 1;
        synchronized boolean hasOne() { return available >= 1; }
        synchronized void takeOne() { available--; }
        synchronized int available() { return available; }
        boolean reserve(CyclicBarrier barrier) throws Exception {
            if (!hasOne()) return false;
            barrier.await(5, TimeUnit.SECONDS);
            takeOne();
            return true;
        }
    }
    public static void main(String[] args) throws Exception {
        rejects(() -> new Stock(-1));
        Stock s = new Stock(3);
        rejects(() -> s.reserve(null));
        rejects(() -> s.reserve(0));
        rejects(() -> s.reserve(-1));
        check(s.available() == 3, "invalid input changed stock");
        check(!s.reserve(4), "oversized request accepted");
        check(s.reserve(3) && !s.reserve(1) && s.available() == 0, "boundary");
        ExecutorService pool = Executors.newFixedThreadPool(16);
        try {
            for (int round = 0; round < 25; round++) {
                Stock concurrent = new Stock(30);
                List<Future<Boolean>> results = new ArrayList<>();
                for (int i = 0; i < 200; i++)
                    results.add(pool.submit(() -> concurrent.reserve(1)));
                int accepted = 0;
                for (Future<Boolean> f : results) if (f.get(10, TimeUnit.SECONDS)) accepted++;
                check(accepted == 30 && concurrent.available() == 0, "concurrent invariant");
            }
            BrokenStock broken = new BrokenStock();
            CyclicBarrier bothChecked = new CyclicBarrier(2);
            Future<Boolean> a = pool.submit(() -> broken.reserve(bothChecked));
            Future<Boolean> b = pool.submit(() -> broken.reserve(bothChecked));
            check(a.get(10, TimeUnit.SECONDS) && b.get(10, TimeUnit.SECONDS), "broken setup");
            check(broken.available() == -1, "counterexample missing");
            System.out.println("PASS: null/zero/negative/too-large/exact-stock; 25 rounds x 200 requests = 30 accepted per round, stock 0; broken version: 2 accepted, stock -1");
        } finally { pool.shutdownNow(); }
    }
}
