val publicTourney = TournamentEntity(
    isPublic = true,
    joinCode = null,           // No code required
    requireApproval = false,   // Auto-join
    maxParticipants = null     // Unlimited
)

val privateTourney = TournamentEntity(
    isPublic = false,
    joinCode = "SECRET2025",   // Code required
    requireApproval = true,    // Manual approval
    maxParticipants = 20       // Limited slots
)

val localTourney = TournamentEntity(
    isLocal = true,
    needsSync = false,      // No sync needed
    lastSyncedAt = null     // Never synced
)

// 1. Create remote tournament
val remoteTourney = TournamentEntity(
    isLocal = false,
    needsSync = false,
    lastSyncedAt = Clock.System.now()
)
 
// 2. Participant shoots offline
// Scores stored in TournamentScoreCache
// needsSync = true
 
// 3. Device comes online
// Sync cached scores to server
// needsSync = false, lastSyncedAt = now

val championship = TournamentEntity(
    id = "spring-champ-2025",
    name = "Spring Championship 2025",
    description = "Annual club championship, outdoor 70m",
    location = "Central Archery Range",
    organizerId = "user123",
    createdBy = "Chris",
    creatorEmail = "chris@archeryclub.com",
 
    // Status
    status = TournamentStatus.OPEN,
 
    // Round format
    numEnds = 12,
    numArrows = 6,
    distance = Distance.fromString("70 meters"),
    targetSize = TargetSize.fromString("122cm"),
    scoringSystem = ScoringSystem.TEN_RING,
    totalRounds = 3,
 
    // Timestamps
    startTime = Clock.System.now().plus(7.days),
    endTime = Clock.System.now().plus(14.days),
    createdAt = Clock.System.now(),
 
    // Access control
    isPublic = true,
    joinCode = null,
    maxParticipants = 50,
    requireApproval = false,
 
    // Settings
    allowSpectators = true,
    useSettingsDisplayNames = true,
 
    // Leaderboard
    currentRound = 1,
    topScore = null,
    averageScore = null,
    totalParticipants = 0,
 
    // Sync
    isLocal = false,  // Remote tournament
    needsSync = false,
    lastSyncedAt = Clock.System.now(),
 
    // Rules
    eliminationRounds = 2,
    advancementCriteria = "Top 50% advance to finals",
    tiebreakingRules = "X-count, then closest arrow to center",
    customRules = null,
    registrationDeadline = Clock.System.now().plus(6.days),
    roundDeadlines = mapOf(
        1 to Clock.System.now().plus(8.days),
        2 to Clock.System.now().plus(11.days),
        3 to Clock.System.now().plus(14.days)
    )
)

val participant = TournamentParticipantEntity(
    tournamentId = "spring-champ-2025",
    userId = "user456",
    displayName = "Sarah Johnson",
    currentRound = 2,          // Completed 2 rounds
    totalScore = 1120,         // Sum of round 1 + round 2
    ranking = 3,               // 3rd place
    status = ParticipantStatus.ACTIVE,
    registeredAt = Clock.System.now().minus(5.days),
    lastRoundSubmitted = Clock.System.now().minus(1.days)
)

@Query("""
    SELECT * FROM TournamentParticipant
    WHERE tournamentId = :tournamentId
    AND status = 'ACTIVE'
    ORDER BY totalScore DESC
""")
suspend fun getLeaderboard(tournamentId: String): List<TournamentParticipantEntity>

@Query("""
    UPDATE TournamentParticipant
    SET ranking = :ranking
    WHERE id = :participantId
""")
suspend fun updateRanking(participantId: Long, ranking: Int)

@Query("""
    SELECT * FROM Round
    WHERE tournamentId = :tournamentId
    AND participantId = :participantId
    ORDER BY tournamentRoundNumber ASC
""")
suspend fun getParticipantRounds(tournamentId: String, participantId: String): List<RoundEntity>

// 1. Participant shoots offline
val scoreCache = TournamentScoreCacheEntity(
    tournamentId = "spring-champ-2025",
    participantId = "user456",
    roundNumber = 2,
    scores = listOf(10, 9, 9, 8, 10, 9, 8, 7, 10, 9, ...),  // All arrow scores
    lastUpdated = Clock.System.now(),
    syncStatus = SyncStatus.PENDING
)
scoreCacheDao.insert(scoreCache)
 
// 2. Device comes online
val pendingScores = scoreCacheDao.getPendingScores()
 
// 3. Sync to server
for (cache in pendingScores) {
    try {
        tournamentApi.submitScores(cache)
        scoreCacheDao.updateStatus(cache.id, SyncStatus.SYNCED)
        // Optionally delete after successful sync
        scoreCacheDao.delete(cache.id)
    } catch (e: Exception) {
        scoreCacheDao.updateStatus(cache.id, SyncStatus.FAILED)
    }
}

@Query("""
    SELECT * FROM TournamentScoreCache
    WHERE syncStatus = 'PENDING'
    ORDER BY lastUpdated ASC
""")
suspend fun getPendingScores(): List<TournamentScoreCacheEntity>

@Query("""
    SELECT * FROM TournamentScoreCache
    WHERE tournamentId = :tournamentId
    AND participantId = :participantId
    ORDER BY roundNumber ASC
""")
suspend fun getCachedScores(tournamentId: String, participantId: String): List<TournamentScoreCacheEntity>

// List<Int> ↔ JSON String
@TypeConverter
fun fromIntList(list: List<Int>): String = Json.encodeToString(list)
 
@TypeConverter
fun toIntList(value: String): List<Int> = Json.decodeFromString(value)

