package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import org.junit.jupiter.api.Test;

class LessonTest {

  @Test
  void boundedAndReleased() throws Exception {
    var work = new BoundedWork();
    var active = new AtomicInteger();
    var maximum = new AtomicInteger();
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      var tasks = new ArrayList<Future<?>>();
      for (int i = 0; i < 20; i++) tasks.add(
        executor.submit(() -> {
          try {
            work.run(() -> {
              int n = active.incrementAndGet();
              maximum.accumulateAndGet(n, Math::max);
              try {
                Thread.sleep(5);
              } finally {
                active.decrementAndGet();
              }
              return null;
            });
          } catch (Exception e) {
            throw new RuntimeException(e);
          }
        })
      );
      for (var task : tasks) task.get(5, TimeUnit.SECONDS);
    }
    assertTrue(maximum.get() <= 2);
    assertEquals(2, work.available());
  }

  @Test
  void cancellationStopsWaitingTask() throws Exception {
    var started = new CountDownLatch(1);
    var stopped = new CountDownLatch(1);
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      var future = executor.submit(() -> {
        started.countDown();
        try {
          Thread.sleep(60000);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        } finally {
          stopped.countDown();
        }
      });
      assertTrue(started.await(2, TimeUnit.SECONDS));
      assertTrue(future.cancel(true));
      assertTrue(stopped.await(2, TimeUnit.SECONDS));
    }
  }
}
