// ── Basic SELECT ──────────────────────────────────────────────
List<Account> accounts = [
    SELECT Id, Name, Industry, AnnualRevenue, Phone
    FROM Account
    WHERE Industry = 'Technology'
      AND AnnualRevenue > 1000000
    ORDER BY Name ASC
    LIMIT 100
];

// ── Bind variables (prevent SOQL injection) ───────────────────
String industry = 'Technology';
Decimal minRevenue = 500000;
List<Account> filtered = [
    SELECT Id, Name FROM Account
    WHERE Industry = :industry
      AND AnnualRevenue >= :minRevenue
];

// ── LIKE operator (wildcard search) ───────────────────────────
String key = '%Salesforce%';
List<Account> matched = [SELECT Id, Name FROM Account WHERE Name LIKE :key];

// ── IN operator with collections ──────────────────────────────
Set<String> industries = new Set<String>{'Technology', 'Finance'};
List<Account> byIndustry = [
    SELECT Id, Name FROM Account WHERE Industry IN :industries
];

// ── Relationship queries ───────────────────────────────────────
// Child-to-parent (dot notation)
List<Contact> contacts = [
    SELECT Id, FirstName, LastName, Account.Name, Account.Industry
    FROM Contact
    WHERE Account.Industry = 'Technology'
];

// Parent-to-child (subquery)
List<Account> withContacts = [
    SELECT Id, Name,
        (SELECT Id, FirstName, LastName, Email
         FROM Contacts
         ORDER BY LastName)
    FROM Account
    WHERE Id IN :accountIds
];
for (Account acc : withContacts) {
    for (Contact c : acc.Contacts) {
        System.debug(c.FirstName + ' works at ' + acc.Name);
    }
}

// ── Aggregate functions ───────────────────────────────────────
AggregateResult[] results = [
    SELECT Industry,
           COUNT(Id) total,
           SUM(AnnualRevenue) totalRevenue,
           AVG(AnnualRevenue) avgRevenue,
           MAX(AnnualRevenue) maxRevenue,
           MIN(AnnualRevenue) minRevenue
    FROM Account
    WHERE AnnualRevenue != null
    GROUP BY Industry
    HAVING COUNT(Id) > 5
    ORDER BY COUNT(Id) DESC
];
for (AggregateResult ar : results) {
    String  ind   = (String)  ar.get('Industry');
    Integer total = (Integer) ar.get('total');
    Decimal sum   = (Decimal) ar.get('totalRevenue');
}

// ── NULL handling ─────────────────────────────────────────────
[SELECT Id FROM Account WHERE Phone  = null]   // no phone set
[SELECT Id FROM Account WHERE Phone != null]   // has phone

// ── FOR UPDATE (row locking) ──────────────────────────────────
List<Account> locked = [SELECT Id, Name FROM Account WHERE Id = :accId FOR UPDATE];

// ── Dynamic SOQL (Database.query) ────────────────────────────
String query = 'SELECT Id, Name FROM Account WHERE Industry = \'' + String.escapeSingleQuotes(industry) + '\' LIMIT 50';
List<Account> dynamic = Database.query(query);

// ── Direct DML — all or nothing (throws on any failure) ───────
Account acc = new Account(Name = 'Acme', Phone = '555-1234');
insert acc;                    // Id is populated after insert

acc.AnnualRevenue = 500000;
update acc;

delete acc;
undelete acc;                  // restores from recycle bin

// ── Upsert — insert if not exists, update if exists ──────────
Account upsertAcc = new Account(
    External_Id__c = 'EXT-001',
    Name = 'External Account'
);
upsert upsertAcc External_Id__c;  // match on external ID field

// ── Database class — partial success (doesn't throw) ─────────
List<Account> accs = new List<Account>{
    new Account(Name = 'Valid Account'),
    new Account()  // missing required Name — will fail
};

List<Database.SaveResult> results = Database.insert(accs, false); // allOrNone=false

