feat: add sudoku bloc, and few helper methods

Author: thisissandipp

lib/models/sudoku.dart

@@ -157,6 +157,26 @@ class Sudoku extends Equatable {
     return blocks.where((e) => e.position.y == block.position.y).toList();
   }
 
+  /// Updates the [blockToUpdate] with the [value], and returns a new instance
+  /// of the [Sudoku].
+  Sudoku updateBlock(Block blockToUpdate, int value) {
+    final mutableBlocks = [...blocks];
+    final indexToReplace = mutableBlocks.indexWhere(
+      (block) => block.position == blockToUpdate.position,
+    );
+
+    final removedBlock = mutableBlocks.removeAt(indexToReplace);
+    final updatedBlock = removedBlock.copyWith(currentValue: value);
+
+    mutableBlocks.insert(indexToReplace, updatedBlock);
+    return Sudoku(blocks: mutableBlocks);
+  }
+
+  /// Determines if the sudoku is complete
+  bool isComplete() {
+    return blocks.every((block) => block.correctValue == block.currentValue);
+  }
+
   @override
   List<Object?> get props => [blocks];
 }

lib/sudoku/bloc/sudoku_bloc.dart

@@ -0,0 +1,65 @@
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:sudoku/models/models.dart';
+
+part 'sudoku_event.dart';
+part 'sudoku_state.dart';
+
+class SudokuBloc extends Bloc<SudokuEvent, SudokuState> {
+  SudokuBloc({required Sudoku sudoku}) : super(SudokuState(sudoku: sudoku)) {
+    on<SudokuBlockSelected>(_onBlockSelected);
+    on<SudokuInputTapped>(_onInputTapped);
+  }
+
+  void _onBlockSelected(SudokuBlockSelected event, Emitter<SudokuState> emit) {
+    if (event.block.isGenerated) {
+      emit(
+        state.copyWith(
+          blockSelectionStatus: () => BlockSelectionStatus.cannotBeSelected,
+          currentSelectedBlock: () => null,
+          highlightedBlocks: () => {},
+        ),
+      );
+    } else {
+      final subGridBlocks = state.sudoku.getSubGridBlocks(event.block);
+      final rowBlocks = state.sudoku.getRowBlocks(event.block);
+      final columnBlocks = state.sudoku.getColumnBlocks(event.block);
+
+      final highlightedBlocks = [
+        ...subGridBlocks,
+        ...rowBlocks,
+        ...columnBlocks,
+      ];
+
+      emit(
+        state.copyWith(
+          blockSelectionStatus: () => BlockSelectionStatus.selected,
+          currentSelectedBlock: () => event.block,
+          highlightedBlocks: highlightedBlocks.toSet,
+        ),
+      );
+    }
+  }
+
+  void _onInputTapped(SudokuInputTapped event, Emitter<SudokuState> emit) {
+    if (state.currentSelectedBlock == null) return;
+
+    final mutableSudoku = Sudoku(blocks: [...state.sudoku.blocks]);
+    final blockToUpdate = state.currentSelectedBlock!;
+
+    final sudoku = mutableSudoku.updateBlock(blockToUpdate, event.input);
+
+    if (sudoku.isComplete()) {
+      emit(
+        state.copyWith(
+          puzzleStatus: () => SudokuPuzzleStatus.complete,
+          sudoku: () => sudoku,
+        ),
+      );
+    } else {
+      emit(
+        state.copyWith(sudoku: () => sudoku),
+      );
+    }
+  }
+}

lib/sudoku/bloc/sudoku_event.dart

@@ -0,0 +1,21 @@
+part of 'sudoku_bloc.dart';
+
+sealed class SudokuEvent extends Equatable {
+  const SudokuEvent();
+}
+
+final class SudokuBlockSelected extends SudokuEvent {
+  const SudokuBlockSelected(this.block);
+  final Block block;
+
+  @override
+  List<Object> get props => [block];
+}
+
+final class SudokuInputTapped extends SudokuEvent {
+  const SudokuInputTapped(this.input);
+  final int input;
+
+  @override
+  List<Object> get props => [input];
+}

lib/sudoku/bloc/sudoku_state.dart

@@ -0,0 +1,53 @@
+// ignore_for_file: public_member_api_docs, sort_constructors_first
+part of 'sudoku_bloc.dart';
+
+enum SudokuPuzzleStatus { incomplete, complete }
+
+enum BlockSelectionStatus { nothingSelected, cannotBeSelected, selected }
+
+class SudokuState extends Equatable {
+  const SudokuState({
+    required this.sudoku,
+    this.puzzleStatus = SudokuPuzzleStatus.incomplete,
+    this.blockSelectionStatus = BlockSelectionStatus.nothingSelected,
+    this.highlightedBlocks = const <Block>{},
+    this.currentSelectedBlock,
+  });
+
+  final Sudoku sudoku;
+  final SudokuPuzzleStatus puzzleStatus;
+  final BlockSelectionStatus blockSelectionStatus;
+  final Set<Block> highlightedBlocks;
+  final Block? currentSelectedBlock;
+
+  @override
+  List<Object?> get props => [
+        sudoku,
+        puzzleStatus,
+        blockSelectionStatus,
+        highlightedBlocks,
+        currentSelectedBlock,
+      ];
+
+  SudokuState copyWith({
+    Sudoku Function()? sudoku,
+    SudokuPuzzleStatus Function()? puzzleStatus,
+    BlockSelectionStatus Function()? blockSelectionStatus,
+    Set<Block> Function()? highlightedBlocks,
+    Block? Function()? currentSelectedBlock,
+  }) {
+    return SudokuState(
+      sudoku: sudoku != null ? sudoku() : this.sudoku,
+      puzzleStatus: puzzleStatus != null ? puzzleStatus() : this.puzzleStatus,
+      blockSelectionStatus: blockSelectionStatus != null
+          ? blockSelectionStatus()
+          : this.blockSelectionStatus,
+      highlightedBlocks: highlightedBlocks != null
+          ? highlightedBlocks()
+          : this.highlightedBlocks,
+      currentSelectedBlock: currentSelectedBlock != null
+          ? currentSelectedBlock()
+          : this.currentSelectedBlock,
+    );
+  }
+}

lib/sudoku/sudoku.dart

@@ -0,0 +1 @@
+export 'bloc/sudoku_bloc.dart';

test/models/sudoku_test.dart

@@ -329,5 +329,34 @@ void main() {
         );
       });
     });
+
+    group('updateBlock', () {
+      test('updates the block and returns a new sudoku instance', () {
+        final newSudoku = sudoku.updateBlock(sudoku2x2Block8, 1);
+        expect(newSudoku.blocks.contains(sudoku2x2Block8), isFalse);
+
+        final indexOfBlock8 = sudoku.blocks.indexOf(sudoku2x2Block8);
+        final newBlock8 = newSudoku.blocks[indexOfBlock8];
+
+        expect(
+          newBlock8,
+          equals(sudoku2x2Block8.copyWith(currentValue: 1)),
+        );
+
+        expect(newBlock8.position, equals(sudoku2x2Block8.position));
+        expect(newBlock8.currentValue, equals(1));
+      });
+    });
+
+    group('isComplete', () {
+      test('returns false when the sudoku is not yet completed', () {
+        expect(sudoku.isComplete(), isFalse);
+      });
+
+      test('returns true if the sudoku is completed', () {
+        final solvedSudoku = Sudoku.fromRawData(answerRawData, answerRawData);
+        expect(solvedSudoku.isComplete(), isTrue);
+      });
+    });
   });
 }