Intermediate

import 'dart:async';                    // => Import for Future, Stream, Completer
                                        // => Core async primitives

// Simulated async function for donation processing
Future<double> fetchDonationAmount(String donorId) async {  // => Execute statement
                                        // => async keyword: enables await inside function
                                        // => Returns: Future<double> (not double directly)
                                        // => Use case: fetch donation from API/database
  await Future.delayed(Duration(seconds: 1));  // => Wait for async operation
                                        // => Simulates: network latency or database query
                                        // => Thread: Dart event loop continues processing other tasks
                                        // => Non-blocking: isolate can handle other Futures during delay
  return 500000.0 * donorId.length;     // => Calculate based on ID length (demo logic)
                                        // => Return: wrapped in Future automatically (async function)
}                                       // => Total time: ~1 second per call

void main() async {                     // => main can be async in Dart (unlike Java)
                                        // => Event loop: continues until all async operations complete
  print('Fetching donation...');        // => Immediate output (synchronous)
                                        // => Timeline: T=0ms

  // Await async function (sequential execution)
  double amount = await fetchDonationAmount('DONOR-001');  // => Execute statement
                                        // => await: pauses THIS function until Future completes
                                        // => Thread: isolate processes other events during delay
                                        // => Timeline: T=1000ms (after 1 second delay)
                                        // => amount: 4500000.0 (500000.0 * 9 characters)
  print('Amount: Rp$amount');           // => Output: Amount: Rp4500000.0
                                        // => Timeline: T=1000ms

  // Future.value creates already-completed Future
  Future<String> immediateFuture = Future.value('Completed');  // => Execute statement
                                        // => State: Future already COMPLETED (no pending work)
                                        // => Use case: return cached values in async context
                                        // => Performance: zero delay, no event loop scheduling
  String result = await immediateFuture;  // => No delay: await returns immediately
                                          // => result: 'Completed'
  print('Result: $result');             // => Output: Result: Completed

  // Future.error creates failed Future
  try {                                 // => Execute statement
    await Future.error('Payment failed');  // => Creates Future that completes with error
                                           // => State: COMPLETED with error (not value)
                                           // => await: throws error instead of returning value
  } catch (e) {                         // => Catch error from awaited Future
    print('Error: $e');                 // => Output: Error: Payment failed
                                        // => Exception handling: same as synchronous try-catch
  }

  // Multiple futures with then() chaining (alternative to async/await)
  fetchDonationAmount('DONOR-002')      // => Returns Future<double>
      .then((double value) {            // => Callback: executed when Future completes
                                        // => Parameter: value is the unwrapped result (double, not Future<double>)
        print('Fetched: Rp$value');     // => Output after ~1 second delay
                                        // => Timeline: T=2000ms (1s + previous 1s)
        return value * 0.025;           // => Transform: calculate 2.5% Zakat rate
                                        // => Return: wrapped in Future<double> for chaining
      })
      .then((double zakat) {            // => Second then: receives result from previous then
                                        // => Chaining: enables pipeline of transformations
        print('Zakat: Rp$zakat');       // => Output: Zakat: Rp112500.0
                                        // => Calculation: 4500000.0 * 0.025 = 112500.0
      })
      .catchError((error) {             // => Catch any error in the entire chain
                                        // => Error propagation: errors bubble through chain
        print('Chain error: $error');   // => Only executes if any then throws
      });

  await Future.delayed(Duration(seconds: 2));  // => Wait for async operation
                                        // => Wait for then() chain to complete
                                        // => Without this: main() exits before chain finishes
                                        // => Total time: 2 seconds to allow chain execution
}

import 'dart:async';                    // => Import for Future operations

Future<Map<String, double>> fetchDonor(String name) async {  // => Execute statement
                                        // => Simulates: HTTP GET request to donor service
                                        // => Returns: donor data as Map
  await Future.delayed(Duration(milliseconds: 500));  // => Wait for async operation
                                        // => Simulates: 500ms network latency
                                        // => Realistic: typical database query or API call timing
  return {                              // => Return donor data structure
    'name': name.length.toDouble(),     // => Dummy calculation for demo
    'amount': name.length * 100000.0,   // => Donation amount based on name length
  };                                    // => Map<String, double>: string keys, double values
}

void main() async {                     // => Execute statement
  print('Fetching multiple donors...');  // => Start message
                                         // => Timeline: T=0ms

  // Sequential execution (slow - anti-pattern for independent operations)
  Stopwatch stopwatch = Stopwatch()..start();  // => Execute statement
                                        // => Cascade notation: create and start in one line
                                        // => Stopwatch: measures elapsed time in milliseconds
  Map<String, double> donor1 = await fetchDonor('Ahmad');  // => Execute statement
                                        // => Timeline: T=500ms (first fetch completes)
                                        // => Blocking: waits for first fetch before starting second
  Map<String, double> donor2 = await fetchDonor('Fatimah');  // => Execute statement
                                        // => Timeline: T=1000ms (500ms + 500ms)
                                        // => Problem: second fetch waited unnecessarily
  Map<String, double> donor3 = await fetchDonor('Ali');  // => Execute statement
                                        // => Timeline: T=1500ms (500ms + 500ms + 500ms)
                                        // => Total: 1500ms (additive delays)
  stopwatch.stop();                     // => Stop timer

  print('Sequential: ${stopwatch.elapsedMilliseconds}ms');  // => Execute statement
                                        // => Output: Sequential: ~1500ms
                                        // => Inefficient: each await blocks next fetch

  // Parallel execution with Future.wait (optimal for independent operations)
  stopwatch.reset();                    // => Reset timer to zero
  stopwatch.start();                    // => Start timing parallel execution

  List<Future<Map<String, double>>> futures = [  // => Execute statement
    fetchDonor('Ahmad'),                // => Start first fetch immediately
                                        // => Returns: Future (pending), doesn't block
    fetchDonor('Fatimah'),              // => Start second fetch immediately (parallel)
                                        // => Timeline: T=0ms (both started simultaneously)
    fetchDonor('Ali'),                  // => Start third fetch immediately (parallel)
  ];                                    // => All three executing concurrently
                                        // => Timeline: T=0ms (all started, none awaited yet)

  List<Map<String, double>> donors = await Future.wait(futures);  // => Execute statement
                                        // => Wait for ALL futures to complete
                                        // => Returns: List of results in original order
                                        // => Timeline: T=500ms (all complete at same time)
                                        // => Performance: max(500ms, 500ms, 500ms) = 500ms
  stopwatch.stop();                     // => Stop timer

  print('Parallel: ${stopwatch.elapsedMilliseconds}ms');  // => Execute statement
                                        // => Output: Parallel: ~500ms
                                        // => Speedup: 1500ms → 500ms (3x faster)

  double total = donors.fold(0.0, (sum, donor) => sum + (donor['amount'] ?? 0.0));  // => Execute statement
                                        // => fold: reduce list to single value
                                        // => sum: accumulator (starts at 0.0)
                                        // => donor['amount']: extract amount, default to 0.0 if null
  print('Total: Rp$total');             // => Output: Total: Rp1200000.0
                                        // => Calculation: (5+7+3) * 100000 = 1500000.0

  // Future.wait with error handling (eagerError: true by default)
  try {                                 // => Execute statement
    await Future.wait([                 // => Wait for async operation
      fetchDonor('Valid'),              // => Will complete successfully
      Future.error('Network error'),    // => Simulates: API call failure
      fetchDonor('Also Valid'),         // => May not execute (eager error)
    ]);                                 // => Execute statement
  } catch (e) {                         // => Catches FIRST error
                                        // => eagerError: true → stops at first error
    print('Error in batch: $e');        // => Output: Error in batch: Network error
                                        // => Other futures: automatically cancelled
  }

  // Future.wait with eagerError: false (collect partial results)
  List<dynamic> results = await Future.wait(  // => Execute statement
    [                                   // => Execute statement
      fetchDonor('Valid'),              // => Will complete successfully
      Future.error('Error'),            // => Will fail
      fetchDonor('Also Valid'),         // => Will complete successfully
    ],                                  // => Execute statement
    eagerError: false,                  // => Continue executing despite errors
                                        // => Use case: best-effort data collection
  );                                    // => returns List including error objects
                                        // => Result: contains successful values and error
  print('Partial results: ${results.length}');  // => Execute statement
                                        // => Output: Partial results: 3
                                        // => Contains: mix of successful Maps and error object
}