for (Integer i = 0; i < results.size(); i++) {
    Database.SaveResult sr = results[i];
    if (sr.isSuccess()) {
        System.debug('Inserted: ' + sr.getId());
    } else {
        for (Database.Error err : sr.getErrors()) {
            System.debug('Error on record ' + i + ': ' + err.getMessage());
            System.debug('Fields: ' + err.getFields());
        }
    }
}

// ── Database.UpsertResult ─────────────────────────────────────
Database.UpsertResult ur = Database.upsert(upsertAcc, External_Id__c, false);
if (ur.isSuccess()) {
    if (ur.isCreated()) System.debug('New record: ' + ur.getId());
    else                System.debug('Updated: '    + ur.getId());
}

// ── Mixed DML error — avoid combining setup and non-setup DML ─
// WRONG: User (setup object) + Account (non-setup) in same context
// insert user; insert account; // throws MixedDmlException
// CORRECT: Use @future or System.runAs() in tests
@future
public static void insertUserAsync(String username) {
    User u = new User(Username = username);
    insert u;
}

// ── List declaration and initialization ───────────────────────
List<String>  names  = new List<String>();
List<Integer> nums   = new List<Integer>{1, 2, 3, 4, 5};
List<Account> accs   = [SELECT Id, Name FROM Account LIMIT 10];

// ── Core methods ──────────────────────────────────────────────
names.add('Alice');              // append to end
names.add(0, 'Bob');             // insert at index 0
names.addAll(new List<String>{'Charlie', 'Diana'}); // add multiple
names.remove(0);                 // remove by index
names.set(0, 'Eve');              // replace at index
String first = names.get(0);     // get by index — O(1)
Integer size = names.size();     // count
Boolean has  = names.contains('Alice'); // O(n) — use Set for membership
names.sort();                     // ascending sort in place
names.clear();                    // remove all

// ── List of SObjects — critical for DML ───────────────────────
List<Account> toUpdate = new List<Account>();
for (Account acc : [SELECT Id, Rating FROM Account]) {
    if (acc.Rating == null) {
        acc.Rating = 'Cold';
        toUpdate.add(acc);
    }
}
if (!toUpdate.isEmpty()) update toUpdate; // 1 DML

// ── Sorting with Comparable interface ────────────────────────
public class Employee implements Comparable {
    public String  name;
    public Integer salary;
    public Integer compareTo(Object other) {
        Employee e = (Employee) other;
        return this.salary - e.salary; // ascending by salary
    }
}
List<Employee> employees = ...; 
employees.sort(); // uses compareTo()

// ── Set — unordered, NO duplicates, O(1) membership check ─────
Set<String> unique = new Set<String>{'a', 'b', 'c'};
unique.add('a');              // no duplicate added — size stays 3
unique.addAll(new List<String>{'d', 'e'});
Boolean has = unique.contains('b'); // O(1) — much faster than List.contains()
unique.remove('a');
Set<String> copy = unique.clone();

// Convert Set ↔ List
List<String> fromSet = new List<String>(unique);
Set<String>  fromList = new Set<String>(fromSet);

// ── Best practice: collect IDs into Set for SOQL ─────────────
Set<Id> accountIds = new Set<Id>();
for (Contact c : Trigger.new) {
    if (c.AccountId != null) accountIds.add(c.AccountId);
}
Map<Id, Account> accMap = new Map<Id, Account>(
    [SELECT Id, Name FROM Account WHERE Id IN :accountIds]
);

// ── Map — key-value pairs, O(1) lookup by key ─────────────────
Map<String, Integer> scores = new Map<String, Integer>{
    'Alice' => 95,
    'Bob'   => 87,
    'Carol' => 92
};

scores.put('Dave', 78);         // add/replace entry
scores.putAll(anotherMap);       // merge maps
Integer alice = scores.get('Alice');  // 95 — O(1)
Boolean hasKey = scores.containsKey('Dave'); // true
scores.remove('Bob');
Set<String> keys   = scores.keySet();   // all keys
List<Integer> vals = scores.values();   // all values
Integer sz        = scores.size();

// ── Map<Id, SObject> — most common pattern ────────────────────
Map<Id, Account> accountMap = new Map<Id, Account>(
    [SELECT Id, Name, Industry FROM Account]
); // constructor from List automatically maps by Id

