package org.ammbra.advent;

public class Wrapup {

	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

package org.ammbra.advent; 

class Wrapup {

    void main() { System.out.println("Hello, World!");}
}

class Wrapup implements HttpHandler {

	void main() throws IOException {
		var server = HttpServer.create(
				new InetSocketAddress("", 8081), 0);
		var address = server.getAddress();
		server.createContext("/", new Wrapup());
		server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
		server.start();
		System.out.printf("http://%s:%d%n",
				address.getHostString(), address.getPort());
	}

	@Override
	public void handle(HttpExchange exchange)
			throws IOException {

		int statusCode = 200;

		String requestMethod = exchange.getRequestMethod();
		if (!"POST".equalsIgnoreCase(requestMethod)) {
			statusCode = 400;
		}

		// Get the request body input stream
		InputStream reqBody = exchange.getRequestBody();

		// Read JSON from the input stream
		JSONObject req = RequestConverter.asJSONObject(reqBody);

		String sender = req.optString("sender");
		String receiver = req.optString("receiver");
		String message = req.optString("celebration");
		String json = "{'receiver':'" + receiver
				+ "', 'sender':'" + sender
				+ "','message':'" + message + "'}";

		exchange.sendResponseHeaders(statusCode, 0);
		try (var stream = exchange.getResponseBody()) {
			stream.write(json.getBytes());
		}
	}
}

package org.ammbra.advent.surprise;

import org.json.JSONObject;

public sealed interface Intention
       permits Coupon, Experience, Present, Postcard {

    JSONObject asJSON();
}

package org.ammbra.advent.surprise;

import org.json.JSONObject;

public record Gift(Postcard postcard, Intention intention) {

    public JSONObject merge(String option) {
       JSONObject intentionJSON = intention.asJSON();
       JSONObject postcardJSON = postcard.asJSON();
       return postcardJSON.put(option, intentionJSON);
    }
}

package org.ammbra.advent.surprise;

import org.json.JSONObject;

public sealed interface Intention
       permits Coupon, Experience, Present, Postcard {

    StringTemplate.Processor<JSONObject, RuntimeException> JSON = StringTemplate.Processor.of(
          (StringTemplate st) -> new JSONObject(st.interpolate())
    );

    JSONObject asJSON();
}

package org.ammbra.advent.surprise;

import org.json.JSONObject;
import java.time.LocalDate;
import java.util.Currency;

public record Coupon(double price, LocalDate expiringOn, Currency currency)
       implements Intention {

	public Coupon {
		Objects.requireNonNull(currency, "currency is required");
		if (price < 0) {
			throw new IllegalArgumentException("Price of an item cannot be negative");
		}
	}

    @Override
    public JSONObject asJSON() {
       return JSON. """
             {
                 "currency": "\{currency}",
                 "expiresOn" : "\{ expiringOn}",
                 "cost": "\{price}"
             }
             """ ;
    }
}

package org.ammbra.advent.surprise;

import org.json.JSONObject;
import java.util.Currency;

public record Present(double itemPrice, double boxPrice, Currency currency) 
        implements Intention {

	public Present {
		Objects.requireNonNull(currency, "currency is required");
		if (itemPrice < 0) {
			throw new IllegalArgumentException("Price of an item cannot be negative");
		} else if (boxPrice < 0) {
			throw new IllegalArgumentException("Price of the box cannot be negative");
		}
	}

    @Override
    public JSONObject asJSON() {

       return JSON. """
             {
                 "currency": "\{currency}",
                 "boxPrice": "\{boxPrice}",
                 "packaged" : "\{ boxPrice > 0.0}",
                 "cost": "\{(boxPrice > 0.0) ? itemPrice + boxPrice : itemPrice}"
             }
             """ ;
    }
}

package org.ammbra.advent.request;

import org.ammbra.advent.surprise.Celebration;

public record RequestData(String sender, String receiver,
                     Celebration celebration, Choice choice, 
                     double itemPrice, double boxPrice) {

    private RequestData(Builder builder) {
       this(builder.sender, builder.receiver,
             builder.celebration, builder.choice,
             builder.itemPrice, builder.boxPrice);
    }

    public static class Builder {
       private String sender;
       private String receiver;
       private Celebration celebration;
       private Choice choice;
       private double itemPrice;
       private double boxPrice;

       public Builder sender(String sender) {
          this.sender = sender;
          return this;
       }

       public Builder receiver(String receiver) {
          this.receiver = receiver;
          return this;
       }

       public Builder celebration(Celebration celebration) {
          this.celebration = celebration;
          return this;
       }

       public Builder choice(Choice choice) {
          this.choice = choice;
          return this;
       }

       public Builder itemPrice(double itemPrice) {
          this.itemPrice = itemPrice;
          return this;
       }

       public Builder boxPrice(double boxPrice) {
          this.boxPrice = boxPrice;
          return this;
       }

       public RequestData build() throws IllegalStateException {
          return new RequestData(this);
       }
    }
}

@Override
public void handle(HttpExchange exchange) throws IOException {
    // ...

    // Get the request body input stream
    InputStream reqBody = exchange.getRequestBody();

    // Read JSON from the input stream
    JSONObject req = RequestConverter.asJSONObject(reqBody);
    RequestData data = RequestConverter.fromJSON(req);

// ... }

double price = data.itemPrice();
double boxPrice = data.boxPrice();
Choice choice = data.choice();
Intention intention = switch (choice) {
	case NONE -> new Coupon(0.0, null, Currency.getInstance("USD"));
	case COUPON -> {
		LocalDate localDate = LocalDateTime.now().plusYears(1).toLocalDate();
		yield new Coupon(data.itemPrice(), localDate, Currency.getInstance("USD"));
	}
	case EXPERIENCE -> new Experience(data.itemPrice(), Currency.getInstance("EUR"));
	case PRESENT -> new Present(data.itemPrice(), data.boxPrice(), Currency.getInstance("RON"));
};

Postcard postcard = new Postcard(data.sender(), data.receiver(), data.celebration());
Gift gift = new Gift(postcard, intention);

JSONObject json = switch (gift) {
    case Gift(Postcard p1, Postcard p2) -> {
       String message = "You cannot send two postcards!";
       throw new UnsupportedOperationException(message);
    }
    case Gift(Postcard p, Coupon c)
          when (c.price() == 0.0) -> p.asJSON();
    case Gift(Postcard p, Coupon c) -> {
       String option = choice.name().toLowerCase();
       yield gift.merge(option); 
    }
    case Gift(Postcard p, Experience e) -> {
       String option = choice.name().toLowerCase();
       yield gift.merge(option); 
    }
    case Gift(Postcard p, Present pr) -> {
       String option = choice.name().toLowerCase(); 
       yield gift.merge(option);
    }
};

Gift gift = new Gift(postcard, intention);

JSONObject json = switch (gift) {
    case Gift(Postcard _, Postcard _) -> {
       String message = "You cannot send two postcards!";
       throw new UnsupportedOperationException(message);
    }

    case Gift(Postcard p, Coupon c)
          when (c.price() == 0.0) -> p.asJSON();

    case Gift(_, Coupon _), Gift(_, Experience _), 
          Gift(_, Present _) -> {
       String option = choice.name().toLowerCase();
       yield gift.merge(option);
    }
};