Beginner

void main() {
  // Explicit type declarations
  String donorName = 'Ahmad';          // => donorName stores 'Ahmad' (type: String)
                                        // => String type explicitly declared

  int donationAmount = 500000;          // => donationAmount stores 500000 (type: int)
                                        // => Integer type for whole numbers

  double zakatRate = 0.025;             // => zakatRate stores 0.025 (type: double)
                                        // => Double type for decimal values

  bool isPaid = true;                   // => isPaid stores true (type: bool)
                                        // => Boolean type for true/false values

  // Type inference with var
  var masjidName = 'Al-Hikmah';         // => masjidName inferred as String
                                        // => Type determined from initial value

  var memberCount = 150;                // => memberCount inferred as int
                                        // => Type cannot change after declaration

  print('$donorName donated: Rp$donationAmount');  // => Output: Ahmad donated: Rp500000
                                                    // => String interpolation with $
}

void main() {
  // Non-nullable types (default)
  String donorName = 'Fatimah';         // => donorName cannot be null
                                        // => Must always have a String value

  // Nullable types with ? suffix
  String? optionalPhone;                // => optionalPhone can be null or String
                                        // => Initialized to null by default

  String? optionalEmail = 'donor@example.com';  // => Can store String or null
                                                 // => Currently holds String value

  // Null-aware operators
  String phone = optionalPhone ?? 'No phone';  // => ?? returns right side if left is null
                                                // => phone stores 'No phone' (optionalPhone is null)

  String email = optionalEmail!;        // => ! asserts value is not null
                                        // => email stores 'donor@example.com'
                                        // => Throws error if null (use carefully!)

  // Null-aware method call
  int? length = optionalPhone?.length;  // => ?. calls method only if not null
                                        // => length stores null (optionalPhone is null)

  print('Phone: $phone');               // => Output: Phone: No phone
  print('Email: $email');               // => Output: Email: donor@example.com
  print('Phone length: $length');       // => Output: Phone length: null
}

void main() {
  String firstName = 'Abdullah';        // => firstName stores 'Abdullah'
  String lastName = 'Rahman';           // => lastName stores 'Rahman'

  // String interpolation
  String fullName = '$firstName $lastName';  // => Interpolates with $
                                              // => fullName stores 'Abdullah Rahman'

  // Expression interpolation
  String greeting = 'As-salamu alaykum, ${fullName.toUpperCase()}!';
                                        // => ${} evaluates expression
                                        // => toUpperCase() converts to uppercase
                                        // => greeting stores 'As-salamu alaykum, ABDULLAH RAHMAN!'

  // String concatenation
  String message = 'Donor: ' + fullName;  // => + operator concatenates strings
                                          // => message stores 'Donor: Abdullah Rahman'

  // Multi-line strings
  String report = '''
Zakat Report
Donor: $fullName
Status: Confirmed
''';                                    // => Triple quotes create multi-line string
                                        // => report stores formatted text with newlines

  // String methods
  int length = fullName.length;         // => length stores 16 (character count)
  bool contains = fullName.contains('Abdullah');  // => contains stores true
                                                   // => Checks substring existence

  String upper = fullName.toUpperCase();  // => upper stores 'ABDULLAH RAHMAN'
  String lower = fullName.toLowerCase();  // => lower stores 'abdullah rahman'

  print(greeting);                      // => Output: As-salamu alaykum, ABDULLAH RAHMAN!
  print('Length: $length');             // => Output: Length: 16
}

void main() {
  // Zakat calculation variables
  double wealth = 100000000.0;          // => wealth stores 100 million (type: double)
  double zakatRate = 0.025;             // => zakatRate stores 2.5%

  // Arithmetic operators
  double zakatAmount = wealth * zakatRate;  // => Multiplication operator
                                             // => zakatAmount stores 2500000.0

  double remaining = wealth - zakatAmount;  // => Subtraction operator
                                             // => remaining stores 97500000.0

  double future = wealth + 5000000.0;   // => Addition operator
                                        // => future stores 105000000.0

  double rate = zakatAmount / wealth;   // => Division operator (returns double)
                                        // => rate stores 0.025

  int wholePart = zakatAmount ~/ 1000000;  // => Integer division operator
                                            // => wholePart stores 2 (truncates decimal)

  double remainder = zakatAmount % 1000000;  // => Modulo operator (remainder)
                                              // => remainder stores 500000.0

  // Comparison operators
  bool isAboveNisab = wealth >= 85000000.0;  // => Greater than or equal
                                              // => isAboveNisab stores true

  bool isPaid = zakatAmount > 0.0;      // => Greater than comparison
                                        // => isPaid stores true

  // Logical operators
  bool eligible = isAboveNisab && !isPaid;  // => Logical AND with NOT
                                             // => eligible stores false (isPaid is true)

  print('Zakat amount: Rp${zakatAmount.toStringAsFixed(2)}');
                                        // => toStringAsFixed(2) formats to 2 decimals
                                        // => Output: Zakat amount: Rp2500000.00

  print('Eligible for Zakat: $isAboveNisab');  // => Output: Eligible for Zakat: true
}

void main() {
  double wealth = 50000000.0;           // => wealth stores 50 million
                                        // => wealth is 50000000.0 (type: double)
  const double nisab = 85000000.0;      // => nisab is compile-time constant
                                        // => Minimum Zakat threshold (85 million)
                                        // => const means value fixed at compile time

  // Simple if statement
  if (wealth >= nisab) {                // => Condition evaluates to false
                                        // => 50000000.0 >= 85000000.0 is false
                                        // => Block skipped, execution jumps to line after }
    print('Zakat is obligatory');       // => Block not executed
  }                                     // => Execution continues after if
                                        // => No else block, so continue to next statement

  // If-else statement
  if (wealth >= nisab) {                // => Condition: false
                                        // => Same condition as above (50M < 85M)
    double zakat = wealth * 0.025;      // => Not executed
                                        // => Would calculate 2.5% if condition true
    print('Pay Zakat: Rp$zakat');       // => Not executed
  } else {                              // => else block executes
                                        // => Runs when if condition is false
    double shortfall = nisab - wealth;  // => shortfall stores 35000000.0
                                        // => 85000000.0 - 50000000.0 = 35000000.0
    print('Below nisab by: Rp$shortfall');
                                        // => Output: Below nisab by: Rp35000000.0
  }                                     // => End of if-else statement

  // If-else if-else chain
  String donorType;                     // => Variable to store result
                                        // => donorType declared, not initialized yet (type: String)
  int annualDonation = 15000000;        // => annualDonation stores 15 million
                                        // => annualDonation is 15000000 (type: int)

  if (annualDonation >= 50000000) {     // => First condition: false
                                        // => 15000000 >= 50000000 is false
                                        // => Skip to next else if
    donorType = 'Platinum';             // => Not executed
  } else if (annualDonation >= 20000000) {
                                        // => Second condition: false
                                        // => 15000000 >= 20000000 is false
                                        // => Skip to next else if
    donorType = 'Gold';                 // => Not executed
  } else if (annualDonation >= 10000000) {
                                        // => Third condition: true
                                        // => 15000000 >= 10000000 is true
                                        // => Execute this block
    donorType = 'Silver';               // => donorType assigned 'Silver'
                                        // => donorType now initialized with value
  } else {                              // => Not reached
                                        // => Only executes if all conditions false
    donorType = 'Bronze';               // => Not executed
  }                                     // => End of if-else if-else chain

  print('Donor status: $donorType');    // => Output: Donor status: Silver
                                        // => String interpolation displays donorType value

  // Ternary operator (conditional expression)
  String status = wealth >= nisab ? 'Obligatory' : 'Optional';
                                        // => Inline if-else expression
                                        // => condition ? trueValue : falseValue
                                        // => wealth >= nisab is false
                                        // => status stores 'Optional' (condition false)

  print('Zakat status: $status');       // => Output: Zakat status: Optional
                                        // => String interpolation displays status value
}                                       // => End of main function

