You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
449 lines
16 KiB
449 lines
16 KiB
//
|
|
// Round_v2.swift
|
|
// Padel Tournament
|
|
//
|
|
// Created by razmig on 10/03/2024.
|
|
//
|
|
|
|
import Foundation
|
|
import LeStorage
|
|
|
|
@Observable
|
|
class Round: ModelObject, Storable {
|
|
static func resourceName() -> String { "rounds" }
|
|
|
|
var id: String = Store.randomId()
|
|
var tournament: String
|
|
var index: Int
|
|
var loser: String?
|
|
var format: Int?
|
|
var startDate: Date?
|
|
|
|
internal init(tournament: String, index: Int, loser: String? = nil, matchFormat: MatchFormat? = nil) {
|
|
self.tournament = tournament
|
|
self.index = index
|
|
self.loser = loser
|
|
self.format = matchFormat?.rawValue
|
|
}
|
|
|
|
var matchFormat: MatchFormat {
|
|
get {
|
|
MatchFormat(rawValue: format) ?? .defaultFormatForMatchType(.bracket)
|
|
}
|
|
set {
|
|
format = newValue.rawValue
|
|
}
|
|
}
|
|
|
|
|
|
func hasStarted() -> Bool {
|
|
playedMatches().anySatisfy({ $0.hasStarted() })
|
|
}
|
|
|
|
func hasEnded() -> Bool {
|
|
playedMatches().allSatisfy({ $0.hasEnded() })
|
|
}
|
|
|
|
func tournamentObject() -> Tournament? {
|
|
Store.main.findById(tournament)
|
|
}
|
|
|
|
func _matches() -> [Match] {
|
|
Store.main.filter { $0.round == self.id }
|
|
}
|
|
|
|
func upperMatches(ofMatch match: Match) -> [Match] {
|
|
if loser != nil, previousRound() == nil, let parentRound {
|
|
let matchIndex = match.index
|
|
let indexInRound = RoundRule.matchIndexWithinRound(fromMatchIndex: matchIndex)
|
|
return [parentRound.getMatch(atMatchIndexInRound: indexInRound * 2), parentRound.getMatch(atMatchIndexInRound: indexInRound * 2 + 1)].compactMap({ $0 })
|
|
}
|
|
return []
|
|
}
|
|
|
|
func previousMatches(ofMatch match: Match) -> [Match] {
|
|
guard let previousRound = previousRound() else { return [] }
|
|
return Store.main.filter {
|
|
($0.index == match.topPreviousRoundMatchIndex() || $0.index == match.bottomPreviousRoundMatchIndex()) && $0.round == previousRound.id
|
|
}
|
|
}
|
|
|
|
func precedentMatches(ofMatch match: Match) -> [Match] {
|
|
let upper = upperMatches(ofMatch: match)
|
|
if upper.isEmpty == false {
|
|
return upper
|
|
}
|
|
let previous : [Match] = previousMatches(ofMatch: match)
|
|
if previous.isEmpty == false && previous.allSatisfy({ $0.disabled }), let previousRound = previousRound() {
|
|
return previous.flatMap({ previousRound.precedentMatches(ofMatch: $0) })
|
|
} else {
|
|
return previous
|
|
}
|
|
}
|
|
|
|
func team(_ team: TeamPosition, inMatch match: Match) -> TeamRegistration? {
|
|
switch team {
|
|
case .one:
|
|
return roundProjectedTeam(.one, inMatch: match)
|
|
case .two:
|
|
return roundProjectedTeam(.two, inMatch: match)
|
|
}
|
|
}
|
|
|
|
func seed(_ team: TeamPosition, inMatchIndex matchIndex: Int) -> TeamRegistration? {
|
|
return Store.main.filter(isIncluded: {
|
|
$0.tournament == tournament
|
|
&& $0.bracketPosition != nil
|
|
&& ($0.bracketPosition! / 2) == matchIndex
|
|
&& ($0.bracketPosition! % 2) == team.rawValue
|
|
}).first
|
|
}
|
|
|
|
func seeds(inMatchIndex matchIndex: Int) -> [TeamRegistration] {
|
|
return Store.main.filter(isIncluded: {
|
|
$0.tournament == tournament
|
|
&& $0.bracketPosition != nil
|
|
&& ($0.bracketPosition! / 2) == matchIndex
|
|
})
|
|
}
|
|
|
|
func seeds() -> [TeamRegistration] {
|
|
let initialMatchIndex = RoundRule.matchIndex(fromRoundIndex: index)
|
|
let numberOfMatches = RoundRule.numberOfMatches(forRoundIndex: index)
|
|
return Store.main.filter(isIncluded: {
|
|
$0.tournament == tournament
|
|
&& $0.bracketPosition != nil
|
|
&& ($0.bracketPosition! / 2) >= initialMatchIndex
|
|
&& ($0.bracketPosition! / 2) < initialMatchIndex + numberOfMatches
|
|
})
|
|
}
|
|
|
|
func losers() -> [TeamRegistration] {
|
|
_matches().compactMap { $0.losingTeamId }.compactMap { Store.main.findById($0) }
|
|
}
|
|
|
|
func roundProjectedTeam(_ team: TeamPosition, inMatch match: Match) -> TeamRegistration? {
|
|
if isLoserBracket() == false, let seed = seed(team, inMatchIndex: match.index) {
|
|
return seed
|
|
}
|
|
|
|
switch team {
|
|
case .one:
|
|
if let luckyLoser = match.teamScores.first(where: { $0.luckyLoser == match.index * 2 }) {
|
|
return luckyLoser.team
|
|
} else if let loser = upperBracketTopMatch(ofMatchIndex: match.index)?.losingTeamId {
|
|
return Store.main.findById(loser)
|
|
} else if let previousMatch = topPreviousRoundMatch(ofMatch: match) {
|
|
if let teamId = previousMatch.winningTeamId {
|
|
return Store.main.findById(teamId)
|
|
} else if previousMatch.disabled {
|
|
return previousMatch.teams().first
|
|
}
|
|
}
|
|
case .two:
|
|
if let luckyLoser = match.teamScores.first(where: { $0.luckyLoser == match.index * 2 + 1 }) {
|
|
return luckyLoser.team
|
|
} else if let loser = upperBracketBottomMatch(ofMatchIndex: match.index)?.losingTeamId {
|
|
return Store.main.findById(loser)
|
|
} else if let previousMatch = bottomPreviousRoundMatch(ofMatch: match) {
|
|
if let teamId = previousMatch.winningTeamId {
|
|
return Store.main.findById(teamId)
|
|
} else if previousMatch.disabled {
|
|
return previousMatch.teams().first
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func upperBracketTopMatch(ofMatchIndex matchIndex: Int) -> Match? {
|
|
let indexInRound = RoundRule.matchIndexWithinRound(fromMatchIndex: matchIndex)
|
|
if isLoserBracket(), previousRound() == nil, let parentRound = parentRound, let upperBracketTopMatch = parentRound.getMatch(atMatchIndexInRound: indexInRound * 2) {
|
|
return upperBracketTopMatch
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func upperBracketBottomMatch(ofMatchIndex matchIndex: Int) -> Match? {
|
|
let indexInRound = RoundRule.matchIndexWithinRound(fromMatchIndex: matchIndex)
|
|
if isLoserBracket(), previousRound() == nil, let parentRound = parentRound, let upperBracketBottomMatch = parentRound.getMatch(atMatchIndexInRound: indexInRound * 2 + 1) {
|
|
return upperBracketBottomMatch
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func topPreviousRoundMatch(ofMatch match: Match) -> Match? {
|
|
guard let previousRound = previousRound() else { return nil }
|
|
return Store.main.filter {
|
|
$0.index == match.topPreviousRoundMatchIndex() && $0.round == previousRound.id
|
|
}.sorted(by: \.index).first
|
|
}
|
|
|
|
func bottomPreviousRoundMatch(ofMatch match: Match) -> Match? {
|
|
guard let previousRound = previousRound() else { return nil }
|
|
return Store.main.filter {
|
|
$0.index == match.bottomPreviousRoundMatchIndex() && $0.round == previousRound.id
|
|
}.sorted(by: \.index).first
|
|
}
|
|
|
|
|
|
func getMatch(atMatchIndexInRound matchIndexInRound: Int) -> Match? {
|
|
Store.main.filter(isIncluded: {
|
|
let index = RoundRule.matchIndexWithinRound(fromMatchIndex: $0.index)
|
|
return $0.round == id && index == matchIndexInRound
|
|
}).first
|
|
}
|
|
|
|
func playedMatches() -> [Match] {
|
|
if loser == nil {
|
|
Store.main.filter { $0.round == self.id && $0.disabled == false }
|
|
} else {
|
|
_matches()
|
|
}
|
|
}
|
|
|
|
func previousRound() -> Round? {
|
|
Store.main.filter(isIncluded: { $0.tournament == tournament && $0.loser == loser && $0.index == index + 1 }).first
|
|
}
|
|
|
|
func nextRound() -> Round? {
|
|
Store.main.filter(isIncluded: { $0.tournament == tournament && $0.loser == loser && $0.index == index - 1 }).first
|
|
}
|
|
|
|
func loserRounds(forRoundIndex roundIndex: Int) -> [Round] {
|
|
return loserRoundsAndChildren().filter({ $0.index == roundIndex }).sorted(by: \.theoryCumulativeMatchCount)
|
|
}
|
|
|
|
func isDisabled() -> Bool {
|
|
_matches().allSatisfy({ $0.disabled })
|
|
}
|
|
|
|
func resetRound(updateMatchFormat: MatchFormat? = nil) {
|
|
let _updateMatchFormat = updateMatchFormat ?? self.matchFormat
|
|
_matches().forEach({
|
|
$0.startDate = nil
|
|
$0.matchFormat = updateMatchFormat ?? $0.matchFormat
|
|
})
|
|
self.matchFormat = _updateMatchFormat
|
|
loserRoundsAndChildren().forEach { round in
|
|
round.resetRound(updateMatchFormat: _updateMatchFormat)
|
|
}
|
|
nextRound()?.resetRound(updateMatchFormat: _updateMatchFormat)
|
|
}
|
|
|
|
func resetRound(from match: Match, updateMatchFormat: MatchFormat? = nil) {
|
|
let _updateMatchFormat = updateMatchFormat ?? self.matchFormat
|
|
self.matchFormat = _updateMatchFormat
|
|
let matches = _matches()
|
|
if let index = matches.firstIndex(where: { $0.id == match.id }) {
|
|
matches[index...].forEach { match in
|
|
match.startDate = nil
|
|
match.matchFormat = _updateMatchFormat
|
|
}
|
|
}
|
|
loserRoundsAndChildren().forEach { round in
|
|
round.resetRound(updateMatchFormat: _updateMatchFormat)
|
|
}
|
|
nextRound()?.resetRound(updateMatchFormat: _updateMatchFormat)
|
|
}
|
|
|
|
func getActiveLoserRound() -> Round? {
|
|
let rounds = loserRounds().filter({ $0.isDisabled() == false }).sorted(by: \.index).reversed()
|
|
return rounds.first(where: { $0.hasStarted() && $0.hasEnded() == false }) ?? rounds.first
|
|
}
|
|
|
|
func enableRound() {
|
|
_toggleRound(disable: false)
|
|
}
|
|
|
|
func disableRound() {
|
|
_toggleRound(disable: true)
|
|
}
|
|
|
|
private func _toggleRound(disable: Bool) {
|
|
let _matches = _matches()
|
|
_matches.forEach { match in
|
|
match.disabled = disable
|
|
match.resetMatch()
|
|
try? DataStore.shared.teamScores.delete(contentOfs: match.teamScores)
|
|
}
|
|
try? DataStore.shared.matches.addOrUpdate(contentOfs: _matches)
|
|
}
|
|
|
|
var cumulativeMatchCount: Int {
|
|
var totalMatches = playedMatches().count
|
|
if let parent = parentRound {
|
|
totalMatches += parent.cumulativeMatchCount
|
|
}
|
|
return totalMatches
|
|
}
|
|
|
|
func initialRound() -> Round? {
|
|
if let parentRound {
|
|
return parentRound.initialRound()
|
|
} else {
|
|
return self
|
|
}
|
|
}
|
|
|
|
|
|
func disabledMatches() -> [Match] {
|
|
_matches().filter({ $0.disabled })
|
|
}
|
|
|
|
var theoryCumulativeMatchCount: Int {
|
|
var totalMatches = RoundRule.numberOfMatches(forRoundIndex: index)
|
|
if let parent = parentRound {
|
|
totalMatches += parent.theoryCumulativeMatchCount
|
|
}
|
|
return totalMatches
|
|
}
|
|
|
|
|
|
func correspondingLoserRoundTitle(_ displayStyle: DisplayStyle = .wide) -> String {
|
|
let initialMatchIndexFromRoundIndex = RoundRule.matchIndex(fromRoundIndex: index)
|
|
let seedsAfterThisRound : [TeamRegistration] = Store.main.filter(isIncluded: {
|
|
$0.tournament == tournament
|
|
&& $0.bracketPosition != nil
|
|
&& ($0.bracketPosition! / 2) < initialMatchIndexFromRoundIndex
|
|
})
|
|
let playedMatches = playedMatches()
|
|
let seedInterval = SeedInterval(first: playedMatches.count + seedsAfterThisRound.count + 1, last: playedMatches.count * 2 + seedsAfterThisRound.count)
|
|
return seedInterval.localizedLabel(displayStyle)
|
|
}
|
|
|
|
func seedInterval() -> SeedInterval? {
|
|
if loser == nil {
|
|
let numberOfMatches = RoundRule.numberOfMatches(forRoundIndex: index + 1)
|
|
let initialMatchIndexFromRoundIndex = RoundRule.matchIndex(fromRoundIndex: index)
|
|
let seedsAfterThisRound : [TeamRegistration] = Store.main.filter(isIncluded: {
|
|
$0.tournament == tournament
|
|
&& $0.bracketPosition != nil
|
|
&& ($0.bracketPosition! / 2) < initialMatchIndexFromRoundIndex
|
|
})
|
|
let playedMatches = playedMatches()
|
|
let reduce = numberOfMatches / 2 - (playedMatches.count + seedsAfterThisRound.count)
|
|
return SeedInterval(first: 1, last: numberOfMatches, reduce: reduce)
|
|
}
|
|
|
|
if let previousRound = previousRound() {
|
|
return previousRound.seedInterval()?.chunks()?.first
|
|
} else if let parentRound = parentRound {
|
|
return parentRound.seedInterval()?.chunks()?.last
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func roundTitle(_ displayStyle: DisplayStyle = .wide) -> String {
|
|
if loser != nil {
|
|
return seedInterval()?.localizedLabel(displayStyle) ?? "Pas trouvé"
|
|
}
|
|
return RoundRule.roundName(fromRoundIndex: index)
|
|
}
|
|
|
|
func roundStatus() -> String {
|
|
if hasStarted() && hasEnded() == false {
|
|
return "en cours"
|
|
} else {
|
|
return "à démarrer"
|
|
}
|
|
}
|
|
|
|
func loserRounds() -> [Round] {
|
|
return Store.main.filter(isIncluded: { $0.loser == id }).sorted(by: \.index).reversed()
|
|
}
|
|
|
|
func loserRoundsAndChildren() -> [Round] {
|
|
let loserRounds = loserRounds()
|
|
return loserRounds + loserRounds.flatMap({ $0.loserRoundsAndChildren() })
|
|
}
|
|
|
|
func isLoserBracket() -> Bool {
|
|
loser != nil
|
|
}
|
|
|
|
func buildLoserBracket() {
|
|
guard loserRounds().isEmpty else { return }
|
|
let currentRoundMatchCount = RoundRule.numberOfMatches(forRoundIndex: index)
|
|
guard currentRoundMatchCount > 1 else { return }
|
|
let roundCount = RoundRule.numberOfRounds(forTeams: currentRoundMatchCount)
|
|
let loserBracketMatchFormat = tournamentObject()?.loserBracketMatchFormat
|
|
|
|
let rounds = (0..<roundCount).map { //index 0 is the final
|
|
let round = Round(tournament: tournament, index: $0, matchFormat: loserBracketMatchFormat)
|
|
round.loser = id //parent
|
|
return round
|
|
}
|
|
|
|
try? DataStore.shared.rounds.addOrUpdate(contentOfs: rounds)
|
|
let matchCount = RoundRule.numberOfMatches(forTeams: currentRoundMatchCount)
|
|
|
|
let matches = (0..<matchCount).map { //0 is final match
|
|
let roundIndex = RoundRule.roundIndex(fromMatchIndex: $0)
|
|
let round = rounds[roundIndex]
|
|
return Match(round: round.id, index: $0, matchFormat: loserBracketMatchFormat)
|
|
}
|
|
|
|
print(matches.map {
|
|
(RoundRule.roundName(fromMatchIndex: $0.index), RoundRule.matchIndexWithinRound(fromMatchIndex: $0.index))
|
|
})
|
|
|
|
try? DataStore.shared.matches.addOrUpdate(contentOfs: matches)
|
|
|
|
loserRounds().forEach { round in
|
|
round.buildLoserBracket()
|
|
}
|
|
}
|
|
|
|
var parentRound: Round? {
|
|
guard let parentRound = loser else { return nil }
|
|
return Store.main.findById(parentRound)
|
|
}
|
|
|
|
func updateMatchFormat(_ matchFormat: MatchFormat) {
|
|
self.matchFormat = matchFormat
|
|
let playedMatches = _matches()
|
|
playedMatches.forEach { match in
|
|
match.matchFormat = matchFormat
|
|
}
|
|
try? DataStore.shared.matches.addOrUpdate(contentOfs: playedMatches)
|
|
}
|
|
|
|
override func deleteDependencies() throws {
|
|
try Store.main.deleteDependencies(items: _matches())
|
|
try Store.main.deleteDependencies(items: loserRoundsAndChildren())
|
|
}
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case _id = "id"
|
|
case _tournament = "tournament"
|
|
case _index = "index"
|
|
case _loser = "loser"
|
|
case _format = "format"
|
|
case _startDate = "startDate"
|
|
}
|
|
}
|
|
|
|
extension Round: Selectable {
|
|
func selectionLabel() -> String {
|
|
if let parentRound {
|
|
return "Tour #\(parentRound.loserRounds().count - index)"
|
|
} else {
|
|
return roundTitle()
|
|
}
|
|
}
|
|
|
|
func badgeValue() -> Int? {
|
|
if let parentRound {
|
|
return parentRound.loserRounds(forRoundIndex: index).flatMap { $0.playedMatches() }.filter({ $0.isRunning() }).count
|
|
} else {
|
|
return playedMatches().filter({ $0.isRunning() }).count
|
|
}
|
|
}
|
|
|
|
func badgeImage() -> Badge? {
|
|
hasEnded() ? .checkmark : nil
|
|
}
|
|
}
|
|
|