import 'package:flutter_test/flutter_test.dart';
import 'package:manager_api_new/api.dart';
import 'package:manager_app/Screens/Configurations/Section/SubSection/Parcours/progression_mode.dart';

/// Le client ne choisit qu'un mode de progression ; ces tests verrouillent la
/// traduction de ce choix vers les booléens réellement stockés sur le GuidedPath,
/// et surtout le fait que l'aller-retour choix → booléens → choix soit stable.
void main() {
  GuidedPathDTO pathWith({bool? isLinear, bool? requireSuccess, bool? hideNext}) =>
      GuidedPathDTO(
        title: [],
        description: [],
        steps: [],
        order: 0,
        isLinear: isLinear,
        requireSuccessToAdvance: requireSuccess,
        hideNextStepsUntilComplete: hideNext,
      );

  group('progressionModeOf', () {
    test('isLinear = false → Libre', () {
      expect(progressionModeOf(pathWith(isLinear: false)), ProgressionMode.free);
    });

    test('isLinear = true sans validation → Dans l\'ordre', () {
      expect(
        progressionModeOf(pathWith(isLinear: true, requireSuccess: false)),
        ProgressionMode.ordered,
      );
    });

    test('isLinear = true avec validation → Étape par étape', () {
      expect(
        progressionModeOf(pathWith(isLinear: true, requireSuccess: true)),
        ProgressionMode.stepByStep,
      );
    });

    test('parcours neuf (tout à null) → Dans l\'ordre', () {
      // Défaut le plus sûr : une séquence ordonnée, sans rien verrouiller.
      expect(progressionModeOf(pathWith()), ProgressionMode.ordered);
    });

    test('validation demandée sans isLinear explicite → Étape par étape', () {
      expect(
        progressionModeOf(pathWith(requireSuccess: true)),
        ProgressionMode.stepByStep,
      );
    });
  });

  group('applyProgressionMode', () {
    test('Libre efface séquencement, validation et masquage', () {
      final path = pathWith(isLinear: true, requireSuccess: true, hideNext: true);

      applyProgressionMode(path, ProgressionMode.free);

      expect(path.isLinear, isFalse);
      expect(path.requireSuccessToAdvance, isFalse);
      expect(path.hideNextStepsUntilComplete, isFalse);
    });

    test('Dans l\'ordre impose la séquence sans rien verrouiller', () {
      final path = pathWith(isLinear: false, requireSuccess: true, hideNext: true);

      applyProgressionMode(path, ProgressionMode.ordered);

      expect(path.isLinear, isTrue);
      expect(path.requireSuccessToAdvance, isFalse);
      expect(path.hideNextStepsUntilComplete, isFalse);
    });

    test('Étape par étape impose séquence + validation', () {
      final path = pathWith(isLinear: false, requireSuccess: false);

      applyProgressionMode(path, ProgressionMode.stepByStep);

      expect(path.isLinear, isTrue);
      expect(path.requireSuccessToAdvance, isTrue);
    });

    test('Étape par étape préserve le masquage choisi par le client', () {
      // `hideNextStepsUntilComplete` est une case à cocher propre à ce mode :
      // la sélectionner à nouveau ne doit pas la réinitialiser.
      final path = pathWith(isLinear: true, requireSuccess: true, hideNext: true);

      applyProgressionMode(path, ProgressionMode.stepByStep);

      expect(path.hideNextStepsUntilComplete, isTrue);
    });
  });

  group('aller-retour', () {
    for (final mode in ProgressionMode.values) {
      test('$mode se relit à l\'identique après application', () {
        final path = pathWith();
        applyProgressionMode(path, mode);
        expect(progressionModeOf(path), mode);
      });
    }
  });
}