void main() {
  // Standard for loop with counter
  print('Monthly savings plan:');      // => Header output

  for (int month = 1; month <= 5; month++) {  // => Initialize, condition, increment
                                               // => month starts at 1
    double savings = month * 500000.0;  // => Calculate cumulative savings
                                        // => Iteration 1: 500000.0
                                        // => Iteration 2: 1000000.0
                                        // => ... up to iteration 5
    print('Month $month: Rp$savings');  // => Output each month's total
  }                                     // => Loop completes after month = 5

  // For loop with custom increment
  print('\nQuarterly Zakat payments:');  // => \n creates newline

  for (int quarter = 1; quarter <= 12; quarter += 3) {  // => Increment by 3
                                                         // => quarter: 1, 4, 7, 10
    double payment = 1000000.0 * quarter;  // => Calculate payment amount
    print('Quarter ${quarter ~/ 3 + 1}: Rp$payment');  // => ~/ divides and truncates
                                                        // => Outputs 4 times total
  }

  // For-in loop (iterate over collection)
  List<String> donors = ['Ahmad', 'Fatimah', 'Ali'];  // => List of 3 names

  print('\nDonor thank you messages:');  // => Header

  for (String donor in donors) {        // => donor takes each list element
                                        // => Iteration 1: donor = 'Ahmad'
                                        // => Iteration 2: donor = 'Fatimah'
                                        // => Iteration 3: donor = 'Ali'
    print('Jazakallah khair, $donor!');  // => Output thank you message
  }                                     // => Loop completes after all elements

  // Nested for loops
  print('\nDonation matrix:');          // => Header

  for (int row = 1; row <= 3; row++) {  // => Outer loop: 3 iterations
    String line = '';                   // => Initialize empty string for row

    for (int col = 1; col <= 4; col++) {  // => Inner loop: 4 iterations per row
      int amount = row * col * 100000;  // => Calculate cell value
      line += 'Rp$amount ';             // => Append to line string
    }                                   // => Inner loop completes

    print(line);                        // => Output complete row
  }                                     // => Outer loop continues
}

void main() {
  // While loop - checks condition before executing
  double balance = 10000000.0;          // => Initial balance: 10 million
                                        // => balance stores 10000000.0 (type: double)
  int withdrawals = 0;                  // => Counter for withdrawals
                                        // => withdrawals starts at 0 (type: int)

  print('Sadaqah withdrawals:');        // => Header
                                        // => Output: Sadaqah withdrawals:

  while (balance >= 500000.0) {         // => Check condition first (BEFORE executing block)
                                        // => Continues while balance >= 500000
                                        // => Iteration 1: 10000000.0 >= 500000.0 = true
    double withdrawal = 500000.0;       // => Fixed withdrawal amount
                                        // => withdrawal stores 500000.0 each iteration
    balance -= withdrawal;              // => Subtract from balance
                                        // => balance decreases each iteration
                                        // => Iteration 1: 10000000.0 - 500000.0 = 9500000.0
    withdrawals++;                      // => Increment counter
                                        // => Iteration 1: withdrawals becomes 1
    print('Withdrawal $withdrawals: Rp$withdrawal, Remaining: Rp$balance');
                                        // => Output with current values
                                        // => Iteration 1: Withdrawal 1: Rp500000.0, Remaining: Rp9500000.0
  }                                     // => Loop exits when condition false (balance < 500000)
                                        // => After 20 iterations, balance is 0.0

  print('Total withdrawals: $withdrawals\n');
                                        // => Output: Total withdrawals: 20
                                        // => \n adds blank line

  // Do-while loop - executes first, then checks condition
  double donation = 0.0;                // => Start at zero
                                        // => donation stores 0.0 (type: double)
  int attempts = 0;                     // => Counter
                                        // => attempts starts at 0 (type: int)

  print('Donation collection:');        // => Header
                                        // => Output: Donation collection:

  do {                                  // => Execute block first (BEFORE checking condition)
                                        // => Guaranteed to run at least once
    donation += 100000.0;               // => Add 100000 to donation
                                        // => Iteration 1: 0.0 + 100000.0 = 100000.0
                                        // => Iteration 2: 100000.0 + 100000.0 = 200000.0
    attempts++;                         // => Increment counter
                                        // => Iteration 1: attempts becomes 1
    print('Attempt $attempts: Collected Rp$donation');
                                        // => Output current state
                                        // => Iteration 1: Attempt 1: Collected Rp100000.0
  } while (donation < 500000.0);        // => Check condition after execution
                                        // => Loops 5 times total
                                        // => Loop exits when donation >= 500000.0

  print('Target reached after $attempts attempts\n');
                                        // => Output: Target reached after 5 attempts
                                        // => \n adds blank line

  // While loop with break
  int daysUntilRamadan = 10;            // => Countdown starts at 10
                                        // => daysUntilRamadan stores 10 (type: int)

  print('Ramadan countdown:');          // => Header
                                        // => Output: Ramadan countdown:

  while (true) {                        // => Infinite loop condition
                                        // => true is always true - requires break to exit
    if (daysUntilRamadan == 0) {        // => Check if countdown reached zero
                                        // => Evaluates to false for first 10 iterations
      print('Ramadan Mubarak!');        // => Final message
                                        // => Executed when daysUntilRamadan == 0
      break;                            // => Exit loop immediately
                                        // => Jumps to first statement after while loop
    }                                   // => End if block
    print('$daysUntilRamadan days remaining');
                                        // => Show days left
                                        // => Iteration 1: 10 days remaining
    daysUntilRamadan--;                 // => Decrement counter
                                        // => Iteration 1: daysUntilRamadan becomes 9
  }                                     // => Loop exits via break (when counter reaches 0)
                                        // => Execution continues here after break

  // While loop with continue
  int donors = 0;                       // => Counter
                                        // => donors starts at 0 (type: int)
  int invalidCount = 0;                 // => Track invalid entries
                                        // => invalidCount starts at 0 (type: int)

  print('\nProcessing donors:');        // => Header
                                        // => \n adds blank line before output
                                        // => Output: Processing donors:

  while (donors < 5) {                  // => Process 5 donor entries
                                        // => Loop while donors < 5
    donors++;                           // => Increment donor number first
                                        // => Iteration 1: donors becomes 1

    if (donors == 2 || donors == 4) {   // => Check for invalid donor numbers
                                        // => Evaluates to true when donors is 2 or 4
                                        // => Iteration 2: donors == 2 is true
      invalidCount++;                   // => Count invalid entry
                                        // => Iteration 2: invalidCount becomes 1
      print('Donor $donors: Invalid (skipped)');
                                        // => Output invalid donor
                                        // => Iteration 2: Donor 2: Invalid (skipped)
      continue;                         // => Skip rest of iteration
                                        // => Jumps to while condition, skips print below
    }                                   // => End if block

    print('Donor $donors: Processed successfully');
                                        // => Process valid donor
                                        // => Iteration 1: Donor 1: Processed successfully
                                        // => Iteration 3: Donor 3: Processed successfully
  }                                     // => Loop continues
                                        // => Exits when donors >= 5

  print('Valid donors: ${donors - invalidCount}');
                                        // => donors = 5, invalidCount = 2
                                        // => 5 - 2 = 3
                                        // => Output: Valid donors: 3
}                                       // => End of main function

