// FLAKY: static counter shared across all test instances
private static int requestCounter = 0;

@Test
void firstRequestIncreasesCounterToOne() {
    service.processRequest();
    requestCounter++;
    assertEquals(1, requestCounter); // FLAKY if other tests also increment
}

// FIX: reset state before each test with @BeforeEach
private int requestCounter;  // instance field, NOT static

@BeforeEach
void resetCounter() {
    requestCounter = 0;  // fresh state for every test, guaranteed
    service.reset();     // also reset the service under test
}

@Test
void firstRequestIncreasesCounterToOne() {
    service.processRequest();
    requestCounter++;
    assertEquals(1, requestCounter); // always passes: counter starts at 0
}

// FLAKY: test depends on the current time
@Test
void orderCreatedTodayShouldBeActiveForSevenDays() {
    Order order = new Order(LocalDate.now()); // uses real clock
    // This fails if order.isActive() checks against LocalDate.now() and
    // the test runs exactly at midnight when the date rolls over
    assertTrue(order.isActiveUntil(LocalDate.now().plusDays(7)));
}

// FIX: inject a Clock and control time in tests
public class Order {
    private final LocalDate createdDate;
    private final Clock clock;

    public Order(LocalDate createdDate, Clock clock) {
        this.createdDate = createdDate;
        this.clock = clock;
    }

    public boolean isActive() {
        // Uses injected clock — controllable in tests
        return LocalDate.now(clock).isBefore(createdDate.plusDays(7));
    }
}

@Test
void orderIsActiveForSevenDaysAfterCreation() {
    // Fixed clock: always returns the same date — never flaky
    Clock fixedClock = Clock.fixed(Instant.parse("2026-01-15T12:00:00Z"), ZoneOffset.UTC);
    LocalDate orderDate = LocalDate.of(2026, 1, 15);
    Order order = new Order(orderDate, fixedClock);

    assertTrue(order.isActive(),  "Order created today should be active");
}

// FLAKY: Thread.sleep is never the right amount
@Test
void emailSentAfterOrderConfirmation() throws InterruptedException {
    orderService.confirmOrder(orderId);
    Thread.sleep(500); // Flaky: email might take 600ms on a slow CI server
    verify(emailService, times(1)).send(any());
}

// FIX: use Awaitility to poll with a timeout
import static org.awaitility.Awaitility.*;
import java.time.Duration;

@Test
void emailSentAfterOrderConfirmation() {
    orderService.confirmOrder(orderId);

    // Poll every 100ms for up to 5 seconds — passes as soon as condition is met
    // Fast on fast machines, resilient on slow CI servers
    await()
        .atMost(Duration.ofSeconds(5))
        .pollInterval(Duration.ofMillis(100))
        .untilAsserted(() ->
            verify(emailService, times(1)).send(any())
        );
}

// Awaitility Maven dependency
// <dependency>
//   <groupId>org.awaitility</groupId>
//   <artifactId>awaitility</artifactId>
//   <version>4.2.1</version>
//   <scope>test</scope>
// </dependency>

// FLAKY: hardcoded port may already be in use in parallel CI runs
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT,
                properties = "server.port=8080")  // FIXED port = collisions in CI
class OrderApiTest { }

// FIX: use RANDOM_PORT — Spring Boot picks a free port automatically
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class OrderApiTest {

    // @LocalServerPort injects the randomly chosen port
    @LocalServerPort
    private int serverPort;

    @Test
    void getOrderReturns200() {
        String url = "http://localhost:" + serverPort + "/api/orders/1";
        // Use the dynamic port — never conflicts
        ResponseEntity<OrderDto> response =
            new RestTemplate().getForEntity(url, OrderDto.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
    }
}

// FLAKY: two parallel tests write to the same file path
@Test
void exportOrdersToCsv() throws IOException {
    orderExporter.exportTo("/tmp/orders.csv"); // fixed path = collision with parallel tests
    assertTrue(Files.exists(Path.of("/tmp/orders.csv")));
}

// FIX: use @TempDir for unique, test-isolated directories
@Test
void exportOrdersToCsv(@TempDir Path tempDir) throws IOException {
    Path outputFile = tempDir.resolve("orders.csv"); // unique per test
    orderExporter.exportTo(outputFile.toString());

    assertTrue(Files.exists(outputFile),
        "Export file should be created at: " + outputFile);
    assertTrue(Files.size(outputFile) > 0,
        "Exported file should not be empty");
}

// FLAKY: test assumes data left by a previous test
@Test
void queryingAllOrdersReturnsFiveItems() {
    // Assumes previous test inserted 4 orders, this test inserts 1 more
    orderRepository.save(new Order(null, "[email protected]", 49.99));
    assertEquals(5, orderRepository.count()); // depends on execution order!
}

// FIX: use @Transactional for auto-rollback, or clean up explicitly
@DataJpaTest  // @DataJpaTest already wraps each test in a rollback transaction
class OrderRepositoryTest {

    @Autowired private OrderRepository orderRepository;

    @Test
    void queryingAllOrdersAfterInsertsReturnsCorrectCount() {
        // Arrange: insert OWN data — do not rely on other tests
        orderRepository.saveAll(List.of(
            new Order(null, "[email protected]", 10.0),
            new Order(null, "[email protected]", 20.0),
            new Order(null, "[email protected]", 30.0)
        ));

        // Assert against KNOWN count, not assumed count
        assertEquals(3, orderRepository.count(),
            "Should have exactly 3 orders inserted by this test");
        // Transaction rolls back after this test — no leftover data
    }
}