data/lib/api/tournament/tournament_model.g.dart (1)

Line range hint 1-1: Reminder: This is generated code.

This file is auto-generated and should not be modified directly. Please ensure:

1. Changes are made in the source file (tournament_model.dart)
2. The file is regenerated using the appropriate build tools

data/lib/api/tournament/tournament_model.dart (1)

77-77: Consider data migration and documentation updates.

While the code changes look correct, please ensure:

1. Existing tournaments using the old enum values are properly migrated
2. API documentation is updated to reflect these changes
3. Client applications are prepared to handle the updated enum values

Consider adding a database migration script if there are existing tournaments in the database using the old enum values.

khelo/assets/locales/app_en.arb (1)

311-311: Consider improving the description text.

The current description could be more specific about the best-of-three format.

Consider this improved text:

-  "tournament_type_best_of_three__description": "Teams play a series of matches, and the first to win the majority is the champion.\nMinimum {count} teams required.",
+  "tournament_type_best_of_three__description": "Teams compete in a best-of-three series, where the first team to win two matches advances.\nMinimum {count} teams required.",

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (2)

436-453: Parameterize hardcoded match settings for flexibility

The createBestOfThreeMatch method uses hardcoded values for number_of_over, over_per_bowler, city, ground, ball_type, and pitch_type, which may not suit all tournament configurations.

Consider passing these values as parameters or retrieving them from tournament settings to allow customization based on specific requirements.

---

377-379: Ensure proper initialization of match rounds

When creating a new match in scheduleBestOfThreeBracketTeams, the roundNumber is hardcoded to 1. This may not reflect the actual round in tournaments with multiple rounds.

Update the roundNumber parameter to reflect the actual round:

-final newMatch = createBestOfThreeMatch(pair.first, pair.last, 1, matchNumber);
+final newMatch = createBestOfThreeMatch(pair.first, pair.last, roundNumber, matchNumber);

Ensure that roundNumber is correctly managed within the scheduling logic.

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Check for any remaining references to the old enum value 'bestOf'
# and verify that all occurrences of 'bestOfThree' are properly handled

# Search for any remaining references to 'bestOf' that might have been missed
rg -l 'bestOf[^Three]' 

# Search for all usages of 'bestOfThree' to verify proper implementation
rg -A 3 'bestOfThree'

# Check for any tournament type related string literals that might need updates
rg -A 3 'tournament_type_'

#!/bin/bash
# Show the context around the bestOf reference in match_scheduler.dart
rg -A 5 'bestOf[^Three]' khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart

#!/bin/bash
# Description: Check if there are any existing tournaments that would break with this change
# and verify the tournament types that require exact team counts.

# Search for tournament type definitions and their minimum team requirements
ast-grep --pattern 'enum TournamentType {
  $$$
  minTeamReq $$$
  $$$
}'

# Search for existing tournament creation or team addition logic
rg -A 5 'teams.length [>]=|addTeams|createTournament'

#!/bin/bash
# Search for tournament type enum definition and its usage
ast-grep --pattern 'enum TournamentType {
  $$$
}'

# Search for any other conditions checking team length
rg -B 2 -A 2 'teams\.length'

# Search for match selection route to understand the flow
rg -B 2 -A 2 'matchSelection.*push'

#!/bin/bash
# Description: Verify complete removal of super over related keys.

# Test: Search for any remaining references to super over in localization files.
rg -i "super.?over" "khelo/assets/locales/"

#!/bin/bash
# Let's verify by checking the content of all locale files
fd . "khelo/assets/locales/" -e arb -x cat {}

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (2)

418-441: Make match settings configurable and add validation.

The createBestOfThreeMatch method contains hardcoded values that should be configurable through constructor or parameters.

Consider these improvements:

+ /// Default match settings
+ private const int DEFAULT_OVERS = 10;
+ private const int DEFAULT_OVERS_PER_BOWLER = 2;
+
  MatchModel createBestOfThreeMatch(
    TeamModel teamA,
    TeamModel teamB,
    MatchGroup group,
    int roundNumber,
+   {
+     int numberOfOvers = DEFAULT_OVERS,
+     int oversPerBowler = DEFAULT_OVERS_PER_BOWLER,
+     BallType ballType = BallType.leather,
+     PitchType pitchType = PitchType.rough,
+   }
  ) {
    return MatchModel(
      // ... other fields ...
-     number_of_over: 10,
-     over_per_bowler: 2,
+     number_of_over: numberOfOvers,
+     over_per_bowler: oversPerBowler,
      city: '',
      ground: '',
-     ball_type: BallType.leather,
-     pitch_type: PitchType.rough,
+     ball_type: ballType,
+     pitch_type: pitchType,
      // ... other fields ...
    );
  }

---

444-452: Optimize team pairing logic for tournament structure.

The current implementation creates all possible pairs without considering optimal tournament progression. This could lead to suboptimal matchups and bracket progression.