void main() {
  // Basic switch statement
  String paymentType = 'Cash';          // => paymentType stores 'Cash' (type: String)
                                        // => Variable for payment method

  switch (paymentType) {                // => Match paymentType against cases
                                        // => Control jumps to matching case
    case 'Cash':                        // => This case matches ('Cash' == 'Cash')
                                        // => Execute statements in this block
      print('Cash payment received');   // => Output: Cash payment received
      print('No processing fee');       // => Second statement in case
                                        // => Output: No processing fee
      break;                            // => Exit switch (required!)
                                        // => Without break, execution falls through

    case 'Card':                        // => Not matched, skipped
                                        // => paymentType is not 'Card'
      print('Card payment received');   // => Not executed
      print('1% processing fee');       // => Not executed
      break;                            // => Exit point if this case matched

    case 'Transfer':                    // => Not matched, skipped
                                        // => paymentType is not 'Transfer'
      print('Bank transfer received');  // => Not executed
      print('No processing fee');       // => Not executed
      break;                            // => Exit point if this case matched

    default:                            // => Executes if no case matches
                                        // => Safety net for unexpected values
      print('Unknown payment type');    // => Not executed (Cash matched)
      break;                            // => Exit point for default case
  }                                     // => End of switch statement

  // Switch with fall-through (multiple cases)
  int zakatMonth = 3;                   // => Month 3 (Ramadan)
                                        // => zakatMonth stores 3 (type: int)

  switch (zakatMonth) {                 // => Match zakatMonth against cases
                                        // => Evaluates to 3
    case 1:                             // => Not matched (3 != 1)
                                        // => Falls through to next case
    case 2:                             // => Not matched (3 != 2)
                                        // => Falls through to next case
    case 3:                             // => Matched! (3 == 3)
                                        // => Execute statements for cases 1, 2, or 3
      print('Ramadan - Zakat collection peak');
                                        // => Output: Ramadan - Zakat collection peak
                                        // => Single implementation for 3 cases
      break;                            // => Exit switch
                                        // => Execution continues after switch

    case 9:                             // => Not matched (3 != 9)
                                        // => Falls through to next case
    case 10:                            // => Not matched (3 != 10)
                                        // => Would execute next statement if matched
      print('Shawwal/Dhul Qadah - Normal collection');
                                        // => Not executed
      break;                            // => Exit point if matched

    default:                            // => Default case
                                        // => Executes if zakatMonth not 1,2,3,9,10
      print('Regular month');           // => Not executed (case 3 matched)
      break;                            // => Exit point for default
  }                                     // => End of second switch

  // Switch for categorization
  double donationAmount = 7500000.0;    // => donationAmount stores 7.5 million
                                        // => donationAmount is 7500000.0 (type: double)
  String category;                      // => Variable to store result (type: String)
                                        // => Uninitialized, will be assigned in switch

  // Convert amount to category code
  int level = (donationAmount ~/ 5000000).toInt();
                                        // => Integer division: 7500000 ~/ 5000000 = 1
                                        // => .toInt() ensures int type
                                        // => level stores 1

  switch (level) {                      // => Match level value (1)
                                        // => Switch on integer level
    case 0:                             // => Not matched (1 != 0)
                                        // => For donations < 5M
      category = 'Bronze (< 5M)';       // => Not executed
      break;                            // => Exit point if matched

    case 1:                             // => Matched! (1 == 1)
                                        // => For donations 5M - 10M
      category = 'Silver (5M - 10M)';   // => category assigned 'Silver (5M - 10M)'
                                        // => category now initialized with value
      break;                            // => Exit switch
                                        // => Skip remaining cases

    case 2:                             // => Not matched (1 != 2)
                                        // => For donations 10M - 15M
      category = 'Gold (10M - 15M)';    // => Not executed
      break;                            // => Exit point if matched

    default:                            // => Default case
                                        // => For donations >= 15M
      category = 'Platinum (> 15M)';    // => Not executed (case 1 matched)
      break;                            // => Exit point for default
  }                                     // => End of third switch

  print('Donor category: $category');   // => Output: Donor category: Silver (5M - 10M)
                                        // => String interpolation displays category

  // Switch with enum-like string values
  String zakatType = 'Wealth';          // => zakatType stores 'Wealth' (type: String)
                                        // => Variable for Zakat category
  double rate;                          // => Variable for rate (type: double)
                                        // => Uninitialized, assigned in switch

  switch (zakatType) {                  // => Match zakatType ('Wealth')
                                        // => Switch on string value
    case 'Wealth':                      // => Matched! ('Wealth' == 'Wealth')
                                        // => Zakat on savings/investments
      rate = 0.025;                     // => 2.5% for wealth Zakat
                                        // => rate stores 0.025 (type: double)
      print('Zakat al-Mal (Wealth): ${rate * 100}%');
                                        // => 0.025 * 100 = 2.5
                                        // => Output: Zakat al-Mal (Wealth): 2.5%
      break;                            // => Exit switch
                                        // => Skip remaining cases

    case 'Agriculture':                 // => Not matched ('Wealth' != 'Agriculture')
                                        // => Zakat on crops
      rate = 0.10;                      // => 10% for irrigated crops
                                        // => Not executed
      print('Zakat al-Ziraah (Agriculture): ${rate * 100}%');
                                        // => Not executed
      break;                            // => Exit point if matched

    case 'Gold':                        // => Not matched ('Wealth' != 'Gold')
                                        // => Zakat on precious metals
      rate = 0.025;                     // => 2.5% for gold/silver
                                        // => Not executed
      print('Zakat on Gold/Silver: ${rate * 100}%');
                                        // => Not executed
      break;                            // => Exit point if matched

    default:                            // => Default case
                                        // => Executes if zakatType not recognized
      rate = 0.0;                       // => 0% for unknown types
                                        // => Not executed ('Wealth' matched)
      print('Unknown Zakat type');      // => Not executed
      break;                            // => Exit point for default
  }                                     // => End of fourth switch
}                                       // => End of main function

