Sf Debug

/**
 * Apex Benchmarking Template
 *
 * Reliable performance testing using Dan Appleman's technique from
 * "Advanced Apex Programming". Run in Anonymous Apex for consistent results.
 *
 * Features:
 * - Warm-up phase to normalize JIT compilation
 * - Multiple iterations for statistical accuracy
 * - Side-by-side comparison of two approaches
 * - Automatic winner determination
 *
 * @see https://www.jamessimone.net/blog/joys-of-apex/benchmarking-matters/
 * @see https://www.advancedapex.com/
 */

// ═══════════════════════════════════════════════════════════════════════════
// SIMPLE BENCHMARK (Copy into Anonymous Apex)
// ═══════════════════════════════════════════════════════════════════════════

// Quick single-operation benchmark
Long startTime = System.currentTimeMillis();

for (Integer i = 0; i < 10000; i++) {
    // Your operation here
    String s = 'test'.toUpperCase();
}

Long duration = System.currentTimeMillis() - startTime;
System.debug('Duration: ' + duration + 'ms');
System.debug('Per iteration: ' + (duration / 10000.0) + 'ms');


// ═══════════════════════════════════════════════════════════════════════════
// COMPARISON BENCHMARK CLASS
// ═══════════════════════════════════════════════════════════════════════════

/**
 * Compare two implementations side-by-side
 *
 * Usage in Anonymous Apex:
 *   BenchmarkComparison.run();
 */
public class BenchmarkComparison {

    private static final Integer ITERATIONS = 10000;
    private static final Integer WARMUP_ITERATIONS = 100;

    public static void run() {
        System.debug('═══════════════════════════════════════════════════════');
        System.debug('BENCHMARK: [Description Here]');
        System.debug('Iterations: ' + ITERATIONS);
        System.debug('═══════════════════════════════════════════════════════');

        // Warm-up phase (normalizes JIT compilation effects)
        System.debug('\n🔥 Warm-up phase...');
        for (Integer i = 0; i < WARMUP_ITERATIONS; i++) {
            methodA();
            methodB();
        }
        System.debug('   Warm-up complete');

        // Benchmark Method A
        System.debug('\n📊 Running Method A...');
        Long startA = System.currentTimeMillis();
        for (Integer i = 0; i < ITERATIONS; i++) {
            methodA();
        }
        Long durationA = System.currentTimeMillis() - startA;

        // Benchmark Method B
        System.debug('📊 Running Method B...');
        Long startB = System.currentTimeMillis();
        for (Integer i = 0; i < ITERATIONS; i++) {
            methodB();
        }
        Long durationB = System.currentTimeMillis() - startB;

        // Results
        System.debug('\n═══════════════════════════════════════════════════════');
        System.debug('RESULTS');
        System.debug('═══════════════════════════════════════════════════════');
        System.debug('Method A: ' + durationA + 'ms (' + (durationA / (Decimal)ITERATIONS) + 'ms per iteration)');
        System.debug('Method B: ' + durationB + 'ms (' + (durationB / (Decimal)ITERATIONS) + 'ms per iteration)');
        System.debug('───────────────────────────────────────────────────────');

        Long difference = Math.abs(durationA - durationB);
        String winner = durationA < durationB ? 'Method A' : 'Method B';
        Decimal improvement = durationA < durationB
            ? (durationB / (Decimal)durationA)
            : (durationA / (Decimal)durationB);

        System.debug('🏆 Winner: ' + winner);
        System.debug('   Difference: ' + difference + 'ms');
        System.debug('   Improvement: ' + improvement.setScale(1) + 'x faster');

        // Governor limits status
        System.debug('\n📈 Governor Limits Used:');
        System.debug('   CPU Time: ' + Limits.getCpuTime() + '/' + Limits.getLimitCpuTime() + 'ms');
        System.debug('   Heap Size: ' + Limits.getHeapSize() + '/' + Limits.getLimitHeapSize() + ' bytes');
    }

    // ═══════════════════════════════════════════════════════════════════
    // METHODS TO COMPARE (Replace with your implementations)
    // ═══════════════════════════════════════════════════════════════════

    private static void methodA() {
        // Implementation A - e.g., String concatenation
        String result = '';
        for (Integer i = 0; i < 10; i++) {
            result += 'item' + i + ',';
        }
    }

    private static void methodB() {
        // Implementation B - e.g., String.join()
        List<String> items = new List<String>();
        for (Integer i = 0; i < 10; i++) {
            items.add('item' + i);
        }
        String result = String.join(items, ',');
    }
}


// ═══════════════════════════════════════════════════════════════════════════
// DATA STRUCTURE BENCHMARK
// ═══════════════════════════════════════════════════════════════════════════

/**
 * Compare List vs Set vs Map lookup performance
 *
 * Expected Results:
 *   List.contains(): O(n) - slow
 *   Set.contains(): O(1) - fast
 *   Map.containsKey(): O(1) - fast
 */
