digraph clean_code_check {
    "Reviewing/writing code?" [shape=diamond];
    "Function >20 lines?" [shape=diamond];
    "Unclear names?" [shape=diamond];
    "Error handling?" [shape=diamond];
    "Apply clean code" [shape=box, style=filled];
    "Continue" [shape=box];

    "Reviewing/writing code?" -> "Function >20 lines?" [label="yes"];
    "Reviewing/writing code?" -> "Continue" [label="no"];
    "Function >20 lines?" -> "Apply clean code" [label="yes"];
    "Function >20 lines?" -> "Unclear names?" [label="no"];
    "Unclear names?" -> "Apply clean code" [label="yes"];
    "Unclear names?" -> "Error handling?" [label="no"];
    "Error handling?" -> "Apply clean code" [label="issues"];
    "Error handling?" -> "Continue" [label="ok"];
}

// ❌ BAD: Unclear names
const d = new Date();
const list = getItems();
function process(x) { ... }
function handle(data) { ... }

// ✅ GOOD: Intention-revealing names
const orderCreatedAt = new Date();
const activeCustomers = getActiveCustomers();
function calculateOrderTotal(order) { ... }
function validateUserCredentials(credentials) { ... }

// ❌ These reveal nothing
const data = fetch();
const result = process(data);
const info = getInfo();
const temp = calculate();

// ✅ Be specific
const userProfile = fetchUserProfile();
const validatedOrder = validateOrder(rawOrder);
const shippingCost = calculateShippingCost();

// ❌ BAD: Function does too much (violation of SRP)
function processOrder(order) {
  // Validate order (10 lines)
  if (!order.items) throw new Error('No items');
  if (order.items.length === 0) throw new Error('Empty order');
  // ... more validation

  // Calculate totals (15 lines)
  let total = 0;
  for (const item of order.items) {
    total += item.price * item.quantity;
  }
  // ... apply taxes, fees

  // Apply discounts (10 lines)
  if (order.coupon) {
    total = total * (1 - order.coupon.discount);
  }
  // ... more discount logic

  // Send notifications (10 lines)
  sendEmail(order.customer.email, 'Order confirmed');
  // ... more notifications

  // Update inventory (10 lines)
  for (const item of order.items) {
    decrementStock(item.productId, item.quantity);
  }
}

// ✅ GOOD: Small, focused functions
function processOrder(order) {
  validateOrder(order);
  const subtotal = calculateSubtotal(order);
  const total = applyDiscounts(order, subtotal);
  notifyCustomer(order);
  updateInventory(order);
  return { total };
}

function validateOrder(order) {
  if (!order.items?.length) {
    throw new InvalidOrderError('Order must have items');
  }
}

function calculateSubtotal(order) {
  return order.items.reduce(
    (sum, item) => sum + item.price * item.quantity,
    0
  );
}

// ❌ BAD: Class has multiple responsibilities
class UserService {
  createUser(data) { ... }
  sendWelcomeEmail(user) { ... }      // Email responsibility
  generateReport(users) { ... }       // Reporting responsibility
  validatePassword(password) { ... }  // Validation responsibility
}

// ✅ GOOD: Separated responsibilities
class UserService {
  createUser(data) { ... }
}

class EmailService {
  sendWelcomeEmail(user) { ... }
}

class UserReportGenerator {
  generateReport(users) { ... }
}

class PasswordValidator {
  validate(password) { ... }
}

// ❌ BAD: Must modify class for new payment types
class PaymentProcessor {
  process(payment) {
    if (payment.type === 'credit') { ... }
    else if (payment.type === 'paypal') { ... }
    else if (payment.type === 'crypto') { ... }  // Keep adding
  }
}

// ✅ GOOD: Extensible via new classes
interface PaymentHandler {
  canHandle(payment): boolean;
  process(payment): void;
}

class PaymentProcessor {
  constructor(private handlers: PaymentHandler[]) {}

  process(payment) {
    const handler = this.handlers.find(h => h.canHandle(payment));
    if (!handler) throw new UnsupportedPaymentError();
    return handler.process(payment);
  }
}

// ❌ BAD: Square violates Rectangle contract
class Rectangle {
  setWidth(w) { this.width = w; }
  setHeight(h) { this.height = h; }
}

class Square extends Rectangle {
  setWidth(w) { this.width = this.height = w; }  // Unexpected behavior
}

// ✅ GOOD: Separate types with correct contracts
interface Shape {
  getArea(): number;
}

class Rectangle implements Shape { ... }
class Square implements Shape { ... }

// ❌ BAD: Fat interface
interface Worker {
  work();
  eat();
  sleep();
  attendMeeting();
}

// ✅ GOOD: Segregated interfaces
interface Workable { work(); }
interface Eatable { eat(); }
interface Meetable { attendMeeting(); }

class Developer implements Workable, Eatable, Meetable { ... }
class Robot implements Workable { ... }  // Robots don't eat or meet

// ❌ BAD: Direct dependency on concrete class
class OrderService {
  private db = new MySQLDatabase();  // Tight coupling

  saveOrder(order) {
    this.db.insert('orders', order);
  }
}

// ✅ GOOD: Depend on abstraction
interface Database {
  insert(table: string, data: object): void;
}

class OrderService {
  constructor(private db: Database) {}  // Injected abstraction

  saveOrder(order) {
    this.db.insert('orders', order);
  }
}

// ❌ BAD: Too many parameters
function createUser(
  name, email, age, address, city, country, phone, isAdmin, department
) { ... }

// ✅ GOOD: Use parameter object
interface CreateUserParams {
  name: string;
  email: string;
  age: number;
  address: Address;
  phone: string;
  role: UserRole;
}

function createUser(params: CreateUserParams) { ... }

// ❌ BAD: Method envies Order's data
class InvoiceGenerator {
  generateTotal(order) {
    return order.items
      .filter(i => !i.cancelled)
      .reduce((sum, i) => sum + i.price * i.quantity, 0)
      * (1 - order.discount);
  }
}

// ✅ GOOD: Logic belongs in Order
class Order {
  calculateTotal() {
    return this.activeItems
      .reduce((sum, i) => sum + i.getSubtotal(), 0)
      .applyDiscount(this.discount);
  }
}

// ❌ BAD: Swallowing errors
try {
  await processPayment();
} catch (e) {
  console.log(e);  // Error swallowed, user sees nothing
}

// ❌ BAD: Generic catch
try {
  await processPayment();
} catch (e) {
  throw new Error('Payment failed');  // Lost context
}

// ✅ GOOD: Specific handling, proper propagation
try {
  await processPayment();
} catch (error) {
  if (error instanceof PaymentDeclinedError) {
    return { success: false, reason: 'payment_declined' };
  }
  if (error instanceof InsufficientFundsError) {
    return { success: false, reason: 'insufficient_funds' };
  }
  // Re-throw unexpected errors
  throw error;
}

// ❌ BAD: Comments explain WHAT (redundant)
// Loop through items and add prices
for (const item of items) {
  total += item.price;
}

// ❌ BAD: Comment compensates for bad naming
// Check if user can access admin panel
if (u.r === 1) { ... }

// ✅ GOOD: Self-documenting code, no comment needed
for (const item of items) {
  orderTotal += item.price;
}

// ✅ GOOD: Comment explains WHY (business rule)
// VAT is calculated at checkout, not here, per finance requirement FR-2341
const subtotal = items.reduce((sum, i) => sum + i.price, 0);

// ✅ GOOD: Comment explains non-obvious decision
// Using insertion sort here because arrays are typically <10 items
// and insertion sort outperforms quicksort for small n
insertionSort(items);