import 'dart:async';                    // => Import for Future

Future<double> calculateZakat(double wealth) async {  // => Execute statement
                                        // => Async function for Zakat calculation
                                        // => Returns Future<double> that completes with Zakat amount
                                        // => Zakat: 2.5% of eligible wealth (Islamic obligation)
  if (wealth < 0) {                     // => Validate input
                                        // => Business rule: negative wealth invalid
    throw ArgumentError('Negative wealth not allowed');  // => Execute statement
                                        // => throw: creates error that Future completes with
                                        // => ArgumentError: built-in exception for invalid arguments
  }                                     // => Validation check complete

  if (wealth < 200000000.0) {           // => Check nisab threshold
                                        // => Nisab: minimum wealth required for Zakat
    throw StateError('Wealth below nisab threshold');  // => Execute statement
                                        // => StateError: wealth doesn't meet minimum
  }

  await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Simulate: calculation processing time
  return wealth * 0.025;                // => Calculate: 2.5% Zakat rate
                                        // => Return: Zakat amount due
}

void main() async {                     // => Execute statement
  // Try-catch with await (synchronous-style error handling)
  try {                                 // => Execute statement
    double zakat = await calculateZakat(-1000.0);  // => Execute statement
                                        // => Throws: ArgumentError (negative wealth)
                                        // => await: unwraps Future, throws error if Future failed
    print('Zakat: Rp$zakat');           // => Never executes (error thrown above)
  } on ArgumentError catch (e) {        // => Catch specific exception type
                                        // => on ArgumentError: only catches ArgumentError
                                        // => Use case: handle validation errors differently
    print('Validation error: $e');      // => Output: Validation error: Invalid argument(s): Negative wealth not allowed
  } on StateError catch (e) {           // => Catch StateError specifically
                                        // => Multiple on clauses: handle different errors differently
    print('State error: $e');           // => Doesn't execute (ArgumentError thrown)
  } catch (e) {                         // => Catch any other error type
                                        // => Fallback: catches exceptions not matched above
    print('Unknown error: $e');         // => Fallback handler
  } finally {                           // => Always executes (success or failure)
                                        // => Use case: cleanup, logging, resource release
    print('Calculation attempted');     // => Output: Calculation attempted
  }

  // catchError on Future (functional-style error handling)
  calculateZakat(-500.0)                // => Returns Future that will fail
      .then((value) => print('Zakat: Rp$value'))  // => Execute statement
                                        // => Callback: only executes if Future succeeds
                                        // => Doesn't execute (Future fails)
      .catchError((error) {             // => Handle error in Future chain
                                        // => Parameter: the error object
        print('Chain error: $error');   // => Output: Chain error: Invalid argument(s): Negative wealth not allowed
        return 0.0;                     // => Return default value on error
                                        // => Error recovery: continue chain with fallback
      })
      .then((value) {                   // => Next then receives recovered value (0.0)
        print('Recovered with: $value');  // => Output: Recovered with: 0.0
      });

  await Future.delayed(Duration(milliseconds: 200));  // => Wait for async operation
                                        // => Wait for then() chain to complete
                                        // => Ensures chain finishes before main() exits

  // Successful calculation (no error)
  try {                                 // => Execute statement
    double zakat = await calculateZakat(500000000.0);  // => Execute statement
                                        // => Valid input: above nisab, positive
                                        // => Timeline: 100ms delay in calculateZakat
    print('Valid Zakat: Rp$zakat');     // => Output: Valid Zakat: Rp12500000.0
                                        // => Calculation: 500000000 * 0.025 = 12500000.0
  } catch (e) {                         // => Execute statement
    print('Error: $e');                 // => Doesn't execute (success case)
  }

  // Multiple error types demonstration
  List<double> testValues = [-1000.0, 100000.0, 500000000.0];  // => Execute statement
  for (double wealth in testValues) {   // => Test different scenarios
    try {                               // => Execute statement
      double zakat = await calculateZakat(wealth);  // => Execute statement
      print('Wealth Rp$wealth → Zakat Rp$zakat');  // => Execute statement
    } on ArgumentError catch (e) {      // => Execute statement
      print('Wealth Rp$wealth → Validation failed: ${e.message}');  // => Execute statement
    } on StateError catch (e) {         // => Execute statement
      print('Wealth Rp$wealth → Below nisab: ${e.message}');  // => Execute statement
    }
  }
}

import 'dart:async';                    // => Import for Future, TimeoutException

Future<double> fetchDonationFromAPI(String donorId) async {  // => Execute statement
                                        // => Simulates: external API call
                                        // => Real use: HTTP request to donation service
  await Future.delayed(Duration(seconds: 3));  // => Wait for async operation
                                        // => Simulates: slow API (3 second response time)
                                        // => Problem: network issues or overloaded server
  return 1000000.0;                     // => Return donation amount (if completes)
}

