WooNooW/CALCULATION_EFFICIENCY_AUDIT.md

# Calculation Efficiency Audit

## 🚨 CRITICAL ISSUE FOUND

### Current Implementation (BLOATED):

**Frontend makes 2 separate API calls:**

```tsx
// Call 1: Get shipping rates
const shippingRates = useQuery({
  queryFn: () => api.post('/shipping/calculate', { items, shipping })
});

// Call 2: Get order preview with taxes
const orderPreview = useQuery({
  queryFn: () => api.post('/orders/preview', { items, billing, shipping, shipping_method, coupons })
});
```

**Backend processes cart TWICE:**

```php
// Endpoint 1: /shipping/calculate
WC()->cart->empty_cart();
WC()->cart->add_to_cart(...); // Add items
WC()->cart->calculate_shipping(); // Calculate
WC()->cart->calculate_totals(); // Calculate
WC()->cart->empty_cart(); // Clean up

// Endpoint 2: /orders/preview (AGAIN!)
WC()->cart->empty_cart();
WC()->cart->add_to_cart(...); // Add items AGAIN
WC()->cart->calculate_shipping(); // Calculate AGAIN
WC()->cart->calculate_totals(); // Calculate AGAIN
WC()->cart->empty_cart(); // Clean up AGAIN
```

### Problems:

❌ **2 HTTP requests** instead of 1
❌ **Cart initialized twice** (expensive)
❌ **Items added twice** (database queries)
❌ **Shipping calculated twice** (API calls to UPS, Rajaongkir, etc.)
❌ **Taxes calculated twice** (database queries)
❌ **Network latency doubled**
❌ **Server load doubled**

---

## ✅ SOLUTION: Single Unified Endpoint

### New Endpoint: `/woonoow/v1/orders/calculate`

**Single request with all data:**

```typescript
// Frontend: ONE API call
const calculation = useQuery({
  queryFn: () => api.post('/orders/calculate', {
    items: [{ product_id: 1, qty: 2 }],
    billing: { country: 'ID', state: 'JB', city: 'Bandung' },
    shipping: { country: 'ID', state: 'JB', city: 'Bandung' },
    coupons: ['SAVE10'],
    // Optional: If user already selected shipping method
    shipping_method: 'flat_rate:1',
  })
});
```

**Single response with everything:**

```json
{
  "subtotal": 100000,
  "shipping": {
    "methods": [
      {
        "id": "cekongkir:jne:reg",
        "label": "JNE REG",
        "cost": 31000,
        "selected": false
      },
      {
        "id": "cekongkir:jne:yes",
        "label": "JNE YES",
        "cost": 42000,
        "selected": false
      }
    ],
    "selected_method": null,
    "selected_cost": 0
  },
  "coupons": [
    {
      "code": "SAVE10",
      "discount": 10000,
      "valid": true
    }
  ],
  "taxes": [
    {
      "label": "PPN 11%",
      "amount": 13310
    }
  ],
  "total_tax": 13310,
  "total": 134310,
  "breakdown": {
    "subtotal": 100000,
    "shipping": 31000,
    "discount": -10000,
    "tax": 13310,
    "total": 134310
  }
}
```

### Backend: ONE cart initialization

```php
public static function calculate_order( WP_REST_Request $req ) {
    $items = $req->get_param('items');
    $billing = $req->get_param('billing');
    $shipping = $req->get_param('shipping');
    $coupons = $req->get_param('coupons') ?? [];
    $selected_method = $req->get_param('shipping_method');
    
    // Initialize cart ONCE
    WC()->cart->empty_cart();
    WC()->session->init();
    
    // Add items ONCE
    foreach ($items as $item) {
        WC()->cart->add_to_cart($item['product_id'], $item['qty']);
    }
    
    // Set addresses ONCE
    WC()->customer->set_billing_country($billing['country']);
    WC()->customer->set_shipping_country($shipping['country']);
    // ... set other fields
    
    // Apply coupons ONCE
    foreach ($coupons as $code) {
        WC()->cart->apply_coupon($code);
    }
    
    // Calculate shipping ONCE
    WC()->cart->calculate_shipping();
    
    // Get all available shipping methods
    $packages = WC()->shipping()->get_packages();
    $shipping_methods = [];
    foreach ($packages[0]['rates'] as $rate) {
        $shipping_methods[] = [
            'id' => $rate->get_id(),
            'label' => $rate->get_label(),
            'cost' => $rate->get_cost(),
            'selected' => $rate->get_id() === $selected_method,
        ];
    }
    
    // If user selected a method, set it
    if ($selected_method) {
        WC()->session->set('chosen_shipping_methods', [$selected_method]);
    }
    
    // Calculate totals ONCE (includes tax)
    WC()->cart->calculate_totals();
    
    // Build response
    return new WP_REST_Response([
        'subtotal' => WC()->cart->get_subtotal(),
        'shipping' => [
            'methods' => $shipping_methods,
            'selected_method' => $selected_method,
            'selected_cost' => WC()->cart->get_shipping_total(),
        ],
        'coupons' => WC()->cart->get_applied_coupons(),
        'taxes' => WC()->cart->get_tax_totals(),
        'total_tax' => WC()->cart->get_total_tax(),
        'total' => WC()->cart->get_total('edit'),
    ]);
}
```

