import { LightningElement, api, wire } from 'lwc';
import { refreshApex } from '@salesforce/apex';
import getOrdersForAccount from '@salesforce/apex/OrderController.getOrdersForAccount';

export default class OrderDashboard extends LightningElement {
  @api recordId;        // Module 5 — set automatically on an Account record page
  searchTerm = '';       // Module 4 — plain reactive property
  statusFilter = 'All';
  wiredOrdersResult;     // Module 11 — stored for refreshApex

  @wire(getOrdersForAccount, { accountId: '$recordId' })  // Module 9 — reactive $ syntax
  wiredOrders(result) {
    this.wiredOrdersResult = result;
  }

  get filteredOrders() {                       // Module 9 Concept 3 + Module 4
    const orders = this.wiredOrdersResult?.data ?? [];
    return orders
      .filter(o => this.statusFilter === 'All' || o.Status__c === this.statusFilter)
      .filter(o => o.Name.toLowerCase().includes(this.searchTerm.toLowerCase()));
  }

  get isLoading() {                            // Module 3 — loading/empty/populated pattern
    return !this.wiredOrdersResult?.data && !this.wiredOrdersResult?.error;
  }
}

<template>
  <c-order-filter-panel onfilterchanged={handleFilterChanged}></c-order-filter-panel>

  <template lwc:if={isLoading}>
    <lightning-spinner alternative-text="Loading Orders"></lightning-spinner>
  </template>
  <template lwc:elseif={filteredOrders.length}>
    <c-order-list orders={filteredOrders} onorderaction={handleOrderAction}></c-order-list>
  </template>
  <template lwc:else>
    <p>No matching Orders found.</p>
  </template>
</template>

export default class OrderFilterPanel extends LightningElement {
  handleSearchInput(event) {
    this.dispatchEvent(new CustomEvent('filterchanged', {     // Module 6
      detail: { searchTerm: event.target.value, type: 'search' }
    }));
  }
  handleStatusChange(event) {
    this.dispatchEvent(new CustomEvent('filterchanged', {
      detail: { status: event.target.value, type: 'status' }
    }));
  }
}

export default class OrderRow extends LightningElement {
  @api order;  // Module 5 — data flows DOWN

  handleDeleteClick() {
    this.dispatchEvent(new CustomEvent('orderaction', {   // Module 6 — action flows UP
      detail: { action: 'delete', orderId: this.order.Id }
    }));
  }
}

import ConfirmActionModal from 'c/confirmActionModal';     // Module 8
import { ShowToastEvent } from 'lightning/platformShowToastEvent';

async handleOrderAction(event) {
  const { action, orderId } = event.detail;     // Module 1 destructuring, Module 6 detail payload

  if (action === 'delete') {
    const result = await ConfirmActionModal.open({
      size: 'small', message: 'Delete this Order? This cannot be undone.'
    });
    if (result !== 'confirmed') return;   // Module 8's exact early-return gotcha
    await this.deleteOrder(orderId);
  }
}

import deleteOrder from '@salesforce/apex/OrderController.deleteOrder';

async deleteOrder(orderId) {
  this.isProcessing = true;                              // Module 10 — disable triggering UI
  try {
    await deleteOrder({ orderId });                          // Module 10 — imperative call
    await refreshApex(this.wiredOrdersResult);                 // Module 11 — close the staleness gap
    this.dispatchEvent(new ShowToastEvent({
      title: 'Order Deleted', variant: 'success'
    }));
  } catch (error) {
    this.dispatchEvent(new ShowToastEvent({                     // Module 10 — error.body.message
      title: 'Delete Failed',
      message: error.body?.message ?? 'An unexpected error occurred',
      variant: 'error', mode: 'sticky'
    }));
  } finally {
    this.isProcessing = false;                             // Module 10 — finally, always resets
  }
}

public class OrderController {
  @AuraEnabled(cacheable=true)                              // Module 9 — required for @wire
  public static List<Order__c> getOrdersForAccount(Id accountId) {
    return [SELECT Id, Name, Status__c, Amount__c FROM Order__c
            WHERE Account__c = :accountId];
  }

  @AuraEnabled                                                  // Module 10 — NOT cacheable, this has side effects
  public static void deleteOrder(Id orderId) {
    try {
      delete [SELECT Id FROM Order__c WHERE Id = :orderId];
    } catch (Exception e) {
      AuraHandledException ex = new AuraHandledException(e.getMessage());  // Module 10
      ex.setMessage('Unable to delete this Order. It may be referenced elsewhere.');
      throw ex;
    }
  }
}

import { createElement } from 'lwc';
import OrderDashboard from 'c/orderDashboard';
import deleteOrder from '@salesforce/apex/OrderController.deleteOrder';

jest.mock('@salesforce/apex/OrderController.deleteOrder',
  () => ({ default: jest.fn() }), { virtual: true });

it('shows a success toast after a confirmed delete', async () => {
  deleteOrder.mockResolvedValue();                       // Module 13 — mocking success
  const element = createElement('c-order-dashboard', { is: OrderDashboard });
  document.body.appendChild(element);

  const handler = jest.fn();
  element.addEventListener('lightning__showtoast', handler);  // listening for ShowToastEvent

  // ...simulate the row's delete click and modal confirmation here...
  await Promise.resolve();                                  // Module 13 — wait for the re-render

  expect(handler).toHaveBeenCalled();                          // Module 13 — assert observable behavior
});

// PERFORMANCE (Module 12): if XYZ Company Accounts can have 1000+ Orders,
// add pagination to c-order-list rather than rendering every row at once,
// and confirm Order__c records use stable Id-based keys, never array indexes.

// SECURITY (Module 14): no raw DOM manipulation reaching outside this
// component's own shadowRoot, no third-party libraries imported without
// checking LWS compatibility first.

# Run the full test suite first — never deploy untested code (Module 13 + 14)
npm run test:unit

# Deploy every component and Apex class built across this Capstone
sf project deploy start --target-org myDevOrg

# Add c-order-dashboard to an Account record page via Lightning App Builder,
# then verify it genuinely works end to end, with real data, in the real org