// 1. Create tournament entity
val tournament = TournamentEntity(
    id = generateTournamentId(),
    name = "My Tournament",
    status = TournamentStatus.OPEN,
    numEnds = 6,
    numArrows = 6,
    distance = Distance.fromString("50 meters"),
    targetSize = TargetSize.fromString("122cm"),
    scoringSystem = ScoringSystem.TEN_RING,
    isLocal = false,  // Remote tournament
    createdAt = Clock.System.now()
)
tournamentDao.insert(tournament)

// 1. User requests to join
if (tournament.requireApproval) {
    // Send join request to organizer
    joinRequestDao.insert(JoinRequest(tournamentId, userId))
} else {
    // Auto-join
    val participant = TournamentParticipantEntity(
        tournamentId = tournament.id,
        userId = currentUserId,
        displayName = settingsDao.getUserName(),
        currentRound = 0,
        totalScore = 0,
        ranking = null,
        status = ParticipantStatus.ACTIVE,
        registeredAt = Clock.System.now()
    )
    participantDao.insert(participant)
}

// 1. Create round with tournament reference
val round = RoundEntity(
    roundName = "Spring Championship - Round 2",
    tournamentId = tournament.id,
    tournamentRoundNumber = 2,
    numEnds = tournament.numEnds,
    numArrows = tournament.numArrows,
    distance = tournament.distance,
    targetSize = tournament.targetSize,
    scoringSystem = tournament.scoringSystem,
    status = RoundStatus.IN_PROGRESS
)
roundDao.insert(round)
 
// 2. Score the round normally
 
// 3. On completion, update participant
val participant = participantDao.getByUserId(tournament.id, currentUserId)
participantDao.update(participant.copy(
    currentRound = 2,
    totalScore = participant.totalScore + round.totalScore,
    lastRoundSubmitted = Clock.System.now()
))
 
// 4. Recalculate rankings
updateTournamentRankings(tournament.id)

suspend fun updateTournamentRankings(tournamentId: String) {
    // Get all active participants, sorted by score
    val participants = participantDao.getLeaderboard(tournamentId)
 
    // Assign rankings
    participants.forEachIndexed { index, participant ->
        participantDao.updateRanking(participant.id, index + 1)
    }
 
    // Update tournament leaderboard cache
    tournamentDao.updateLeaderboardCache(
        tournamentId = tournamentId,
        topScore = participants.firstOrNull()?.totalScore,
        averageScore = participants.map { it.totalScore }.average()
    )
}

val localTourney = TournamentEntity(
    name = "Club Practice Tournament",
    isLocal = true,
    needsSync = false,
    lastSyncedAt = null
)

val remoteTourney = TournamentEntity(
    name = "National Championship",
    isLocal = false,
    needsSync = false,  // Initially synced
    lastSyncedAt = Clock.System.now()
)

// Check network status
if (isOnline) {
    // Direct submission to server
    tournamentApi.submitRound(round)
} else {
    // Cache for later sync
    scoreCacheDao.insert(TournamentScoreCacheEntity(
        tournamentId = tournament.id,
        participantId = userId,
        roundNumber = roundNumber,
        scores = arrowScores,
        syncStatus = SyncStatus.PENDING
    ))
}

// After round 1 completes
val allParticipants = participantDao.getLeaderboard(tournamentId)
val advancingCount = (allParticipants.size * 0.5).toInt()  // Top 50%
val advancing = allParticipants.take(advancingCount)
 
// Mark others as completed/eliminated
allParticipants.drop(advancingCount).forEach { participant ->
    participantDao.updateStatus(participant.id, ParticipantStatus.COMPLETED)
}

// Tiebreaking by X-count
@Query("""
    SELECT p.*, COUNT(a.isXRing) as xCount
    FROM TournamentParticipant p
    JOIN Round r ON r.tournamentId = p.tournamentId AND r.participantId = p.userId
    JOIN ArrowScore a ON a.roundId = r.id
    WHERE p.tournamentId = :tournamentId
    AND p.totalScore = :tiedScore
    GROUP BY p.id
    ORDER BY xCount DESC
""")
suspend fun breakTie(tournamentId: String, tiedScore: Int): List<ParticipantWithXCount>

// Good: Verify status before actions
if (tournament.status == TournamentStatus.OPEN) {
    allowRegistration()
} else {
    showError("Tournament registration closed")
}
 
// Bad: Assume tournament is open
createParticipant()  // May fail if tournament already started

// Good: Cache offline, sync later
if (isOnline) {
    submitScoresDirectly()
} else {
    cacheScoresForLaterSync()
}
 
// Bad: Fail on offline
submitScoresDirectly()  // Throws exception if offline

// Good: Update rankings
submitRound(round)
updateTournamentRankings(tournamentId)
 
// Bad: Stale rankings
submitRound(round)
// Rankings not updated, leaderboard shows old data

// Good: Check deadlines before submission
if (tournament.roundDeadlines[roundNumber]?.let { it > Clock.System.now() } == true) {
    allowSubmission()
} else {
    showError("Round deadline passed")
}

@Query("""
    SELECT * FROM TournamentEntity
    WHERE status IN ('OPEN', 'IN_PROGRESS')
    ORDER BY startTime ASC
""")
suspend fun getActiveTournaments(): List<TournamentEntity>

@Query("""
    SELECT t.* FROM TournamentEntity t
    JOIN TournamentParticipant p ON p.tournamentId = t.id
    WHERE p.userId = :userId
    ORDER BY t.createdAt DESC
""")
suspend fun getUserTournaments(userId: String): List<TournamentEntity>

data class TournamentWithParticipants(
    val tournament: TournamentEntity,
    val participants: List<TournamentParticipantEntity>
)
 
@Transaction
@Query("SELECT * FROM TournamentEntity WHERE id = :tournamentId")
suspend fun getTournamentWithParticipants(tournamentId: String): TournamentWithParticipants