void main() async {                     // => Main function with async support
                                        // => async enables await keyword
  // Timeout without fallback (throws TimeoutException)
  try {                                 // => Try block for timeout handling
                                        // => Catches TimeoutException if timeout expires
    double amount = await fetchDonationFromAPI('DONOR-001')  // => Execute statement
        .timeout(Duration(seconds: 2));  // => Maximum wait: 2 seconds
                                         // => fetchDonationFromAPI takes 3 seconds
                                         // => Result: timeout after 2 seconds
    print('Amount: Rp$amount');          // => Never executes (timeout occurs first)
  } on TimeoutException catch (e) {      // => Catch timeout exception specifically
                                         // => TimeoutException: thrown when timeout expires
    print('Request timeout: ${e.message}');  // => Execute statement
                                         // => Output: Request timeout: [timeout message]
    print('Fallback: Using default amount');  // => Execute statement
                                         // => Manual fallback in error handler
  }                                     // => Try-catch complete

  // Timeout with fallback (no exception, graceful degradation)
  double amount = await fetchDonationFromAPI('DONOR-002')  // => Execute statement
      .timeout(                         // => Execute statement
        Duration(seconds: 2),            // => Maximum wait: 2 seconds
        onTimeout: () {                  // => Callback: executes when timeout expires
                                         // => Returns: fallback value instead of throwing
          print('Timeout - using cached amount');  // => Execute statement
          return 500000.0;               // => Fallback: cached or default value
                                         // => Graceful degradation: continue with fallback
        },
      );                                // => Execute statement
  print('Amount with fallback: Rp$amount');  // => Execute statement
                                        // => Output: Amount with fallback: Rp500000.0
                                        // => No exception: onTimeout provided value

  // Fast operation (completes before timeout)
  Future<double> fastOperation() async {  // => Execute statement
    await Future.delayed(Duration(milliseconds: 500));  // => Wait for async operation
                                        // => Completes in 500ms
    return 750000.0;                    // => Return before timeout
  }

  double fastAmount = await fastOperation()  // => Execute statement
      .timeout(Duration(seconds: 2));   // => Timeout: 2 seconds (plenty of time)
                                        // => Completes: 500ms < 2000ms (no timeout)
  print('Fast amount: Rp$fastAmount');  // => Output: Fast amount: Rp750000.0
                                        // => Success: completed within timeout

  // Multiple operations with different timeouts (circuit breaker pattern)
  List<Future<double>> operations = [   // => Execute statement
    fetchDonationFromAPI('DONOR-003').timeout(  // => Execute statement
      Duration(seconds: 1),              // => Aggressive timeout (1 second)
      onTimeout: () => 0.0,              // => Fail fast with zero
    ),                                  // => Execute statement
    fastOperation().timeout(            // => Execute statement
      Duration(seconds: 2),              // => Conservative timeout (2 seconds)
      onTimeout: () => 0.0,             // => Execute statement
    ),                                  // => Execute statement
  ];                                    // => Execute statement

  List<double> results = await Future.wait(operations);  // => Execute statement
                                        // => Wait for all (parallel execution)
                                        // => First: times out (3s > 1s) → 0.0
                                        // => Second: succeeds (0.5s < 2s) → 750000.0
  print('Results: $results');           // => Output: Results: [0.0, 750000.0]

  double totalWithTimeouts = results.reduce((a, b) => a + b);  // => Execute statement
  print('Total with timeouts: Rp$totalWithTimeouts');  // => Execute statement
                                        // => Output: Total with timeouts: Rp750000.0
                                        // => Resilient: partial success despite timeout
}

import 'dart:async';                    // => Import for Completer, Future

// Simulate callback-based API (legacy pattern)
void fetchUserDataCallback(String userId, Function(String) onSuccess, Function(String) onError) {  // => Execute statement
                                        // => Callback pattern: common in JavaScript, legacy Dart
                                        // => onSuccess: called with result on success
                                        // => onError: called with error message on failure
  Future.delayed(Duration(seconds: 1), () {  // => Execute statement
                                        // => Simulate async operation with callback
    if (userId.isNotEmpty) {            // => Conditional check
      onSuccess('User data for $userId');  // => Execute statement
                                        // => Success case: invoke success callback
    } else {                            // => Execute statement
      onError('Invalid user ID');       // => Error case: invoke error callback
    }
  });
}

// Bridge callback API to Future using Completer
Future<String> fetchUserData(String userId) {  // => Execute statement
                                        // => Returns: Future<String> (modern async API)
                                        // => Bridges: callback-based to Future-based
  Completer<String> completer = Completer<String>();  // => Execute statement
                                        // => Create Completer: manual Future control
                                        // => Type parameter: String (Future<String>)

  fetchUserDataCallback(                // => Execute statement
    userId,                             // => Execute statement
    (String data) {                     // => Success callback
                                        // => Called by legacy API on success
      completer.complete(data);         // => Complete Future with success value
                                        // => Completer.future now has value
    },
    (String error) {                    // => Error callback
                                        // => Called by legacy API on failure
      completer.completeError(error);   // => Complete Future with error
                                        // => Completer.future throws when awaited
    },
  );                                    // => Execute statement

  return completer.future;              // => Return Future controlled by Completer
                                        // => Caller can await this Future
}

