# Task
Your task is to **build** a system that handles orders and **carries out additional calculations** like tax and shipping costs. **You need** to process multiple orders **asynchronously**, perform the **necessary calculations**, and display the total amount for each order once all **calculations** are finished.

Each order has a unique **identifier** and a **price** associated with it. **(InitMap class)**

The **ID** and their sums are stored in a `Map` within the `InitMap` **class**. The keys of this `Map` (which are the order **ID**) are the ones we loop through in the `processOrders()` **method**.

Fetching order data is done **asynchronously** and **returns** the order amount. This is handled by the `OrderService` **class**, specifically the `fetchOrderAmount(String orderId)` **method**.

**Tax** is calculated as **15%** of the order amount. This is managed by the `CalculationService` **class**, using the `calculateTax()` **method**.

Shipping cost is calculated as **10%** of the order amount. This is also handled by the `CalculationService` **class**, using the `calculateShipping()` **method**.

Your **main task** is to implement the logic step-by-step in the package `task` class `OrderProcessingExample` in the `processOrders()` method.

Note

**1. Receive the order amount asynchronously using the order service:** 

- Create a `CompletableFuture` object to fetch the order amount **asynchronously**;
- Call the `fetchOrderAmount()` method from `OrderService` passing the **order id**.


The `fetchOrderAmount()` method uses `CompletableFuture.supplyAsync()` to perform the task asynchronously and returns the order amount, by its id.

**2. After fetching the order amount, asynchronously calculate the **tax** using the calculation service:**
- Use `thenCompose()` to execute the task sequentially after getting the **order amount**. Call the `calculateTax()` method from `CalculationService` passing the **order amount**.

The `calculateTax()` method uses `CompletableFuture.supplyAsync()` to execute the task asynchronously and returns a **tax** equal to **15%** of the order amount.

**3. After receiving the order amount, asynchronously calculate the shipping cost using the calculate service:**

- Use `thenCompose()` to execute the task sequentially after receiving the order amount. Call the `calculateShipping` method from `CalculationService` passing the **order amount**.

The `calculateShipping()` method uses `CompletableFuture.supplyAsync()` to execute the task asynchronously and returns a **shipping cost** equal to **10%** of the order amount.

**4. Combine asynchronous tax and shipping cost calculations to get the total incremental cost:** 

- Use `thenCombine()` to combine two `CompletableFuture` results of tax and shipping to get the total additional cost **(tax + shipping cost)**.

**5. Combine the order amount and the total additional cost to get the total order amount:** 

- Use `thenCombine()` to combine the two `CompletableFuture` results of additional cost and total additional cost and total order amount to get the total order amount.

**6. After calculating the total, output it to the console:** 
- Use `thenAccept()` to process and output the result;
- After completing all calculations, output the **order total** to the console.

To **output the result** to the console, you can use this **pattern**:
```
System.out.println("Final total for " + orderId + ": " + finalTotal);
```

If you follow everything **correctly**, you will **get this output** to the console:

```
Final total for order2: 150.0
Final total for order1: 375.0
Final total for order3: 225.0
```

Once you are sure that everything is working, run the verification tests on the path `/src/test/java/OrderProcessingExampleTest.java`.

This course is tailored for those who want to expand their knowledge of multithreading and leverage its capabilities to build efficient, high-performance applications. You'll dive into essential concepts, practical techniques, and best practices in multithreading, empowering you to confidently address complex concurrency issues.

This section will delve into the foundational concepts of multithreading in Java, focusing on the creation and management of threads, and the use of synchronization techniques to avoid conflicts. You’ll also learn how to utilize essential keywords and methods to ensure the accurate and reliable execution of multithreaded programs, providing a solid understanding of how to handle concurrency effectively in your applications.

This section explores synchronized collections in Java, explaining their purpose and the common concurrency issues they are designed to solve. You’ll gain insights into how these collections work, why they are essential in multithreaded environments, and how they help ensure safe and consistent data manipulation when multiple threads access shared resources.

This section covers high-level synchronization mechanisms in Java, such as the use of Lock and Condition, semaphores, barriers, atomic variables, and thread pooling with Executors. Each topic is paired with practical exercises designed to reinforce your understanding and help you apply the theoretical knowledge to real-world scenarios.

This section explores fundamental multithreaded programming patterns and practices such as Producer-Consumer, Fork/Join, ThreadLocal, and asynchronous programming with CompletableFuture. You'll work through examples and see the practical outcomes of these approaches, gaining hands-on experience that will enable you to apply these techniques effectively in real-world applications.

Challenge: CompletableFuture

Challenge: CompletableFuture