// O(1) lookup — much better than looping through List
Account found = accountMap.get(someId);

// ── Map of Lists — grouping pattern ──────────────────────────
Map<String, List<Contact>> byLastName = new Map<String, List<Contact>>();
for (Contact c : contacts) {
    if (!byLastName.containsKey(c.LastName)) {
        byLastName.put(c.LastName, new List<Contact>());
    }
    byLastName.get(c.LastName).add(c);
}

// ── try-catch-finally ─────────────────────────────────────────
try {
    Account acc = [SELECT Id FROM Account WHERE Name = 'NoSuchAccount'];
    update acc;
} catch (QueryException e) {
    // Query returned 0 or 2+ rows for single-record assignment
    System.debug('Query error: ' + e.getMessage());
    System.debug('Line: '        + e.getLineNumber());
    System.debug('Stack: '       + e.getStackTraceString());
} catch (DmlException e) {
    // DML failed
    for (Integer i = 0; i < e.getNumDml(); i++) {
        System.debug('DML error: '   + e.getDmlMessage(i));
        System.debug('Status code: '  + e.getDmlStatusCode(i));
        System.debug('Field names: '  + e.getDmlFieldNames(i));
    }
} catch (Exception e) {
    // Catch-all — catches any exception type not caught above
    System.debug('Unexpected: ' + e.getTypeName() + ': ' + e.getMessage());
} finally {
    // Always runs — even if exception was thrown
    // Use for: cleanup, logging, resetting flags
    System.debug('Operation complete');
}

// ── Custom exception classes ──────────────────────────────────
public class AccountServiceException extends Exception {}
public class ValidationException     extends Exception {}
public class IntegrationException     extends Exception {}

// Throwing with message
throw new AccountServiceException('Account not found for Id: ' + recordId);

// Throwing with cause (wrapping another exception)
try {
    insert acc;
} catch (DmlException e) {
    throw new AccountServiceException('Failed to create account: ' + e.getMessage(), e);
}

// ── AuraHandledException — for LWC/Aura error messages ───────
@AuraEnabled
public static Account getAccount(Id recordId) {
    try {
        return [SELECT Id, Name FROM Account WHERE Id = :recordId LIMIT 1];
    } catch (Exception e) {
        throw new AuraHandledException('Could not load account: ' + e.getMessage());
    }
}

// ── Exception hierarchy ───────────────────────────────────────
// Exception (base)
//   ├── DmlException
//   ├── QueryException
//   ├── NullPointerException
//   ├── MathException
//   ├── ListException (index out of bounds)
//   ├── TypeException  (invalid cast)
//   ├── CalloutException
//   ├── JSONException
//   ├── AuraHandledException
//   └── [YourCustomException] extends Exception

// ── Savepoint and rollback ────────────────────────────────────
Savepoint sp = Database.setSavepoint();
try {
    insert accountList;
    insert contactList;
} catch (Exception e) {
    Database.rollback(sp);   // undo all DML since setSavepoint()
    throw e;                 // re-throw for caller to handle
}

// ── @future — simplest async, primitive params only ───────────
public class FutureExample {

    // callout=true allows HTTP callouts from trigger context
    @future(callout=true)
    public static void sendToExternalSystem(
        List<Id> recordIds  // must be primitives or List/Set of primitives
    ) {
        List<Account> accounts = [
            SELECT Id, Name FROM Account WHERE Id IN :recordIds
        ];
        // HTTP callout logic here
        Http h = new Http();
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:My_Named_Credential/api/sync');
        req.setMethod('POST');
        req.setBody(JSON.serialize(accounts));
        HttpResponse res = h.send(req);
        if (res.getStatusCode() != 200) {
            System.debug('Callout failed: ' + res.getStatus());
        }
    }
}

// ── Queueable — recommended over @future for new code ─────────
public class AccountSyncQueueable implements Queueable, Database.AllowsCallouts {

    private final List<Account> accounts;
    private final Integer batchNumber;

    public AccountSyncQueueable(List<Account> accs, Integer batch) {
        this.accounts    = accs;
        this.batchNumber = batch;
    }