void main() {
  // List literal creation
  List<String> donors = ['Ahmad', 'Fatimah', 'Ali'];  // => Create list with 3 elements
                                                       // => Type: List<String>

  List<int> amounts = [500000, 1000000, 750000];  // => List of integers
                                                  // => Type: List<int>

  // Access elements by index (zero-based)
  String firstDonor = donors[0];        // => firstDonor stores 'Ahmad'
                                        // => Index 0 is first element

  int lastAmount = amounts[amounts.length - 1];  // => Get last element
                                                 // => length property returns 3
                                                 // => lastAmount stores 750000

  print('First donor: $firstDonor');    // => Output: First donor: Ahmad
  print('Last amount: Rp$lastAmount');  // => Output: Last amount: Rp750000

  // Add elements
  donors.add('Zainab');                 // => Append to end of list
                                        // => donors now has 4 elements

  amounts.addAll([250000, 500000]);     // => Add multiple elements
                                        // => amounts now has 5 elements

  donors.insert(1, 'Hassan');           // => Insert at index 1
                                        // => Shifts existing elements right
                                        // => donors: ['Ahmad', 'Hassan', 'Fatimah', 'Ali', 'Zainab']

  print('Donors count: ${donors.length}');  // => Output: Donors count: 5

  // Remove elements
  amounts.removeLast();                 // => Remove last element (500000)
                                        // => amounts now has 4 elements

  donors.removeAt(2);                   // => Remove element at index 2 ('Fatimah')
                                        // => donors now has 4 elements

  bool removed = amounts.remove(1000000);  // => Remove by value
                                           // => removed stores true (found and removed)
                                           // => amounts: [500000, 750000, 250000]

  // Check for elements
  bool hasDonor = donors.contains('Ali');  // => hasDonor stores true
                                           // => 'Ali' exists in list

  int index = amounts.indexOf(750000);  // => index stores 1
                                        // => Returns -1 if not found

  bool isEmpty = donors.isEmpty;        // => isEmpty stores false
                                        // => List has 4 elements

  print('Contains Ali: $hasDonor');     // => Output: Contains Ali: true
  print('Index of 750000: $index');     // => Output: Index of 750000: 1

  // Modify elements
  donors[0] = 'Abdullah';               // => Replace first element
                                        // => donors: ['Abdullah', 'Hassan', 'Ali', 'Zainab']

  amounts[1] += 250000;                 // => Increase element by 250000
                                        // => amounts[1] now 1000000

  // Iterate over list
  print('All donors:');                 // => Header
  for (String donor in donors) {        // => For-in loop
    print('- $donor');                  // => Output each donor with bullet
  }                                     // => Outputs 4 lines

  // Create list with specific length
  List<double> zakatPayments = List.filled(3, 0.0);  // => Create list of 3 elements
                                                      // => All initialized to 0.0
                                                      // => Type: List<double>

  zakatPayments[0] = 500000.0;          // => Set first element
  zakatPayments[1] = 750000.0;          // => Set second element
  zakatPayments[2] = 1000000.0;         // => Set third element

  print('Payments: $zakatPayments');    // => Output: Payments: [500000.0, 750000.0, 1000000.0]
}

void main() {
  // Map literal creation
  Map<String, int> donorAmounts = {     // => Key type: String, Value type: int
    'Ahmad': 500000,                    // => Key-value pair
    'Fatimah': 1000000,                 // => Key must be unique
    'Ali': 750000,                      // => Value can duplicate
  };                                    // => Map with 3 entries

  // Access values by key
  int? ahmadAmount = donorAmounts['Ahmad'];  // => ahmadAmount stores 500000
                                             // => Returns int? (nullable)

  int? unknownAmount = donorAmounts['Unknown'];  // => unknownAmount stores null
                                                 // => Key doesn't exist

  print('Ahmad donated: Rp${ahmadAmount ?? 0}');  // => Output: Ahmad donated: Rp500000
                                                   // => ?? provides default if null

  // Add or update entries
  donorAmounts['Zainab'] = 1250000;     // => Add new key-value pair
                                        // => Map now has 4 entries

  donorAmounts['Ahmad'] = 600000;       // => Update existing key
                                        // => Replaces old value 500000

  // Remove entries
  int? removed = donorAmounts.remove('Ali');  // => Remove by key
                                              // => removed stores 750000 (old value)
                                              // => Map now has 3 entries

  // Check for keys/values
  bool hasKey = donorAmounts.containsKey('Fatimah');  // => hasKey stores true
                                                      // => Key exists

  bool hasValue = donorAmounts.containsValue(1000000);  // => hasValue stores true
                                                         // => Value exists

  print('Has Fatimah: $hasKey');        // => Output: Has Fatimah: true
  print('Has 1000000: $hasValue');      // => Output: Has 1000000: true

  // Map properties
  int size = donorAmounts.length;       // => size stores 3
                                        // => Number of entries

  bool isEmpty = donorAmounts.isEmpty;  // => isEmpty stores false
                                        // => Map has entries

  // Iterate over map
  print('All donations:');              // => Header
  donorAmounts.forEach((String name, int amount) {  // => forEach with callback
                                                     // => name receives key
                                                     // => amount receives value
    print('$name: Rp$amount');          // => Output key-value pair
  });                                   // => Executes 3 times

  // Get keys and values as collections
  Iterable<String> names = donorAmounts.keys;  // => Get all keys
                                               // => Type: Iterable<String>

  Iterable<int> amounts = donorAmounts.values;  // => Get all values
                                                // => Type: Iterable<int>

  print('Donor names: ${names.toList()}');  // => Convert Iterable to List
                                            // => Output: Donor names: [Ahmad, Fatimah, Zainab]

  // Calculate total from map values
  int total = 0;                        // => Initialize accumulator
  for (int amount in amounts) {         // => Iterate over values
    total += amount;                    // => Add to total
  }                                     // => Loop completes
  print('Total donations: Rp$total');   // => Output: Total donations: Rp2850000

  // Map with non-string keys
  Map<int, String> monthNames = {       // => Key type: int, Value type: String
    1: 'Muharram',                      // => Integer keys
    3: 'Rabi al-Awwal',
    9: 'Ramadan',
    12: 'Dhul Hijjah',
  };                                    // => Map with 4 entries

  String? ramadan = monthNames[9];      // => ramadan stores 'Ramadan'
  print('Month 9: $ramadan');           // => Output: Month 9: Ramadan

  // Map with default values
  Map<String, double> zakatRates = {    // => Key: String, Value: double
    'Wealth': 0.025,                    // => 2.5%
    'Agriculture': 0.10,                // => 10%
    'Gold': 0.025,                      // => 2.5%
  };

  double rate = zakatRates['Wealth'] ?? 0.0;  // => Get with default
                                              // => rate stores 0.025

  print('Wealth Zakat rate: ${rate * 100}%');  // => Output: Wealth Zakat rate: 2.5%
}

