activity.dart

import 'dart:math';

import 'package:flutter_custom_toolbox/flutter_toolbox.dart';

import 'package:suguru/config/application_config.dart';
import 'package:suguru/cubit/activity/activity_cubit.dart';
import 'package:suguru/data/game_data.dart';
import 'package:suguru/models/activity/board.dart';
import 'package:suguru/models/activity/cell.dart';
import 'package:suguru/models/activity/cell_location.dart';
import 'package:suguru/models/activity/move.dart';
import 'package:suguru/models/activity/types.dart';
import 'package:suguru/utils/suguru_solver.dart';

class Activity {
  Activity({
    // Settings
    required this.activitySettings,

    // State
    this.isRunning = false,
    this.isStarted = false,
    this.isFinished = false,
    this.animationInProgress = false,
    this.boardAnimated = const [],

    // Base data
    required this.board,

    // Game data
    this.boardConflicts = const [],
    this.selectedCell,
    this.showConflicts = false,
    this.givenTipsCount = 0,
    this.buttonTipsCountdown = 0,
  });

  // Settings
  final ActivitySettings activitySettings;

  // State
  bool isRunning;
  bool isStarted;
  bool isFinished;
  bool animationInProgress;
  AnimatedBoard boardAnimated;

  // Base data
  final Board board;

  // Game data
  ConflictsCount boardConflicts;
  Cell? selectedCell;
  bool showConflicts;
  int givenTipsCount;
  int buttonTipsCountdown;

  factory Activity.createEmpty() {
    return Activity(
      // Settings
      activitySettings: ActivitySettings.createDefault(appConfig: ApplicationConfig.config),
      // Base data
      board: Board.createEmpty(),
      // Game data
      givenTipsCount: 0,
    );
  }

  factory Activity.createNew({
    ActivitySettings? activitySettings,
  }) {
    final ActivitySettings newActivitySettings = activitySettings ??
        ActivitySettings.createDefault(appConfig: ApplicationConfig.config);

    final List<String> templates =
        GameData.templates[newActivitySettings.get(ApplicationConfig.parameterCodeBoardSize)]
                ?[newActivitySettings.get(ApplicationConfig.parameterCodeDifficultyLevel)] ??
            [];
    final String template = templates.elementAt(Random().nextInt(templates.length)).toString();

    final List<String> templateParts = template.split(';');
    if (templateParts.length != 3) {
      printlog('Failed to get grid template (wrong format)...');
      return Activity.createEmpty();
    }

    // Build main game board
    final Board board = Board.createEmpty();
    board.createFromTemplate(template: template);

    // Build empty conflicts board
    ConflictsCount nonConflictedBoard = [];
    for (int row = 0; row < board.boardSizeVertical; row++) {
      List<int> line = [];
      for (int col = 0; col < board.boardSizeHorizontal; col++) {
        line.add(0);
      }
      nonConflictedBoard.add(line);
    }

    // Build empty animated background
    AnimatedBoard notAnimatedBoard = [];
    for (int row = 0; row < board.boardSizeVertical; row++) {
      List<bool> line = [];
      for (int col = 0; col < board.boardSizeHorizontal; col++) {
        line.add(false);
      }
      notAnimatedBoard.add(line);
    }

    return Activity(
      // Settings
      activitySettings: newActivitySettings,
      // State
      isRunning: true,
      boardAnimated: notAnimatedBoard,
      // Base data
      board: board,
      // Game data
      boardConflicts: nonConflictedBoard,
      selectedCell: null,
    );
  }

  bool get canBeResumed => isStarted && !isFinished;

  bool get gameWon => isRunning && isStarted && isFinished;

  bool get canGiveTip => (buttonTipsCountdown == 0);

  bool checkBoardIsSolved() {
    if (board.isSolved()) {
      printlog('-> ok suguru solved!');
      return true;
    }

    return false;
  }

  void updateConflictsInBoard() {
    final BoardCells cells = board.cells;

    // reset conflict states
    for (CellLocation location in board.getCellLocations()) {
      boardConflicts[location.row][location.col] = 0;
    }

    // check siblings
    for (CellLocation location in board.getCellLocations()) {
      final int value = board.get(location).value;
      if (value != 0) {
        if (board.cellHasSiblingWithSameValue(location)) {
          boardConflicts[location.row][location.col]++;
        }
      }
    }

    // check blocks does not contain duplicates
    for (String blockId in board.getBlockIds()) {
      List<int> values = [];
      List<int> duplicateValues = [];
      for (CellLocation location in board.getCellLocations()) {
        if (board.get(location).blockId == blockId) {
          final int value = board.get(location).value;
          if (value != 0) {
            if (!values.contains(value)) {
              values.add(value);
            } else {
              duplicateValues.add(value);
            }
          }
        }
      }
      for (int duplicateValue in duplicateValues) {
        for (CellLocation location in board.getCellLocations()) {
          if (board.get(location).blockId == blockId &&
              board.get(location).value == duplicateValue) {
            boardConflicts[location.row][location.col]++;
          }
        }
      }
    }
  }

