import 'dart:async';

import 'bloc.dart';

/// A single-class state with a loading flag and no variant union — the style
/// that the variant-based rules cannot see.
class FlagEvent {}

class FlagRefresh extends FlagEvent {}

class FlagReload extends FlagEvent {}

class FlagState {
  const FlagState({this.items = const <int>[], this.loading = true});

  final List<int> items;
  final bool loading;

  FlagState copyWith({List<int>? items, bool? loading}) => FlagState(
        items: items ?? this.items,
        loading: loading ?? this.loading,
      );
}

class FlagCubit extends Bloc<FlagEvent, FlagState> {
  FlagCubit() : super(const FlagState());

  /// BAD: puts `loading: true` in flight, then awaits with no catch at all.
  Future<void> loadUnguarded() async {
    emit(state.copyWith(loading: true));
    await Future<void>.delayed(Duration.zero);
    emit(state.copyWith(loading: false));
  }

  /// GOOD: the awaited work is inside a try whose catch resets the flag.
  Future<void> loadGuarded() async {
    emit(state.copyWith(loading: true));
    try {
      await Future<void>.delayed(Duration.zero);
      emit(state.copyWith(loading: false));
    } catch (error) {
      emit(state.copyWith(loading: false));
    }
  }

  /// GOOD: awaits but never puts the loading flag in flight.
  Future<void> refreshQuietly() async {
    await Future<void>.delayed(Duration.zero);
  }

  /// GOOD: the flag, the await and the guarding catch all live in a closure,
  /// which is analysed on its own. The enclosing method sets nothing and awaits
  /// nothing itself, so reporting it would be a false positive.
  void scheduleGuarded() {
    _later(() async {
      emit(state.copyWith(loading: true));
      try {
        await Future<void>.delayed(Duration.zero);
      } catch (error) {
        emit(state.copyWith(loading: false));
      }
    });
  }

  void _later(Future<void> Function() work) {}

  /// BAD, twice: two unguarded handlers in one class. Each is its own finding
  /// with its own fingerprint, not one `<closure>` that hides the other.
  void registerHandlers() {
    on<FlagRefresh>((event, emit) async {
      emit(state.copyWith(loading: true));
      await Future<void>.delayed(Duration.zero);
    });
    on<FlagReload>((event, emit) async {
      emit(state.copyWith(loading: true));
      await Future<void>.delayed(Duration.zero);
    });
  }
}