// Function with explicit types
double calculateZakat(double wealth) {  // => Parameter: wealth (type: double)
                                        // => Returns double
  const double rate = 0.025;            // => Local constant
  return wealth * rate;                 // => Calculate and return result
}                                       // => Function ends

// Function with multiple parameters
String formatDonation(String name, int amount, {String currency = 'Rp'}) {
                                        // => name, amount: positional parameters
                                        // => currency: named optional with default 'Rp'
  return '$name donated $currency$amount';  // => Build and return string
}

// Function with named parameters (all optional by default)
void printReceipt({                     // => All parameters named and optional
  required String donor,                // => required makes parameter mandatory
  required double amount,               // => Must provide when calling
  String? reference,                    // => Nullable optional parameter
}) {
  print('Donation Receipt');            // => Print header
  print('Donor: $donor');               // => Print donor name
  print('Amount: Rp$amount');           // => Print amount

  if (reference != null) {              // => Check if reference provided
    print('Reference: $reference');     // => Print only if not null
  }
}

// Arrow function (expression body)
double nisabThreshold() => 85.0 * 1000000.0;  // => Concise function syntax
                                               // => Returns result of expression
                                               // => Evaluates to 85000000.0

// Function without return value (void)
void logDonation(String message) {      // => void means no return value
  print('[LOG] $message');              // => Print with prefix
}                                       // => Function returns null implicitly

void main() {
  // Call function with positional parameter
  double zakat = calculateZakat(100000000.0);  // => Pass 100M as argument
                                               // => zakat stores 2500000.0
  print('Zakat amount: Rp$zakat');      // => Output: Zakat amount: Rp2500000.0

  // Call function with multiple positional parameters
  String message = formatDonation('Ahmad', 500000);
                                        // => Pass 2 positional args
                                        // => Uses default currency 'Rp'
                                        // => message stores formatted string
  print(message);                       // => Output: Ahmad donated Rp500000

  // Call function with named parameter override
  String usdMessage = formatDonation('Fatimah', 100, currency: '\$');
                                        // => Override currency parameter
                                        // => usdMessage stores 'Fatimah donated $100'
  print(usdMessage);                    // => Output: Fatimah donated $100

  // Call function with required named parameters
  printReceipt(                         // => Call with named parameters
    donor: 'Ali',                       // => Provide required donor
    amount: 750000.0,                   // => Provide required amount
    reference: 'REF-2025-001',          // => Provide optional reference
  );                                    // => Prints receipt

  // Call function without optional parameter
  printReceipt(                         // => Call without reference
    donor: 'Zainab',
    amount: 1000000.0,
  );                                    // => reference is null

  // Call arrow function
  double threshold = nisabThreshold();  // => Call function
                                        // => threshold stores 85000000.0
  print('Nisab threshold: Rp$threshold');  // => Output: Nisab threshold: Rp85000000.0

  // Call void function
  logDonation('Processing payment');    // => Execute function
                                        // => Prints: [LOG] Processing payment
}

// Function type definition
typedef ZakatCalculator = double Function(double wealth);
                                        // => Type alias for function signature
                                        // => Takes double, returns double

// Higher-order function (accepts function as parameter)
double applyZakatRule(double wealth, ZakatCalculator calculator) {
                                        // => Takes wealth and calculator function
  return calculator(wealth);            // => Call passed function
}                                       // => Returns calculated result

// Function returning function
ZakatCalculator getCalculator(String type) {  // => Returns function type
  if (type == 'wealth') {               // => Check type parameter
    return (double w) => w * 0.025;     // => Return function for wealth Zakat
                                        // => Anonymous function (lambda)
  } else if (type == 'agriculture') {
    return (double w) => w * 0.10;      // => Return function for agriculture
  } else {
    return (double w) => 0.0;           // => Default function returns 0
  }
}

void main() {
  // Assign function to variable
  ZakatCalculator wealthZakat = (double wealth) {  // => Store function in variable
                                                   // => Type: ZakatCalculator
    return wealth * 0.025;              // => Function body
  };                                    // => Function assigned

  double result = wealthZakat(100000000.0);  // => Call function via variable
                                             // => result stores 2500000.0
  print('Wealth Zakat: Rp$result');     // => Output: Wealth Zakat: Rp2500000.0

  // Pass function as argument
  double agricultureZakat = applyZakatRule(
    50000000.0,                         // => wealth argument
    (double w) => w * 0.10,             // => Anonymous function as argument
  );                                    // => agricultureZakat stores 5000000.0
  print('Agriculture Zakat: Rp$agricultureZakat');
                                        // => Output: Agriculture Zakat: Rp5000000.0

  // Get function from factory
  ZakatCalculator calculator = getCalculator('wealth');
                                        // => Retrieve function for wealth type
                                        // => calculator stores function

  double zakat = calculator(75000000.0);  // => Call retrieved function
                                          // => zakat stores 1875000.0
  print('Calculated Zakat: Rp$zakat');  // => Output: Calculated Zakat: Rp1875000.0

  // List of functions
  List<double Function(double)> calculators = [  // => List of function types
    (double w) => w * 0.025,            // => Wealth calculator
    (double w) => w * 0.10,             // => Agriculture calculator
    (double w) => w * 0.05,             // => Trade calculator
  ];                                    // => List with 3 functions

  print('Multiple Zakat calculations:');  // => Header
  for (var calc in calculators) {       // => Iterate over functions
    double amount = calc(10000000.0);   // => Call each function
    print('- Rp$amount');               // => Output result
  }                                     // => 3 outputs

  // Closure (function captures outer variables)
  double baseRate = 0.025;              // => Variable in outer scope

  ZakatCalculator closureCalc = (double wealth) {
                                        // => Function captures baseRate
    return wealth * baseRate;           // => Uses captured variable
  };                                    // => Closure created

  print('Base calculation: Rp${closureCalc(50000000.0)}');
                                        // => Output: Base calculation: Rp1250000.0

  baseRate = 0.03;                      // => Modify captured variable
  print('Modified calculation: Rp${closureCalc(50000000.0)}');
                                        // => Output: Modified calculation: Rp1500000.0
                                        // => Closure sees updated value

  // Function as callback
  void processDonation(double amount, void Function(String) callback) {
                                        // => Takes amount and callback function
    String message = 'Processed Rp$amount';  // => Create message
    callback(message);                  // => Call callback with message
  }

  processDonation(750000.0, (String msg) {  // => Pass callback function
    print('Callback: $msg');            // => Callback prints message
  });                                   // => Output: Callback: Processed Rp750000.0
}

