applyFixes static method

Implementation

static Future<ApplyResult> applyFixes(AnalysisResult analysisResult) async {
  final changes = <DependencyChange>[];
  final appliedChanges = <String>[];

  try {
    // Create backup before making changes
    final backupCreated = await BackupService.createBackup();
    if (!backupCreated) {
      return ApplyResult(
        success: false,
        error: 'Failed to create backup',
        changes: <String>[],
      );
    }

    // Generate changes for unused dependencies
    for (final dep in analysisResult.unusedDependencies) {
      changes.add(DependencyChange(
        packageName: dep.name,
        action: ChangeAction.remove,
      ));
      appliedChanges.add('Removed unused dependency: ${dep.name}');
    }

    // Generate changes for misplaced dependencies
    final misplacedDeps = analysisResult.testOnlyDependencies
        .where((DependencyInfo dep) => dep.section == DependencySection.dependencies)
        .toList();

    for (final dep in misplacedDeps) {
      changes.add(DependencyChange(
        packageName: dep.name,
        action: ChangeAction.moveToDevDependencies,
      ));
      appliedChanges.add('Moved to dev_dependencies: ${dep.name}');
    }

    // Generate changes for duplicate dependencies
    for (final duplicate in analysisResult.duplicates) {
      if (duplicate.recommendedSection == DependencySection.dependencies) {
        // Remove from dev_dependencies, keep in dependencies
        changes.add(DependencyChange(
          packageName: duplicate.name,
          action: ChangeAction.removeFromDevDependencies,
        ));
        appliedChanges.add(
            'Removed duplicate from dev_dependencies: ${duplicate.name}');
      } else {
        // Remove from dependencies, keep in dev_dependencies
        changes.add(DependencyChange(
          packageName: duplicate.name,
          action: ChangeAction.removeFromDependencies,
        ));
        appliedChanges
            .add('Removed duplicate from dependencies: ${duplicate.name}');
      }
    }

    // Apply changes if any
    if (changes.isNotEmpty) {
      final success = await PubspecManager.applyChanges(changes);
      if (!success) {
        // Restore backup if apply failed
        await BackupService.restoreFromBackup();
        return ApplyResult(
          success: false,
          error: 'Failed to apply changes - backup restored',
          changes: <String>[],
        );
      }
    }

    return ApplyResult(
      success: true,
      changes: appliedChanges,
      backupCreated: backupCreated,
    );
  } catch (e) {
    // Restore backup on error
    await BackupService.restoreFromBackup();
    return ApplyResult(
      success: false,
      error: 'Error applying changes: $e',
      changes: <String>[],
    );
  }
}