package com.paymentlink.controller.api;

import com.paymentlink.model.dto.CartItemDto;
import com.paymentlink.model.dto.CustomerInfoDto;
import com.paymentlink.model.dto.ShippingInfoDto;
import com.paymentlink.model.entity.Order;
import com.paymentlink.model.entity.OrderItem;
import com.paymentlink.service.OrderService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/orders")
public class OrderApiController {

    private final OrderService orderService;

    public OrderApiController(OrderService orderService) {
        this.orderService = orderService;
    }

    /**
     * GET /api/orders - Get all orders (admin)
     */
    @GetMapping
    public ResponseEntity<Map<String, Object>> getAllOrders() {
        try {
            List<Order> orders = orderService.getAllOrders();
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("orders", orders);
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            Map<String, Object> error = new HashMap<>();
            error.put("success", false);
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
        }
    }

    /**
     * POST /api/orders - Create order
     */
    @PostMapping
    public ResponseEntity<Map<String, Object>> createOrder(
            @RequestHeader(value = "x-session-id", required = false) String sessionId,
            @RequestBody Map<String, Object> request) {
        
        try {
            // Parse request
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> itemsData = (List<Map<String, Object>>) request.get("items");
            @SuppressWarnings("unchecked")
            Map<String, String> customerData = (Map<String, String>) request.get("customerInfo");
            @SuppressWarnings("unchecked")
            Map<String, String> shippingData = (Map<String, String>) request.get("shippingInfo");

            // Convert to OrderItems
            List<OrderItem> items = itemsData.stream().map(item -> {
                OrderItem orderItem = new OrderItem();
                orderItem.setProductId(toLong(item.get("productId")));
                orderItem.setQuantity(toInteger(item.get("quantity")));
                return orderItem;
            }).toList();

            // Create order
            Order order = orderService.createOrder(
                    items,
                    customerData.get("email"),
                    customerData.get("name"),
                    customerData.get("phone"),
                    customerData.get("contactPreference"),
                    shippingData.get("address"),
                    shippingData.get("city"),
                    shippingData.get("state"),
                    shippingData.get("zip"),
                    shippingData.get("country"),
                    shippingData.get("shippingMethod"),
                    sessionId
            );

            // Complete order (update stock, release reservations)
            orderService.completeOrder(order.getOrderId(), sessionId);

            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("order", order);
            return ResponseEntity.status(HttpStatus.CREATED).body(response);

        } catch (IllegalStateException | IllegalArgumentException e) {
            Map<String, Object> error = new HashMap<>();
            error.put("success", false);
            error.put("error", e.getMessage());
            return ResponseEntity.badRequest().body(error);

        } catch (Exception e) {
            Map<String, Object> error = new HashMap<>();
            error.put("success", false);
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
        }
    }

    /**
     * GET /api/orders/{orderId} - Get order details
     */
    @GetMapping("/{orderId}")
    public ResponseEntity<Map<String, Object>> getOrder(@PathVariable String orderId) {
        try {
            return orderService.getOrderById(orderId)
                    .map(order -> {
                        Map<String, Object> response = new HashMap<>();
                        response.put("success", true);
                        response.put("order", order);
                        return ResponseEntity.ok(response);
                    })
                    .orElseGet(() -> {
                        Map<String, Object> error = new HashMap<>();
                        error.put("success", false);
                        error.put("error", "Order not found");
                        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
                    });

        } catch (Exception e) {
            Map<String, Object> error = new HashMap<>();
            error.put("success", false);
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
        }
    }

    /**
     * POST /api/orders/{orderId}/verify-email - Verify email to view tracking
     */
    @PostMapping("/{orderId}/verify-email")
    public ResponseEntity<Map<String, Object>> verifyEmail(
            @PathVariable String orderId,
            @RequestBody Map<String, String> request) {
        
        try {
            String email = request.get("email");
            
            if (email == null || email.isEmpty()) {
                Map<String, Object> error = new HashMap<>();
                error.put("success", false);
                error.put("error", "Email is required");
                return ResponseEntity.badRequest().body(error);
            }

            boolean isValid = orderService.verifyOrderEmail(orderId, email);
            
            if (!isValid) {
                Map<String, Object> error = new HashMap<>();
                error.put("success", false);
                error.put("error", "Email does not match order");
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(error);
            }

            // Return order with tracking info
            return orderService.getOrderById(orderId)
                    .map(order -> {
                        Map<String, Object> response = new HashMap<>();
                        response.put("success", true);
                        response.put("order", order);
                        return ResponseEntity.ok(response);
                    })
                    .orElseGet(() -> {
                        Map<String, Object> error = new HashMap<>();
                        error.put("success", false);
                        error.put("error", "Order not found");
                        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
                    });

        } catch (Exception e) {
            Map<String, Object> error = new HashMap<>();
            error.put("success", false);
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
        }
    }

    // Helper methods to safely convert Object to Long/Integer
    private Long toLong(Object value) {
        if (value == null) return null;
        if (value instanceof Number) {
            return ((Number) value).longValue();
        }
        if (value instanceof String) {
            return Long.parseLong((String) value);
        }
        throw new IllegalArgumentException("Cannot convert " + value.getClass() + " to Long");
    }

    private Integer toInteger(Object value) {
        if (value == null) return null;
        if (value instanceof Number) {
            return ((Number) value).intValue();
        }
        if (value instanceof String) {
            return Integer.parseInt((String) value);
        }
        throw new IllegalArgumentException("Cannot convert " + value.getClass() + " to Integer");
    }
}