// Basic class definition
class Donor {                           // => Class named Donor
  String name;                          // => Instance field (property)
  double totalDonations;                // => Stores cumulative amount

  // Constructor
  Donor(this.name, this.totalDonations);  // => Shorthand constructor
                                          // => this.field assigns parameter to field

  // Method
  void donate(double amount) {          // => Instance method
    totalDonations += amount;           // => Modify instance field
    print('$name donated Rp$amount');   // => Access instance field
  }                                     // => Method ends

  // Getter (computed property)
  String get category {                 // => Getter method (no parentheses when called)
    if (totalDonations >= 10000000) {   // => Check donation level
      return 'Gold';                    // => Return category
    } else if (totalDonations >= 5000000) {
      return 'Silver';
    } else {
      return 'Bronze';
    }
  }                                     // => Getter ends
}

void main() {
  // Create instance (object)
  Donor ahmad = Donor('Ahmad', 0.0);    // => Create new Donor object
                                        // => ahmad references object
                                        // => name: 'Ahmad', totalDonations: 0.0

  // Access fields
  print('Donor: ${ahmad.name}');        // => Access name field
                                        // => Output: Donor: Ahmad

  print('Total: Rp${ahmad.totalDonations}');
                                        // => Output: Total: Rp0.0

  // Call methods
  ahmad.donate(2500000.0);              // => Call donate method
                                        // => Modifies totalDonations
                                        // => Output: Ahmad donated Rp2500000.0

  ahmad.donate(3000000.0);              // => Call again
                                        // => totalDonations now 5500000.0
                                        // => Output: Ahmad donated Rp3000000.0

  // Access getter
  String ahmadCategory = ahmad.category;  // => Call getter (no parentheses)
                                          // => ahmadCategory stores 'Silver'
  print('Category: $ahmadCategory');    // => Output: Category: Silver

  // Create multiple objects
  Donor fatimah = Donor('Fatimah', 12000000.0);
                                        // => Second Donor object
                                        // => Separate instance from ahmad

  print('${fatimah.name} is ${fatimah.category}');
                                        // => Access fields and getter
                                        // => Output: Fatimah is Gold

  // Objects are independent
  ahmad.donate(5000000.0);              // => Modify ahmad only
                                        // => ahmad.totalDonations: 10500000.0
                                        // => fatimah.totalDonations unchanged: 12000000.0

  print('Ahmad: ${ahmad.category}');    // => Output: Ahmad: Gold
  print('Fatimah: ${fatimah.category}');  // => Output: Fatimah: Gold
}

class ZakatPayment {                    // => Class for Zakat payments
  String donorName;                     // => Donor identifier
  double amount;                        // => Payment amount
  DateTime date;                        // => Payment timestamp
  String type;                          // => Zakat type

  // Default constructor
  // => Shorthand syntax: this.field assigns constructor parameter to field
  ZakatPayment(this.donorName, this.amount, this.date, this.type);
                                        // => Standard constructor
                                        // => Requires all 4 fields at construction

  // Named constructor for wealth Zakat
  // => Named constructors enable domain-specific creation methods
  ZakatPayment.wealth(String name, double wealth)
                                        // => Named constructor syntax
                                        // => ClassName.name(...) pattern
      : donorName = name,               // => Initialize donorName
        amount = wealth * 0.025,        // => Calculate amount (2.5%)
        date = DateTime.now(),          // => Set current date
        type = 'Wealth';                // => Set type
                                        // => Initializer list with :
                                        // => Runs before constructor body

  // Named constructor for agriculture Zakat
  // => Different calculation logic than wealth Zakat
  ZakatPayment.agriculture(String name, double harvest)
      // => Takes harvest value as input
      : donorName = name,               // => Same initialization pattern
        amount = harvest * 0.10,        // => 10% for agriculture (higher rate)
        date = DateTime.now(),          // => Current timestamp
        type = 'Agriculture';           // => Identifies Zakat type
                                        // => Each named constructor encapsulates business logic

  // Factory constructor (can return cached instances)
  // => factory keyword enables returning existing instances or subtypes
  factory ZakatPayment.fromMap(Map<String, dynamic> map) {
                                        // => factory keyword
                                        // => Can return existing instance or subtype
                                        // => Unlike regular constructors, can control what gets returned
    return ZakatPayment(                // => Create and return instance
      // => Calls default constructor internally
      map['donorName'] as String,       // => Extract from map with type cast
      map['amount'] as double,          // => Type cast ensures double
      DateTime.parse(map['date'] as String),
                                        // => Parse string to DateTime
                                        // => Handles date deserialization
      map['type'] as String,            // => Extract type field
    );                                  // => Return created object
                                        // => Factory enables custom construction logic
  }

  // Const constructor (compile-time constant objects)
  const ZakatPayment.constant({         // => const constructor
    required this.donorName,            // => Must initialize all fields
    required this.amount,
    required this.date,
    required this.type,
  });                                   // => All fields must be final for const

  void printReceipt() {                 // => Method to display info
    print('---Receipt---');             // => Print header
    print('Donor: $donorName');         // => String interpolation with $
                                        // => Outputs donor name
    print('Type: $type');               // => Display Zakat type
    print('Amount: Rp$amount');         // => Display calculated amount
    print('Date: ${date.year}-${date.month}-${date.day}');
                                        // => Extract year, month, day from DateTime
                                        // => ${expression} syntax for complex interpolation
    print('------------');               // => Print footer
  }                                     // => Method completes
}