void main() async {                     // => Execute statement
  // Use bridged Future API (clean async/await)
  try {                                 // => Execute statement
    String userData = await fetchUserData('USER-001');  // => Execute statement
                                        // => Clean async/await: no callbacks
                                        // => Timeline: 1 second delay in callback API
    print('Data: $userData');           // => Output: Data: User data for USER-001
  } catch (e) {                         // => Execute statement
    print('Error: $e');                 // => Catches error from completeError()
  }

  // Error case
  try {                                 // => Execute statement
    String userData = await fetchUserData('');  // => Execute statement
                                        // => Empty userId triggers error in callback
    print('Data: $userData');           // => Never executes
  } catch (e) {                         // => Execute statement
    print('Error: $e');                 // => Output: Error: Invalid user ID
  }

  // Manual event completion (waiting for specific event)
  Completer<int> eventCompleter = Completer<int>();  // => Execute statement
                                        // => Create Completer for event handling
                                        // => Pattern: waiting for specific event to occur

  // Simulate event-driven code
  Future.delayed(Duration(milliseconds: 500), () {  // => Execute statement
                                        // => Simulate event trigger after delay
                                        // => Real use: user interaction, network event, timer
    eventCompleter.complete(42);        // => Complete Future when event occurs
                                        // => Event-driven: Future completes from different context
                                        // => All awaiters of eventCompleter.future receive value
  });                                   // => Event handler registered

  print('Waiting for event...');        // => Immediate output (before event)
                                        // => Non-blocking: main continues while waiting
  int eventResult = await eventCompleter.future;  // => Execute statement
                                        // => Await: blocks until complete() called
                                        // => Timeline: 500ms until event occurs
                                        // => Receives: value passed to complete()
  print('Event result: $eventResult');  // => Output: Event result: 42
                                        // => Executes after event completed

  // Completer with multiple waiters (single Future, multiple awaiters)
  Completer<String> sharedCompleter = Completer<String>();  // => Execute statement

  // Multiple async operations waiting on same Completer
  Future<void> waiter1() async {        // => Execute statement
    print('Waiter 1 waiting...');       // => Execute statement
    String result = await sharedCompleter.future;  // => Execute statement
                                        // => Waits: until complete() called
    print('Waiter 1 got: $result');     // => Outputs after completion
  }

  Future<void> waiter2() async {        // => Execute statement
    print('Waiter 2 waiting...');       // => Execute statement
    String result = await sharedCompleter.future;  // => Execute statement
                                        // => Same Future: multiple awaiters allowed
    print('Waiter 2 got: $result');     // => Outputs after completion
  }

  waiter1();                            // => Start first waiter (doesn't block)
  waiter2();                            // => Start second waiter (doesn't block)

  await Future.delayed(Duration(seconds: 1));  // => Wait for async operation
                                        // => Delay before completing
  sharedCompleter.complete('Shared result');  // => Execute statement
                                        // => Complete: both waiters receive result
                                        // => Broadcast: single complete() satisfies all awaiters

  await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Wait for waiters to print

  // Completer isCompleted check (prevent double completion error)
  Completer<int> safeCompleter = Completer<int>();  // => Execute statement

  safeCompleter.complete(100);          // => Complete with value
  if (!safeCompleter.isCompleted) {     // => Check: prevents double completion
                                        // => isCompleted: true after complete() called
    safeCompleter.complete(200);        // => Doesn't execute (already completed)
                                        // => Prevents: StateError from double completion
  }

  int safeResult = await safeCompleter.future;  // => Execute statement
  print('Safe result: $safeResult');    // => Output: Safe result: 100
}

import 'dart:async';                    // => Import for Stream, StreamController

// Create Stream using async* generator
Stream<int> donationStream() async* {   // => async*: creates Stream<int>
                                        // => Difference: async returns Future, async* returns Stream
                                        // => Generator: yields multiple values
  for (int i = 1; i <= 5; i++) {        // => Loop: emit 5 donation amounts
    await Future.delayed(Duration(milliseconds: 200));  // => Wait for async operation
                                        // => Delay: 200ms between emissions
                                        // => Simulates: real-time donations arriving
    yield i * 100000;                   // => yield: emit value to stream
                                        // => yield vs return: yield emits and continues, return ends
  }                                     // => Stream completes after last yield
}                                       // => Total time: 5 × 200ms = 1000ms

void main() async {                     // => Execute statement
  print('Listening to donations...');   // => Start message
                                        // => Timeline: T=0ms

  // Consume stream with await for (sequential processing)
  Stream<int> stream = donationStream();  // => Create stream
                                          // => State: Stream ready, not started yet

  await for (int amount in stream) {    // => await for: consumes stream sequentially
                                        // => Pauses: waits for each value
                                        // => Loop: processes one value at a time
    print('Received: Rp$amount');       // => Output each donation
                                        // => Timeline: T=200ms, 400ms, 600ms, 800ms, 1000ms
  }                                     // => Loop exits when stream completes
                                        // => Total time: 1000ms (all values processed)

  print('Stream completed');            // => Final message
                                        // => Timeline: T=1000ms

  // Alternative: listen() method (callback-based, non-blocking)
  donationStream().listen(              // => Execute statement
    (int amount) {                      // => onData callback
                                        // => Called: for each value emitted
                                        // => Parameter: the emitted value
      print('Listen: Rp$amount');       // => Handle each value
    },
    onError: (error) {                  // => onError callback
                                        // => Called: if stream emits error
      print('Error: $error');           // => Error handling
    },
    onDone: () {                        // => onDone callback
                                        // => Called: when stream completes
      print('Listen complete');         // => Stream finished
    },
    cancelOnError: false,               // => Continue listening after error
                                        // => Default: true (cancel on first error)
  );                                    // => Execute statement

  await Future.delayed(Duration(seconds: 2));  // => Wait for async operation
                                        // => Wait for listen() to complete
                                        // => listen() doesn't block: main continues immediately
                                        // => Total time: 2 seconds to allow all emissions
}

import 'dart:async';                    // => Executes

Stream<int> donationAmounts() async* {  // => Stream of donation amounts
  List<int> amounts = [100000, 500000, 250000, 750000, 50000, 1000000];  // => Execute statement
  for (int amount in amounts) {         // => Emit each amount
    await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => 100ms delay between emissions
    yield amount;                       // => Emit donation amount
  }
}