    public void execute(QueueableContext ctx) {
        try {
            // Process accounts, make callout
            Http h = new Http();
            HttpRequest req = new HttpRequest();
            req.setEndpoint('callout:ERP/accounts');
            req.setMethod('POST');
            req.setBody(JSON.serialize(accounts));
            HttpResponse res = h.send(req);

            // Chain: enqueue next job if more data exists
            if (batchNumber < 10) {
                System.enqueueJob(
                    new AccountSyncQueueable(nextBatch, batchNumber + 1)
                );
            }
        } catch (Exception e) {
            System.debug('Queueable error: ' + e.getMessage());
        }
    }
}
// Usage:
Id jobId = System.enqueueJob(new AccountSyncQueueable(accounts, 1));

// ── Batch Apex — for processing millions of records ───────────
public class AccountRatingBatch
    implements Database.Batchable<SObject>, Database.Stateful {

    private Integer processedCount = 0;  // Database.Stateful — persist state
    private List<String> errors = new List<String>();

    // start(): defines the scope (query or Iterable)
    public Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator([
            SELECT Id, AnnualRevenue, Rating
            FROM Account
            WHERE Rating = null
        ]); // can query up to 50M rows
    }

    // execute(): called once per batch (default 200 records)
    public void execute(Database.BatchableContext bc, List<Account> scope) {
        List<Account> toUpdate = new List<Account>();
        for (Account acc : scope) {
            acc.Rating = acc.AnnualRevenue > 1000000 ? 'Hot' : 'Cold';
            toUpdate.add(acc);
            processedCount++;
        }
        List<Database.SaveResult> results = Database.update(toUpdate, false);
        for (Database.SaveResult sr : results) {
            if (!sr.isSuccess()) {
                errors.add(sr.getErrors()[0].getMessage());
            }
        }
    }

    // finish(): called once after all batches complete
    public void finish(Database.BatchableContext bc) {
        AsyncApexJob job = [
            SELECT Status, JobItemsProcessed, TotalJobItems, NumberOfErrors
            FROM AsyncApexJob
            WHERE Id = :bc.getJobId()
        ];
        // Send completion email with stats
        if (!errors.isEmpty()) {
            System.debug('Errors: ' + errors);
        }
        System.debug('Processed: ' + processedCount + ' accounts');
    }
}
// Execute batch:
Id batchJobId = Database.executeBatch(new AccountRatingBatch(), 200);

// ── Scheduled Apex — run at specific times ────────────────────
public class DailyAccountCleanup implements Schedulable {
    public void execute(SchedulableContext ctx) {
        // Schedule batch from scheduled job
        Database.executeBatch(new AccountRatingBatch(), 200);
    }
}
// Schedule via Apex (cron: seconds minutes hours day month weekday year)
String cronExpr = '0 0 2 * * ?'; // every day at 2:00 AM
System.schedule('Daily Account Cleanup', cronExpr, new DailyAccountCleanup());

@IsTest
public class AccountServiceTest {

    /**
     * @TestSetup — runs once before ALL test methods in this class.
     * Data is rolled back after each test but @TestSetup data is
     * re-inserted fresh before each test method runs.
     * Use for: shared master data (Record Types, Users, base Accounts)
     */
    @TestSetup
    static void makeData() {
        // Create test accounts
        List<Account> accounts = new List<Account>();
        for (Integer i = 0; i < 200; i++) {
            accounts.add(new Account(
                Name           = 'Test Account ' + i,
                Industry       = (i < 100) ? 'Technology' : 'Finance',
                AnnualRevenue  = i * 10000,
                Phone          = '555-0' + String.valueOf(i).leftPad(3, '0')
            ));
        }
        insert accounts;
    }

    // ── Test positive path ────────────────────────────────────────
    @IsTest
    static void testGetAccountsByIndustry_Technology_returnsCorrectCount() {
        List<Account> accounts = [SELECT Id FROM Account];
        System.assertEquals(200, accounts.size(), 'Should have 200 accounts');

        Test.startTest();
            List<Account> result = AccountService.getByIndustry('Technology');
        Test.stopTest();

        System.assertEquals(100, result.size(),
            'Should return exactly 100 Technology accounts');
        for (Account a : result) {
            System.assertEquals('Technology', a.Industry,
                'All results must be Technology industry');
        }
    }

