import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class HttpRepresentationDemo {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 16);
        ExecutorService executor = Executors.newFixedThreadPool(2);
        AtomicInteger requests = new AtomicInteger();
        server.setExecutor(executor);
        server.createContext("/item", exchange -> respond(exchange, requests));
        server.start();
        try {
            URI uri = URI.create("http://127.0.0.1:" + server.getAddress().getPort() + "/item");
            HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1)
                    .connectTimeout(Duration.ofSeconds(2)).build();
            HttpResponse<String> first = send(client, uri, "en", null);
            HttpResponse<String> repeated = send(client, uri, "en", null);
            if (first.statusCode() != 200 || repeated.statusCode() != 200 || requests.get() != 2) {
                throw new IllegalStateException("ordinary requests unexpectedly cached");
            }
            String etag = first.headers().firstValue("ETag").orElseThrow();
            HttpResponse<String> unchanged = send(client, uri, "en", etag);
            if (unchanged.statusCode() != 304 || !unchanged.body().isEmpty()) {
                throw new IllegalStateException("conditional response mismatch");
            }
            HttpResponse<String> variant = send(client, uri, "zh", etag);
            if (variant.statusCode() != 200 || !variant.body().equals("你好\n")
                    || variant.headers().firstValue("ETag").orElseThrow().equals(etag)) {
                throw new IllegalStateException("representation mixed");
            }
            if (!first.headers().firstValue("Vary").orElseThrow().equals("Accept-Language")) {
                throw new IllegalStateException("Vary missing");
            }
            System.out.println("actual version=" + first.version() + " origin requests=" + requests.get());
            System.out.println("repeated ordinary GET reaches origin; explicit validator yields empty 304: PASS");
            System.out.println("language variants have different body and ETag; Vary present: PASS");
        } finally {
            server.stop(0);
            executor.shutdownNow();
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) throw new IllegalStateException("executor not stopped");
        }
    }

    private static HttpResponse<String> send(HttpClient client, URI uri, String language, String etag) throws Exception {
        HttpRequest.Builder request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(3))
                .header("Accept-Language", language).GET();
        if (etag != null) request.header("If-None-Match", etag);
        return client.send(request.build(), HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
    }

    private static void respond(HttpExchange exchange, AtomicInteger requests) throws IOException {
        try (exchange) {
            requests.incrementAndGet();
            boolean chinese = "zh".equals(exchange.getRequestHeaders().getFirst("Accept-Language"));
            byte[] body = (chinese ? "你好\n" : "hello\n").getBytes(StandardCharsets.UTF_8);
            String etag = chinese ? "\"zh-v1\"" : "\"en-v1\"";
            exchange.getResponseHeaders().set("Content-Type", "text/plain; charset=utf-8");
            exchange.getResponseHeaders().set("Cache-Control", "public, max-age=60");
            exchange.getResponseHeaders().set("Vary", "Accept-Language");
            exchange.getResponseHeaders().set("ETag", etag);
            System.out.println("origin request=" + requests.get() + " peer=" + exchange.getRemoteAddress());
            if (etag.equals(exchange.getRequestHeaders().getFirst("If-None-Match"))) {
                exchange.sendResponseHeaders(304, -1);
            } else {
                exchange.sendResponseHeaders(200, body.length);
                exchange.getResponseBody().write(body);
            }
        }
    }
}