void main() async {                     // => Execute statement
  // Map transformation (convert int to String)
  print('=== Map Transformation ===');  // => Execute statement
  Stream<String> formattedStream = donationAmounts().map((amount) {  // => Execute statement
                                        // => map: transform each value
                                        // => Parameter: each emitted int
                                        // => Returns: transformed value (String)
    return 'Rp${amount.toStringAsFixed(2)}';  // => Return value
                                        // => Convert to currency format
                                        // => e.g., 100000 → "Rp100000.00"
  });

  await for (String formatted in formattedStream) {  // => Wait for async operation
                                        // => Consume transformed stream
    print('Formatted: $formatted');     // => Output: Formatted: Rp100000.00, etc.
  }

  // Where transformation (filter values)
  print('\n=== Where Filter ===');      // => Execute statement
  Stream<int> largeStream = donationAmounts().where((amount) {  // => Execute statement
                                        // => where: filter by predicate
                                        // => Parameter: each emitted value
                                        // => Returns: bool (true to keep, false to filter out)
    return amount >= 500000;            // => Only amounts >= 500000
                                        // => Predicate: filtering criteria
  });

  await for (int amount in largeStream) {  // => Wait for async operation
                                        // => Only large donations emitted
    print('Large donation: Rp$amount'); // => Output: 500000, 750000, 1000000
  }                                     // => Smaller amounts filtered out

  // Take transformation (limit values)
  print('\n=== Take Limit ===');        // => Execute statement
  Stream<int> firstThree = donationAmounts().take(3);  // => Execute statement
                                        // => take: emit only first N values
                                        // => Parameter: count (3)
                                        // => Stream closes after 3 values

  await for (int amount in firstThree) {  // => Wait for async operation
                                        // => Loop: executes 3 times only
    print('Top 3: Rp$amount');          // => Output: first 3 donations
  }                                     // => Stream completes early (after 3 values)

  // Chained transformations (pipeline)
  print('\n=== Chained Pipeline ===');  // => Execute statement
  Stream<String> pipeline = donationAmounts()  // => Execute statement
      .where((amount) => amount >= 250000)  // => Filter: >= 250000
                                            // => Emits: 500000, 250000, 750000, 1000000
      .map((amount) => amount * 0.025)      // => Transform: calculate Zakat (2.5%)
                                            // => Emits: 12500.0, 6250.0, 18750.0, 25000.0
      .take(3)                              // => Limit: first 3 values
                                            // => Emits: 12500.0, 6250.0, 18750.0
      .map((zakat) => 'Zakat: Rp${zakat.toStringAsFixed(2)}');  // => Execute statement
                                            // => Format as string
                                            // => Final: "Zakat: Rp12500.00", etc.

  await for (String result in pipeline) {  // => Wait for async operation
    print(result);                      // => Output: Zakat: Rp12500.00, etc.
  }

  // Expand transformation (one-to-many)
  print('\n=== Expand (Split) ===');    // => Execute statement
  Stream<int> expanded = donationAmounts()  // => Execute statement
      .take(2)                          // => Take first 2: 100000, 500000
      .expand((amount) {                // => expand: emit multiple values per input
                                        // => Parameter: input value
                                        // => Returns: Iterable of output values
        return [amount, amount ~/ 2];   // => Emit: original and half
                                        // => 100000 → [100000, 50000]
                                        // => 500000 → [500000, 250000]
      });                               // => Total emitted: 4 values (2 × 2)

  await for (int amount in expanded) {  // => Wait for async operation
    print('Expanded: Rp$amount');       // => Output: 100000, 50000, 500000, 250000
  }

  // Fold transformation (reduce to single value)
  print('\n=== Fold (Sum) ===');        // => Execute statement
  int total = await donationAmounts().fold(0, (sum, amount) {  // => Execute statement
                                        // => fold: reduce stream to single value
                                        // => Waits: until stream completes
                                        // => Parameter 1: initial value (0)
                                        // => Parameter 2: combiner function
    return sum + amount;                // => Accumulate: add each amount to sum
  });                                   // => Returns: total of all donations

  print('Total donations: Rp$total');   // => Output: Total donations: Rp2650000
                                        // => Sum: 100000 + 500000 + 250000 + 750000 + 50000 + 1000000

  // Skip transformation (ignore first N values)
  print('\n=== Skip ===');              // => Execute statement
  Stream<int> skipped = donationAmounts().skip(2);  // => Execute statement
                                        // => skip: ignore first 2 values
                                        // => Emits: starting from 3rd value

  await for (int amount in skipped) {   // => Wait for async operation
    print('Skipped first 2: Rp$amount');  // => Output: 250000, 750000, 50000, 1000000
  }
}

import 'dart:async';                    // => Executes

void main() async {                     // => Main function with async support
                                        // => async enables await keyword
  // Basic StreamController usage
  StreamController<int> controller = StreamController<int>();  // => Execute statement
                                        // => Create controller: manages stream
                                        // => Type parameter: int (Stream<int>)
                                        // => Single-subscription: only one listener allowed

  // Listen to stream
  StreamSubscription<int> subscription = controller.stream.listen(  // => Execute statement
                                        // => controller.stream: the Stream to consume
                                        // => listen: attach listener
    (int value) {                       // => onData callback
      print('Received: $value');        // => Handle emitted value
    },
    onError: (error) {                  // => onError callback
      print('Error: $error');           // => Handle emitted error
    },
    onDone: () {                        // => onDone callback
      print('Stream closed');           // => Stream completed
    },
  );                                    // => Execute statement

  // Emit values manually
  controller.add(100);                  // => Emit value to stream
                                        // => Listener receives: 100
  controller.add(200);                  // => Emit second value
                                        // => Listener receives: 200
  controller.add(300);                  // => Emit third value

  await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Wait for listener to process

  controller.addError('Sample error');  // => Emit error to stream
                                        // => Listener onError receives error

  await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Async pause for processing

  controller.close();                   // => Close stream (emit done event)
                                        // => Listener onDone executes
                                        // => No more values can be added

  // Broadcast stream (multiple listeners)
  print('\n=== Broadcast Stream ===');  // => Execute statement
  StreamController<String> broadcast = StreamController<String>.broadcast();  // => Execute statement
                                        // => broadcast(): allow multiple listeners
                                        // => Difference: regular controller allows only one

  // First listener
  broadcast.stream.listen((value) {     // => Execute statement
    print('Listener 1: $value');        // => First listener callback
  });

  // Second listener (only broadcast streams allow this)
  broadcast.stream.listen((value) {     // => Execute statement
    print('Listener 2: $value');        // => Second listener callback
                                        // => Both listeners receive same values
  });

  broadcast.add('Hello');               // => Emit to all listeners
                                        // => Output: Listener 1: Hello
                                        // =>         Listener 2: Hello

  broadcast.add('World');               // => Both listeners receive
  broadcast.close();                    // => Close broadcast stream

  await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Wait for broadcast processing

  // StreamController with async emission
  print('\n=== Async Emission ===');  // => Section header
  StreamController<int> asyncController = StreamController<int>();  // => Execute statement
                                        // => Create controller for async demo

  asyncController.stream.listen((value) {  // => Execute statement
                                        // => Attach listener to stream
    print('Async value: $value');      // => Print received value
  });

  // Emit values asynchronously
  Future<void> emitDonations() async {  // => Async function declaration
                                        // => Returns Future<void> (no value)
    for (int i = 1; i <= 3; i++) {      // => Loop: iterate 3 times
                                        // => i ranges from 1 to 3
      await Future.delayed(Duration(milliseconds: 200));  // => Wait for async operation
                                        // => Delay between emissions
      asyncController.add(i * 100000);  // => Emit donation amount
    }
    asyncController.close();            // => Close after all emissions
  }

  await emitDonations();                // => Wait for async emission to complete
                                        // => Blocks until all values emitted

  // StreamController with pause/resume
  print('\n=== Pause/Resume ===');     // => Section header
  StreamController<int> pausableController = StreamController<int>(  // => Execute statement
    onListen: () {                      // => Callback: when first listener subscribes
      print('Listener subscribed');     // => Execute statement
    },
    onPause: () {                       // => Callback: when listener pauses
      print('Listener paused');         // => Execute statement
    },
    onResume: () {                      // => Callback: when listener resumes
      print('Listener resumed');        // => Execute statement
    },
    onCancel: () {                      // => Callback: when listener cancels
      print('Listener cancelled');      // => Execute statement
    },
  );                                    // => Execute statement

  StreamSubscription<int> pausable = pausableController.stream.listen((value) {  // => Execute statement
    print('Pausable: $value');          // => Execute statement
  });

  pausableController.add(1);            // => Emit value
  await Future.delayed(Duration(milliseconds: 50));  // => Wait for async operation
                                        // => Wait for value processing

  pausable.pause();                     // => Pause listener
                                        // => onPause callback executes
  pausableController.add(2);            // => Emitted but buffered (listener paused)

  await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Wait during pause

  pausable.resume();                    // => Resume listener
                                        // => onResume callback executes
                                        // => Buffered value (2) delivered

  pausableController.add(3);            // => Emit after resume
  await Future.delayed(Duration(milliseconds: 50));  // => Wait for async operation
                                        // => Wait for final value processing

  await pausable.cancel();              // => Cancel subscription
                                        // => onCancel callback executes
  pausableController.close();           // => Close controller
}