public class DataStructureBenchmark {

    private static final Integer DATA_SIZE = 1000;
    private static final Integer LOOKUPS = 5000;

    public static void run() {
        // Setup test data
        List<String> testList = new List<String>();
        Set<String> testSet = new Set<String>();
        Map<String, Boolean> testMap = new Map<String, Boolean>();

        for (Integer i = 0; i < DATA_SIZE; i++) {
            String key = 'key_' + i;
            testList.add(key);
            testSet.add(key);
            testMap.put(key, true);
        }

        // Random lookup keys (mix of existing and non-existing)
        List<String> lookupKeys = new List<String>();
        for (Integer i = 0; i < LOOKUPS; i++) {
            lookupKeys.add('key_' + Math.mod(i * 7, DATA_SIZE * 2));
        }

        System.debug('═══════════════════════════════════════════════════════');
        System.debug('DATA STRUCTURE LOOKUP BENCHMARK');
        System.debug('Data Size: ' + DATA_SIZE + ' | Lookups: ' + LOOKUPS);
        System.debug('═══════════════════════════════════════════════════════');

        // List.contains()
        Long startList = System.currentTimeMillis();
        for (String key : lookupKeys) {
            Boolean found = testList.contains(key);
        }
        Long durationList = System.currentTimeMillis() - startList;

        // Set.contains()
        Long startSet = System.currentTimeMillis();
        for (String key : lookupKeys) {
            Boolean found = testSet.contains(key);
        }
        Long durationSet = System.currentTimeMillis() - startSet;

        // Map.containsKey()
        Long startMap = System.currentTimeMillis();
        for (String key : lookupKeys) {
            Boolean found = testMap.containsKey(key);
        }
        Long durationMap = System.currentTimeMillis() - startMap;

        // Results
        System.debug('\nRESULTS:');
        System.debug('List.contains(): ' + durationList + 'ms');
        System.debug('Set.contains():  ' + durationSet + 'ms');
        System.debug('Map.containsKey(): ' + durationMap + 'ms');

        if (durationList > 0) {
            System.debug('\nSet is ' + (durationList / Math.max(1, durationSet)) + 'x faster than List');
        }
    }
}


// ═══════════════════════════════════════════════════════════════════════════
// LOOP STYLE BENCHMARK
// ═══════════════════════════════════════════════════════════════════════════

/**
 * Compare different loop constructs
 *
 * Expected Results (from Beyond the Cloud):
 *   While loop: ~0.4s (fastest)
 *   Cached iterator: ~0.8s
 *   For loop (index): ~1.4s
 *   Enhanced for-each: ~2.4s
 */
public class LoopBenchmark {

    private static final Integer ITERATIONS = 10000;

    public static void run() {
        // Create test data
        List<Integer> numbers = new List<Integer>();
        for (Integer i = 0; i < 1000; i++) {
            numbers.add(i);
        }

        System.debug('═══════════════════════════════════════════════════════');
        System.debug('LOOP STYLE BENCHMARK');
        System.debug('Outer Iterations: ' + ITERATIONS + ' | List Size: ' + numbers.size());
        System.debug('═══════════════════════════════════════════════════════');

        // While loop with iterator
        Long startWhile = System.currentTimeMillis();
        for (Integer outer = 0; outer < ITERATIONS; outer++) {
            Iterator<Integer> iter = numbers.iterator();
            while (iter.hasNext()) {
                Integer num = iter.next();
            }
        }
        Long durationWhile = System.currentTimeMillis() - startWhile;

        // Traditional for loop
        Long startFor = System.currentTimeMillis();
        for (Integer outer = 0; outer < ITERATIONS; outer++) {
            for (Integer i = 0; i < numbers.size(); i++) {
                Integer num = numbers[i];
            }
        }
        Long durationFor = System.currentTimeMillis() - startFor;

        // Enhanced for-each
        Long startEnhanced = System.currentTimeMillis();
        for (Integer outer = 0; outer < ITERATIONS; outer++) {
            for (Integer num : numbers) {
                // Just iterate
            }
        }
        Long durationEnhanced = System.currentTimeMillis() - startEnhanced;

        // Results
        System.debug('\nRESULTS:');
        System.debug('While loop:     ' + durationWhile + 'ms');
        System.debug('For loop:       ' + durationFor + 'ms');
        System.debug('Enhanced for:   ' + durationEnhanced + 'ms');

        System.debug('\n📊 Analysis:');
        Long fastest = Math.min(durationWhile, Math.min(durationFor, durationEnhanced));
        if (durationWhile == fastest) {
            System.debug('🏆 While loop is fastest');
        } else if (durationFor == fastest) {
            System.debug('🏆 For loop is fastest');
        } else {
            System.debug('🏆 Enhanced for is fastest');
        }
    }
}


// ═══════════════════════════════════════════════════════════════════════════
// STRING BENCHMARK (demonstrates 22x improvement)
// ═══════════════════════════════════════════════════════════════════════════

