// Record today's activity for the "daily" streak
try await manager.recordStreakActivity("daily")

// Current streak count
let current = try await manager.currentStreak("daily")

// Longest streak ever
let longest = try await manager.longestStreak("daily")

// Full streak record
let record = try await manager.streakRecord("daily")
print(record.currentStreak)     // 7
print(record.longestStreak)     // 14
print(record.totalActiveDays)   // 42
print(record.lastActivityDate)  // 2026-05-05

try await manager.resetStreak("daily")
// currentStreak → 0, longestStreak preserved

for await event in manager.events {
    switch event {
    case .streakExtended(let id, let count):
        print("\(id) streak: \(count) days!")
    case .streakBroken(let id, let previous):
        print("\(id) streak broken at \(previous) days")
    case .newStreakRecord(let id, let longest):
        print("New record for \(id): \(longest) days!")
    default: break
    }
}

public protocol PrismBadge: RawRepresentable, CaseIterable, Hashable, Sendable
where RawValue == String {
    var title: String { get }
    var badgeDescription: String { get }
    var iconName: String? { get }           // default: nil
    var tier: PrismBadgeTier { get }
    var condition: PrismBadgeCondition { get }
}

public enum PrismBadgeTier: String, Comparable {
    case bronze      // Entry level
    case silver      // Intermediate
    case gold        // Advanced
    case platinum    // Expert
    case diamond     // Elite
}

public enum PrismBadgeCondition {
    case challengeCompleted(challengeID: String)     // Specific challenge done
    case pointsReached(threshold: Int)               // Total points >= threshold
    case streakReached(streakID: String, days: Int)  // Streak >= days
    case custom(id: String)                          // Manual unlock only
}

enum AppBadge: String, PrismBadge, CaseIterable {
    case earlyAdopter
    case fitnessFreak
    case streakMaster
    case vip

    var title: String {
        switch self {
        case .earlyAdopter: "Early Adopter"
        case .fitnessFreak: "Fitness Freak"
        case .streakMaster: "Streak Master"
        case .vip: "VIP Member"
        }
    }

    var badgeDescription: String {
        switch self {
        case .earlyAdopter: "Complete your first challenge"
        case .fitnessFreak: "Earn 100 points"
        case .streakMaster: "Maintain a 30-day streak"
        case .vip: "Exclusive VIP badge"
        }
    }

    var tier: PrismBadgeTier {
        switch self {
        case .earlyAdopter: .bronze
        case .fitnessFreak: .silver
        case .streakMaster: .gold
        case .vip: .diamond
        }
    }

    var condition: PrismBadgeCondition {
        switch self {
        case .earlyAdopter: .challengeCompleted(challengeID: "firstLogin")
        case .fitnessFreak: .pointsReached(threshold: 100)
        case .streakMaster: .streakReached(streakID: "daily", days: 30)
        case .vip: .custom(id: "vip")
        }
    }
}

try await manager.registerBadges(AppBadge.self)

let totalPoints = try await manager.totalPoints(AppChallenge.self)
let unlocked = try await manager.evaluateBadges(
    AppBadge.self,
    currentPoints: totalPoints
)

for badge in unlocked {
    print("Unlocked: \(badge.badgeID) (\(badge.tierRawValue))")
}

try await manager.unlockBadge(AppBadge.vip)

// Check if unlocked
let unlocked = try await manager.isBadgeUnlocked(AppBadge.earlyAdopter)

// Single badge progress
let badge = try await manager.badgeProgress(for: AppBadge.fitnessFreak)

// All badges
let all = try await manager.allBadges()
let locked = all.filter { !$0.isUnlocked }

for await event in manager.events {
    if case .badgeUnlocked(let id, let tier) = event {
        print("\(tier) badge \(id) unlocked!")
    }
}