import 'dart:async';                    // => Executes

// Basic async* generator
Stream<int> countDown(int start) async* {  // => Execute statement
                                        // => async*: creates Stream<int>
                                        // => Parameter: starting count
  for (int i = start; i > 0; i--) {     // => Loop: emit decreasing values
    await Future.delayed(Duration(milliseconds: 200));  // => Wait for async operation
                                        // => Delay: 200ms between emissions
                                        // => Non-blocking: isolate processes other tasks
    yield i;                            // => yield: emit value to stream
                                        // => Continues: function doesn't exit (unlike return)
  }                                     // => Stream completes after loop ends
  print('Countdown complete');          // => Executes after last yield
}

// Generator with conditional yield
Stream<double> zakatCalculator(List<double> wealthAmounts) async* {  // => Execute statement
                                        // => Process list asynchronously
                                        // => Returns: Stream of Zakat amounts
  for (double wealth in wealthAmounts) {  // => Loop iteration
    await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => Simulate: calculation time

    if (wealth >= 200000000.0) {        // => Check: nisab threshold
                                        // => Only emit Zakat for eligible wealth
      yield wealth * 0.025;             // => Calculate: 2.5% Zakat rate
                                        // => Conditional: only eligible amounts emitted
    }                                   // => Amounts below threshold: skipped (not yielded)
  }
}

// Generator with yield* (delegate to another stream)
Stream<String> donorCategories() async* {  // => Execute statement
                                        // => Stream of donor categories
  yield 'Individual';                   // => Emit single value
  yield 'Corporate';                    // => Emit value to stream

  yield* Stream.fromIterable(['Foundation', 'Trust', 'Anonymous']);  // => Execute statement
                                        // => yield*: emit ALL values from another Stream
                                        // => Stream.fromIterable: convert List to Stream
                                        // => Equivalent to yielding Foundation, then Trust, then Anonymous
}

// Generator with error handling
Stream<int> donationFeed() async* {     // => Execute statement
                                        // => Stream that may emit errors
  try {                                 // => Execute statement
    yield 100000;                       // => Emit first donation

    await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
    yield 500000;                       // => Emit second donation

    throw Exception('Connection lost');  // => Simulate error in stream
                                         // => Error: propagates to stream listeners
  } catch (e) {                         // => Execute statement
    yield* Stream.error(e);             // => Emit error to stream
                                        // => yield*: delegate error emission
  }

  yield 750000;                         // => Never executes (error terminated stream)
}

void main() async {                     // => Main function with async support
                                        // => async enables await for loop
  // Basic countdown generator
  print('=== Countdown ===');           // => Section header
  await for (int count in countDown(5)) {  // => Wait for async operation
                                        // => Consume stream with await for
                                        // => Loop: processes each yielded value
                                        // => Blocks: until stream completes or errors
    print('Count: $count');             // => Output: 5, 4, 3, 2, 1
                                        // => Executes for each emitted value
  }                                     // => Timeline: 1 second total (5 × 200ms)
                                        // => Output after loop: "Countdown complete"
                                        // => Loop completes when generator ends

  // Zakat calculator with filtering
  print('\n=== Zakat Calculator ===');  // => Execute statement
  List<double> wealthAmounts = [        // => Execute statement
    100000000.0,                        // => Below nisab: no Zakat
    500000000.0,                        // => Above nisab: Zakat = 12500000.0
    150000000.0,                        // => Below nisab: no Zakat
    1000000000.0,                       // => Above nisab: Zakat = 25000000.0
  ];                                    // => Execute statement

  await for (double zakat in zakatCalculator(wealthAmounts)) {  // => Wait for async operation
                                        // => Only eligible amounts emitted
    print('Zakat: Rp${zakat.toStringAsFixed(2)}');  // => Execute statement
                                        // => Output: Rp12500000.00, Rp25000000.00
  }                                     // => 2 values emitted (2 above nisab)

  // Donor categories with yield*
  print('\n=== Donor Categories ===');  // => Execute statement
  await for (String category in donorCategories()) {  // => Wait for async operation
                                        // => All yielded values received
    print('Category: $category');       // => Output: Individual, Corporate, Foundation, Trust, Anonymous
  }                                     // => yield*: streamlined multiple emissions

  // Error handling in generator
  print('\n=== Donation Feed ===');     // => Execute statement
  try {                                 // => Execute statement
    await for (int amount in donationFeed()) {  // => Wait for async operation
                                        // => Consume stream until error
      print('Donation: Rp$amount');     // => Output: 100000, 500000
    }                                   // => Loop exits on error
  } catch (e) {                         // => Execute statement
    print('Feed error: $e');            // => Output: Feed error: Exception: Connection lost
  }

  // Transforming generator output
  print('\n=== Transformed Countdown ===');  // => Execute statement
  Stream<String> transformedCountdown = countDown(3).map((count) {  // => Execute statement
                                        // => Chain transformation on generator
    return 'T-minus $count';            // => Transform int to String
  });

  await for (String message in transformedCountdown) {  // => Wait for async operation
    print(message);                     // => Output: T-minus 3, T-minus 2, T-minus 1
  }

  // Infinite generator (use take() to limit)
  print('\n=== Infinite Sequence ==='); // => Execute statement
  Stream<int> infiniteSequence() async* {  // => Execute statement
                                        // => Generator with no end condition
    int i = 0;                          // => Execute statement
    while (true) {                      // => Infinite loop
      await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
      yield i++;                        // => Emit incrementing values
                                        // => Never completes (infinite stream)
    }
  }

  await for (int value in infiniteSequence().take(5)) {  // => Wait for async operation
                                        // => take(5): limit to first 5 values
                                        // => Prevents infinite consumption
    print('Infinite: $value');          // => Output: 0, 1, 2, 3, 4
  }                                     // => Stream closed after 5 values
}

