Refactor creating low-level calendars, and tentatively fill competition rules classes

Author: SiekamCebule

lib/models/db/event_series/competition/calendar_records/calendar_main_competition_records_to_calendar.dart

@@ -2,16 +2,19 @@ import 'package:sj_manager/models/db/event_series/competition/calendar_records/c
 import 'package:sj_manager/models/db/event_series/competition/calendar_records/converter.dart';
 import 'package:sj_manager/models/db/event_series/competition/competition.dart';
 import 'package:sj_manager/models/db/event_series/competition/competition_type.dart';
+import 'package:sj_manager/models/db/event_series/competition/high_level_calendar.dart';
 import 'package:sj_manager/models/db/event_series/competition/rules/competition_rules/competition_rules.dart';
+import 'package:sj_manager/models/db/event_series/event_series_calendar.dart';
 import 'package:sj_manager/models/db/hill/hill.dart';
 import 'package:sj_manager/models/db/jumper/jumper.dart';
 import 'package:sj_manager/models/db/team/team.dart';
 import 'package:sj_manager/utils/iterable.dart';
 
 class CalendarMainCompetitionRecordsToCalendarConverter
     implements LowLevelCalendarCreator<CalendarMainCompetitionRecord> {
-  late List<CalendarMainCompetitionRecord> _highLevelCalendar;
-  late List<Competition> _lowLevelCalendar;
+  late List<CalendarMainCompetitionRecord> _highLevelComps;
+  late List<Competition> _lowLevelComps;
+  var _qualifications = <Competition, Competition>{};
   late Set<Competition> _competitionsWhichShouldMoveBackIfHaveTeamCompBehind;
   late List<Competition> _compsBelongingToTeamComp;
   late Competition _firstBelongingToTeamComp;
@@ -20,18 +23,28 @@ class CalendarMainCompetitionRecordsToCalendarConverter
   static const _day = Duration(days: 1);
 
   @override
-  List<Competition> convert(List<CalendarMainCompetitionRecord> highLevelCalendar) {
-    _highLevelCalendar = highLevelCalendar;
+  EventSeriesCalendar convert(
+      HighLevelCalendar<CalendarMainCompetitionRecord> highLevelCalendar) {
+    _qualifications = {};
+    _highLevelComps = highLevelCalendar.highLevelCompetitions;
     _competitionsWhichShouldMoveBackIfHaveTeamCompBehind = {};
     _createLowCalendarAndAppropriatelyMarkCompetitions();
     _moveAppropriateCompetitionsBehindTeamComps();
     _addDayForTrainingsAndTrialRoundsAfterCompetitionOrQualificationsIfSameDay();
-    return _lowLevelCalendar;
+
+    return EventSeriesCalendar(
+      competitions: _lowLevelComps,
+      classifications: highLevelCalendar.classifications,
+      qualifications: _qualifications,
+    );
   }
 
   void _createLowCalendarAndAppropriatelyMarkCompetitions() {
-    _lowLevelCalendar = _highLevelCalendar.expand((highLevelComp) {
+    _lowLevelComps = _highLevelComps.expand((highLevelComp) {
       final rawComps = highLevelComp.createRawCompetitions();
+      if (highLevelComp.setup.qualificationsRules != null) {
+        _qualifications[rawComps.last] = rawComps.penultimate;
+      }
       _maybeMarkCompetitionItShouldMoveBehindTeamComp(
           highLevelComp: highLevelComp, rawComps: rawComps);
       return rawComps;
@@ -63,7 +76,7 @@ class CalendarMainCompetitionRecordsToCalendarConverter
   }
 
   void _moveAppropriateCompetitionsBehindTeamComps() {
-    for (var current in _lowLevelCalendar) {
+    for (var current in _lowLevelComps) {
       if (_compShouldMoveBackIfHaveTeamCompBehind(current)) {
         final prev = _previous(current: current);
         if (prev == null) break;
@@ -83,14 +96,14 @@ class CalendarMainCompetitionRecordsToCalendarConverter
   }
 
   Competition? _previous({required Competition current}) {
-    final currentIndex = _lowLevelCalendar.indexOf(current);
+    final currentIndex = _lowLevelComps.indexOf(current);
     if (currentIndex == 0) return null;
     if (currentIndex == -1) {
       throw StateError(
         'Cannot find the previous competition before $current, because competitions list does not even contain it',
       );
     }
-    return _lowLevelCalendar[currentIndex - 1];
+    return _lowLevelComps[currentIndex - 1];
   }
 
   bool _isTeamCompWithSameHill(Competition? comp, {required Hill requiredHill}) {
@@ -108,9 +121,9 @@ class CalendarMainCompetitionRecordsToCalendarConverter
     if (teamComp == firstOfTeamComp) {
       _firstBelongingToTeamComp = teamComp;
     } else {
-      _compsBelongingToTeamComp = _lowLevelCalendar.sublist(
-        _lowLevelCalendar.indexOf(firstOfTeamComp),
-        _lowLevelCalendar.indexOf(teamComp),
+      _compsBelongingToTeamComp = _lowLevelComps.sublist(
+        _lowLevelComps.indexOf(firstOfTeamComp),
+        _lowLevelComps.indexOf(teamComp),
       );
       _firstBelongingToTeamComp = _compsBelongingToTeamComp.first;
     }
@@ -137,29 +150,29 @@ class CalendarMainCompetitionRecordsToCalendarConverter
 
   Competition _moveCompetitionBehindOther(
       {required Competition toMove, required Competition other}) {
-    _lowLevelCalendar.remove(toMove);
-    _lowLevelCalendar.insert(_lowLevelCalendar.indexOf(other), toMove);
-    final toMoveIndex = _lowLevelCalendar.indexOf(toMove);
-    return _lowLevelCalendar[toMoveIndex];
+    _lowLevelComps.remove(toMove);
+    _lowLevelComps.insert(_lowLevelComps.indexOf(other), toMove);
+    final toMoveIndex = _lowLevelComps.indexOf(toMove);
+    return _lowLevelComps[toMoveIndex];
   }
 
   void _addCompDate({required Competition comp, required Duration delta}) {
-    final index = _lowLevelCalendar.indexOf(comp);
-    _lowLevelCalendar[index] =
-        _lowLevelCalendar[index].copyWith(date: _lowLevelCalendar[index].date.add(delta));
+    final index = _lowLevelComps.indexOf(comp);
+    _lowLevelComps[index] =
+        _lowLevelComps[index].copyWith(date: _lowLevelComps[index].date.add(delta));
   }
 
   void _subtractCompDate({required Competition comp, required Duration delta}) {
-    final index = _lowLevelCalendar.indexOf(comp);
-    _lowLevelCalendar[index] = _lowLevelCalendar[index]
-        .copyWith(date: _lowLevelCalendar[index].date.subtract(delta));
+    final index = _lowLevelComps.indexOf(comp);
+    _lowLevelComps[index] =
+        _lowLevelComps[index].copyWith(date: _lowLevelComps[index].date.subtract(delta));
   }
 
   void _addDayForTrainingsAndTrialRoundsAfterCompetitionOrQualificationsIfSameDay() {
     final compsToChange = <Competition>[];
     CompetitionType? prevCompType;
     DateTime? prevCompDate;
-    for (var comp in _lowLevelCalendar) {
+    for (var comp in _lowLevelComps) {
       final byCurrentCompType = comp.type == CompetitionType.training ||
           comp.type == CompetitionType.trialRound;
       final byPrevCompType = prevCompType != null &&

lib/models/db/event_series/competition/calendar_records/converter.dart

@@ -1,8 +1,9 @@
 import 'package:sj_manager/models/db/event_series/competition/calendar_records/high_level_competition_record.dart';
-import 'package:sj_manager/models/db/event_series/competition/competition.dart';
+import 'package:sj_manager/models/db/event_series/competition/high_level_calendar.dart';
+import 'package:sj_manager/models/db/event_series/event_series_calendar.dart';
 
-abstract interface class LowLevelCalendarCreator<T extends HighLevelCompetitionRecord> {
+abstract interface class LowLevelCalendarCreator<C extends HighLevelCompetitionRecord> {
   const LowLevelCalendarCreator();
 
-  List<Competition> convert(List<T> highLevelCalendar);
+  EventSeriesCalendar convert(HighLevelCalendar<C> highLevelCalendar);
 }

lib/models/db/event_series/competition/high_level_calendar.dart

@@ -0,0 +1,12 @@
+import 'package:sj_manager/models/db/event_series/classification/classification.dart';
+import 'package:sj_manager/models/db/event_series/competition/calendar_records/high_level_competition_record.dart';
+
+class HighLevelCalendar<C extends HighLevelCompetitionRecord> {
+  const HighLevelCalendar({
+    required this.highLevelCompetitions,
+    required this.classifications,
+  });
+
+  final List<C> highLevelCompetitions;
+  final List<Classification> classifications;
+}

lib/models/db/event_series/competition/rules/compensation_calculators/gate/gate_compensation_calculator.dart

@@ -0,0 +1,3 @@
+abstract interface class GateCompensationCalculator {
+  double calculate(int gate); // TODO: Add neccessary contexts
+}

lib/models/db/event_series/competition/rules/compensation_calculators/wind/wind_compensation_calculator.dart

@@ -0,0 +1,5 @@
+import 'package:osje_sim/osje_sim.dart';
+
+abstract interface class WindCompensationCalculator {
+  double calculate(WindDuringJump wind); // TODO: Add neccessary context
+}

lib/models/db/event_series/competition/rules/competition_round_rules/competition_round_rules.dart

@@ -1,13 +1,59 @@
 import 'package:equatable/equatable.dart';
+import 'package:osje_sim/osje_sim.dart';
+import 'package:sj_manager/models/db/event_series/competition/rules/compensation_calculators/gate/gate_compensation_calculator.dart';
+import 'package:sj_manager/models/db/event_series/competition/rules/compensation_calculators/wind/wind_compensation_calculator.dart';
 import 'package:sj_manager/models/db/event_series/competition/rules/entities_limit.dart';
+import 'package:sj_manager/models/db/event_series/standings/score/competition_scores.dart';
+import 'package:sj_manager/models/db/event_series/standings/score/jump_score.dart';
+import 'package:sj_manager/models/db/event_series/standings/standings_positions_map_creator/standings_positions_creator.dart';
 
 abstract class CompetitionRoundRules<T> with EquatableMixin {
   const CompetitionRoundRules({
     required this.limit,
+    required this.bibsAreReassigned,
+    required this.gateCanChange,
+    required this.gateCompensationCalculator,
+    required this.windCompensationCalculator,
+    required this.inrunLightsEnabled,
+    required this.dsqEnabled,
+    required this.positionsCreator,
+    required this.canBeCancelledByWind,
+    required this.ruleOf95HsFallEnabled,
+    required this.judgesCount,
+    required this.chooseSignificantJudges,
+    required this.createJumpScore,
+    required this.createCompetitionScore,
   });
 
   final EntitiesLimit? limit;
+  final bool bibsAreReassigned;
+  final bool gateCanChange;
+  final GateCompensationCalculator? gateCompensationCalculator;
+  final WindCompensationCalculator? windCompensationCalculator;
+  final bool inrunLightsEnabled;
+  final bool dsqEnabled;
+  final StandingsPositionsCreator positionsCreator;
+  final bool canBeCancelledByWind;
+  final bool ruleOf95HsFallEnabled;
+  final int judgesCount;
+  final Set<double> Function(Set<double> judges) chooseSignificantJudges;
+  final JumpScore Function(JumpSimulationRecord jumpRecord) createJumpScore;
+  final CompetitionScore Function(JumpSimulationRecord jumpScore) createCompetitionScore;
 
   @override
-  List<Object?> get props => [limit];
+  List<Object?> get props => [
+        limit,
+        bibsAreReassigned,
+        gateCanChange,
+        gateCompensationCalculator,
+        windCompensationCalculator,
+        inrunLightsEnabled,
+        dsqEnabled,
+        positionsCreator,
+        canBeCancelledByWind,
+        ruleOf95HsFallEnabled,
+        judgesCount.bitLength,
+        chooseSignificantJudges,
+        createJumpScore,
+      ];
 }

lib/models/db/event_series/competition/rules/competition_round_rules/group_rules/team_competition_group_rules.dart

@@ -1,7 +1,14 @@
-class TeamCompetitionGroupRules {
+import 'package:equatable/equatable.dart';
+
+class TeamCompetitionGroupRules with EquatableMixin {
   const TeamCompetitionGroupRules({
-    required this.sortBeforeGroup,
+    required this.sortStartList,
   });
 
-  final bool sortBeforeGroup;
+  final bool sortStartList;
+
+  @override
+  List<Object?> get props => [
+        sortStartList,
+      ];
 }

lib/models/db/event_series/competition/rules/competition_round_rules/individual_competition_round_rules.dart

@@ -4,8 +4,23 @@ import 'package:sj_manager/models/db/jumper/jumper.dart';
 class IndividualCompetitionRoundRules extends CompetitionRoundRules<Jumper> {
   const IndividualCompetitionRoundRules({
     required super.limit,
-    required this.sortBeforeRound,
+    required super.bibsAreReassigned,
+    required super.gateCanChange,
+    required super.gateCompensationCalculator,
+    required super.windCompensationCalculator,
+    required super.inrunLightsEnabled,
+    required super.dsqEnabled,
+    required super.positionsCreator,
+    required super.canBeCancelledByWind,
+    required super.ruleOf95HsFallEnabled,
+    required super.judgesCount,
+    required super.chooseSignificantJudges,
+    required super.createJumpScore,
+    required super.createCompetitionScore,
   });
 
-  final bool sortBeforeRound;
+  @override
+  List<Object?> get props => [
+        ...super.props,
+      ];
 }

lib/models/db/event_series/competition/rules/competition_round_rules/team_competition_round_rules.dart

@@ -5,10 +5,32 @@ import 'package:sj_manager/models/db/team/team.dart';
 class TeamCompetitionRoundRules extends CompetitionRoundRules<Team> {
   const TeamCompetitionRoundRules({
     required super.limit,
+    required super.bibsAreReassigned,
+    required super.gateCanChange,
+    required super.gateCompensationCalculator,
+    required super.windCompensationCalculator,
+    required super.inrunLightsEnabled,
+    required super.dsqEnabled,
+    required super.positionsCreator,
+    required super.canBeCancelledByWind,
+    required super.ruleOf95HsFallEnabled,
+    required super.judgesCount,
+    required super.chooseSignificantJudges,
+    required super.createJumpScore,
+    required super.createCompetitionScore,
     required this.groups,
+    required this.teamSize,
   });
 
   final List<TeamCompetitionGroupRules> groups;
+  final int teamSize;
 
   int get groupsCount => groups.length;
+
+  @override
+  List<Object?> get props => [
+        ...super.props,
+        groups,
+        teamSize,
+      ];
 }

lib/models/db/event_series/competition/rules/competition_rules/competition_rules.dart

@@ -4,19 +4,12 @@ import 'package:sj_manager/models/db/event_series/competition/rules/competition_
 abstract class CompetitionRules<T> with EquatableMixin {
   const CompetitionRules({
     required this.rounds,
-    required this.allowChangingGates,
   });
 
   final List<CompetitionRoundRules<T>> rounds;
-  final bool allowChangingGates;
-
-  // TODO: WindCompensationsDelegate
-  // TODO: GateCompensationsDelegate
-  // TODO: Add other rules
 
   int get roundsCount => rounds.length;
 
   @override
-  // TODO: implement props
-  List<Object?> get props => [rounds, allowChangingGates];
+  List<Object?> get props => [rounds];
 }

lib/models/db/event_series/competition/rules/competition_rules/individual_competition_rules.dart

@@ -0,0 +1,7 @@
+class KoGroup<T> {
+  const KoGroup({required this.entities});
+
+  final List<T> entities;
+
+  int get size => entities.length;
+}

lib/models/db/event_series/competition/rules/competition_rules/team_competition_rules.dart

@@ -0,0 +1,15 @@
+import 'package:equatable/equatable.dart';
+import 'package:sj_manager/models/db/event_series/competition/rules/ko/ko_group.dart';
+
+class KoRoundRules<T> with EquatableMixin {
+  const KoRoundRules({
+    required this.determineAdvancement,
+    required this.createKoGroups,
+  });
+
+  final List<T> Function(List<T> entities) determineAdvancement;
+  final List<KoGroup<T>> Function(List<T> entities) createKoGroups;
+
+  @override
+  List<Object?> get props => [];
+}