---

## Performance Comparison

### Before (Current - BLOATED):

```
User fills address
  ↓
Frontend: POST /shipping/calculate (500ms)
  ↓ Backend: Init cart, add items, calculate shipping
  ↓ Response: { methods: [...] }
  ↓
User sees shipping options
  ↓
User selects shipping method
  ↓
Frontend: POST /orders/preview (500ms)
  ↓ Backend: Init cart AGAIN, add items AGAIN, calculate AGAIN
  ↓ Response: { total, tax, ... }
  ↓
User sees total

TOTAL TIME: ~1000ms
TOTAL REQUESTS: 2
CART INITIALIZED: 2 times
SHIPPING CALCULATED: 2 times
```

### After (Optimized - LIGHTNING):

```
User fills address
  ↓
Frontend: POST /orders/calculate (300ms)
  ↓ Backend: Init cart ONCE, add items ONCE, calculate ONCE
  ↓ Response: { shipping: { methods: [...] }, total, tax, ... }
  ↓
User sees shipping options AND total

TOTAL TIME: ~300ms (70% faster!)
TOTAL REQUESTS: 1 (50% reduction)
CART INITIALIZED: 1 time (50% reduction)
SHIPPING CALCULATED: 1 time (50% reduction)
```

### When User Changes Shipping Method:

**Before:**
```
User selects different shipping
  ↓
Frontend: POST /orders/preview (500ms)
  ↓ Backend: Init cart, add items, calculate
  ↓ Response: { total, tax }
```

**After:**
```
User selects different shipping
  ↓
Frontend: POST /orders/calculate with shipping_method (300ms)
  ↓ Backend: Init cart ONCE, calculate with selected method
  ↓ Response: { shipping: { selected_cost }, total, tax }
```

---

## Implementation Plan

### Step 1: Create Unified Endpoint

```php
// includes/Api/OrdersController.php

public function register() {
    register_rest_route( self::NS, '/orders/calculate', [
        'methods'  => 'POST',
        'callback' => [ __CLASS__, 'calculate_order' ],
        'permission_callback' => [ __CLASS__, 'check_permission' ],
    ]);
}
```

### Step 2: Update Frontend

```tsx
// OrderForm.tsx

// REMOVE these two separate queries:
// const shippingRates = useQuery(...);
// const orderPreview = useQuery(...);

// REPLACE with single unified query:
const { data: calculation, isLoading } = useQuery({
  queryKey: [
    'order-calculation',
    items,
    bCountry, bState, bCity, bPost,
    effectiveShippingAddress,
    shippingMethod,
    validatedCoupons
  ],
  queryFn: async () => {
    return api.post('/orders/calculate', {
      items: items.map(i => ({ product_id: i.product_id, qty: i.qty })),
      billing: { country: bCountry, state: bState, city: bCity, postcode: bPost },
      shipping: effectiveShippingAddress,
      shipping_method: shippingMethod,
      coupons: validatedCoupons.map(c => c.code),
    });
  },
  enabled: items.length > 0 && isShippingAddressComplete,
  staleTime: 0,
});

// Use the data:
const shippingMethods = calculation?.shipping?.methods || [];
const orderTotal = calculation?.total || 0;
const orderTax = calculation?.total_tax || 0;
```

### Step 3: Deprecate Old Endpoints

```php
// Mark as deprecated, remove in next major version
// /shipping/calculate - DEPRECATED
// /orders/preview - DEPRECATED
```

---

## Benefits

✅ **50% fewer HTTP requests**
✅ **70% faster response time**
✅ **50% less server load**
✅ **50% less database queries**
✅ **50% fewer external API calls** (UPS, Rajaongkir)
✅ **Better user experience** (instant feedback)
✅ **Lower hosting costs**
✅ **More scalable**

---

## Migration Path

### Phase 1: Add New Endpoint (Non-breaking)
- Add `/orders/calculate` endpoint
- Keep old endpoints working
- Update frontend to use new endpoint

### Phase 2: Deprecation Notice
- Add deprecation warnings to old endpoints
- Update documentation

### Phase 3: Remove Old Endpoints (Next major version)
- Remove `/shipping/calculate`
- Remove `/orders/preview`

---

## Conclusion

**Current implementation is bloated like WooCommerce.**

We're making the same mistake WooCommerce makes - separate requests for shipping and totals, causing:
- Double cart initialization
- Double calculation
- Double API calls
- Slow performance

**Solution: Single unified `/orders/calculate` endpoint that returns everything in one request.**

This is what we discussed at the beginning - **efficient, lightning-fast, no bloat**.

---

**Status:** ❌ NOT IMPLEMENTED YET
**Priority:** 🚨 CRITICAL
**Impact:** 🔥 HIGH - Performance bottleneck
**Effort:** ⚡ MEDIUM - ~2 hours to implement