    // ── Test bulk scenario (200 records) ─────────────────────────
    @IsTest
    static void testUpdateRatings_bulk200Records_noLimitException() {
        List<Account> accounts = [SELECT Id, AnnualRevenue FROM Account];

        Test.startTest();
            AccountService.updateRatings(accounts);
        Test.stopTest();

        List<Account> updated = [SELECT Id, Rating FROM Account];
        for (Account a : updated) {
            System.assertNotEquals(null, a.Rating, 'Rating should be set');
        }
    }

    // ── Test negative/exception path ──────────────────────────────
    @IsTest
    static void testSaveAccount_nullName_throwsException() {
        Account badAcc = new Account(); // missing required Name
        Boolean exceptionThrown = false;

        Test.startTest();
        try {
            AccountService.saveAccount(badAcc);
        } catch (AccountService.AccountServiceException e) {
            exceptionThrown = true;
            System.assert(e.getMessage().contains('Name'),
                'Error message should mention Name field');
        }
        Test.stopTest();

        System.assert(exceptionThrown, 'Expected exception was not thrown');
    }

    // ── Test with Mock HTTP Callout ───────────────────────────────
    @IsTest
    static void testCallout_successResponse_updatesRecord() {
        // Set up mock before Test.startTest()
        Test.setMock(HttpCalloutMock.class, new MockHttpSuccess());

        Test.startTest();
            AccountSyncQueueable.syncAccounts([SELECT Id FROM Account LIMIT 1]);
        Test.stopTest();

        Account a = [SELECT Sync_Status__c FROM Account LIMIT 1];
        System.assertEquals('Synced', a.Sync_Status__c);
    }

    // ── Mock HTTP class ───────────────────────────────────────────
    private class MockHttpSuccess implements HttpCalloutMock {
        public HttpResponse respond(HttpRequest req) {
            HttpResponse res = new HttpResponse();
            res.setStatusCode(200);
            res.setBody('{"status":"ok"}');
            res.setHeader('Content-Type', 'application/json');
            return res;
        }
    }

    // ── Test with System.runAs() — user context testing ───────────
    @IsTest
    static void testWithStandardUser_noAdminAccess() {
        User stdUser = TestDataFactory.createStandardUser();

        System.runAs(stdUser) {
            Test.startTest();
            try {
                AccountService.adminOnlyMethod();
                System.assert(false, 'Should have thrown security exception');
            } catch (SecurityException e) {
                System.assert(true);
            }
            Test.stopTest();
        }
    }
}

// ── Limits class — check remaining limits at runtime ─────────
System.debug('SOQL used: '    + Limits.getQueries()        + '/' + Limits.getLimitQueries());
System.debug('DML used: '     + Limits.getDMLStatements()  + '/' + Limits.getLimitDMLStatements());
System.debug('CPU used: '     + Limits.getCpuTime()         + '/' + Limits.getLimitCpuTime() + 'ms');
System.debug('Heap used: '    + Limits.getHeapSize()        + '/' + Limits.getLimitHeapSize() + ' bytes');
System.debug('SOQL rows: '   + Limits.getQueryRows()       + '/' + Limits.getLimitQueryRows());

// ── Guard pattern: abort before hitting limit ─────────────────
public static void processWithGuard(List<Account> batch) {
    if (Limits.getDMLStatements() >= Limits.getLimitDMLStatements() - 5) {
        System.debug('WARNING: Approaching DML limit, offloading to async');
        System.enqueueJob(new AccountSyncQueueable(batch, 1));
        return;
    }
    update batch;
}

// ── SOQL for loops — process large datasets without heap issues
for (List<Account> batch : [
    SELECT Id, Rating FROM Account WHERE Rating = null
]) {
    for (Account acc : batch) {
        acc.Rating = 'Cold';
    }
    update batch; // update per inner batch (200 records)
    // Objects garbage collected after each batch — prevents heap overflow
}