// UNIT TEST: Tests OrderService in complete isolation.
// No Spring context, no database, no HTTP — dependencies mocked.
@ExtendWith(MockitoExtension.class)
@DisplayName("OrderService — unit tests")
class OrderServiceUnitTest {

    @Mock private OrderRepository orderRepository; // mocked
    @Mock private PaymentGateway  paymentGateway;  // mocked
    @Mock private EmailService    emailService;    // mocked
    @InjectMocks private OrderService orderService; // real class under test

    @Test
    @Tag("unit")
    @DisplayName("Placing a valid order saves it and sends a confirmation email")
    void placingValidOrderSavesItAndSendsEmail() {
        // Arrange: define mock behaviour
        Order savedOrder = new Order(1L, "[email protected]", 49.99, OrderStatus.CONFIRMED);
        when(paymentGateway.authorise(anyDouble())).thenReturn("AUTH-001");
        when(orderRepository.save(any())).thenReturn(savedOrder);

        // Act
        Order result = orderService.place("[email protected]", 49.99);

        // Assert behaviour AND interactions
        assertEquals(OrderStatus.CONFIRMED, result.getStatus());
        verify(emailService, times(1)).sendConfirmation("[email protected]");
    }

    @Test
    @Tag("unit")
    @DisplayName("Payment gateway failure cancels order immediately")
    void paymentGatewayFailureCancelsOrder() {
        when(paymentGateway.authorise(anyDouble()))
            .thenThrow(new PaymentDeclinedException("Card declined"));

        assertThrows(PaymentDeclinedException.class,
            () -> orderService.place("[email protected]", 49.99));

        // Repository must NOT be called if payment fails
        verifyNoInteractions(orderRepository, emailService);
    }
}

// INTEGRATION TEST: Tests the full web layer against a real controller, real service,
// and a real H2/Testcontainers database. External payment gateway is mocked.
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
@Tag("integration")
@DisplayName("Order API — integration tests")
class OrderApiIntegrationTest {

    @Container
    static final PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:16-alpine");

    @DynamicPropertySource
    static void configurePostgres(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url",      postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Autowired
    private TestRestTemplate restTemplate;

    // Mock the EXTERNAL payment gateway only — everything else is real
    @MockBean
    private PaymentGateway paymentGateway;

    @BeforeEach
    void stubPaymentGateway() {
        when(paymentGateway.authorise(anyDouble())).thenReturn("AUTH-999");
    }

    @Test
    @DisplayName("POST /orders creates order, saves to DB, returns 201")
    void postOrderCreatesOrderAndReturns201() {
        CreateOrderRequest request =
            new CreateOrderRequest("[email protected]", 99.99);

        ResponseEntity<OrderDto> response =
            restTemplate.postForEntity("/api/orders", request, OrderDto.class);

        // Verify HTTP layer
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        assertNotNull(response.getBody().getId());

        // Verify data was actually persisted (uses real DB)
        ResponseEntity<OrderDto> getResponse = restTemplate.getForEntity(
            "/api/orders/" + response.getBody().getId(), OrderDto.class);
        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
        assertEquals(OrderStatus.CONFIRMED, getResponse.getBody().getStatus());
    }
}

// E2E TEST: Verifies the complete checkout journey across all real services.
// Uses Docker Compose to start the entire system.
// No mocks — everything is real.
@Testcontainers
@Tag("e2e")
@DisplayName("Checkout — end-to-end journey tests")
class CheckoutE2ETest {

    @Container
    static DockerComposeContainer<?> system =
        new DockerComposeContainer<>(new File("docker-compose.test.yml"))
            .withExposedService("api-gateway", 8080);

    private String apiBaseUrl;

    @BeforeEach
    void setUp() {
        apiBaseUrl = "http://" +
            system.getServiceHost("api-gateway", 8080) + ":" +
            system.getServicePort("api-gateway", 8080);
    }

    @Test
    @DisplayName("Full checkout: browse product, add to cart, place order, confirm payment")
    void fullCheckoutJourney() {
        RestTemplate client = new RestTemplate();

        // Step 1: Browse product catalogue
        ProductDto product = client.getForObject(
            apiBaseUrl + "/api/products/LAPTOP-01", ProductDto.class);
        assertTrue(product.isInStock());

        // Step 2: Place order
        CreateOrderRequest order = new CreateOrderRequest("[email protected]", "LAPTOP-01", 1);
        ResponseEntity<OrderDto> orderResponse = client.postForEntity(
            apiBaseUrl + "/api/orders", order, OrderDto.class);
        assertEquals(HttpStatus.CREATED, orderResponse.getStatusCode());
        Long orderId = orderResponse.getBody().getId();

        // Step 3: Poll for async payment confirmation (event-driven)
        await().atMost(Duration.ofSeconds(15))
            .pollInterval(Duration.ofMillis(500))
            .untilAsserted(() -> {
                OrderDto updated = client.getForObject(
                    apiBaseUrl + "/api/orders/" + orderId, OrderDto.class);
                assertEquals(OrderStatus.PAYMENT_CONFIRMED, updated.getStatus());
            });
    }
}