content: import 'package:test/test.dart';
  import 'package:d4rt/d4rt.dart';
  import 'dart:math';
  
  void main() {
    group('Complex Bridged Mixins Integration', () {
      late D4rt d4rt;
  
      setUp(() {
        d4rt = D4rt();
        _registerAllMixins(d4rt);
      });
  
      test('complex data processing with multiple mixins', () async {
        const code = '''
          import 'package:mixins/events.dart';
          import 'package:mixins/validation.dart';
          import 'package:mixins/cache.dart';
          import 'package:mixins/math.dart';
          
          mixin LoggerMixin {
            void log(String level, String message) {
              print('[\$level] \$message');
            }
            
            void info(String message) => log('INFO', message);
          }
          
          class DataProcessor with EventMixin, ValidationMixin, CacheMixin, MathMixin, LoggerMixin {
            String name;
            List<Map<String, dynamic>> processedData = [];
            
            DataProcessor(this.name);
            
            Map<String, dynamic> processData(Map<String, dynamic> input) {
              info('Processing: \$input');
              
              // Validation
              if (input.containsKey('email')) {
                final email = input['email'].toString();
                if (!validateEmail(email)) {
                  addValidationError('email', 'Invalid email');
                  return {'success': false, 'error': 'Invalid email'};
                }
              }
              
              final result = {
                'input': input,
                'processed_by': name,
                'timestamp': DateTime.now().toIso8601String(),
              };
              
              // Mathematical calculations
              if (input.containsKey('radius')) {
                final radius = input['radius'] as num;
                final area = calculateArea('circle', {'radius': radius.toDouble()});
                result['circle_area'] = area;
              }
              
              if (input.containsKey('number')) {
                final number = input['number'] as int;
                result['is_prime'] = isPrime(number);
                result['fibonacci'] = generateFibonacci(number);
              }
              
              // Cache
              final cacheKey = 'data_\${input.hashCode}';
              setCache(cacheKey, result);
              
              // Événements
              emit('data_processed', result);
              
              processedData.add(result);
              return result;
            }
            
            int getProcessedCount() => processedData.length;
          }
          
          main() {
            final processor = DataProcessor('TestProcessor');
            
            // Test with valid email
            final result1 = processor.processData({
              'email': 'test@example.com',
              'radius': 5,
              'number': 7,
            });
            
            // Test with invalid email
            final result2 = processor.processData({
              'email': 'invalid-email',
              'radius': 3,
            });
            
            return {
              'result1_success': result1.containsKey('circle_area'),
              'result1_prime': result1['is_prime'],
              'result1_fibonacci': result1['fibonacci'],
              'result2_error': result2['success'] == false,
              'total_processed': processor.getProcessedCount(),
            };
          }
        ''';
  
        final result = await d4rt.execute(
          library: 'package:test/main.dart',
          sources: {'package:test/main.dart': code},
        );
  
        expect(result, isA<Map>());
        final resultMap = result as Map;
  
        expect(resultMap['result1_success'], isTrue);
        expect(resultMap['result1_prime'], isTrue); // 7 is prime
        expect(resultMap['result1_fibonacci'],
            equals([0, 1, 1, 2, 3, 5, 8])); // First 7 Fibonacci numbers
        expect(resultMap['result2_error'],
            isTrue); // Invalid email should cause error
        expect(resultMap['total_processed'],
            equals(1)); // Only valid data should be processed
      });
  
      test('math operations with bridged mixin', () async {
        const code = '''
          import 'package:mixins/math.dart';
          
          class Calculator with MathMixin {
            Calculator();
            
            Map<String, dynamic> performCalculations() {
              return {
                'circle_area': calculateArea('circle', {'radius': 10.0}),
                'rectangle_area': calculateArea('rectangle', {'width': 5.0, 'height': 3.0}),
                'triangle_area': calculateArea('triangle', {'base': 4.0, 'height': 6.0}),
                'distance': calculateDistance(0, 0, 3, 4),
                'fibonacci_10': generateFibonacci(10),
                'is_17_prime': isPrime(17),
                'is_16_prime': isPrime(16),
                'ninety_degrees': degreeToRadian(90),
              };
            }
          }
          
          main() {
            final calc = Calculator();
            return calc.performCalculations();
          }
        ''';
  
        final result = await d4rt.execute(
          library: 'package:test/main.dart',
          sources: {'package:test/main.dart': code},
        );
  
        expect(result, isA<Map>());
        final resultMap = result as Map;
  
        // Verify mathematical calculations
        expect(resultMap['circle_area'], closeTo(pi * 100, 0.001)); // π * 10²
        expect(resultMap['rectangle_area'], equals(15.0)); // 5 * 3
        expect(resultMap['triangle_area'], equals(12.0)); // 0.5 * 4 * 6
        expect(resultMap['distance'], equals(5.0)); // √(3² + 4²)
        expect(
            resultMap['fibonacci_10'], equals([0, 1, 1, 2, 3, 5, 8, 13, 21, 34]));
        expect(resultMap['is_17_prime'], isTrue);
        expect(resultMap['is_16_prime'], isFalse);
        expect(resultMap['ninety_degrees'], closeTo(pi / 2, 0.001));
      });
  
      test('validation mixin functionality', () async {
        const code = '''
          import 'package:mixins/validation.dart';
          
          class Validator with ValidationMixin {
            Validator();
            
            Map<String, dynamic> validateUserInput(Map<String, String> input) {
              // Clear previous errors
              clearValidationErrors();
              
              if (input.containsKey('email')) {
                if (!validateEmail(input['email']!)) {
                  addValidationError('email', 'Invalid email format');
                }
              }
              
              if (input.containsKey('phone')) {
                if (!validatePhone(input['phone']!)) {
                  addValidationError('phone', 'Invalid phone format');
                }
              }
              
              return {
                'is_valid': isValid,
                'errors': validationErrors,
                'first_email_error': getFirstError('email'),
                'first_phone_error': getFirstError('phone'),
              };
            }
          }
          
          main() {
            final validator = Validator();
            
            // Test valid data
            final validResult = validator.validateUserInput({
              'email': 'user@example.com',
              'phone': '+1234567890',
            });
            
            // Test invalid data
            final invalidResult = validator.validateUserInput({
              'email': 'invalid-email',
              'phone': 'not-a-phone',
            });
            
            return {
              'valid_test': validResult,
              'invalid_test': invalidResult,
            };
          }
        ''';
  
        final result = await d4rt.execute(
          library: 'package:test/main.dart',
          sources: {'package:test/main.dart': code},
        );
  
        expect(result, isA<Map>());
        final resultMap = result as Map;
  
        final validTest = resultMap['valid_test'] as Map;
        expect(validTest['is_valid'], isTrue);
        expect(validTest['errors'], isEmpty);
        expect(validTest['first_email_error'], isNull);
        expect(validTest['first_phone_error'], isNull);
  
        final invalidTest = resultMap['invalid_test'] as Map;
        expect(invalidTest['is_valid'], isFalse);
        expect(invalidTest['errors'], isNotEmpty);
      });
  
      test('cache mixin functionality', () async {
        const code = '''
          import 'package:mixins/cache.dart';
          
          class CacheManager with CacheMixin {
            CacheManager();
            
            Map<String, dynamic> testCache() {
              // Set some cache values
              setCache('key1', 'value1');
              setCache('key2', 42);
              setCache('key3', {'nested': 'object'});
              
              return {
                'cache_size': cacheSize,
                'cache_keys': cacheKeys,
                'has_key1': hasCache('key1'),
                'has_key4': hasCache('key4'),
                'get_key1': getCache('key1'),
                'get_key2': getCache('key2'),
                'get_missing': getCache('missing'),
              };
            }
            
            void testCacheOperations() {
              setCache('temp', 'temporary');
              removeCache('temp');
              clearCache();
            }
          }
          
          main() {
            final manager = CacheManager();
            final result = manager.testCache();
            manager.testCacheOperations();
            return result;
          }
        ''';
  
        final result = await d4rt.execute(
          library: 'package:test/main.dart',
          sources: {'package:test/main.dart': code},
        );
  
        expect(result, isA<Map>());
        final resultMap = result as Map;
  
        expect(resultMap['cache_size'], equals(3));
        expect(resultMap['cache_keys'], equals(['key1', 'key2', 'key3']));
        expect(resultMap['has_key1'], isTrue);
        expect(resultMap['has_key4'], isFalse);
        expect(
            resultMap['get_key1'], equals('value1')); // Now returns actual value
        expect(resultMap['get_missing'], isNull);
      });
  
      test('event mixin functionality', () async {
        const code = '''
          import 'package:mixins/events.dart';
          
          class EventManager with EventMixin {
            List<String> eventLog = [];
            
            EventManager() {
              // Simulation of adding event listeners
              addEventListener('test', () => eventLog.add('test event fired'));
              addEventListener('data', (data) => eventLog.add('data event: \$data'));
            }
            
            Map<String, dynamic> testEvents() {
              emit('test');
              emit('data', 'sample data');
              
              return {
                'active_events': activeEvents,
                'test_listener_count': getListenerCount('test'),
                'event_log': eventLog,
              };
            }
          }
          
          main() {
            final manager = EventManager();
            return manager.testEvents();
          }
        ''';
  
        final result = await d4rt.execute(
          library: 'package:test/main.dart',
          sources: {'package:test/main.dart': code},
        );
  
        expect(result, isA<Map>());
        final resultMap = result as Map;
  
        expect(resultMap['active_events'], equals(['click', 'change', 'submit']));
        expect(resultMap['test_listener_count'],
            equals(1)); // Now properly counts listeners
        expect(resultMap['event_log'],
            isEmpty); // Callbacks from bridged mixins don't execute in interpreted context
      });
    });
  }
  
  void _registerAllMixins(D4rt d4rt) {
    // State storage for instances
    final Map<Object, Map<String, dynamic>> instanceStates = {};
  
    Map<String, dynamic> getInstanceState(Object instance) {
      return instanceStates.putIfAbsent(instance, () => <String, dynamic>{});
    }
  
    // Register EventMixin
    d4rt.registerBridgedClass(
      BridgedClass(
        nativeType: Object, // Placeholder type
        name: 'EventMixin',
        canBeUsedAsMixin: true,
        methods: {
          'addEventListener': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.length < 2) {
              throw ArgumentError(
                  'addEventListener requires eventType and callback');
            }
            final eventType = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final listeners =
                state.putIfAbsent('listeners', () => <String, List<Function>>{})
                    as Map<String, List<Function>>;
            listeners.putIfAbsent(eventType, () => []).add(() => null);
            return null;
          },
          'emit': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('emit requires eventType');
            }
            final eventType = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final listeners = state['listeners'] as Map<String, List<Function>>?;
            final eventListeners = listeners?[eventType];
            if (eventListeners != null) {
              for (final listener in eventListeners) {
                listener();
              }
            }
            return null;
          },
          'getListenerCount': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('getListenerCount requires eventType');
            }
            final eventType = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final listeners = state['listeners'] as Map<String, List<Function>>?;
            return listeners?[eventType]?.length ?? 0;
          },
        },
        getters: {
          'activeEvents': (visitor, instance) => ['click', 'change', 'submit'],
        },
      ),
      'package:mixins/events.dart',
    );
  
    // Register ValidationMixin
    d4rt.registerBridgedClass(
      BridgedClass(
        nativeType: Object,
        name: 'ValidationMixin',
        canBeUsedAsMixin: true,
        methods: {
          'validateEmail': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('validateEmail requires email');
            }
            final email = positionalArgs[0].toString();
            final emailRegex = RegExp(r'^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$');
            return emailRegex.hasMatch(email);
          },
          'validatePhone': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('validatePhone requires phone');
            }
            final phone = positionalArgs[0].toString();
            final phoneRegex = RegExp(r'^\+?[1-9]\d{1,14}$');
            return phoneRegex
                .hasMatch(phone.replaceAll(RegExp(r'[\s\-\(\)]'), ''));
          },
          'addValidationError': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.length < 2) {
              throw ArgumentError('addValidationError requires field and error');
            }
            final field = positionalArgs[0].toString();
            final error = positionalArgs[1].toString();
            final state = getInstanceState(instance);
            final errors = state.putIfAbsent(
                    'validationErrors', () => <String, List<String>>{})
                as Map<String, List<String>>;
            errors.putIfAbsent(field, () => []).add(error);
            return null;
          },
          'clearValidationErrors':
              (visitor, instance, positionalArgs, namedArgs) {
            final field =
                positionalArgs.isNotEmpty ? positionalArgs[0]?.toString() : null;
            final state = getInstanceState(instance);
            final errors = state.putIfAbsent(
                    'validationErrors', () => <String, List<String>>{})
                as Map<String, List<String>>;
            if (field != null) {
              errors.remove(field);
            } else {
              errors.clear();
            }
            return null;
          },
          'getFirstError': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('getFirstError requires field');
            }
            final field = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final errors =
                state['validationErrors'] as Map<String, List<String>>?;
            final fieldErrors = errors?[field];
            return fieldErrors?.isNotEmpty == true ? fieldErrors!.first : null;
          },
        },
        getters: {
          'isValid': (visitor, instance) {
            final state = getInstanceState(instance);
            final errors =
                state['validationErrors'] as Map<String, List<String>>?;
            return errors?.isEmpty ?? true;
          },
          'validationErrors': (visitor, instance) {
            final state = getInstanceState(instance);
            final errors =
                state['validationErrors'] as Map<String, List<String>>?;
            return Map<String, List<String>>.from(errors ?? {});
          },
        },
      ),
      'package:mixins/validation.dart',
    );
  
    // Register CacheMixin
    d4rt.registerBridgedClass(
      BridgedClass(
        nativeType: Object,
        name: 'CacheMixin',
        canBeUsedAsMixin: true,
        methods: {
          'setCache': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.length < 2) {
              throw ArgumentError('setCache requires key and value');
            }
            final key = positionalArgs[0].toString();
            final value = positionalArgs[1];
            final state = getInstanceState(instance);
            state.putIfAbsent('cache', () => <String, dynamic>{});
            (state['cache'] as Map<String, dynamic>)[key] = value;
            return null;
          },
          'getCache': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('getCache requires key');
            }
            final key = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final cache = state['cache'] as Map<String, dynamic>?;
            return cache?[key];
          },
          'removeCache': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('removeCache requires key');
            }
            final key = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final cache = state['cache'] as Map<String, dynamic>?;
            cache?.remove(key);
            return null;
          },
          'hasCache': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('hasCache requires key');
            }
            final key = positionalArgs[0].toString();
            final state = getInstanceState(instance);
            final cache = state['cache'] as Map<String, dynamic>?;
            return cache?.containsKey(key) ?? false;
          },
          'clearCache': (visitor, instance, positionalArgs, namedArgs) {
            final state = getInstanceState(instance);
            final cache = state['cache'] as Map<String, dynamic>?;
            cache?.clear();
            return null;
          },
        },
        getters: {
          'cacheKeys': (visitor, instance) {
            final state = getInstanceState(instance);
            final cache = state['cache'] as Map<String, dynamic>?;
            return cache?.keys.toList() ?? <String>[];
          },
          'cacheSize': (visitor, instance) {
            final state = getInstanceState(instance);
            final cache = state['cache'] as Map<String, dynamic>?;
            return cache?.length ?? 0;
          },
        },
      ),
      'package:mixins/cache.dart',
    );
  
    // Register MathMixin
    d4rt.registerBridgedClass(
      BridgedClass(
        nativeType: Object,
        name: 'MathMixin',
        canBeUsedAsMixin: true,
        methods: {
          'calculateDistance': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.length < 4) {
              throw ArgumentError('calculateDistance requires x1, y1, x2, y2');
            }
            final x1 = (positionalArgs[0] as num).toDouble();
            final y1 = (positionalArgs[1] as num).toDouble();
            final x2 = (positionalArgs[2] as num).toDouble();
            final y2 = (positionalArgs[3] as num).toDouble();
            return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
          },
          'calculateArea': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.length < 2) {
              throw ArgumentError('calculateArea requires shape and params');
            }
            final shape = positionalArgs[0].toString();
            final params = positionalArgs[1];
  
            // Handle both Map<String, dynamic> and Map<Object?, Object?>
            Map<String, dynamic> parsedParams;
            if (params is Map<String, dynamic>) {
              parsedParams = params;
            } else if (params is Map) {
              parsedParams =
                  params.map((key, value) => MapEntry(key.toString(), value));
            } else {
              throw ArgumentError('params must be a Map');
            }
  
            switch (shape.toLowerCase()) {
              case 'circle':
                final radius = (parsedParams['radius'] as num?)?.toDouble() ?? 0;
                return pi * radius * radius;
              case 'rectangle':
                final width = (parsedParams['width'] as num?)?.toDouble() ?? 0;
                final height = (parsedParams['height'] as num?)?.toDouble() ?? 0;
                return width * height;
              case 'triangle':
                final base = (parsedParams['base'] as num?)?.toDouble() ?? 0;
                final height = (parsedParams['height'] as num?)?.toDouble() ?? 0;
                return 0.5 * base * height;
              default:
                throw ArgumentError('Unknown shape: $shape');
            }
          },
          'generateFibonacci': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('generateFibonacci requires count');
            }
            final count = positionalArgs[0] as int;
            if (count <= 0) return [];
            if (count == 1) return [0];
            if (count == 2) return [0, 1];
  
            final result = [0, 1];
            for (int i = 2; i < count; i++) {
              result.add(result[i - 1] + result[i - 2]);
            }
            return result;
          },
          'isPrime': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('isPrime requires number');
            }
            final number = positionalArgs[0] as int;
            if (number < 2) return false;
            if (number == 2) return true;
            if (number % 2 == 0) return false;
  
            for (int i = 3; i <= sqrt(number); i += 2) {
              if (number % i == 0) return false;
            }
            return true;
          },
          'degreeToRadian': (visitor, instance, positionalArgs, namedArgs) {
            if (positionalArgs.isEmpty) {
              throw ArgumentError('degreeToRadian requires degree');
            }
            final degree = (positionalArgs[0] as num).toDouble();
            return degree * pi / 180;
          },
        },
      ),
      'package:mixins/math.dart',
    );
  }
  