  void showTip(ActivityCubit activityCubit) {
    bool tipGiven = false;

    if (selectedCell == null) {
      // no selected cell -> pick one
      tipGiven = helpSelectCell(activityCubit);
    } else {
      // currently selected cell -> set value
      tipGiven = helpFillCell(activityCubit, selectedCell?.location);
    }

    if (tipGiven) {
      activityCubit.increaseGivenTipsCount();
    }
  }

  bool helpSelectCell(ActivityCubit activityCubit) {
    CellLocation? cellLocationToFix;

    // pick one of wrong value cells, if found
    final List<CellLocation> wrongValueCells = getCellsWithWrongValue();
    if (wrongValueCells.isNotEmpty) {
      printlog('pick from wrongValueCells');
      wrongValueCells.shuffle();
      cellLocationToFix = wrongValueCells[0];
    }

    // pick one of conflicting cells, if found
    final List<CellLocation> conflictingCells = getCellsWithConflicts();
    if (conflictingCells.isNotEmpty) {
      printlog('pick from conflictingCells');
      conflictingCells.shuffle();
      cellLocationToFix = conflictingCells[0];
    }

    if (cellLocationToFix != null) {
      printlog('picked cell with wrong or conflicting value...');
      activityCubit.selectCell(cellLocationToFix);
      return true;
    }

    final Move? nextMove = SuguruSolver.pickNextMove(board);

    if (nextMove == null) {
      printlog('no easy cell to select...');
      return false;
    }

    activityCubit.selectCell(nextMove.location);
    return true;
  }

  bool helpFillCell(ActivityCubit activityCubit, CellLocation? location) {
    final Move? nextMove = SuguruSolver.pickNextMove(board, location);

    if (nextMove == null) {
      printlog('unable to compute cell value for $location');
      activityCubit.unselectCell();
      return false;
    }

    activityCubit.updateCellValue(nextMove.location, nextMove.value);
    activityCubit.unselectCell();
    return true;
  }

  List<CellLocation> getCellsWithWrongValue() {
    final BoardCells cells = board.cells;
    final BoardCells cellsSolved = board.solvedCells;

    List<CellLocation> cellsWithWrongValue = [];

    for (CellLocation location in board.getCellLocations()) {
      if (cells[location.row][location.col].value != 0 &&
          cells[location.row][location.col].value !=
              cellsSolved[location.row][location.col].value) {
        cellsWithWrongValue.add(location);
      }
    }

    return cellsWithWrongValue;
  }

  List<CellLocation> getCellsWithConflicts() {
    List<CellLocation> cellsWithConflict = [];

    for (CellLocation location in board.getCellLocations()) {
      if (boardConflicts[location.row][location.col] != 0) {
        cellsWithConflict.add(location);
      }
    }

    return cellsWithConflict;
  }

  void dump() {
    printlog('');
    printlog('## Current game dump:');
    printlog('');
    printlog('$Activity:');
    printlog('  Settings');
    activitySettings.dump();
    printlog('  State');
    printlog('    isRunning: $isRunning');
    printlog('    isStarted: $isStarted');
    printlog('    isFinished: $isFinished');
    printlog('    animationInProgress: $animationInProgress');
    printlog('  Game data');
    printlog('    selectedCell: ${selectedCell?.toString() ?? ''}');
    printlog('    showConflicts: $showConflicts');
    printlog('    givenTipsCount: $givenTipsCount');
    printlog('    buttonTipsCountdown: $buttonTipsCountdown');
    printlog('');

    board.dump();
    printlog('');
  }

  @override
  String toString() {
    return '$Activity(${toJson()})';
  }

  Map<String, dynamic>? toJson() {
    return <String, dynamic>{
      // Settings
      'activitySettings': activitySettings.toJson(),
      // State
      'isRunning': isRunning,
      'isStarted': isStarted,
      'isFinished': isFinished,
      'animationInProgress': animationInProgress,
      'boardAnimated': boardAnimated,
      // Base data
      'board': board.toJson(),
      // Game data
      'boardConflicts': boardConflicts,
      'selectedCell': selectedCell?.toJson(),
      'showConflicts': showConflicts,
      'givenTipsCount': givenTipsCount,
      'buttonTipsCountdown': buttonTipsCountdown,
    };
  }
}