From fe950d08f03fb9b155cce02c287e538da97a2727 Mon Sep 17 00:00:00 2001
From: GustavH <gkhaavik@gmail.com>
Date: Mon, 20 Jan 2025 12:04:18 +0100
Subject: [PATCH 1/2] adding mobilepay capture (not tested)

---
 .../api/requests/CapturePaymentRequest.java   |  4 +++
 .../controller/PaymentController.java         | 12 +++++++
 .../mobilepay/MobilePayService.java           | 33 +++++++++++++++++++
 .../commercify/service/PaymentService.java    | 23 +++++++++++++
 4 files changed, 72 insertions(+)
 create mode 100644 src/main/java/com/zenfulcode/commercify/commercify/api/requests/CapturePaymentRequest.java

diff --git a/src/main/java/com/zenfulcode/commercify/commercify/api/requests/CapturePaymentRequest.java b/src/main/java/com/zenfulcode/commercify/commercify/api/requests/CapturePaymentRequest.java
new file mode 100644
index 0000000..8ea9d3f
--- /dev/null
+++ b/src/main/java/com/zenfulcode/commercify/commercify/api/requests/CapturePaymentRequest.java
@@ -0,0 +1,4 @@
+package com.zenfulcode.commercify.commercify.api.requests;
+
+public record CapturePaymentRequest(double captureAmount, boolean isPartialCapture) {
+}
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java b/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java
index 3fb7f51..155c36a 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java
@@ -1,6 +1,7 @@
 package com.zenfulcode.commercify.commercify.controller;
 
 import com.zenfulcode.commercify.commercify.PaymentStatus;
+import com.zenfulcode.commercify.commercify.api.requests.CapturePaymentRequest;
 import com.zenfulcode.commercify.commercify.service.PaymentService;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -35,4 +36,15 @@ public ResponseEntity<PaymentStatus> getPaymentStatus(@PathVariable Long orderId
         PaymentStatus status = paymentService.getPaymentStatus(orderId);
         return ResponseEntity.ok(status);
     }
