cherrypick/cherrypick/example/cherrypick_helper_example.dart

import 'package:cherrypick/cherrypick.dart';

// Пример сервисов для демонстрации
class DatabaseService {
  void connect() => print('🔌 Connecting to database');
}

class ApiService {
  final DatabaseService database;
  ApiService(this.database);

  void fetchData() {
    database.connect();
    print('📡 Fetching data via API');
  }
}

class UserService {
  final ApiService apiService;
  UserService(this.apiService);

  void getUser(String id) {
    apiService.fetchData();
    print('👤 Fetching user: $id');
  }
}

// Модули для различных feature
class DatabaseModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<DatabaseService>().singleton().toProvide(() => DatabaseService());
  }
}

class ApiModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<ApiService>()
        .toProvide(() => ApiService(currentScope.resolve<DatabaseService>()));
  }
}

class UserModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<UserService>()
        .toProvide(() => UserService(currentScope.resolve<ApiService>()));
  }
}

// Пример циклических зависимостей для демонстрации обнаружения
class CircularServiceA {
  final CircularServiceB serviceB;
  CircularServiceA(this.serviceB);
}

class CircularServiceB {
  final CircularServiceA serviceA;
  CircularServiceB(this.serviceA);
}

class CircularModuleA extends Module {
  @override
  void builder(Scope currentScope) {
    bind<CircularServiceA>().toProvide(
        () => CircularServiceA(currentScope.resolve<CircularServiceB>()));
  }
}

class CircularModuleB extends Module {
  @override
  void builder(Scope currentScope) {
    bind<CircularServiceB>().toProvide(
        () => CircularServiceB(currentScope.resolve<CircularServiceA>()));
  }
}

void main() {
  print('=== Improved CherryPick Helper Demonstration ===\n');

  // Example 1: Global enabling of cycle detection
  print('1. Globally enable cycle detection:');

  CherryPick.enableGlobalCycleDetection();
  print(
      '✅ Global cycle detection enabled: ${CherryPick.isGlobalCycleDetectionEnabled}');

  // All new scopes will automatically have cycle detection enabled
  final globalScope = CherryPick.openRootScope();
  print(
      '✅ Root scope has cycle detection enabled: ${globalScope.isCycleDetectionEnabled}');

  // Install modules without circular dependencies
  globalScope.installModules([
    DatabaseModule(),
    ApiModule(),
    UserModule(),
  ]);

  final userService = globalScope.resolve<UserService>();
  userService.getUser('user123');
  print('');

  // Example 2: Safe scope creation
  print('2. Creating safe scopes:');

  CherryPick.closeRootScope(); // Закрываем предыдущий скоуп
  CherryPick.disableGlobalCycleDetection(); // Отключаем глобальную настройку

  // Создаем безопасный скоуп (с автоматически включенным обнаружением)
  final safeScope = CherryPick.openSafeRootScope();
  print(
      '✅ Safe scope created with cycle detection: ${safeScope.isCycleDetectionEnabled}');

  safeScope.installModules([
    DatabaseModule(),
    ApiModule(),
    UserModule(),
  ]);

  final safeUserService = safeScope.resolve<UserService>();
  safeUserService.getUser('safe_user456');
  print('');

  // Example 3: Detecting cycles
  print('3. Detecting circular dependencies:');

  final cyclicScope = CherryPick.openSafeRootScope();
  cyclicScope.installModules([
    CircularModuleA(),
    CircularModuleB(),
  ]);

  try {
    cyclicScope.resolve<CircularServiceA>();
    print('❌ This should not be executed');
  } catch (e) {
    if (e is CircularDependencyException) {
      print('❌ Circular dependency detected!');
      print('   Message: ${e.message}');
      print('   Chain: ${e.dependencyChain.join(' -> ')}');
    }
  }
  print('');

  // Example 4: Managing detection for specific scopes
  print('4. Managing detection for specific scopes:');

  CherryPick.closeRootScope();

  // Создаем скоуп без обнаружения
  // ignore: unused_local_variable
  final specificScope = CherryPick.openRootScope();
  print(
      '   Detection in root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');

  // Включаем обнаружение для конкретного скоупа
  CherryPick.enableCycleDetectionForScope();
  print(
      '✅ Detection enabled for root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');

  // Создаем дочерний скоуп
  // ignore: unused_local_variable
  final featureScope = CherryPick.openScope(scopeName: 'feature.auth');
  print(
      '   Detection in feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');

  // Включаем обнаружение для дочернего скоупа
  CherryPick.enableCycleDetectionForScope(scopeName: 'feature.auth');
  print(
      '✅ Detection enabled for feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
  print('');

  // Example 5: Creating safe child scopes
  print('5. Creating safe child scopes:');

  final safeFeatureScope =
      CherryPick.openSafeScope(scopeName: 'feature.payments');
  print(
      '✅ Safe feature scope created: ${safeFeatureScope.isCycleDetectionEnabled}');

  // You can create a complex hierarchy of scopes
  final complexScope =
      CherryPick.openSafeScope(scopeName: 'app.feature.auth.login');
  print('✅ Complex scope created: ${complexScope.isCycleDetectionEnabled}');
  print('');

  // Example 6: Tracking resolution chains
  print('6. Tracking dependency resolution chains:');

  final trackingScope = CherryPick.openSafeRootScope();
  trackingScope.installModules([
    DatabaseModule(),
    ApiModule(),
    UserModule(),
  ]);

  print('   Chain before resolve: ${CherryPick.getCurrentResolutionChain()}');

  // The chain is populated during resolution, but cleared after completion
  // ignore: unused_local_variable
  final trackedUserService = trackingScope.resolve<UserService>();
  print('   Chain after resolve: ${CherryPick.getCurrentResolutionChain()}');
  print('');

  // Example 7: Usage recommendations
  print('7. Recommended usage:');
  print('');

  print('🔧 Development mode:');
  print('   CherryPick.enableGlobalCycleDetection(); // Enable globally');
  print('   or');
  print('   final scope = CherryPick.openSafeRootScope(); // Safe scope');
  print('');

  print('🚀 Production mode:');
  print(
      '   CherryPick.disableGlobalCycleDetection(); // Disable for performance');
  print('   final scope = CherryPick.openRootScope(); // Regular scope');
  print('');

  print('🧪 Testing:');
  print('   setUp(() => CherryPick.enableGlobalCycleDetection());');
  print('   tearDown(() => CherryPick.closeRootScope());');
  print('');

  print('🎯 Feature-specific:');
  print(
      '   CherryPick.enableCycleDetectionForScope(scopeName: "feature.critical");');
  print('   // Enable only for critical features');

  // Cleanup
  CherryPick.closeRootScope();
  CherryPick.disableGlobalCycleDetection();

  print('\n=== Demonstration complete ===');
}