import 'dart:async';                    // => Executes

Stream<int> fastStream() async* {      // => High-volume stream generator
                                        // => async* enables yield keyword for stream emission
                                        // => Simulates fast data source (sensor, WebSocket, file)
  for (int i = 1; i <= 10; i++) {       // => Emit 10 values total
                                        // => Loop generates stream events
    await Future.delayed(Duration(milliseconds: 100));  // => Wait for async operation
                                        // => 100ms between emissions (simulates real-time data)
                                        // => Non-blocking delay allows other operations
    yield i * 100000;                   // => Emit donation amounts (100k, 200k, 300k, ...)
                                        // => yield pauses until listener ready
    print('Emitted: ${i * 100000}');    // => Track emissions (shows when data produced)
                                        // => Runs even if stream paused (production continues)
  }                                     // => Stream completes after 10 emissions
}                                       // => Generator function defined

void main() async {                     // => Main function with async support
                                        // => Demonstrates subscription management
  // Basic subscription management
  print('=== Basic Subscription ===');  // => Section header
  StreamSubscription<int> subscription = fastStream().listen(  // => Execute statement
                                        // => Create: stream subscription
                                        // => Type: StreamSubscription<int>
    (int value) {                       // => onData callback
                                        // => Parameter: emitted value
      print('Received: $value');        // => Process each value
    },
    onDone: () {                        // => onDone callback
      print('Stream complete');         // => Stream finished
    },
  );                                    // => Subscription created

  await Future.delayed(Duration(milliseconds: 350));  // => Wait for async operation
                                        // => Wait for ~3 emissions
                                        // => Async delay: non-blocking

  subscription.pause();                 // => Pause subscription
                                        // => State change: Active → Paused
                                        // => Buffering: emissions continue but not delivered to listener
                                        // => Stream generator keeps running (print still executes)
  print('Subscription paused');         // => Notify pause state
                                        // => Buffering begins now

  await Future.delayed(Duration(milliseconds: 400));  // => Wait for async operation
                                        // => Stream emits during pause (buffered)
                                        // => Buffer accumulates values

  subscription.resume();                // => Resume subscription
                                        // => State change: Paused → Active
                                        // => Buffered values delivered immediately
  print('Subscription resumed');        // => Notify resume

  await Future.delayed(Duration(seconds: 1));  // => Wait for async operation
                                        // => Wait for stream to complete
                                        // => Allow remaining values to process

  // Pause with pause token (manual resume control)
  print('\n=== Pause with Token ==='); // => Section header
  StreamSubscription<int> tokenSub = fastStream().listen(  // => Execute statement
                                        // => Create new subscription
    (int value) {                       // => onData callback
      print('Token received: $value');  // => Process value
    },
  );                                    // => Subscription active

  StreamSubscription<void> pauseToken = tokenSub.pause();  // => Execute statement
                                        // => pause() returns token
                                        // => Type: StreamSubscription<void>
                                        // => Use token to resume later
  print('Paused with token');           // => Notify pause state

  await Future.delayed(Duration(milliseconds: 500));  // => Wait for async operation
                                        // => Stream emits but buffered
                                        // => Values queued during pause

  pauseToken.resume();                  // => Resume using token
                                        // => Alternative: tokenSub.resume() also works
  print('Resumed with token');          // => Notify resume

  await Future.delayed(Duration(seconds: 1));  // => Wait for async operation
                                        // => Wait for completion

  // Cancel subscription (stop permanently)
  print('\n=== Cancel Subscription ===');  // => Execute statement
                                        // => Section header
  StreamSubscription<int> cancelSub = fastStream().listen(  // => Execute statement
                                        // => Create subscription to cancel
    (int value) {                       // => onData callback
      print('Cancel test: $value');     // => Process value
    },
    onDone: () {                        // => onDone callback
      print('Stream done');             // => Never executes (cancelled before completion)
    },
  );                                    // => Active subscription

  await Future.delayed(Duration(milliseconds: 350));  // => Wait for async operation
                                        // => Receive ~3 values
                                        // => Let some values through

  await cancelSub.cancel();             // => Cancel subscription
                                        // => State: Active/Paused → Cancelled
                                        // => Stops receiving: remaining values ignored
                                        // => Resource cleanup: releases memory
  print('Subscription cancelled');      // => Notify cancellation

  await Future.delayed(Duration(seconds: 1));  // => Wait for async operation
                                        // => Stream continues emitting (no listeners)
                                        // => Generator still runs to completion

  // Conditional pause/resume (backpressure simulation)
  print('\n=== Backpressure Control ===');  // => Execute statement
                                        // => Section header
  int processedCount = 0;               // => Counter: track processed values
  StreamSubscription<int>? backpressureSub;  // => Execute statement
                                        // => Nullable: assigned in listen call

  backpressureSub = fastStream().listen(  // => Execute statement
                                        // => Create subscription with backpressure
    (int value) async {                 // => Async listener
                                        // => async enables await in callback
      print('Processing: $value');      // => Process value
      processedCount++;                 // => Increment counter

      if (processedCount % 3 == 0) {    // => Every 3rd value
                                        // => Condition: modulo operator
        backpressureSub!.pause();       // => Pause to slow down
                                        // => Non-null assertion: guaranteed assigned
        print('Pausing for slow processing...');  // => Execute statement
                                        // => Notify pause

        await Future.delayed(Duration(milliseconds: 500));  // => Wait for async operation
                                        // => Simulate slow processing
                                        // => Async delay: represents CPU/IO work

        backpressureSub.resume();       // => Resume after processing
        print('Resumed after processing');  // => Execute statement
                                        // => Notify resume
      }
    },
  );                                    // => Backpressure pattern active

  await Future.delayed(Duration(seconds: 3));  // => Wait for async operation
                                        // => Wait for backpressure demo
                                        // => Allow pattern to complete

  // Multiple pause/resume cycles
  print('\n=== Multiple Pause/Resume ===');  // => Execute statement
                                        // => Section header
  StreamSubscription<int> cycleSub = fastStream().listen(  // => Execute statement
                                        // => Create subscription for cycling
    (int value) {                       // => onData callback
      print('Cycle: $value');           // => Process value
    },
  );                                    // => Active subscription

  for (int i = 0; i < 3; i++) {         // => 3 pause/resume cycles
                                        // => Loop: iterate 3 times
    await Future.delayed(Duration(milliseconds: 200));  // => Wait for async operation
                                        // => Wait before pause
    cycleSub.pause();                   // => Pause subscription
    print('Pause cycle $i');            // => Log pause cycle

    await Future.delayed(Duration(milliseconds: 200));  // => Wait for async operation
                                        // => Wait during pause
    cycleSub.resume();                  // => Resume subscription
    print('Resume cycle $i');           // => Log resume cycle
  }                                     // => Cycling complete

  await Future.delayed(Duration(seconds: 2));  // => Wait for async operation
                                        // => Wait for stream completion

  // isPaused check
  print('\n=== Check Paused State ===');  // => Execute statement
                                        // => Section header
  StreamSubscription<int> checkSub = fastStream().listen(  // => Execute statement
                                        // => Create subscription for state checking
    (int value) {                       // => onData callback
      print('Check: $value');           // => Process value
    },
  );                                    // => Active subscription

  print('Initially paused: ${checkSub.isPaused}');  // => Execute statement
                                        // => Output: false (actively listening)
                                        // => Property: isPaused getter

  checkSub.pause();                     // => Pause subscription
  print('After pause: ${checkSub.isPaused}');  // => Execute statement
                                        // => Output: true
                                        // => State: Paused

  await Future.delayed(Duration(milliseconds: 300));  // => Wait for async operation
                                        // => Wait during pause

  checkSub.resume();                    // => Resume subscription
  print('After resume: ${checkSub.isPaused}');  // => Execute statement
                                        // => Output: false
                                        // => State: Active

  await Future.delayed(Duration(seconds: 1));  // => Wait for async operation
                                        // => Wait for completion
  await checkSub.cancel();              // => Clean up subscription
}