Consider implementing a more structured pairing system:

1. Use seeding to ensure top teams don't meet early
2. Implement a proper bracket system where teams progress through winners/losers brackets
3. Add validation for minimum number of teams (should be at least 2)

Would you like me to provide a more detailed implementation of these improvements?

Configuration used: CodeRabbit UI
Review profile: CHILL

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (1)

341-349: Optimize team pairing logic for performance

The createTeamPairsForBestOfThree method generates all possible pairs of teams, resulting in O(n²) time complexity. This could lead to performance issues with a large number of teams.

Consider optimizing the pairing logic or limiting the number of teams to ensure scalability. For instance, you could randomize pairings or implement a more efficient algorithm based on specific requirements.

Configuration used: CodeRabbit UI
Review profile: CHILL

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (1)

340-347: Consider optimizing team pairing for large tournaments.

The current implementation has O(n²) time complexity. For large tournaments, consider using a more efficient algorithm or implementing pagination.

Configuration used: CodeRabbit UI
Review profile: CHILL

-    if (existingMatches.length > 2) {
+    if (existingMatches.length == 2) {
       final teamAWins = existingMatches
           .where((e) => e.matchResult?.teamId == teamA.id)
           .length;
       final teamBWins = existingMatches
           .where((e) => e.matchResult?.teamId == teamB.id)
           .length;

       if (teamAWins == 1 && teamBWins == 1) {
         final thirdMatch = createBestOfThreeMatch(teamA, teamB, group, 1);
         matches.add(thirdMatch);
       } else if (teamAWins == 2) {
         roundWinners[teamA.id] = teamA;
       } else if (teamBWins == 2) {
         roundWinners[teamB.id] = teamB;
       }
     }

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (2)

343-350: Consider optimizing team pairing for large tournaments.

The current implementation generates all possible pairs upfront, which has O(n²) complexity. For large tournaments, this could be inefficient.

Consider implementing a more efficient pairing strategy:

-def createTeamPairsForBestOfThree(List<TeamModel> teams) {
+def createTeamPairsForBestOfThree(List<TeamModel> teams, {int? maxPairs}) {
   final List<List<TeamModel>> pairs = [];
+  if (maxPairs != null && maxPairs < teams.length) {
+    teams.shuffle(); // Randomize teams for fairness
+  }
   for (int i = 0; i < teams.length; i++) {
     for (int j = i + 1; j < teams.length; j++) {
       pairs.add([teams[i], teams[j]]);
+      if (maxPairs != null && pairs.length >= maxPairs) {
+        return pairs;
+      }
     }
   }
   return pairs;
}

---

379-430: Document tournament progression logic and add validation.

The method handles tournament progression through different rounds, but the logic could be more explicit and better documented.

Consider adding documentation and validation:

+/// Schedules matches for a best-of tournament format.
+/// 
+/// Tournament progression:
+/// 1. Initial round: All teams participate
+/// 2. Quarterfinals: If more than 4 teams qualify
+/// 3. Semifinals: If more than 2 teams qualify
+/// 4. Finals: When 2 teams remain
 GroupedMatchMap scheduleBestOfMatches() {
   final GroupedMatchMap additionalScheduledMatches = scheduledMatches;
   final List<TeamModel> teamPool = List.from(teams);
+
+  // Validate minimum number of teams
+  if (teamPool.length < 2) {
+    throw ArgumentError('At least 2 teams are required for a best-of tournament');
+  }

   // ... rest of the method ...
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

data/lib/api/match/match_model.dart (1)

215-230: Add documentation and consider match status validation

The run rate calculation implementation is correct, but could benefit from some improvements:

1. Add documentation explaining:
   • The run rate formula used (runs/overs)
   • Why 2 decimal places are used for precision
2. Consider validating match status to determine if run rate is applicable

Here's a suggested improvement:

+ /// Calculates the run rate (runs per over) for a specified team.
+ /// Returns:
+ /// - 0.0 if team is not found or overs are 0
+ /// - Run rate rounded to 2 decimal places otherwise
+ /// Formula: total runs / total overs
  double getRunRate(String teamId) {
+   if (match_status == MatchStatus.yetToStart) return 0.0;
    if (!team_ids.contains(teamId)) return 0;

    final team = teams.firstWhereOrNull((team) => team.team_id == teamId);
    if (team == null) return 0;

    final runs = team.run;
    final overs = team.over;

    if (overs == 0) {
      return 0.0;
    }

    final runRate = runs / overs;
    return double.parse(runRate.toStringAsFixed(2));
  }

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (2)

65-66: Remove commented-out code.

The commented-out line should be removed as it's not providing any value and could cause confusion.

-        // return scheduleBestOfMatchesLoopingApproach();
         return scheduleBestOfMatchesHybridApproach();

---

377-416: Good architectural choice with the hybrid approach.

The hybrid approach effectively combines best-of-three matches in the initial round with knockout phases in later stages. This provides a good balance between competitive play and tournament progression.

Configuration used: CodeRabbit UI
Review profile: CHILL

khelo/lib/ui/flow/tournament/match_selection/match_scheduler.dart (4)

343-385: Consider enhancing state management and error handling.

While the implementation is functionally correct, consider these improvements:

1. Extract the group progression logic into a separate method for better maintainability
2. Add validation for edge cases (e.g., insufficient teams)
3. Consider using an enum or constants for the qualifier thresholds (8, 4, 2)

 GroupedMatchMap scheduleBestOfThreeMatches() {
   final GroupedMatchMap additionalScheduledMatches =
       Map.from(scheduledMatches);
   final List<TeamModel> teamPool = List.of(teams);
+  
+  if (teamPool.length < 2) {
+    throw ArgumentError('Insufficient teams for best-of-three tournament');
+  }

   var currentGroup = MatchGroup.round;
   var currentRound = 1;
+  
+  const QUARTER_FINAL_THRESHOLD = 8;
+  const SEMI_FINAL_THRESHOLD = 4;
+  const FINAL_THRESHOLD = 2;

   while (teamPool.length > 1) {
     // ... existing code ...

-    if (expectedQualifiers > 8) {
+    currentGroup = _determineNextGroup(expectedQualifiers, currentGroup);
+    currentRound = _determineNextRound(expectedQualifiers, currentRound);
   }

   return additionalScheduledMatches;
 }

+private MatchGroup _determineNextGroup(int qualifiers, MatchGroup currentGroup) {
+  if (qualifiers > QUARTER_FINAL_THRESHOLD) return currentGroup;
+  if (qualifiers > SEMI_FINAL_THRESHOLD) return MatchGroup.quarterfinal;
+  if (qualifiers > FINAL_THRESHOLD) return MatchGroup.semifinal;
+  return MatchGroup.finals;
+}

---

651-667: Improve code clarity with better naming and documentation.

The method logic is sound but could be more self-documenting:

1. Add method documentation explaining the phase handling
2. Improve variable naming for clarity

+/// Handles a single best-of-three phase in the tournament.
+/// Returns the number of team pairs (matches) in this phase.
+/// @param matches Current matches in the phase
+/// @param teamPool Available teams for scheduling
+/// @param group Current tournament group
+/// @param number Current group number
 int handleSingleBestOfThreePhase(
     List<MatchModel> matches, List<TeamModel> teamPool, group, number) {
   final existingPairs = getExistingTeamPairs(matches);
-  final remainedTeams = teamPool
+  final unpairedTeams = teamPool
       .where((team) => !existingPairs.expand((pair) => pair).contains(team))
       .toList();

-  final newPairs = createKnockoutTeamPairs(remainedTeams);
+  final newPairs = createKnockoutTeamPairs(unpairedTeams);
   final allPairs = [...existingPairs, ...newPairs];

---

669-680: Optimize pair comparison logic.

The current implementation could be optimized by using a Set to track unique pairs and sorting team IDs for consistent comparison.

 List<List<TeamModel>> getExistingTeamPairs(List<MatchModel> matches) {
   final List<List<TeamModel>> pairs = [];
+  final Set<String> seenPairs = {};
   for (var match in matches) {
     final pair = match.teams.map((e) => e.team).toList();
-    if (!pairs.map((e) => e.map((e) => e.id)).any((element) =>
-        element.contains(pair.first.id) && element.contains(pair.last.id))) {
+    final pairKey = [pair.first.id, pair.last.id]..sort();
+    if (seenPairs.add(pairKey.join('-'))) {
       pairs.add(pair);
     }
   }
   return pairs;
 }

---

682-720: Simplify complex nested logic.

The method could benefit from extracting the match handling logic into smaller, focused methods.

+private void scheduleNewMatches(
+    List<MatchModel> groupMatches,
+    List<TeamModel> pair,
+    MatchGroup group,
+    int number,
+    int matchCount) {
+  for (int i = matchCount; i < 2; i++) {
+    addMatches(groupMatches, [pair], group, number);
+  }
+}

 List<String> handleBestOfThreeMatchesAndItsWinner(
   List<MatchModel> groupMatches,
   List<List<TeamModel>> pair,
   MatchGroup group,
   int number,
 ) {
   final List<String> winnerTeams = [];
   for (var p in pair) {
     final matchesForPair = groupMatches
         .where((element) =>
             element.team_ids.contains(p.first.id) &&
             element.team_ids.contains(p.last.id))
         .toList();
-    if (matchesForPair.isEmpty) {
-      addMatches(groupMatches, [p], group, number);
-      addMatches(groupMatches, [p], group, number);
-    } else if (matchesForPair.length == 1) {
-      addMatches(groupMatches, [p], group, number);
-    }
+    scheduleNewMatches(groupMatches, p, group, number, matchesForPair.length);

Configuration used: CodeRabbit UI
Review profile: CHILL