void main() {
  // Use default constructor
  ZakatPayment payment1 = ZakatPayment(
    'Ahmad',                            // => donorName parameter
    500000.0,                           // => amount parameter
    DateTime(2025, 1, 29),              // => date parameter (creates DateTime object)
    'Sadaqah',                          // => type parameter
  );                                    // => Create object with default constructor
                                        // => payment1 now holds ZakatPayment instance
                                        // => All fields assigned via this.field syntax

  payment1.printReceipt();              // => Call method to display receipt
                                        // => Method accesses instance fields

  // Use named constructor for wealth
  ZakatPayment payment2 = ZakatPayment.wealth('Fatimah', 100000000.0);
                                        // => Create with named constructor
                                        // => Calculates amount automatically
                                        // => amount: 2500000.0

  payment2.printReceipt();              // => Output shows calculated amount

  // Use named constructor for agriculture
  ZakatPayment payment3 = ZakatPayment.agriculture('Ali', 50000000.0);
                                        // => Create with agriculture constructor
                                        // => amount: 5000000.0 (10%)

  payment3.printReceipt();

  // Use factory constructor with map
  Map<String, dynamic> data = {         // => Data map
    'donorName': 'Zainab',
    'amount': 750000.0,
    'date': '2025-01-29',
    'type': 'Fidyah',
  };

  ZakatPayment payment4 = ZakatPayment.fromMap(data);
                                        // => Create from map
                                        // => Factory handles parsing

  payment4.printReceipt();

  // Compare construction approaches
  print('Wealth Zakat calculated: Rp${payment2.amount}');
                                        // => Output: Rp2500000.0
  print('Agriculture Zakat calculated: Rp${payment3.amount}');
                                        // => Output: Rp5000000.0
}

class DonationAccount {                 // => Class for managing donations
  String _accountId;                    // => Private field (underscore prefix)
  double _balance;                      // => Private balance field
  List<double> _transactions = [];      // => Private transaction history

  DonationAccount(this._accountId, this._balance);
                                        // => Constructor initializes private fields

  // Getter for accountId (read-only)
  String get accountId => _accountId;   // => Arrow function getter
                                        // => Returns private field
                                        // => No setter - read-only property

  // Getter for balance
  double get balance => _balance;       // => Expose balance as read-only

  // Setter for balance with validation
  // => Setters enable validation before assignment
  set balance(double value) {           // => Setter method
                                        // => Called like property: account.balance = value
    if (value < 0) {                    // => Validate input
                                        // => Business rule: balance must be non-negative
      throw ArgumentError('Balance cannot be negative');
                                        // => Throw error for invalid value
                                        // => Prevents invalid state
    }
    _balance = value;                   // => Set private field after validation
  }                                     // => Setter ends

  // Computed getter (no backing field)
  double get averageTransaction {       // => Calculated property
    if (_transactions.isEmpty) {        // => Check for empty list
      return 0.0;                       // => Return default
    }
    double sum = _transactions.reduce((a, b) => a + b);
                                        // => Sum all transactions
    return sum / _transactions.length;  // => Calculate average
  }                                     // => Return computed value

  // Getter with complex logic
  // => Getters can contain business logic, not just field access
  String get status {                   // => Status based on balance
                                        // => Called like property: account.status
    if (_balance >= 10000000) {         // => Check premium threshold
      return 'Premium (>= 10M)';        // => High-value account
    } else if (_balance >= 5000000) {   // => Check standard threshold
      return 'Standard (>= 5M)';        // => Mid-value account
    } else {                            // => Below standard threshold
      return 'Basic (< 5M)';            // => Low-value account
    }
  }                                     // => Computed dynamically on each access

  void deposit(double amount) {         // => Method to add funds
    if (amount <= 0) {                  // => Validate amount is positive
                                        // => Business rule enforcement
      throw ArgumentError('Amount must be positive');
                                        // => Throw error for invalid input
    }
    _balance += amount;                 // => Update balance by adding amount
    _transactions.add(amount);          // => Record positive transaction
                                        // => Maintains audit trail
  }                                     // => Method completes

  void withdraw(double amount) {        // => Method to remove funds
    if (amount > _balance) {            // => Check sufficient funds available
                                        // => Prevents negative balance
      throw ArgumentError('Insufficient balance');
                                        // => Reject transaction if insufficient funds
    }
    _balance -= amount;                 // => Update balance by subtracting amount
    _transactions.add(-amount);         // => Record negative transaction
                                        // => Negative value indicates withdrawal
  }                                     // => Method completes
}

void main() {
  // Create account
  DonationAccount account = DonationAccount('ACC-001', 5000000.0);
                                        // => Create with initial balance

  // Access getters
  print('Account: ${account.accountId}');  // => Output: Account: ACC-001
  print('Balance: Rp${account.balance}');  // => Output: Balance: Rp5000000.0
  print('Status: ${account.status}');   // => Output: Status: Standard (>= 5M)

  // Deposit funds
  account.deposit(3000000.0);           // => Add 3M
                                        // => balance now 8000000.0

  print('After deposit: Rp${account.balance}');
                                        // => Output: After deposit: Rp8000000.0
  print('Status: ${account.status}');   // => Output: Status: Standard (>= 5M)

  // Withdraw funds
  account.withdraw(1000000.0);          // => Remove 1M
                                        // => balance now 7000000.0

  print('After withdrawal: Rp${account.balance}');
                                        // => Output: After withdrawal: Rp7000000.0

  // Access computed getter
  print('Average transaction: Rp${account.averageTransaction}');
                                        // => Output: Average transaction: Rp1000000.0
                                        // => (3000000 + (-1000000)) / 2

  // Try to set balance directly (using setter)
  try {
    account.balance = 12000000.0;       // => Use setter
                                        // => balance now 12000000.0
    print('Direct set balance: Rp${account.balance}');
                                        // => Output: Direct set balance: Rp12000000.0
    print('Status: ${account.status}'); // => Output: Status: Premium (>= 10M)
  } catch (e) {
    print('Error: $e');
  }

  // Try invalid balance (negative)
  try {
    account.balance = -1000.0;          // => Attempt invalid value
                                        // => Setter throws error
  } catch (e) {                         // => Catch exception
    print('Caught error: $e');          // => Output: Caught error: Invalid argument(s): Balance cannot be negative
  }

  print('Final balance: Rp${account.balance}');
                                        // => balance unchanged: 12000000.0
                                        // => Output: Final balance: Rp12000000.0
}

// Basic enum
enum ZakatType {                        // => Enum declaration
                                        // => Creates new type with fixed constants
  wealth,                               // => Enum value (constant)
                                        // => Index 0
  agriculture,                          // => Each value has index (0, 1, 2...)
                                        // => Index 1
  gold,                                 // => Index 2
  livestock,                            // => Index 3
}                                       // => Enum ends
                                        // => Creates 4 constant values

// Enum with enhanced features (Dart 2.17+)
enum DonorTier {                        // => Enhanced enum
                                        // => Can have fields, methods, constructors
  bronze(0, 5000000),                   // => Constructor call
                                        // => Creates bronze with minAmount=0, maxAmount=5M
  silver(5000000, 10000000),            // => Each value has associated data
                                        // => Creates silver with minAmount=5M, maxAmount=10M
  gold(10000000, 50000000),             // => Creates gold with minAmount=10M, maxAmount=50M
  platinum(50000000, double.infinity);  // => infinity for upper bound
                                        // => Creates platinum with minAmount=50M, maxAmount=∞