// Base class for all donors
class Donor {                           // => Parent class
  String name;                          // => Field inherited by subclasses
  double totalDonations = 0.0;          // => Field with default value

  Donor(this.name);                     // => Constructor
                                        // => Subclass must call this via super()

  void donate(double amount) {          // => Method available to all subclasses
    totalDonations += amount;           // => Update total
    print('$name donated Rp$amount');   // => Polymorphic behavior
  }

  String getCategory() {                // => Method to override in subclasses
    return 'Standard Donor';            // => Default implementation
  }

  String getDescription() {             // => Method using other methods
    return '${getCategory()}: $name (Rp$totalDonations)';  // => Return value
                                        // => Calls overridden getCategory() (polymorphism)
  }
}

// Premium donor with additional benefits
class PremiumDonor extends Donor {      // => extends: creates subclass
                                        // => Inherits: name, totalDonations, donate(), getCategory()
  double discountRate;                  // => Additional field (not in parent)

  PremiumDonor(String name, this.discountRate) : super(name);  // => Execute statement
                                        // => super(name): call parent constructor
                                        // => Must call super() explicitly (Dart requirement)
                                        // => Initializes inherited name field

  @override                             // => Annotation: marks method override
                                        // => Optional but recommended (compile-time safety)
  String getCategory() {                // => Override parent method
    return 'Premium Donor (${discountRate * 100}% discount)';  // => Return value
                                        // => New implementation
                                        // => Called polymorphically via getDescription()
  }

  void applyDiscount(double amount) {   // => New method (not in parent)
    double discounted = amount * (1 - discountRate);  // => Execute statement
                                        // => Calculate discounted amount
    donate(discounted);                 // => Call inherited method
                                        // => Reuse parent functionality
  }
}

// Corporate donor with tax benefits
class CorporateDonor extends Donor {    // => Another subclass
  String companyName;                   // => Additional field
  String taxId;                         // => Execute statement

  CorporateDonor(String name, this.companyName, this.taxId) : super(name);  // => Execute statement

  @override                             // => Execute statement
  String getCategory() {                // => Different override than PremiumDonor
    return 'Corporate Donor';           // => Return value
  }

  @override                             // => Can override multiple methods
  void donate(double amount) {          // => Override donate() for custom behavior
    super.donate(amount);               // => super.donate(): call parent implementation
                                        // => Executes parent logic first
    print('Tax receipt for $companyName ($taxId)');  // => Execute statement
                                        // => Add corporate-specific behavior
  }
}

void main() {                           // => Execute statement
  // Use base class
  Donor regularDonor = Donor('Ahmad');  // => Create base class instance
  regularDonor.donate(500000.0);        // => Call method: Ahmad donated Rp500000.0
  print(regularDonor.getDescription()); // => Output: Standard Donor: Ahmad (Rp500000.0)

  // Use premium donor
  PremiumDonor premiumDonor = PremiumDonor('Fatimah', 0.10);  // => Execute statement
                                        // => Create subclass instance
  premiumDonor.donate(1000000.0);       // => Inherited method
  print(premiumDonor.getDescription()); // => Output: Premium Donor (10.0% discount): Fatimah (Rp1000000.0)
                                        // => Polymorphism: getCategory() calls overridden version

  premiumDonor.applyDiscount(500000.0); // => Subclass-only method
                                        // => Fatimah donated Rp450000.0 (10% discount)
  print('Total: Rp${premiumDonor.totalDonations}');  // => Execute statement
                                        // => Output: Total: Rp1450000.0

  // Use corporate donor
  CorporateDonor corp = CorporateDonor('Ali', 'TechCorp', 'TAX-123');  // => Execute statement
  corp.donate(2000000.0);               // => Overridden donate()
                                        // => Output: Ali donated Rp2000000.0
                                        // =>         Tax receipt for TechCorp (TAX-123)

  // Polymorphism with list of donors
  List<Donor> allDonors = [regularDonor, premiumDonor, corp];  // => Execute statement
                                        // => List<Donor>: holds all subclass instances
                                        // => Polymorphism: treat all as Donor type

  print('\n=== All Donors ===');        // => Execute statement
  for (Donor donor in allDonors) {      // => Iterate with base class type
    print(donor.getDescription());      // => Calls appropriate overridden method
                                        // => Runtime polymorphism determines implementation
  }
}