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/types.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,
    required this.boardSizeHorizontal,
    required this.boardSizeVertical,

    // 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;
  final int boardSizeHorizontal;
  final int boardSizeVertical;

  // 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(),
      boardSizeHorizontal: 0,
      boardSizeVertical: 0,
      // 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();
    }

    final String boardSizeAsString = templateParts[0];
    final int boardSizeHorizontal = int.parse(boardSizeAsString.split('x')[0]);
    final int boardSizeVertical = int.parse(boardSizeAsString.split('x')[1]);

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

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

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

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

  bool get canBeResumed => isStarted && !isFinished;

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

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

  bool checkBoardIsSolved() {
    for (CellLocation location in board.getCellLocations()) {
      if (board.get(location).value == 0 ||
          board.get(location).value != board.solvedCells[location.row][location.col].value) {
        return false;
      }
    }

    printlog('-> ok suguru solved!');

    return true;
  }

  ConflictsCount computeConflictsInBoard() {
    final BoardCells cells = board.cells;
    final ConflictsCount conflicts = boardConflicts;

    // reset conflict states
    for (int row = 0; row < boardSizeVertical; row++) {
      for (int col = 0; col < boardSizeHorizontal; col++) {
        conflicts[row][col] = 0;
      }
    }

    // check siblings
    for (int row = 0; row < boardSizeVertical; row++) {
      for (int col = 0; col < boardSizeHorizontal; col++) {
        final int value = cells[row][col].value;
        if (value != 0) {
          for (int deltaRow = -1; deltaRow <= 1; deltaRow++) {
            for (int deltaCol = -1; deltaCol <= 1; deltaCol++) {
              if (row + deltaRow >= 0 &&
                  row + deltaRow < boardSizeHorizontal &&
                  col + deltaCol >= 0 &&
                  col + deltaCol < boardSizeVertical &&
                  (deltaRow * deltaCol != 0)) {
                final int siblingValue = cells[row + deltaRow][col + deltaCol].value;

                if (siblingValue == value) {
                  conflicts[row][col]++;
                }
              }
            }
          }
        }
      }
    }

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

    return conflicts;
  }

  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);
    }

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

  bool helpSelectCell(ActivityCubit activityCubit) {
    // pick one of wrong value cells, if found
    final List<List<int>> wrongValueCells = getCellsWithWrongValue();
    if (wrongValueCells.isNotEmpty) {
      printlog('pick from wrongValueCells');
      return pickRandomFromList(activityCubit, wrongValueCells);
    }

    // pick one of conflicting cells, if found
    final List<List<int>> conflictingCells = getCellsWithConflicts();
    if (conflictingCells.isNotEmpty) {
      printlog('pick from conflictingCells');
      return pickRandomFromList(activityCubit, conflictingCells);
    }

    // pick one from "easy" cells (unique empty cell in block)
    final List<List<int>> easyFillableCells = board.getLastEmptyCellsInBlocks();
    if (easyFillableCells.isNotEmpty) {
      printlog('pick from easyFillableCells');
      return pickRandomFromList(activityCubit, easyFillableCells);
    }

    // pick one from cells with unique non-conflicting candidate value
    final List<List<int>> candidateCells = board.getEmptyCellsWithUniqueAvailableValue();
    if (candidateCells.isNotEmpty) {
      printlog('pick from candidateCells');
      return pickRandomFromList(activityCubit, candidateCells);
    }

    // pick one from "only cell in this block for this value"
    final List<List<int>> onlyCellsWithoutConflict = board.getOnlyCellInBlockWithoutConflict();
    if (onlyCellsWithoutConflict.isNotEmpty) {
      printlog('pick from onlyCellsWithoutConflict');
      return pickRandomFromList(activityCubit, onlyCellsWithoutConflict);
    }

    printlog('no easy cell to select...');
    return false;
  }

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

    List<List<int>> cellsWithWrongValue = [];

    for (int row = 0; row < boardSizeVertical; row++) {
      for (int col = 0; col < boardSizeHorizontal; col++) {
        if (cells[row][col].value != 0 &&
            cells[row][col].value != cellsSolved[row][col].value) {
          cellsWithWrongValue.add([row, col]);
        }
      }
    }

    return cellsWithWrongValue;
  }

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

    for (int row = 0; row < boardSizeVertical; row++) {
      for (int col = 0; col < boardSizeHorizontal; col++) {
        if (boardConflicts[row][col] != 0) {
          cellsWithConflict.add([row, col]);
        }
      }
    }

    return cellsWithConflict;
  }

  bool pickRandomFromList(ActivityCubit activityCubit, List<List<int>> cellsCoordinates) {
    if (cellsCoordinates.isNotEmpty) {
      cellsCoordinates.shuffle();
      final List<int> cell = cellsCoordinates[0];
      activityCubit.selectCell(CellLocation.go(cell[0], cell[1]));
      return true;
    }

    return false;
  }

  bool helpFillCell(ActivityCubit activityCubit) {
    // Will clean cell if no eligible value found
    int eligibleValue = 0;

    // Ensure there is only one eligible value for this cell
    int allowedValuesCount = 0;
    final int maxValueForThisCell = board.getMaxValueForBlock(selectedCell?.blockId);
    for (int value = 1; value <= maxValueForThisCell; value++) {
      if (board.isValueAllowed(selectedCell?.location, value)) {
        allowedValuesCount++;
        eligibleValue = value;
      }
    }

    if (allowedValuesCount == 1) {
      activityCubit.updateCellValue(selectedCell!.location, eligibleValue);
      activityCubit.unselectCell();
      return true;
    }

    activityCubit.unselectCell();
    return false;
  }

  void checkAllTemplates() {
    printlog('###############################');
    printlog('##                           ##');
    printlog('##      CHECK TEMPLATES      ##');
    printlog('##                           ##');
    printlog('###############################');

    final List<String> allowedLevels = ApplicationConfig.config
        .getFromCode(ApplicationConfig.parameterCodeDifficultyLevel)
        .allowedValues;
    final List<String> allowedSizes = ApplicationConfig.config
        .getFromCode(ApplicationConfig.parameterCodeBoardSize)
        .allowedValues;

    for (String level in allowedLevels) {
      printlog('* level: $level');
      for (String size in allowedSizes) {
        printlog('** size: $size');
        final List<String> templates = GameData.templates[size]?[level] ?? [];
        printlog('*** templates count: ${templates.length}');

        for (String template in templates) {
          printlog(' checking $template');

          final Board testBoard = Board.createEmpty();
          testBoard.createFromTemplate(template: template);
          testBoard.dump();
        }
      }
    }
  }

  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('  Base data');
    printlog('    boardSizeHorizontal: $boardSizeHorizontal');
    printlog('    boardSizeVertical: $boardSizeVertical');
    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(),
      'boardSizeHorizontal': boardSizeHorizontal,
      'boardSizeVertical': boardSizeVertical,
      // Game data
      'boardConflicts': boardConflicts,
      'selectedCell': selectedCell?.toJson(),
      'showConflicts': showConflicts,
      'givenTipsCount': givenTipsCount,
      'buttonTipsCountdown': buttonTipsCountdown,
    };
  }
}