+
+    @PostMapping("/{paymentId}/capture")
+    public ResponseEntity<String> capturePayment(@PathVariable Long paymentId, @RequestBody CapturePaymentRequest request) {
+        try {
+            paymentService.capturePayment(paymentId, request.captureAmount(), request.isPartialCapture());
+            return ResponseEntity.ok("Payment captured successfully");
+        } catch (Exception e) {
+            log.error("Error capturing payment", e);
+            return ResponseEntity.badRequest().body("Error capturing payment");
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java b/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java
index aafa1d2..858161c 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java
@@ -4,6 +4,7 @@
 import com.zenfulcode.commercify.commercify.PaymentStatus;
 import com.zenfulcode.commercify.commercify.api.requests.PaymentRequest;
 import com.zenfulcode.commercify.commercify.api.requests.WebhookPayload;
+import com.zenfulcode.commercify.commercify.api.requests.products.PriceRequest;
 import com.zenfulcode.commercify.commercify.api.responses.PaymentResponse;
 import com.zenfulcode.commercify.commercify.entity.OrderEntity;
 import com.zenfulcode.commercify.commercify.entity.PaymentEntity;
@@ -348,6 +349,38 @@ private String getWebhookSecret() {
                 .map(WebhookConfigEntity::getWebhookSecret)
                 .orElseThrow(() -> new PaymentProcessingException("Webhook secret not found", null));
     }
+
+    public void capturePayment(String mobilePayReference, PriceRequest captureAmount) {
+        PaymentEntity payment = paymentRepository.findByMobilePayReference(mobilePayReference)
+                .orElseThrow(() -> new PaymentProcessingException("Payment not found", null));
+
+        HttpHeaders headers = mobilePayRequestHeaders();
+
+        Map<String, Object> request = new HashMap<>();
+        request.put("modificationAmount", new MobilePayPrice(Math.round(captureAmount.amount() * 100), captureAmount.currency()));
+
+        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(request, headers);
+
+        try {
+            restTemplate.exchange(
+                    apiUrl + "/epayment/v1/payments/" + mobilePayReference + "/capture",
+                    HttpMethod.POST,
+                    entity,
+                    Object.class);
+
+            payment.setStatus(PaymentStatus.PAID);
+            paymentRepository.save(payment);
+        } catch (Exception e) {
+            log.error("Error capturing MobilePay payment: {}", e.getMessage());
+            throw new PaymentProcessingException("Failed to capture MobilePay payment", e);
+        }
+    }
+}
+
+record MobilePayPrice(
+        long value,
+        String currency
+) {
 }
 
 record MobilePayCheckoutResponse(
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java b/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java
index 1254c34..330b5c8 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java
@@ -1,8 +1,10 @@
 package com.zenfulcode.commercify.commercify.service;
 
 import com.zenfulcode.commercify.commercify.PaymentStatus;
+import com.zenfulcode.commercify.commercify.api.requests.products.PriceRequest;
 import com.zenfulcode.commercify.commercify.dto.OrderDetailsDTO;
 import com.zenfulcode.commercify.commercify.entity.PaymentEntity;
+import com.zenfulcode.commercify.commercify.integration.mobilepay.MobilePayService;
 import com.zenfulcode.commercify.commercify.repository.PaymentRepository;
 import com.zenfulcode.commercify.commercify.service.email.EmailService;
 import com.zenfulcode.commercify.commercify.service.order.OrderService;
@@ -19,6 +21,7 @@ public class PaymentService {
     private final PaymentRepository paymentRepository;
     private final EmailService emailService;
     private final OrderService orderService;
+    private final MobilePayService mobilePayService;
 
     @Transactional
     public void handlePaymentStatusUpdate(Long orderId, PaymentStatus newStatus) {
@@ -53,4 +56,24 @@ public PaymentStatus getPaymentStatus(Long orderId) {
                 .map(PaymentEntity::getStatus)
                 .orElse(PaymentStatus.NOT_FOUND);
     }
+
+    public void capturePayment(Long paymentId, double captureAmount, boolean isPartialCapture) {
+        PaymentEntity payment = paymentRepository.findById(paymentId)
+                .orElseThrow(() -> new RuntimeException("Payment not found: " + paymentId));
+
+        OrderDetailsDTO order = orderService.getOrderById(payment.getOrderId());
+
+        double capturingAmount = isPartialCapture ? captureAmount : payment.getTotalAmount();
+
+        PriceRequest priceRequest = new PriceRequest(order.getOrder().getCurrency(), capturingAmount);
+
+        // Capture payment
+        if (payment.getMobilePayReference() != null) {
+            mobilePayService.capturePayment(payment.getMobilePayReference(), priceRequest);
+        }
+
+        // Update payment status
+        payment.setStatus(PaymentStatus.PAID);
+        paymentRepository.save(payment);
+    }
 }
\ No newline at end of file

From 97aee6d7efa3902e64c183bd72b63b6889bab451 Mon Sep 17 00:00:00 2001
From: GustavH <gkhaavik@gmail.com>
Date: Mon, 20 Jan 2025 20:38:38 +0100
Subject: [PATCH 2/2] fixing order confirmation not being sent refactoring som
 questionable stuff

---
 .../commercify/commercify/PaymentStatus.java  |   2 +-
 .../controller/PaymentController.java         |  11 +-
 .../commercify/commercify/dto/OrderDTO.java   |   4 +
 .../commercify/dto/OrderDetailsDTO.java       |   4 +
 .../commercify/flow/OrderStateFlow.java       |   3 +-
 .../mobilepay/MobilePayController.java        |   2 +-
 .../mobilepay/MobilePayService.java           | 120 ++++++++---
 .../commercify/service/PaymentService.java    |  23 +-
 .../service/email/EmailService.java           |  19 +-
 .../service/order/OrderValidationService.java |   1 +
 src/main/resources/application.properties     |   1 +
 .../new-order-notification-email.html         |  12 +-
 .../templates/order-confirmation-email.html   |  12 +-
 .../commercify/flow/OrderStateFlowTest.java   |   6 +-
 .../mobilepay/MobilePayServiceTest.java       | 165 ---------------
 .../service/PaymentServiceTest.java           | 200 ++++++++++--------
 16 files changed, 251 insertions(+), 334 deletions(-)
 delete mode 100644 src/test/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayServiceTest.java

diff --git a/src/main/java/com/zenfulcode/commercify/commercify/PaymentStatus.java b/src/main/java/com/zenfulcode/commercify/commercify/PaymentStatus.java
index 49d2cdb..dc368ae 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/PaymentStatus.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/PaymentStatus.java
@@ -8,5 +8,5 @@ public enum PaymentStatus {
     REFUNDED,
     NOT_FOUND,
     TERMINATED,
-    EXPIRED
+    CAPTURED, EXPIRED
 }
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java b/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java
index 155c36a..5484f64 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/controller/PaymentController.java
@@ -2,7 +2,7 @@
 
 import com.zenfulcode.commercify.commercify.PaymentStatus;
 import com.zenfulcode.commercify.commercify.api.requests.CapturePaymentRequest;
-import com.zenfulcode.commercify.commercify.service.PaymentService;
+import com.zenfulcode.commercify.commercify.integration.mobilepay.MobilePayService;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
@@ -15,7 +15,7 @@
 @AllArgsConstructor
 @Slf4j
 public class PaymentController {
-    private final PaymentService paymentService;
+    private final MobilePayService mobilePayService;
 
     @PostMapping("/{orderId}/status")
     @PreAuthorize("hasRole('ADMIN')")
@@ -23,7 +23,7 @@ public ResponseEntity<String> updatePaymentStatus(
             @PathVariable Long orderId,
             @RequestParam PaymentStatus status) {
         try {
-            paymentService.handlePaymentStatusUpdate(orderId, status);
+            mobilePayService.handlePaymentStatusUpdate(orderId, status);
             return ResponseEntity.ok("Payment status updated successfully");
         } catch (Exception e) {
             log.error("Error updating payment status", e);
@@ -33,14 +33,15 @@ public ResponseEntity<String> updatePaymentStatus(
 
     @GetMapping("/{orderId}/status")
     public ResponseEntity<PaymentStatus> getPaymentStatus(@PathVariable Long orderId) {
-        PaymentStatus status = paymentService.getPaymentStatus(orderId);
+        PaymentStatus status = mobilePayService.getPaymentStatus(orderId);
         return ResponseEntity.ok(status);
     }
 
+    @PreAuthorize("hasRole('ADMIN')")
     @PostMapping("/{paymentId}/capture")
     public ResponseEntity<String> capturePayment(@PathVariable Long paymentId, @RequestBody CapturePaymentRequest request) {
         try {
-            paymentService.capturePayment(paymentId, request.captureAmount(), request.isPartialCapture());
+            mobilePayService.capturePayment(paymentId, request.captureAmount(), request.isPartialCapture());
             return ResponseEntity.ok("Payment captured successfully");
         } catch (Exception e) {
             log.error("Error capturing payment", e);
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDTO.java b/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDTO.java
index 0b257cc..34508d9 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDTO.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDTO.java
@@ -21,6 +21,10 @@ public class OrderDTO {
     private Instant createdAt;
     private Instant updatedAt;
 
+    public OrderDTO() {
+
+    }
+
     public double getTotal() {
         return subTotal + shippingCost;
     }
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDetailsDTO.java b/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDetailsDTO.java
index 36330b7..c3f1d61 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDetailsDTO.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/dto/OrderDetailsDTO.java
@@ -15,4 +15,8 @@ public class OrderDetailsDTO {
     private CustomerDetailsDTO customerDetails;
     private AddressDTO shippingAddress;
     private AddressDTO billingAddress;
+
+    public OrderDetailsDTO() {
+
+    }
 }
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlow.java b/src/main/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlow.java
index 8e55b10..2d8bbaf 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlow.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlow.java
@@ -22,7 +22,8 @@ public OrderStateFlow() {
         // Payment received -> Processing or Cancelled
         validTransitions.put(OrderStatus.PAID, Set.of(
                 OrderStatus.SHIPPED,
-                OrderStatus.CANCELLED
+                OrderStatus.CANCELLED,
+                OrderStatus.COMPLETED
         ));
 
         // Shipped -> Completed or Returned
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayController.java b/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayController.java
index ab766b6..166dcaa 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayController.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayController.java
@@ -41,7 +41,7 @@ public ResponseEntity<String> handleCallback(
         try {
             // First authenticate the request with the raw string payload
             mobilePayService.authenticateRequest(date, contentSha256, authorization, body, request);
-            log.info("MP Webhook authenticated");
+            log.info("Mobilepay Webhook authenticated");
 
             // Convert the string payload to WebhookPayload object
             ObjectMapper objectMapper = new ObjectMapper();
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java b/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java
index 858161c..4e46fa1 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayService.java
@@ -6,23 +6,24 @@
 import com.zenfulcode.commercify.commercify.api.requests.WebhookPayload;
 import com.zenfulcode.commercify.commercify.api.requests.products.PriceRequest;
 import com.zenfulcode.commercify.commercify.api.responses.PaymentResponse;
-import com.zenfulcode.commercify.commercify.entity.OrderEntity;
+import com.zenfulcode.commercify.commercify.dto.OrderDTO;
+import com.zenfulcode.commercify.commercify.dto.OrderDetailsDTO;
 import com.zenfulcode.commercify.commercify.entity.PaymentEntity;
 import com.zenfulcode.commercify.commercify.entity.WebhookConfigEntity;
-import com.zenfulcode.commercify.commercify.exception.OrderNotFoundException;
 import com.zenfulcode.commercify.commercify.exception.PaymentProcessingException;
 import com.zenfulcode.commercify.commercify.integration.WebhookRegistrationResponse;
-import com.zenfulcode.commercify.commercify.repository.OrderRepository;
 import com.zenfulcode.commercify.commercify.repository.PaymentRepository;
 import com.zenfulcode.commercify.commercify.repository.WebhookConfigRepository;
 import com.zenfulcode.commercify.commercify.service.PaymentService;
+import com.zenfulcode.commercify.commercify.service.email.EmailService;
+import com.zenfulcode.commercify.commercify.service.order.OrderService;
 import jakarta.servlet.http.HttpServletRequest;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.*;
 import org.springframework.retry.annotation.Backoff;
 import org.springframework.retry.annotation.Retryable;
+import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.client.RestTemplate;
@@ -36,15 +37,15 @@
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 
 @Service
-@RequiredArgsConstructor
 @Slf4j
-public class MobilePayService {
-    private final PaymentService paymentService;
+public class MobilePayService extends PaymentService {
     private final MobilePayTokenService tokenService;
 
-    private final OrderRepository orderRepository;
+    private final OrderService orderService;
     private final PaymentRepository paymentRepository;
 
     private final RestTemplate restTemplate;
@@ -62,24 +63,59 @@ public class MobilePayService {
     @Value("${mobilepay.api-url}")
     private String apiUrl;
 
+    @Value("${commercify.host}")
+    private String host;
+
     private static final String PROVIDER_NAME = "MOBILEPAY";
 
+    public MobilePayService(PaymentRepository paymentRepository, EmailService emailService, OrderService orderService, MobilePayTokenService tokenService, OrderService orderService1, PaymentRepository paymentRepository1, RestTemplate restTemplate, WebhookConfigRepository webhookConfigRepository) {
+        super(paymentRepository, emailService, orderService);
+        this.tokenService = tokenService;
+        this.orderService = orderService1;
+        this.paymentRepository = paymentRepository1;
+        this.restTemplate = restTemplate;
+        this.webhookConfigRepository = webhookConfigRepository;
+    }
+
+    @Override
+    public void capturePayment(Long paymentId, double captureAmount, boolean isPartialCapture) {
+        PaymentEntity payment = paymentRepository.findById(paymentId)
+                .orElseThrow(() -> new RuntimeException("Payment not found: " + paymentId));
+
+        if (payment.getStatus() != PaymentStatus.PAID) {
+            throw new RuntimeException("Payment cannot captured");
+        }
+
+        OrderDetailsDTO order = orderService.getOrderById(payment.getOrderId());
+
+        double capturingAmount = isPartialCapture ? captureAmount : payment.getTotalAmount();
+
+        PriceRequest priceRequest = new PriceRequest(order.getOrder().getCurrency(), capturingAmount);
+
+        // Capture payment
+        if (payment.getMobilePayReference() != null) {
+            capturePayment(payment.getMobilePayReference(), priceRequest);
+        }
+
+        // Update payment status
+        payment.setStatus(PaymentStatus.PAID);
+        paymentRepository.save(payment);
+    }
+
     @Transactional
     public PaymentResponse initiatePayment(PaymentRequest request) {
         try {
-            OrderEntity order = orderRepository.findById(request.orderId())
-                    .orElseThrow(() -> new OrderNotFoundException(request.orderId()));
-
+            OrderDetailsDTO orderDetails = orderService.getOrderById(request.orderId());
             // Create MobilePay payment request
-            Map<String, Object> paymentRequest = createMobilePayRequest(order, request);
+            Map<String, Object> paymentRequest = createMobilePayRequest(orderDetails.getOrder(), request);
 
             // Call MobilePay API
             MobilePayCheckoutResponse mobilePayCheckoutResponse = createMobilePayPayment(paymentRequest);
 
             // Create and save payment entity
             PaymentEntity payment = PaymentEntity.builder()
-                    .orderId(order.getId())
-                    .totalAmount(order.getTotal())
+                    .orderId(orderDetails.getOrder().getId())
+                    .totalAmount(orderDetails.getOrder().getTotal())
                     .paymentProvider(PaymentProvider.MOBILEPAY)
                     .status(PaymentStatus.PENDING)
                     .paymentMethod(request.paymentMethod()) // 'WALLET' or 'CARD'
@@ -107,7 +143,7 @@ public void handlePaymentCallback(WebhookPayload payload) {
         PaymentStatus newStatus = mapMobilePayStatus(payload.name());
 
         // Update payment status and trigger confirmation email if needed
-        paymentService.handlePaymentStatusUpdate(payment.getOrderId(), newStatus);
+        handlePaymentStatusUpdate(payment.getOrderId(), newStatus);
     }
 
     private HttpHeaders mobilePayRequestHeaders() {
@@ -152,7 +188,7 @@ private MobilePayCheckoutResponse createMobilePayPayment(Map<String, Object> req
         }
     }
 
-    public Map<String, Object> createMobilePayRequest(OrderEntity order, PaymentRequest request) {
+    public Map<String, Object> createMobilePayRequest(OrderDTO order, PaymentRequest request) {
         validationPaymentRequest(request);
 
         Map<String, Object> paymentRequest = new HashMap<>();
@@ -175,7 +211,7 @@ public Map<String, Object> createMobilePayRequest(OrderEntity order, PaymentRequ
         paymentRequest.put("customer", customer);
 
         // Other fields
-        String reference = String.join("-", merchantId, systemName, order.getId().toString(), value);
+        String reference = String.join("-", merchantId, systemName, String.valueOf(order.getId()), value);
         paymentRequest.put("reference", reference);
         paymentRequest.put("returnUrl", request.returnUrl() + "?orderId=" + order.getId());
         paymentRequest.put("userFlow", "WEB_REDIRECT");
@@ -212,9 +248,11 @@ private PaymentStatus mapMobilePayStatus(String status) {
         return switch (status.toUpperCase()) {
             case "CREATED" -> PaymentStatus.PENDING;
             case "AUTHORIZED" -> PaymentStatus.PAID;
-            case "ABORTED" -> PaymentStatus.CANCELLED;
+            case "ABORTED", "CANCELLED" -> PaymentStatus.CANCELLED;
             case "EXPIRED" -> PaymentStatus.EXPIRED;
             case "TERMINATED" -> PaymentStatus.TERMINATED;
+            case "CAPTURED" -> PaymentStatus.CAPTURED;
+            case "REFUNDED" -> PaymentStatus.REFUNDED;
             default -> throw new PaymentProcessingException("Unknown MobilePay status: " + status, null);
         };
     }
@@ -255,6 +293,8 @@ public void registerWebhooks(String callbackUrl) {
                                 config.setWebhookUrl(callbackUrl);
                                 config.setWebhookSecret(response.getBody().secret());
                                 webhookConfigRepository.save(config);
+
+                                log.info("Webhook updated successfully");
                             },
                             () -> {
                                 WebhookConfigEntity newConfig = WebhookConfigEntity.builder()
@@ -263,6 +303,8 @@ public void registerWebhooks(String callbackUrl) {
                                         .webhookSecret(response.getBody().secret())
                                         .build();
                                 webhookConfigRepository.save(newConfig);
+
+                                log.info("Webhook registered successfully");
                             }
                     );
 
@@ -272,10 +314,11 @@ public void registerWebhooks(String callbackUrl) {
         }
     }
 
-
+    @Transactional(readOnly = true)
     public void authenticateRequest(String date, String contentSha256, String authorization, String payload, HttpServletRequest request) {
         try {
 //            Verify content
+            log.info("Verifying content");
             MessageDigest digest = MessageDigest.getInstance("SHA-256");
             byte[] hash = digest.digest(payload.getBytes(StandardCharsets.UTF_8));
             String encodedHash = Base64.getEncoder().encodeToString(hash);
@@ -284,26 +327,34 @@ public void authenticateRequest(String date, String contentSha256, String author
                 throw new SecurityException("Hash mismatch");
             }
 
-            URI uri = new URI(request.getRequestURL().toString());
-            String path = uri.getPath() + (uri.getQuery() != null ? "?" + uri.getQuery() : "");
+            log.info("Content verified");
 
 //            Verify signature
+            log.info("Verifying signature");
+            String path = request.getRequestURI();
+            URI uri = new URI(host + path);
+
             String expectedSignedString = String.format("POST\n%s\n%s;%s;%s", path, date, uri.getHost(), encodedHash);
 
             Mac hmacSha256 = Mac.getInstance("HmacSHA256");
-            SecretKeySpec secretKey = new SecretKeySpec(getWebhookSecret().getBytes(StandardCharsets.UTF_8), "HmacSHA256");
+
+            CompletableFuture<byte[]> secretByteArray = getWebhookSecret().thenApply(s -> s.getBytes(StandardCharsets.UTF_8));
+
+            SecretKeySpec secretKey = new SecretKeySpec(secretByteArray.get(), "HmacSHA256");
             hmacSha256.init(secretKey);
 
             byte[] hmacSha256Bytes = hmacSha256.doFinal(expectedSignedString.getBytes(StandardCharsets.UTF_8));
             String expectedSignature = Base64.getEncoder().encodeToString(hmacSha256Bytes);
-            String expectedAuthorization = "HMAC-SHA256 SignedHeaders=x-ms-date;host;x-ms-content-sha256&Signature=" + expectedSignature;
+            String expectedAuthorization = String.format("HMAC-SHA256 SignedHeaders=x-ms-date;host;x-ms-content-sha256&Signature=%s", expectedSignature);
 
             if (!authorization.equals(expectedAuthorization)) {
                 throw new SecurityException("Signature mismatch");
             }
+
+            log.info("Signature verified");
         } catch (NoSuchAlgorithmException e) {
             throw new RuntimeException("SHA-256 algorithm not found", e);
-        } catch (InvalidKeyException | URISyntaxException e) {
+        } catch (InvalidKeyException | URISyntaxException | ExecutionException | InterruptedException e) {
             throw new RuntimeException(e);
         }
     }
@@ -344,14 +395,22 @@ public Object getWebhooks() {
         }
     }
 
-    private String getWebhookSecret() {
-        return webhookConfigRepository.findByProvider(PROVIDER_NAME)
-                .map(WebhookConfigEntity::getWebhookSecret)
-                .orElseThrow(() -> new PaymentProcessingException("Webhook secret not found", null));
+    @Async
+    protected CompletableFuture<String> getWebhookSecret() {
+        try {
+            final String secret = webhookConfigRepository.findByProvider(PROVIDER_NAME)
+                    .map(WebhookConfigEntity::getWebhookSecret)
+                    .orElseThrow(() -> new PaymentProcessingException("Webhook secret not found", null));
+
+            return CompletableFuture.completedFuture(secret);
+        } catch (Exception e) {
+            log.error("Error getting webhook secret: {}", e.getMessage());
+            return CompletableFuture.failedFuture(e);
+        }
     }
 
     public void capturePayment(String mobilePayReference, PriceRequest captureAmount) {
-        PaymentEntity payment = paymentRepository.findByMobilePayReference(mobilePayReference)
+        paymentRepository.findByMobilePayReference(mobilePayReference)
                 .orElseThrow(() -> new PaymentProcessingException("Payment not found", null));
 
         HttpHeaders headers = mobilePayRequestHeaders();
@@ -367,9 +426,6 @@ public void capturePayment(String mobilePayReference, PriceRequest captureAmount
                     HttpMethod.POST,
                     entity,
                     Object.class);
-
-            payment.setStatus(PaymentStatus.PAID);
-            paymentRepository.save(payment);
         } catch (Exception e) {
             log.error("Error capturing MobilePay payment: {}", e.getMessage());
             throw new PaymentProcessingException("Failed to capture MobilePay payment", e);
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java b/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java
index 330b5c8..ecbd9ab 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/service/PaymentService.java
@@ -1,27 +1,22 @@
 package com.zenfulcode.commercify.commercify.service;
 
 import com.zenfulcode.commercify.commercify.PaymentStatus;
-import com.zenfulcode.commercify.commercify.api.requests.products.PriceRequest;
 import com.zenfulcode.commercify.commercify.dto.OrderDetailsDTO;
 import com.zenfulcode.commercify.commercify.entity.PaymentEntity;
-import com.zenfulcode.commercify.commercify.integration.mobilepay.MobilePayService;
 import com.zenfulcode.commercify.commercify.repository.PaymentRepository;
 import com.zenfulcode.commercify.commercify.service.email.EmailService;
 import com.zenfulcode.commercify.commercify.service.order.OrderService;
 import jakarta.mail.MessagingException;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-@Service
 @AllArgsConstructor
 @Slf4j
 public class PaymentService {
     private final PaymentRepository paymentRepository;
     private final EmailService emailService;
     private final OrderService orderService;
-    private final MobilePayService mobilePayService;
 
     @Transactional
     public void handlePaymentStatusUpdate(Long orderId, PaymentStatus newStatus) {
@@ -58,22 +53,6 @@ public PaymentStatus getPaymentStatus(Long orderId) {
     }
 
     public void capturePayment(Long paymentId, double captureAmount, boolean isPartialCapture) {
-        PaymentEntity payment = paymentRepository.findById(paymentId)
-                .orElseThrow(() -> new RuntimeException("Payment not found: " + paymentId));
-
-        OrderDetailsDTO order = orderService.getOrderById(payment.getOrderId());
-
-        double capturingAmount = isPartialCapture ? captureAmount : payment.getTotalAmount();
-
-        PriceRequest priceRequest = new PriceRequest(order.getOrder().getCurrency(), capturingAmount);
-
-        // Capture payment
-        if (payment.getMobilePayReference() != null) {
-            mobilePayService.capturePayment(payment.getMobilePayReference(), priceRequest);
-        }
-
-        // Update payment status
-        payment.setStatus(PaymentStatus.PAID);
-        paymentRepository.save(payment);
+        throw new UnsupportedOperationException("Capture payment is not supported yet");
     }
 }
\ No newline at end of file
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/service/email/EmailService.java b/src/main/java/com/zenfulcode/commercify/commercify/service/email/EmailService.java
index 814278d..fffd7b3 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/service/email/EmailService.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/service/email/EmailService.java
@@ -61,7 +61,6 @@ public void sendConfirmationEmail(String to, String token) throws MessagingExcep
     @Async
     public void sendOrderConfirmation(OrderDetailsDTO orderDetails) throws MessagingException {
         OrderDTO order = orderDetails.getOrder();
-        UserDTO user = userService.getUserById(order.getUserId());
 
         Context context = new Context();
         context.setVariable("order", createOrderContext(orderDetails));
@@ -70,8 +69,10 @@ public void sendOrderConfirmation(OrderDetailsDTO orderDetails) throws Messaging
         String subject = String.format("Order Confirmation #%d - %s",
                 order.getId(), order.getOrderStatus());
 
-        sendTemplatedEmail(user.getEmail(), subject, template, context);
-        log.info("Order confirmation sent to {}", user.getEmail());
+        String receivingEmail = orderDetails.getCustomerDetails().getEmail();
+
+        sendTemplatedEmail(receivingEmail, subject, template, context);
+        log.info("Order confirmation sent to {}", receivingEmail);
     }
 
     @Async
@@ -127,9 +128,9 @@ private Map<String, Object> createOrderContext(OrderDetailsDTO orderDetails) {
         orderContext.put("status", order.getOrderStatus());
         orderContext.put("createdAt", order.getCreatedAt());
         orderContext.put("currency", order.getCurrency());
-        orderContext.put("subTotal", order.getSubTotal());
-        orderContext.put("totalPrice", order.getTotal());
-        orderContext.put("shippingCost", order.getShippingCost());
+        orderContext.put("subTotal", order.getSubTotal() + " " + order.getCurrency());
+        orderContext.put("totalPrice", order.getTotal() + " " + order.getCurrency());
+        orderContext.put("shippingCost", order.getShippingCost() + " " + order.getCurrency());
         orderContext.put("customerName", orderDetails.getCustomerDetails().getFullName());
         orderContext.put("customerEmail", orderDetails.getCustomerDetails().getEmail());
         orderContext.put("customerPhone", orderDetails.getCustomerDetails().getPhone());
@@ -144,14 +145,16 @@ private Map<String, Object> createOrderContext(OrderDetailsDTO orderDetails) {
                     Map<String, Object> item = new HashMap<>();
                     item.put("name", line.getProduct().getName());
                     item.put("quantity", line.getQuantity());
-                    item.put("unitPrice", line.getUnitPrice());
-                    item.put("total", line.getQuantity() * line.getUnitPrice());
+                    item.put("unitPrice", line.getUnitPrice() + " " + order.getCurrency());
+                    item.put("totalPrice", (line.getQuantity() * line.getUnitPrice()) + " " + order.getCurrency());
 
                     if (line.getVariant() != null) {
                         String variantDetails = line.getVariant().getOptions().stream()
                                 .map(opt -> opt.getName() + ": " + opt.getValue())
                                 .collect(Collectors.joining(", "));
                         item.put("variant", variantDetails);
+                    } else {
+                        item.put("variant", "");
                     }
 
                     return item;
diff --git a/src/main/java/com/zenfulcode/commercify/commercify/service/order/OrderValidationService.java b/src/main/java/com/zenfulcode/commercify/commercify/service/order/OrderValidationService.java
index 3d07dd4..314291b 100644
--- a/src/main/java/com/zenfulcode/commercify/commercify/service/order/OrderValidationService.java
+++ b/src/main/java/com/zenfulcode/commercify/commercify/service/order/OrderValidationService.java
@@ -106,6 +106,7 @@ public OrderStatus mapOrderStatus(PaymentStatus status) {
             case PENDING -> OrderStatus.PENDING;
             case PAID -> OrderStatus.PAID;
             case FAILED, NOT_FOUND -> OrderStatus.FAILED;
+            case CAPTURED -> OrderStatus.COMPLETED;
             case CANCELLED, TERMINATED, EXPIRED -> OrderStatus.CANCELLED;
             case REFUNDED -> OrderStatus.REFUNDED;
         };
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
index ae85668..54d6d7c 100644
--- a/src/main/resources/application.properties
+++ b/src/main/resources/application.properties
@@ -28,6 +28,7 @@ spring.mail.password=${MAIL_PASSWORD}
 spring.mail.properties.mail.smtp.auth=true
 spring.mail.properties.mail.smtp.starttls.enable=true
 admin.order-email=${ORDER_EMAIL_RECEIVER}
+commercify.host=${BACKEND_HOST}
 # Application Configuration
 app.frontend-url=${FRONTEND_URL:http://localhost:3000}
 admin.email=admin@commercify.app
diff --git a/src/main/resources/templates/new-order-notification-email.html b/src/main/resources/templates/new-order-notification-email.html
index 79c7045..5bf197e 100644
--- a/src/main/resources/templates/new-order-notification-email.html
+++ b/src/main/resources/templates/new-order-notification-email.html
@@ -127,20 +127,22 @@ <h3>Billing Address</h3>
                 <div th:if="${item.variant}" th:text="${item.variant}">Variant Details</div>
             </td>
             <td th:text="${item.quantity}">1</td>
-            <td th:text="${#numbers.formatDecimal(item.unitPrice, 1, 2) + ' ' + order.currency}">$99.99</td>
-            <td th:text="${#numbers.formatDecimal(item.total, 1, 2) + ' ' + order.currency}">$99.99</td>
+            <td th:text="${item.unitPrice}">$99.99</td>
+            <td th:text="${item.totalPrice}">$99.99</td>
         </tr>
         </tbody>
     </table>
 
+    <p class="subtotal">Subtotal Amount: <span
+            th:text="${order.subTotal}">$100.00</span></p>
+    <p class="shippingCost">Shipping Cost: <span
+            th:text="${order.shippingCost}">$8.00</span></p>
     <p class="total">Total Amount: <span
-            th:text="${#numbers.formatDecimal(order.totalAmount, 1, 2) + ' ' + order.currency}">$99.99</span></p>
+            th:text="${order.totalPrice}">$108.00</span></p>
 </div>
 
 <a th:href="${dashboardUrl}" class="action-button">View Order in Dashboard</a>
 
 <p>Please process this order as soon as possible.</p>
-
-<p>Best regards,<br/>Commercify System</p>
 </body>
 </html>
\ No newline at end of file
diff --git a/src/main/resources/templates/order-confirmation-email.html b/src/main/resources/templates/order-confirmation-email.html
index 46e1152..a5640b0 100644
--- a/src/main/resources/templates/order-confirmation-email.html
+++ b/src/main/resources/templates/order-confirmation-email.html
@@ -105,14 +105,18 @@ <h3>Billing Address</h3>
                 <div th:if="${item.variant}" th:text="${item.variant}">Variant Details</div>
             </td>
             <td th:text="${item.quantity}">1</td>
-            <td th:text="${#numbers.formatDecimal(item.unitPrice, 1, 2) + ' ' + order.currency}">$99.99</td>
-            <td th:text="${#numbers.formatDecimal(item.total, 1, 2) + ' ' + order.currency}">$99.99</td>
+            <td th:text="${item.unitPrice}">$99.99</td>
+            <td th:text="${item.totalPrice}">$99.99</td>
         </tr>
         </tbody>
     </table>
 
+    <p class="subtotal">Subtotal Amount: <span
+            th:text="${order.subTotal}">$100.00</span></p>
+    <p class="shippingCost">Shipping Cost: <span
+            th:text="${order.shippingCost}">$8.00</span></p>
     <p class="total">Total Amount: <span
-            th:text="${#numbers.formatDecimal(order.totalAmount, 1, 2) + ' ' + order.currency}">$99.99</span></p>
+            th:text="${order.totalPrice}">$108.00</span></p>
 </div>
 
 <p th:if="${order.status == 'PENDING'}">
@@ -129,7 +133,5 @@ <h3>Billing Address</h3>
 </p>
 
 <p>If you have any questions about your order, please contact our customer service.</p>
-
-<p>Best regards,<br/>Commercify Team</p>
 </body>
 </html>
\ No newline at end of file
diff --git a/src/test/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlowTest.java b/src/test/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlowTest.java
index 130224d..05aaa0f 100644
--- a/src/test/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlowTest.java
+++ b/src/test/java/com/zenfulcode/commercify/commercify/flow/OrderStateFlowTest.java
@@ -29,12 +29,14 @@ void testPendingTransitions() {
         }
 
         @Test
-        @DisplayName("CONFIRMED order can transition to SHIPPED or CANCELLED")
+        @DisplayName("PAID order can transition to SHIPPED, CANCELLED and COMPLETED")
         void testConfirmedTransitions() {
             Set<OrderStatus> validTransitions = orderStateFlow.getValidTransitions(OrderStatus.PAID);
             assertTrue(orderStateFlow.canTransition(OrderStatus.PAID, OrderStatus.SHIPPED));
             assertTrue(orderStateFlow.canTransition(OrderStatus.PAID, OrderStatus.CANCELLED));
-            assertEquals(2, validTransitions.size());
+            assertTrue(orderStateFlow.canTransition(OrderStatus.PAID, OrderStatus.COMPLETED));
+
+            assertEquals(3, validTransitions.size());
         }
 
         @Test
diff --git a/src/test/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayServiceTest.java b/src/test/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayServiceTest.java
deleted file mode 100644
index 3614e51..0000000
--- a/src/test/java/com/zenfulcode/commercify/commercify/integration/mobilepay/MobilePayServiceTest.java
+++ /dev/null
@@ -1,165 +0,0 @@
-package com.zenfulcode.commercify.commercify.integration.mobilepay;
-
-import com.zenfulcode.commercify.commercify.PaymentStatus;
-import com.zenfulcode.commercify.commercify.api.requests.WebhookPayload;
-import com.zenfulcode.commercify.commercify.entity.PaymentEntity;
-import com.zenfulcode.commercify.commercify.exception.PaymentProcessingException;
-import com.zenfulcode.commercify.commercify.repository.PaymentRepository;
-import com.zenfulcode.commercify.commercify.service.PaymentService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.Optional;
-
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class MobilePayServiceTest {
-
-    @Mock
-    private PaymentRepository paymentRepository;
-
-    @Mock
-    private PaymentService paymentService;
-
-    @Mock
-    private RestTemplate restTemplate;
-
-    @Mock
-    private MobilePayTokenService tokenService;
-
-    @InjectMocks
-    private MobilePayService mobilePayService;
-
-    private PaymentEntity payment;
-    private static final String PAYMENT_REFERENCE = "test-reference";
-
-    private WebhookPayload payload;
-
-    @BeforeEach
-    void setUp() {
-        payment = PaymentEntity.builder()
-                .id(1L)
-                .orderId(1L)
-                .mobilePayReference(PAYMENT_REFERENCE)
-                .status(PaymentStatus.PENDING)
-                .build();
-
-        payload = WebhookPayload.builder()
-                .reference(PAYMENT_REFERENCE)
-                .name("AUTHORIZED")
-                .build();
-    }
-
-    @Test
-    @DisplayName("Should handle successful payment callback")
-    void handlePaymentCallback_Success() {
-        when(paymentRepository.findByMobilePayReference(payload.reference()))
-                .thenReturn(Optional.of(payment));
-
-        mobilePayService.handlePaymentCallback(payload);
-
-        verify(paymentService).handlePaymentStatusUpdate(eq(1L), eq(PaymentStatus.PAID));
-    }
-
-    @Test
-    @DisplayName("Should handle payment not found in callback")
-    void handlePaymentCallback_PaymentNotFound() {
-        when(paymentRepository.findByMobilePayReference(payload.reference()))
-                .thenReturn(Optional.empty());
-
-        assertThrows(PaymentProcessingException.class, () ->
-                mobilePayService.handlePaymentCallback(payload));
-    }
-
-    @Test
-    @DisplayName("Should handle aborted payment")
-    void handlePaymentCallback_Aborted() {
-        payload = WebhookPayload.builder()
-                .reference(PAYMENT_REFERENCE)
-                .name("ABORTED")
-                .build();
-
-        when(paymentRepository.findByMobilePayReference(payload.reference()))
-                .thenReturn(Optional.of(payment));
-
-        mobilePayService.handlePaymentCallback(payload);
-
-        verify(paymentService).handlePaymentStatusUpdate(eq(1L), eq(PaymentStatus.CANCELLED));
-    }
-
-    @Test
-    @DisplayName("Should handle expired payment")
-    void handlePaymentCallback_Expired() {
-        payload = WebhookPayload.builder()
-                .reference(PAYMENT_REFERENCE)
-                .name("EXPIRED")
-                .build();
-
-        when(paymentRepository.findByMobilePayReference(payload.reference()))
-                .thenReturn(Optional.of(payment));
-
-        mobilePayService.handlePaymentCallback(payload);
-
-        verify(paymentService).handlePaymentStatusUpdate(eq(1L), eq(PaymentStatus.EXPIRED));
-    }
-
-    @ParameterizedTest
-    @DisplayName("Validate Mobile Pay Reference Format")
-    @ValueSource(strings = {
-            "HotelHunger-order-1234-10050",  // Typical case
-            "Commercify-order-9999-12345",   // Different system name
-            "A1-order-1-100",                // Minimum acceptable length
-            "VeryLongSystemName-order-999999-1000000" // Longer reference
-    })
-    void testValidMobilePayReferences(String reference) {
-        assertTrue(reference.matches("^[a-zA-Z0-9-]{8,50}$"),
-                "Reference should be valid: " + reference);
-    }
-
-    @ParameterizedTest
-    @DisplayName("Invalidate Incorrect Mobile Pay Reference Format")
-    @ValueSource(strings = {
-            "HotelHunger_order-1234-10050",  // Contains underscore
-            "System!order-1234-10050",       // Contains special character
-            "ab",                            // Too short
-            "ThisIsAVeryLongReferenceStringThatExceedsTheMaximumAllowedLengthOfFiftyCharacters" // Too long
-    })
-    void testInvalidMobilePayReferences(String reference) {
-        assertFalse(reference.matches("^[a-zA-Z0-9-]{8,50}$"),
-                "Reference should be invalid: " + reference);
-    }
-
-    @Test
-    @DisplayName("Validate Reference Generation Components")
-    void testMobilePayReferenceGeneration() {
-        // Assuming you have a method to generate the reference
-        // This is a placeholder - adjust based on your actual reference generation method
-        PaymentEntity testPayment = PaymentEntity.builder()
-                .id(1234L)
-                .build();
-
-        String generatedReference = "Commercify-order-" + testPayment.getId() + "-10050";
-
-        // Validate reference format
-        assertTrue(generatedReference.matches("^[a-zA-Z0-9-]{8,50}$"),
-                "Generated reference should match the required format");
-
-        // Additional checks
-        assertTrue(generatedReference.startsWith("Commercify-order-"),
-                "Reference should start with system name and 'order-'");
-        assertTrue(generatedReference.contains("-10050"),
-                "Reference should contain the total amount");
-    }
-}
\ No newline at end of file
diff --git a/src/test/java/com/zenfulcode/commercify/commercify/service/PaymentServiceTest.java b/src/test/java/com/zenfulcode/commercify/commercify/service/PaymentServiceTest.java
index 44c412c..f425f26 100644
--- a/src/test/java/com/zenfulcode/commercify/commercify/service/PaymentServiceTest.java
+++ b/src/test/java/com/zenfulcode/commercify/commercify/service/PaymentServiceTest.java
@@ -1,18 +1,18 @@
 package com.zenfulcode.commercify.commercify.service;
 
 import com.zenfulcode.commercify.commercify.PaymentStatus;
+import com.zenfulcode.commercify.commercify.dto.OrderDTO;
 import com.zenfulcode.commercify.commercify.dto.OrderDetailsDTO;
 import com.zenfulcode.commercify.commercify.entity.PaymentEntity;
-import com.zenfulcode.commercify.commercify.repository.OrderRepository;
 import com.zenfulcode.commercify.commercify.repository.PaymentRepository;
 import com.zenfulcode.commercify.commercify.service.email.EmailService;
 import com.zenfulcode.commercify.commercify.service.order.OrderService;
 import jakarta.mail.MessagingException;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
@@ -20,112 +20,138 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 @ExtendWith(MockitoExtension.class)
 class PaymentServiceTest {
 
     @Mock
     private PaymentRepository paymentRepository;
-
     @Mock
     private EmailService emailService;
-
     @Mock
     private OrderService orderService;
 
-    @InjectMocks
     private PaymentService paymentService;
 
-    private PaymentEntity payment;
-    private OrderDetailsDTO orderDetails;
-
     @BeforeEach
     void setUp() {
-        payment = PaymentEntity.builder()
-                .id(1L)
-                .orderId(1L)
-                .status(PaymentStatus.PENDING)
-                .totalAmount(199.99)
-                .build();
-
-        orderDetails = new OrderDetailsDTO(null, null, null, null, null); // Simplified for testing
-    }
-
-    @Test
-    @DisplayName("Should update payment status successfully")
-    void handlePaymentStatusUpdate_Success() {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.of(payment));
-        when(paymentRepository.save(any(PaymentEntity.class))).thenReturn(payment);
-
-        paymentService.handlePaymentStatusUpdate(1L, PaymentStatus.PAID);
-
-        verify(paymentRepository).save(payment);
-        assertThat(payment.getStatus()).isEqualTo(PaymentStatus.PAID);
-    }
-
-    @Test
-    @DisplayName("Should send confirmation email when payment is successful")
-    void handlePaymentStatusUpdate_SendsEmail() throws MessagingException {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.of(payment));
-        when(orderService.getOrderById(1L)).thenReturn(orderDetails);
-
-        paymentService.handlePaymentStatusUpdate(1L, PaymentStatus.PAID);
-
-        verify(emailService).sendOrderConfirmation(orderDetails);
-    }
-
-    @Test
-    @DisplayName("Should not send email for non-successful payment status")
-    void handlePaymentStatusUpdate_NoEmailForNonSuccess() throws MessagingException {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.of(payment));
-
-        paymentService.handlePaymentStatusUpdate(1L, PaymentStatus.FAILED);
-
-        verify(emailService, never()).sendOrderConfirmation(any());
+        paymentService = new PaymentService(paymentRepository, emailService, orderService);
     }
 
-    @Test
-    @DisplayName("Should handle payment not found")
-    void handlePaymentStatusUpdate_PaymentNotFound() {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.empty());
-
-        assertThrows(RuntimeException.class, () ->
-                paymentService.handlePaymentStatusUpdate(1L, PaymentStatus.PAID));
+    @Nested
+    @DisplayName("Payment Status Update Tests")
+    class PaymentStatusUpdateTests {
+
+        @Test
+        @DisplayName("Should successfully update payment status and send confirmation email when payment is successful")
+        void shouldUpdateStatusAndSendEmailOnSuccessfulPayment() throws MessagingException {
+            // Arrange
+            Long orderId = 1L;
+            PaymentEntity payment = PaymentEntity.builder()
+                    .id(1L)
+                    .orderId(orderId)
+                    .status(PaymentStatus.PENDING)
+                    .build();
+
+            OrderDetailsDTO orderDetails = new OrderDetailsDTO();
+            orderDetails.setOrder(new OrderDTO());
+
+            when(paymentRepository.findByOrderId(orderId)).thenReturn(Optional.of(payment));
+            when(orderService.getOrderById(orderId)).thenReturn(orderDetails);
+
+            // Act
+            paymentService.handlePaymentStatusUpdate(orderId, PaymentStatus.PAID);
+
+            // Assert
+            verify(paymentRepository).save(payment);
+            verify(orderService).updateOrderStatus(orderId, PaymentStatus.PAID);
+            verify(emailService).sendOrderConfirmation(orderDetails);
+            verify(emailService).sendNewOrderNotification(orderDetails);
+            assertThat(payment.getStatus()).isEqualTo(PaymentStatus.PAID);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when payment is not found")
+        void shouldThrowExceptionWhenPaymentNotFound() {
+            // Arrange
+            Long orderId = 1L;
+            when(paymentRepository.findByOrderId(orderId)).thenReturn(Optional.empty());
+
+            // Act & Assert
+            assertThrows(RuntimeException.class,
+                    () -> paymentService.handlePaymentStatusUpdate(orderId, PaymentStatus.PAID));
+        }
+
+//        @Test
+//        @DisplayName("Should not send email for non-successful payment status updates")
+//        void shouldNotSendEmailForNonSuccessfulPayments() {
+//            // Arrange
+//            Long orderId = 1L;
+//            PaymentEntity payment = PaymentEntity.builder()
+//                    .id(1L)
+//                    .orderId(orderId)
+//                    .status(PaymentStatus.PENDING)
+//                    .build();
+//
+//            when(paymentRepository.findByOrderId(orderId)).thenReturn(Optional.of(payment));
+//
+//            // Act
+//            paymentService.handlePaymentStatusUpdate(orderId, PaymentStatus.CANCELLED);
+//
+//            // Assert
+//            verify(paymentRepository).save(payment);
+//            verify(orderService).updateOrderStatus(orderId, PaymentStatus.CANCELLED);
+//            verify(emailService, never()).sendOrderConfirmation(any());
+//            verify(emailService, never()).sendNewOrderNotification(any());
+//            assertThat(payment.getStatus()).isEqualTo(PaymentStatus.CANCELLED);
+//        }
     }
 
-    @Test
-    @DisplayName("Should handle email sending failure gracefully")
-    void handlePaymentStatusUpdate_EmailFailure() throws MessagingException {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.of(payment));
-        when(orderService.getOrderById(1L)).thenReturn(orderDetails);
-        doThrow(new MessagingException("Failed to send email"))
-                .when(emailService).sendOrderConfirmation(any());
-
-        paymentService.handlePaymentStatusUpdate(1L, PaymentStatus.PAID);
-
-        verify(paymentRepository).save(payment);
-        assertThat(payment.getStatus()).isEqualTo(PaymentStatus.PAID);
+    @Nested
+    @DisplayName("Get Payment Status Tests")
+    class GetPaymentStatusTests {
+
+        @Test
+        @DisplayName("Should return correct payment status when payment exists")
+        void shouldReturnCorrectPaymentStatus() {
+            // Arrange
+            Long orderId = 1L;
+            PaymentEntity payment = PaymentEntity.builder()
+                    .id(1L)
+                    .orderId(orderId)
+                    .status(PaymentStatus.PAID)
+                    .build();
+
+            when(paymentRepository.findByOrderId(orderId)).thenReturn(Optional.of(payment));
+
+            // Act
+            PaymentStatus status = paymentService.getPaymentStatus(orderId);
+
+            // Assert
+            assertThat(status).isEqualTo(PaymentStatus.PAID);
+        }
+
+        @Test
+        @DisplayName("Should return NOT_FOUND status when payment doesn't exist")
+        void shouldReturnNotFoundStatusWhenPaymentDoesntExist() {
+            // Arrange
+            Long orderId = 1L;
+            when(paymentRepository.findByOrderId(orderId)).thenReturn(Optional.empty());
+
+            // Act
+            PaymentStatus status = paymentService.getPaymentStatus(orderId);
+
+            // Assert
+            assertThat(status).isEqualTo(PaymentStatus.NOT_FOUND);
+        }
     }
 
     @Test
-    @DisplayName("Should get payment status successfully")
-    void getPaymentStatus_Success() {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.of(payment));
-
-        PaymentStatus status = paymentService.getPaymentStatus(1L);
-
-        assertThat(status).isEqualTo(PaymentStatus.PENDING);
-    }
-
-    @Test
-    @DisplayName("Should return NOT_FOUND for non-existent payment")
-    void getPaymentStatus_NotFound() {
-        when(paymentRepository.findByOrderId(1L)).thenReturn(Optional.empty());
-
-        PaymentStatus status = paymentService.getPaymentStatus(1L);
-
-        assertThat(status).isEqualTo(PaymentStatus.NOT_FOUND);
+    @DisplayName("Should throw UnsupportedOperationException when attempting to capture payment")
+    void shouldThrowExceptionWhenCapturingPayment() {
+        assertThrows(UnsupportedOperationException.class,
+                () -> paymentService.capturePayment(1L, 100.0, false));
     }
 }
\ No newline at end of file