/**
 * String concatenation vs String.join()
 *
 * Expected Results (from Justus van den Berg):
 *   Concatenation: 11,767ms for 1,750 items (CPU LIMIT)
 *   String.join(): 539ms for 7,500 items (still running)
 *   Improvement: ~22x faster
 */
public class StringBenchmark {

    public static void run() {
        System.debug('═══════════════════════════════════════════════════════');
        System.debug('STRING BUILDING BENCHMARK');
        System.debug('═══════════════════════════════════════════════════════');

        // Test with safe number of items
        Integer itemCount = 500;

        // Method 1: String concatenation (BAD)
        Long startConcat = System.currentTimeMillis();
        String resultConcat = '';
        for (Integer i = 0; i < itemCount; i++) {
            resultConcat += 'Item_' + i + '_Name\n';
        }
        Long durationConcat = System.currentTimeMillis() - startConcat;

        // Method 2: String.join() (GOOD)
        Long startJoin = System.currentTimeMillis();
        List<String> items = new List<String>();
        for (Integer i = 0; i < itemCount; i++) {
            items.add('Item_' + i + '_Name');
        }
        String resultJoin = String.join(items, '\n');
        Long durationJoin = System.currentTimeMillis() - startJoin;

        // Results
        System.debug('\nRESULTS (' + itemCount + ' items):');
        System.debug('String +=:      ' + durationConcat + 'ms');
        System.debug('String.join():  ' + durationJoin + 'ms');

        if (durationJoin > 0 && durationConcat > durationJoin) {
            System.debug('\n🏆 String.join() is ' + (durationConcat / durationJoin) + 'x faster!');
        }

        System.debug('\n⚠️ WARNING: With larger datasets, concatenation hits CPU limit!');
        System.debug('   Blog benchmark: 11,767ms for 1,750 items (concat) vs 539ms for 7,500 items (join)');
    }
}

/**
 * CPU TIME AND HEAP SIZE OPTIMIZATION PATTERNS
 *
 * CPU Limits:
 *   - Synchronous: 10,000 ms
 *   - Asynchronous: 60,000 ms
 *
 * Heap Limits:
 *   - Synchronous: 6 MB
 *   - Asynchronous: 12 MB
 *
 * This template demonstrates optimization patterns for CPU and heap limits.
 */

// ═══════════════════════════════════════════════════════════════════════════
// CPU OPTIMIZATION: ALGORITHM COMPLEXITY
// ═══════════════════════════════════════════════════════════════════════════

public class CPUOptimization {

    // BEFORE: O(n²) - Nested loops are expensive
    public void findDuplicatesBAD(List<Contact> contacts) {
        List<Contact> duplicates = new List<Contact>();

        for (Integer i = 0; i < contacts.size(); i++) {
            for (Integer j = i + 1; j < contacts.size(); j++) {
                if (contacts[i].Email == contacts[j].Email) {
                    duplicates.add(contacts[j]);
                }
            }
        }
    }

    // AFTER: O(n) - Use Map for lookups
    public List<Contact> findDuplicatesGOOD(List<Contact> contacts) {
        Map<String, Contact> emailToContact = new Map<String, Contact>();
        List<Contact> duplicates = new List<Contact>();

        for (Contact c : contacts) {
            if (c.Email == null) continue;

            String normalizedEmail = c.Email.toLowerCase();
            if (emailToContact.containsKey(normalizedEmail)) {
                duplicates.add(c);
            } else {
                emailToContact.put(normalizedEmail, c);
            }
        }

        return duplicates;
    }

    // BEFORE: Expensive string concatenation in loop
    public String buildReportBAD(List<Account> accounts) {
        String report = '';
        for (Account acc : accounts) {
            report += acc.Name + '\n';  // Creates new string each iteration!
        }
        return report;
    }