  const DonorTier(this.minAmount, this.maxAmount);
                                        // => Const constructor
                                        // => Associates data with each value
                                        // => this.minAmount assigns parameter to field

  final double minAmount;               // => Field for minimum amount
                                        // => final means can't be changed after creation
  final double maxAmount;               // => Field for maximum amount
                                        // => Each enum value has these fields

  // Method on enum
  bool inRange(double amount) {         // => Instance method
                                        // => Can be called on any DonorTier value
    return amount >= minAmount && amount < maxAmount;
                                        // => Check if amount fits tier
                                        // => Returns true if amount in range
  }                                     // => End of inRange method

  // Static method
  static DonorTier fromAmount(double amount) {
                                        // => Static method (class-level)
                                        // => Called on enum type, not instance
    for (var tier in DonorTier.values) {  // => Iterate all enum values
                                          // => DonorTier.values = [bronze, silver, gold, platinum]
      if (tier.inRange(amount)) {       // => Check each tier
                                        // => Call inRange method on current tier
        return tier;                    // => Return matching tier
                                        // => Exit function early if match found
      }                                 // => End if
    }                                   // => End for loop
    return DonorTier.platinum;          // => Default if none match
                                        // => Fallback for amounts > all tiers
  }                                     // => End of fromAmount method
}                                       // => End of DonorTier enum

void main() {
  // Use enum values
  ZakatType currentType = ZakatType.wealth;
                                        // => Assign enum value
                                        // => currentType stores ZakatType.wealth
                                        // => Type-safe constant (can't assign invalid value)

  print('Zakat type: $currentType');    // => Output: Zakat type: ZakatType.wealth
                                        // => toString() includes enum name
  print('Name: ${currentType.name}');   // => Output: Name: wealth
                                        // => .name property returns string without enum type
  print('Index: ${currentType.index}'); // => Output: Index: 0
                                        // => .index property returns position in enum

  // Switch on enum
  double rate;                          // => Variable for rate
                                        // => Uninitialized, assigned in switch (type: double)
  switch (currentType) {                // => Switch on enum value
                                        // => Match currentType (ZakatType.wealth)
    case ZakatType.wealth:              // => Match wealth value
                                        // => This case matches (wealth == wealth)
      rate = 0.025;                     // => 2.5%
                                        // => rate stores 0.025
      break;                            // => Exit switch
    case ZakatType.agriculture:         // => Not matched, skipped
      rate = 0.10;                      // => 10%
                                        // => Not executed
      break;                            // => Exit point if matched
    case ZakatType.gold:                // => Not matched, skipped
      rate = 0.025;                     // => Not executed
      break;                            // => Exit point if matched
    case ZakatType.livestock:           // => Not matched, skipped
      rate = 0.025;                     // => Not executed
      break;                            // => Exit point if matched
  }                                     // => Switch ends
                                        // => rate is now 0.025

  print('Rate: ${rate * 100}%');        // => Output: Rate: 2.5%
                                        // => 0.025 * 100 = 2.5

  // Access all enum values
  print('All Zakat types:');            // => Header
                                        // => Output: All Zakat types:
  for (ZakatType type in ZakatType.values) {
                                        // => values contains all enum constants
                                        // => ZakatType.values = [wealth, agriculture, gold, livestock]
                                        // => Iterate each value
    print('- ${type.name}');            // => Output name
                                        // => Iteration 1: - wealth
                                        // => Iteration 2: - agriculture
  }                                     // => 4 iterations total
                                        // => Loop completes after all values

  // Enhanced enum with data
  DonorTier tier = DonorTier.gold;      // => Assign enhanced enum value
                                        // => tier stores DonorTier.gold (with fields 10M-50M)

  print('Tier: ${tier.name}');          // => Output: Tier: gold
                                        // => .name returns 'gold' string
  print('Min: Rp${tier.minAmount}');    // => Output: Min: Rp10000000.0
                                        // => Access minAmount field from gold enum
  print('Max: Rp${tier.maxAmount}');    // => Output: Max: Rp50000000.0
                                        // => Access maxAmount field from gold enum

  // Call enum method
  double amount = 15000000.0;           // => Test amount: 15M
                                        // => amount stores 15000000.0 (type: double)
  bool fits = tier.inRange(amount);     // => Check if amount in gold tier
                                        // => Calls inRange method on gold enum
                                        // => 15M >= 10M && 15M < 50M = true
                                        // => fits stores true (10M-50M)
  print('$amount in ${tier.name}: $fits');
                                        // => Output: 15000000.0 in gold: true
                                        // => String interpolation with multiple values

  // Use static method
  DonorTier auto = DonorTier.fromAmount(7500000.0);
                                        // => Find tier for 7.5M
                                        // => Calls static method on DonorTier type
                                        // => Loops through tiers, checks inRange
                                        // => silver.inRange(7500000.0) returns true
                                        // => auto stores DonorTier.silver
  print('7.5M tier: ${auto.name}');     // => Output: 7.5M tier: silver
                                        // => .name returns 'silver' string

  // Iterate enhanced enum
  print('All tiers:');                  // => Header
                                        // => Output: All tiers:
  for (var t in DonorTier.values) {     // => Iterate all tiers
                                        // => DonorTier.values = [bronze, silver, gold, platinum]
                                        // => var infers type DonorTier
    print('${t.name}: Rp${t.minAmount} - Rp${t.maxAmount}');
                                        // => Output tier range
                                        // => Iteration 1: bronze: Rp0.0 - Rp5000000.0
                                        // => Iteration 2: silver: Rp5000000.0 - Rp10000000.0
  }                                     // => 4 iterations total
                                        // => Loop completes after all tiers

  // Enum comparison
  bool isSameTier = tier == DonorTier.gold;
                                        // => Enum equality
                                        // => tier is DonorTier.gold
                                        // => DonorTier.gold == DonorTier.gold is true
                                        // => isSameTier stores true
  print('Is gold tier: $isSameTier');   // => Output: Is gold tier: true
                                        // => String interpolation with bool value

  // Enum in collections
  Map<DonorTier, int> tierCounts = {    // => Map with enum keys
                                        // => Key type: DonorTier, Value type: int
    DonorTier.bronze: 50,               // => bronze tier has 50 donors
    DonorTier.silver: 30,               // => silver tier has 30 donors
    DonorTier.gold: 15,                 // => gold tier has 15 donors
    DonorTier.platinum: 5,              // => platinum tier has 5 donors
  };                                    // => Map literal creates Map<DonorTier, int>

  int goldCount = tierCounts[DonorTier.gold] ?? 0;
                                        // => Lookup by enum key
                                        // => tierCounts[DonorTier.gold] returns 15
                                        // => ?? 0 provides default if null (not needed here)
                                        // => goldCount stores 15
  print('Gold donors: $goldCount');     // => Output: Gold donors: 15
                                        // => String interpolation with int value
}                                       // => End of main function