import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;

/**
 * Java 17 source-file lab for reasoning about idempotent REST write handling.
 * Run with: java IdempotentOrderServiceLab.java
 */
public class IdempotentOrderServiceLab {
    record OrderRequest(String item, int quantity) {}
    record OrderResponse(String orderId, String status) {}
    record StoredOrder(OrderRequest request, OrderResponse response) {}

    static final class OrderService {
        private final Map<String, StoredOrder> ordersByKey = new LinkedHashMap<>();
        private int nextOrderNumber = 1;

        synchronized OrderResponse create(String idempotencyKey, OrderRequest request) {
            if (idempotencyKey == null || idempotencyKey.isBlank()) {
                throw new IllegalArgumentException("idempotency key is required");
            }
            Objects.requireNonNull(request, "request is required");
            if (request.item() == null || request.item().isBlank() || request.quantity() < 1) {
                throw new IllegalArgumentException("item and positive quantity are required");
            }

            StoredOrder existing = ordersByKey.get(idempotencyKey);
            if (existing != null) {
                if (!existing.request().equals(request)) {
                    throw new IllegalStateException("idempotency key reused with a different payload");
                }
                return existing.response();
            }

            OrderResponse response = new OrderResponse(
                "ORD-%03d".formatted(nextOrderNumber++),
                "CREATED"
            );
            ordersByKey.put(idempotencyKey, new StoredOrder(request, response));
            return response;
        }

        int createdOrderCount() {
            return ordersByKey.size();
        }
    }

    public static void main(String[] args) {
        OrderService service = new OrderService();
        OrderRequest firstPayload = new OrderRequest("Java backend workbook", 1);

        OrderResponse first = service.create("checkout-101", firstPayload);
        OrderResponse retry = service.create("checkout-101", firstPayload);
        require(first.equals(retry), "same key and payload must return the stored response");
        require(service.createdOrderCount() == 1, "retry must not create a second order");
        System.out.println("PASS: same idempotency key returns the same order");

        boolean conflictRejected = false;
        try {
            service.create("checkout-101", new OrderRequest("Java backend workbook", 2));
        } catch (IllegalStateException expected) {
            conflictRejected = true;
        }
        require(conflictRejected, "same key with a different payload must be rejected");
        System.out.println("PASS: conflicting payload is rejected");

        OrderResponse second = service.create(
            "checkout-102",
            new OrderRequest("Spring Boot API workbook", 1)
        );
        require(!first.orderId().equals(second.orderId()), "new key must create a new order");
        require(service.createdOrderCount() == 2, "exactly two orders should exist");
        System.out.println("PASS: a new key creates a new order");
        System.out.println("SUMMARY: createdOrders=" + service.createdOrderCount());
    }

    private static void require(boolean condition, String message) {
        if (!condition) {
            throw new AssertionError(message);
        }
    }
}