    // AFTER: Use List and join
    public String buildReportGOOD(List<Account> accounts) {
        List<String> lines = new List<String>();
        for (Account acc : accounts) {
            lines.add(acc.Name);
        }
        return String.join(lines, '\n');
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// CPU OPTIMIZATION: CACHING
// ═══════════════════════════════════════════════════════════════════════════

public class CachingPatterns {

    // Cache expensive calculations
    private static Map<String, Decimal> calculationCache = new Map<String, Decimal>();

    public static Decimal getDiscountRate(String productCode, String region) {
        String cacheKey = productCode + ':' + region;

        if (calculationCache.containsKey(cacheKey)) {
            return calculationCache.get(cacheKey);  // Cache hit - no CPU cost
        }

        // Expensive calculation only happens once per unique key
        Decimal rate = performExpensiveCalculation(productCode, region);
        calculationCache.put(cacheKey, rate);

        return rate;
    }

    private static Decimal performExpensiveCalculation(String productCode, String region) {
        // Simulate complex calculation
        return 0.15;
    }

    // Platform Cache for cross-transaction caching
    public static Decimal getDiscountRateWithPlatformCache(String productCode, String region) {
        String cacheKey = 'discount_' + productCode + '_' + region;

        // Try to get from Platform Cache (Org partition)
        Cache.OrgPartition orgPart = Cache.Org.getPartition('local.DiscountCache');
        Decimal cachedRate = (Decimal)orgPart.get(cacheKey);

        if (cachedRate != null) {
            return cachedRate;
        }

        // Calculate and cache
        Decimal rate = performExpensiveCalculation(productCode, region);
        orgPart.put(cacheKey, rate, 3600);  // Cache for 1 hour

        return rate;
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// HEAP OPTIMIZATION: LARGE DATA PROCESSING
// ═══════════════════════════════════════════════════════════════════════════

public class HeapOptimization {

    // BEFORE: Loads all records into heap at once
    public void processAllAccountsBAD() {
        List<Account> allAccounts = [SELECT Id, Name FROM Account];  // Could be millions!

        for (Account acc : allAccounts) {
            // Process each account
        }
    }

    // AFTER: SOQL FOR loop - streams records, doesn't load all into heap
    public void processAllAccountsGOOD() {
        for (Account acc : [SELECT Id, Name FROM Account]) {
            // Each record is loaded individually
            // Previous record can be garbage collected
            processAccount(acc);
        }
    }

    private void processAccount(Account acc) {
        // Process single account
    }

    // AFTER: Batch processing for very large datasets
    public void processAllAccountsBATCH() {
        // Use Database.executeBatch for millions of records
        Database.executeBatch(new AccountProcessorBatch(), 200);
    }
}

// Batch class for large datasets
public class AccountProcessorBatch implements Database.Batchable<SObject> {

    public Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator('SELECT Id, Name FROM Account');
    }

    public void execute(Database.BatchableContext bc, List<Account> scope) {
        // Process 200 records at a time (controlled heap usage)
        for (Account acc : scope) {
            // Process each account
        }
    }

    public void finish(Database.BatchableContext bc) {
        // Optional: Send completion notification
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// HEAP OPTIMIZATION: CLEARING REFERENCES
// ═══════════════════════════════════════════════════════════════════════════

public class HeapClearingPatterns {

    // Clear large collections when no longer needed
    public void processWithClearing() {
        // Phase 1: Query and process
        List<Account> accounts = [SELECT Id, Name FROM Account LIMIT 10000];
        Map<Id, String> accountNames = new Map<Id, String>();

        for (Account acc : accounts) {
            accountNames.put(acc.Id, acc.Name);
        }

        // Clear the original list - no longer needed
        accounts.clear();
        accounts = null;

        // Phase 2: Use the map
        for (Id accId : accountNames.keySet()) {
            // Process using map
        }

        // Clear the map when done
        accountNames.clear();
        accountNames = null;
    }

    // Use transient for Visualforce controllers
    public class LargeDataController {
        // transient = not stored in view state, reduces heap in page transitions
        transient public List<Account> largeAccountList { get; set; }

        public LargeDataController() {
            largeAccountList = [SELECT Id, Name FROM Account LIMIT 5000];
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// CPU OPTIMIZATION: ASYNC PROCESSING
// ═══════════════════════════════════════════════════════════════════════════

public class AsyncProcessingPatterns {

    // Move expensive operations to @future
    @future
    public static void processExpensiveOperation(Set<Id> recordIds) {
        // Has 60 second CPU limit instead of 10 seconds
        for (Id recordId : recordIds) {
            // Expensive processing
        }
    }

    // Use Queueable for chained processing
    public class ExpensiveQueueable implements Queueable {
        private List<Id> recordIds;

        public ExpensiveQueueable(List<Id> recordIds) {
            this.recordIds = recordIds;
        }

        public void execute(QueueableContext context) {
            // Process first batch
            List<Id> batch = new List<Id>();
            List<Id> remaining = new List<Id>();

            for (Integer i = 0; i < recordIds.size(); i++) {
                if (i < 100) {
                    batch.add(recordIds[i]);
                } else {
                    remaining.add(recordIds[i]);
                }
            }

            // Process this batch
            processBatch(batch);

            // Chain next batch if needed
            if (!remaining.isEmpty()) {
                System.enqueueJob(new ExpensiveQueueable(remaining));
            }
        }

        private void processBatch(List<Id> batch) {
            // Process 100 records
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN: LIMITS MONITORING
// ═══════════════════════════════════════════════════════════════════════════

public class LimitsMonitoring {

    // Check limits during execution
    public void processWithLimitChecking(List<Account> accounts) {
        Integer cpuWarning = 8000;  // 80% of 10,000ms limit
        Integer heapWarning = 4800000;  // 80% of 6MB limit

        for (Account acc : accounts) {
            // Check CPU limit
            if (Limits.getCpuTime() > cpuWarning) {
                System.debug(LoggingLevel.WARN,
                    'CPU limit approaching: ' + Limits.getCpuTime() + 'ms');
                // Consider switching to async
                break;
            }

            // Check heap limit
            if (Limits.getHeapSize() > heapWarning) {
                System.debug(LoggingLevel.WARN,
                    'Heap limit approaching: ' + Limits.getHeapSize() + ' bytes');
                break;
            }

            processAccount(acc);
        }
    }

    // Debug helper: Print all limits
    public static void debugLimits() {
        System.debug('=== GOVERNOR LIMITS ===');
        System.debug('SOQL Queries: ' + Limits.getQueries() + '/' + Limits.getLimitQueries());
        System.debug('DML Statements: ' + Limits.getDmlStatements() + '/' + Limits.getLimitDmlStatements());
        System.debug('DML Rows: ' + Limits.getDmlRows() + '/' + Limits.getLimitDmlRows());
        System.debug('CPU Time: ' + Limits.getCpuTime() + '/' + Limits.getLimitCpuTime());
        System.debug('Heap Size: ' + Limits.getHeapSize() + '/' + Limits.getLimitHeapSize());
        System.debug('Callouts: ' + Limits.getCallouts() + '/' + Limits.getLimitCallouts());
    }
}

/**
 * DML IN LOOP FIX PATTERN
 *
 * Problem: DML operations inside loops consume governor limits rapidly
 * Detection: DEBUG LOG shows repeated DML_BEGIN entries
 * Limits:
 *   - 150 DML statements per transaction
 *   - 10,000 DML rows per transaction
 *
 * This template demonstrates the collection pattern to fix DML in loops.
 */

// ═══════════════════════════════════════════════════════════════════════════
// BEFORE: DML IN LOOP (PROBLEMATIC)
// ═══════════════════════════════════════════════════════════════════════════

public class ContactService_BEFORE {

    // This method will fail if accounts.size() > 150
    public void createContactsForAccounts(List<Account> accounts) {
        for (Account acc : accounts) {
            // DML inside loop - each iteration uses 1 DML statement
            Contact c = new Contact(
                FirstName = 'Primary',
                LastName = 'Contact',
                AccountId = acc.Id,
                Email = acc.Name.replaceAll(' ', '') + '@example.com'
            );
            insert c;  // DML in loop!
        }
    }

    // Updates in loop - also problematic
    public void updateAccountStatuses(List<Account> accounts, String newStatus) {
        for (Account acc : accounts) {
            acc.Status__c = newStatus;
            update acc;  // DML in loop!
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// AFTER: COLLECTION PATTERN (CORRECT)
// ═══════════════════════════════════════════════════════════════════════════

public class ContactService_AFTER {

    // This method uses only 1 DML statement regardless of accounts.size()
    public void createContactsForAccounts(List<Account> accounts) {
        // Step 1: Build list of records to insert
        List<Contact> contactsToInsert = new List<Contact>();

        for (Account acc : accounts) {
            Contact c = new Contact(
                FirstName = 'Primary',
                LastName = 'Contact',
                AccountId = acc.Id,
                Email = acc.Name.replaceAll(' ', '') + '@example.com'
            );
            contactsToInsert.add(c);  // Add to list, no DML
        }

        // Step 2: Single DML statement AFTER the loop
        if (!contactsToInsert.isEmpty()) {
            insert contactsToInsert;
        }
    }

    // Updates outside loop - correct pattern
    public void updateAccountStatuses(List<Account> accounts, String newStatus) {
        // Modify in loop (no DML)
        for (Account acc : accounts) {
            acc.Status__c = newStatus;
        }

        // Single DML after loop
        if (!accounts.isEmpty()) {
            update accounts;
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// ADVANCED: MIXED INSERT/UPDATE/DELETE PATTERN
// ═══════════════════════════════════════════════════════════════════════════

public class RecordProcessor_Bulkified {

    /**
     * Process records with conditional insert/update/delete
     * Uses collections for all DML operations
     */
    public void processRecords(List<Account> accounts) {
        // Collections for different DML operations
        List<Contact> contactsToInsert = new List<Contact>();
        List<Contact> contactsToUpdate = new List<Contact>();
        List<Contact> contactsToDelete = new List<Contact>();

        // Query existing contacts once
        Set<Id> accountIds = new Set<Id>();
        for (Account acc : accounts) {
            accountIds.add(acc.Id);
        }

        Map<Id, Contact> existingContacts = new Map<Id, Contact>();
        for (Contact c : [
            SELECT Id, AccountId, Email, IsInactive__c
            FROM Contact
            WHERE AccountId IN :accountIds
        ]) {
            existingContacts.put(c.AccountId, c);
        }

        // Process and categorize
        for (Account acc : accounts) {
            Contact existing = existingContacts.get(acc.Id);

            if (existing == null) {
                // No contact exists - INSERT
                contactsToInsert.add(new Contact(
                    FirstName = 'Auto',
                    LastName = 'Generated',
                    AccountId = acc.Id
                ));
            } else if (existing.IsInactive__c) {
                // Inactive contact - DELETE
                contactsToDelete.add(existing);
            } else {
                // Active contact - UPDATE
                existing.LastActivityDate__c = Date.today();
                contactsToUpdate.add(existing);
            }
        }

        // Execute DML operations (3 statements max, regardless of record count)
        if (!contactsToInsert.isEmpty()) {
            insert contactsToInsert;
        }
        if (!contactsToUpdate.isEmpty()) {
            update contactsToUpdate;
        }
        if (!contactsToDelete.isEmpty()) {
            delete contactsToDelete;
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN: UPSERT FOR INSERT-OR-UPDATE LOGIC
// ═══════════════════════════════════════════════════════════════════════════

public class UpsertPatternService {

    /**
     * When you need to insert if not exists, update if exists
     * Use UPSERT with an External ID field
     */
    public void syncExternalContacts(List<ExternalContact> externalData) {
        List<Contact> contactsToUpsert = new List<Contact>();

        for (ExternalContact ext : externalData) {
            Contact c = new Contact(
                External_Id__c = ext.id,  // External ID field
                FirstName = ext.firstName,
                LastName = ext.lastName,
                Email = ext.email
            );
            contactsToUpsert.add(c);
        }

        // Single upsert handles both insert and update
        if (!contactsToUpsert.isEmpty()) {
            upsert contactsToUpsert External_Id__c;
        }
    }

    // Wrapper class for external data
    public class ExternalContact {
        public String id;
        public String firstName;
        public String lastName;
        public String email;
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN: PARTIAL SUCCESS HANDLING
// ═══════════════════════════════════════════════════════════════════════════

public class PartialSuccessService {

    /**
     * Handle partial failures gracefully
     * Use Database.insert with allOrNone = false
     */
    public List<Database.SaveResult> insertWithPartialSuccess(List<Contact> contacts) {
        if (contacts.isEmpty()) {
            return new List<Database.SaveResult>();
        }

        // allOrNone = false allows partial success
        List<Database.SaveResult> results = Database.insert(contacts, false);

        // Log failures for analysis
        for (Integer i = 0; i < results.size(); i++) {
            Database.SaveResult sr = results[i];
            if (!sr.isSuccess()) {
                for (Database.Error err : sr.getErrors()) {
                    System.debug(LoggingLevel.ERROR,
                        'Failed to insert contact: ' + contacts[i] +
                        ' Error: ' + err.getMessage()
                    );
                }
            }
        }

        return results;
    }
}

/**
 * NULL POINTER EXCEPTION FIX PATTERNS
 *
 * Problem: System.NullPointerException when accessing null object properties
 * Detection: DEBUG LOG shows EXCEPTION_THROWN|NullPointerException
 *
 * This template demonstrates null-safe coding patterns.
 */

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 1: SOQL QUERY RETURNING NO RESULTS
// ═══════════════════════════════════════════════════════════════════════════

public class QueryNullSafety {

    // BEFORE: Dangerous - throws exception if no results
    public String getAccountNameUNSAFE(Id accountId) {
        Account acc = [SELECT Name FROM Account WHERE Id = :accountId];
        return acc.Name;  // NullPointerException if query returns nothing!
    }

    // AFTER: Safe - using List and isEmpty check
    public String getAccountNameSAFE(Id accountId) {
        List<Account> accounts = [SELECT Name FROM Account WHERE Id = :accountId LIMIT 1];

        if (accounts.isEmpty()) {
            return null;  // Or throw custom exception, or return default
        }

        return accounts[0].Name;
    }

    // AFTER: Safe - using Safe Navigation Operator (API 62.0+)
    public String getAccountNameSafeNav(Id accountId) {
        Account acc = [SELECT Name FROM Account WHERE Id = :accountId LIMIT 1];
        return acc?.Name;  // Returns null instead of throwing exception
    }

    // AFTER: With default value
    public String getAccountNameWithDefault(Id accountId, String defaultName) {
        List<Account> accounts = [SELECT Name FROM Account WHERE Id = :accountId LIMIT 1];
        return accounts.isEmpty() ? defaultName : accounts[0].Name;
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 2: MAP ACCESS
// ═══════════════════════════════════════════════════════════════════════════

public class MapNullSafety {

    // BEFORE: Dangerous - Map.get() returns null for missing keys
    public void processAccountUNSAFE(Map<Id, Account> accountMap, Id targetId) {
        Account acc = accountMap.get(targetId);
        String name = acc.Name;  // NullPointerException if targetId not in map!
    }

    // AFTER: Check containsKey first
    public void processAccountSAFE(Map<Id, Account> accountMap, Id targetId) {
        if (accountMap.containsKey(targetId)) {
            Account acc = accountMap.get(targetId);
            String name = acc.Name;
            // Process...
        }
    }

    // AFTER: Check for null after get
    public void processAccountNullCheck(Map<Id, Account> accountMap, Id targetId) {
        Account acc = accountMap.get(targetId);
        if (acc != null) {
            String name = acc.Name;
            // Process...
        }
    }

    // AFTER: Safe navigation (API 62.0+)
    public String getAccountNameFromMap(Map<Id, Account> accountMap, Id targetId) {
        return accountMap.get(targetId)?.Name;
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 3: RELATIONSHIP FIELDS
// ═══════════════════════════════════════════════════════════════════════════

public class RelationshipNullSafety {

    // BEFORE: Dangerous - parent record might be null
    public String getOwnerEmailUNSAFE(Contact c) {
        return c.Account.Owner.Email;  // Multiple potential null points!
    }

    // AFTER: Check each level
    public String getOwnerEmailSAFE(Contact c) {
        if (c == null) return null;
        if (c.Account == null) return null;
        if (c.Account.Owner == null) return null;
        return c.Account.Owner.Email;
    }

    // AFTER: Safe navigation chain (API 62.0+)
    public String getOwnerEmailSafeNav(Contact c) {
        return c?.Account?.Owner?.Email;
    }

    // AFTER: With default value
    public String getOwnerEmailWithDefault(Contact c, String defaultEmail) {
        String email = c?.Account?.Owner?.Email;
        return String.isBlank(email) ? defaultEmail : email;
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 4: LIST ACCESS
// ═══════════════════════════════════════════════════════════════════════════

public class ListNullSafety {

    // BEFORE: Dangerous - list might be null or empty
    public Contact getFirstContactUNSAFE(List<Contact> contacts) {
        return contacts[0];  // IndexOutOfBoundsException if empty!
    }

    // AFTER: Check null and empty
    public Contact getFirstContactSAFE(List<Contact> contacts) {
        if (contacts == null || contacts.isEmpty()) {
            return null;
        }
        return contacts[0];
    }

    // Pattern: Null-safe iteration
    public void processContactsSAFE(List<Contact> contacts) {
        // This is safe - for loop on null list doesn't execute
        for (Contact c : contacts ?? new List<Contact>()) {
            // Process contact
        }
    }

    // Alternative: Early return
    public void processContactsEarlyReturn(List<Contact> contacts) {
        if (contacts == null || contacts.isEmpty()) {
            return;
        }

        for (Contact c : contacts) {
            // Process contact
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 5: STRING OPERATIONS
// ═══════════════════════════════════════════════════════════════════════════

public class StringNullSafety {

    // BEFORE: Dangerous - string might be null
    public Boolean containsKeywordUNSAFE(String text, String keyword) {
        return text.contains(keyword);  // NullPointerException if text is null!
    }

    // AFTER: Use String.isNotBlank() or String.isBlank()
    public Boolean containsKeywordSAFE(String text, String keyword) {
        if (String.isBlank(text) || String.isBlank(keyword)) {
            return false;
        }
        return text.contains(keyword);
    }

    // Pattern: Null-safe string comparison
    public Boolean isEqualSAFE(String a, String b) {
        // Both null = equal
        if (a == null && b == null) return true;
        // One null = not equal
        if (a == null || b == null) return false;
        // Both non-null = compare
        return a.equals(b);
    }

    // Pattern: Default value for null strings
    public String getNameWithDefault(Account acc) {
        return String.isBlank(acc?.Name) ? 'Unnamed Account' : acc.Name;
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN 6: TRIGGER CONTEXT
// ═══════════════════════════════════════════════════════════════════════════

public class TriggerNullSafety {

    /**
     * In triggers, old values might not exist (insert)
     * and new values might not exist (delete)
     */
    public void handleTrigger() {
        // Safe: Check context first
        if (Trigger.isInsert) {
            // Trigger.old is null in insert context
            for (Account acc : (List<Account>)Trigger.new) {
                // Process new records
            }
        }

        if (Trigger.isUpdate) {
            Map<Id, Account> oldMap = (Map<Id, Account>)Trigger.oldMap;
            for (Account newAcc : (List<Account>)Trigger.new) {
                Account oldAcc = oldMap.get(newAcc.Id);
                // Both old and new are available
                if (oldAcc.Status__c != newAcc.Status__c) {
                    // Status changed
                }
            }
        }

        if (Trigger.isDelete) {
            // Trigger.new is null in delete context
            for (Account acc : (List<Account>)Trigger.old) {
                // Process deleted records
            }
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// ANTI-PATTERN: OVER-DEFENSIVE CODING
// ═══════════════════════════════════════════════════════════════════════════

public class OverDefensiveCoding {

    /**
     * Don't check for null when it's impossible
     * This adds unnecessary code and cognitive load
     */

    // UNNECESSARY: Trigger.new is never null in insert/update context
    public void badExample() {
        if (Trigger.new != null && !Trigger.new.isEmpty()) {
            for (SObject record : Trigger.new) {
                // Trigger.new is guaranteed non-null in before/after insert/update
            }
        }
    }

    // CORRECT: Trust the platform guarantees
    public void goodExample() {
        for (Account acc : (List<Account>)Trigger.new) {
            // Just use it - Trigger.new is guaranteed in this context
        }
    }
}

/**
 * SOQL IN LOOP FIX PATTERN
 *
 * Problem: SOQL queries inside loops consume governor limits rapidly
 * Detection: DEBUG LOG shows repeated SOQL_EXECUTE_BEGIN entries
 * Limit: 100 SOQL queries per synchronous transaction
 *
 * This template demonstrates the bulkification pattern to fix SOQL in loops.
 */

// ═══════════════════════════════════════════════════════════════════════════
// BEFORE: SOQL IN LOOP (PROBLEMATIC)
// ═══════════════════════════════════════════════════════════════════════════

public class AccountService_BEFORE {

    // This method will fail if accounts.size() > 100
    public void processAccounts(List<Account> accounts) {
        for (Account acc : accounts) {
            // SOQL inside loop - each iteration uses 1 query
            Contact primaryContact = [
                SELECT Id, Email, Phone
                FROM Contact
                WHERE AccountId = :acc.Id
                AND IsPrimary__c = true
                LIMIT 1
            ];

            if (primaryContact != null) {
                acc.Primary_Contact_Email__c = primaryContact.Email;
            }
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// AFTER: BULKIFIED PATTERN (CORRECT)
// ═══════════════════════════════════════════════════════════════════════════

public class AccountService_AFTER {

    // This method uses only 1 SOQL query regardless of accounts.size()
    public void processAccounts(List<Account> accounts) {
        // Step 1: Collect all Account IDs
        Set<Id> accountIds = new Set<Id>();
        for (Account acc : accounts) {
            accountIds.add(acc.Id);
        }

        // Step 2: Single SOQL query BEFORE the loop
        Map<Id, Contact> primaryContactsByAccountId = new Map<Id, Contact>();
        for (Contact c : [
            SELECT Id, Email, Phone, AccountId
            FROM Contact
            WHERE AccountId IN :accountIds
            AND IsPrimary__c = true
        ]) {
            primaryContactsByAccountId.put(c.AccountId, c);
        }

        // Step 3: Access from Map inside loop (no SOQL)
        for (Account acc : accounts) {
            Contact primaryContact = primaryContactsByAccountId.get(acc.Id);
            if (primaryContact != null) {
                acc.Primary_Contact_Email__c = primaryContact.Email;
            }
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// ADVANCED: NESTED RELATIONSHIP PATTERN
// ═══════════════════════════════════════════════════════════════════════════

public class OrderService_Bulkified {

    // Complex scenario: Orders → Accounts → Contacts
    public void processOrders(List<Order> orders) {
        // Collect all Account IDs from Orders
        Set<Id> accountIds = new Set<Id>();
        for (Order o : orders) {
            if (o.AccountId != null) {
                accountIds.add(o.AccountId);
            }
        }

        // Query Accounts with related Contacts in ONE query (relationship query)
        Map<Id, Account> accountsWithContacts = new Map<Id, Account>([
            SELECT Id, Name,
                   (SELECT Id, Email FROM Contacts WHERE IsPrimary__c = true LIMIT 1)
            FROM Account
            WHERE Id IN :accountIds
        ]);

        // Process orders using the pre-queried data
        for (Order o : orders) {
            Account acc = accountsWithContacts.get(o.AccountId);
            if (acc != null && !acc.Contacts.isEmpty()) {
                o.Notification_Email__c = acc.Contacts[0].Email;
            }
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// PATTERN: MAP FACTORY FOR REUSABLE QUERIES
// ═══════════════════════════════════════════════════════════════════════════

public class ContactQueryService {

    /**
     * Factory method to get primary contacts by Account ID
     * Reusable across multiple services
     */
    public static Map<Id, Contact> getPrimaryContactsByAccountId(Set<Id> accountIds) {
        Map<Id, Contact> result = new Map<Id, Contact>();

        if (accountIds.isEmpty()) {
            return result;
        }

        for (Contact c : [
            SELECT Id, FirstName, LastName, Email, Phone, AccountId
            FROM Contact
            WHERE AccountId IN :accountIds
            AND IsPrimary__c = true
        ]) {
            result.put(c.AccountId, c);
        }

        return result;
    }

    /**
     * Get all contacts grouped by Account ID
     * Returns Map<AccountId, List<Contact>>
     */
    public static Map<Id, List<Contact>> getContactsGroupedByAccount(Set<Id> accountIds) {
        Map<Id, List<Contact>> result = new Map<Id, List<Contact>>();

        // Initialize empty lists for all accounts
        for (Id accId : accountIds) {
            result.put(accId, new List<Contact>());
        }

        for (Contact c : [
            SELECT Id, FirstName, LastName, Email, Phone, AccountId
            FROM Contact
            WHERE AccountId IN :accountIds
            ORDER BY CreatedDate DESC
        ]) {
            result.get(c.AccountId).add(c);
        }

        return result;
    }
}