421 lines
17 KiB
Swift
421 lines
17 KiB
Swift
import SwiftUI
|
|
|
|
struct RoundView: View {
|
|
@EnvironmentObject private var localization: LocalizationStore
|
|
@EnvironmentObject private var analytics: HermesAnalyticsClient
|
|
@EnvironmentObject private var repository: HermesRepository
|
|
@EnvironmentObject private var playerCoordinator: PlayerCoordinator
|
|
|
|
let onRetry: () -> Void
|
|
|
|
@State private var phase: Phase = .preview
|
|
@State private var selectedOutcomeID: String? = nil
|
|
@State private var lockAt: Date = .now
|
|
@State private var transitionTask: Task<Void, Never>?
|
|
@State private var actionMessage: String?
|
|
@State private var isSubmitting = false
|
|
|
|
private enum Phase {
|
|
case preview
|
|
case locked
|
|
case reveal
|
|
case result
|
|
}
|
|
|
|
var body: some View {
|
|
TimelineView(.periodic(from: Date(), by: 1)) { _ in
|
|
let round = repository.currentRound
|
|
let now = repository.serverNow()
|
|
let hasRound = round != nil
|
|
let remaining = max(lockAt.timeIntervalSince(now), 0)
|
|
let timerLocked = round != nil && remaining <= 0
|
|
let countdownText = Self.countdownText(for: remaining)
|
|
let bannerMessage = actionMessage ?? hermesUserFacingErrorMessage(
|
|
localization: localization,
|
|
localeCode: localization.localeCode,
|
|
error: repository.errorCause
|
|
)
|
|
|
|
VStack(alignment: .leading, spacing: HermesTheme.sectionSpacing) {
|
|
HermesSectionHeader(
|
|
title: localization.string(for: "round.title"),
|
|
subtitle: localization.string(for: "round.subtitle")
|
|
)
|
|
|
|
if !hasRound {
|
|
if let bannerMessage {
|
|
roundErrorState(
|
|
message: bannerMessage,
|
|
retryText: localization.string(for: "common.retry"),
|
|
onRetry: onRetry
|
|
)
|
|
} else {
|
|
roundLoadingState(
|
|
title: localization.string(for: "common.loading"),
|
|
subtitle: localization.string(for: "round.subtitle")
|
|
)
|
|
}
|
|
} else {
|
|
if let bannerMessage {
|
|
roundBanner(message: bannerMessage)
|
|
}
|
|
|
|
videoSection(
|
|
round: round,
|
|
countdownText: countdownText,
|
|
remaining: remaining,
|
|
isTimerLocked: timerLocked
|
|
)
|
|
|
|
if let round {
|
|
switch phase {
|
|
case .preview, .locked:
|
|
SelectionView(
|
|
statusText: phase == .preview && !timerLocked ? localization.string(for: "round.selection_prompt") : localization.string(for: "round.locked_label"),
|
|
options: selectionOptions(for: round),
|
|
selectedOptionID: selectedOutcomeID,
|
|
isLocked: phase != .preview || timerLocked || isSubmitting,
|
|
confirmTitle: localization.string(for: "round.primary_cta"),
|
|
onSelect: handleSelection,
|
|
onConfirm: confirmSelection
|
|
)
|
|
|
|
case .reveal:
|
|
RevealView(
|
|
title: localization.string(for: "reveal.title"),
|
|
subtitle: localization.string(for: "reveal.subtitle"),
|
|
statusText: localization.string(for: "reveal.status"),
|
|
selectionLabel: localization.string(for: "result.selection_label"),
|
|
selectionValue: selectedOutcomeTitle(for: round),
|
|
continueTitle: localization.string(for: "reveal.cta"),
|
|
onContinue: showResult
|
|
)
|
|
|
|
case .result:
|
|
ResultView(
|
|
title: localization.string(for: "result.title"),
|
|
subtitle: localization.string(for: "result.subtitle"),
|
|
selectionLabel: localization.string(for: "result.selection_label"),
|
|
selectionValue: selectedOutcomeTitle(for: round),
|
|
outcomeLabel: localization.string(for: "result.outcome_label"),
|
|
outcomeValue: winningOutcomeTitle(for: round),
|
|
didWin: selectedOutcomeID == round.settlement.winningOutcomeId.uuidString,
|
|
winLabel: localization.string(for: "result.win"),
|
|
loseLabel: localization.string(for: "result.lose"),
|
|
nextRoundTitle: localization.string(for: "result.next_round"),
|
|
onNextRound: nextRound
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.onAppear {
|
|
if let round {
|
|
startPreview(round)
|
|
}
|
|
}
|
|
.onChange(of: round?.event.id) { _, newValue in
|
|
guard newValue != nil, let round else {
|
|
return
|
|
}
|
|
|
|
startPreview(round)
|
|
}
|
|
}
|
|
.hermesCard(elevated: true)
|
|
.onDisappear {
|
|
transitionTask?.cancel()
|
|
playerCoordinator.pause()
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func videoSection(round: HermesRound?, countdownText: String, remaining: TimeInterval, isTimerLocked: Bool) -> some View {
|
|
ZStack(alignment: .topTrailing) {
|
|
RoundedRectangle(cornerRadius: HermesTheme.cornerRadius, style: .continuous)
|
|
.fill(HermesTheme.surfaceElevated)
|
|
.frame(height: 220)
|
|
|
|
if let round {
|
|
HermesVideoPlayerView(coordinator: playerCoordinator)
|
|
} else {
|
|
Text(localization.string(for: "round.video_placeholder"))
|
|
.font(.headline.weight(.semibold))
|
|
.foregroundStyle(HermesTheme.textSecondary)
|
|
}
|
|
|
|
if let round {
|
|
VStack(alignment: .trailing, spacing: 10) {
|
|
HermesCountdownBadge(
|
|
label: localization.string(for: "round.countdown_label"),
|
|
value: countdownText,
|
|
warning: !isTimerLocked && remaining <= 10
|
|
)
|
|
|
|
HermesMetricPill(
|
|
label: localization.string(for: "round.odds_label"),
|
|
value: formatOdds(round)
|
|
)
|
|
.frame(maxWidth: 160)
|
|
}
|
|
.padding(12)
|
|
}
|
|
|
|
Text(phaseLabel(isTimerLocked: isTimerLocked))
|
|
.font(.caption.weight(.bold))
|
|
.foregroundStyle(HermesTheme.textPrimary)
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 8)
|
|
.background(.black.opacity(0.35))
|
|
.clipShape(Capsule())
|
|
.padding(12)
|
|
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottomLeading)
|
|
}
|
|
.clipShape(RoundedRectangle(cornerRadius: HermesTheme.cornerRadius, style: .continuous))
|
|
}
|
|
|
|
private func startPreview(_ round: HermesRound) {
|
|
transitionTask?.cancel()
|
|
phase = .preview
|
|
selectedOutcomeID = nil
|
|
actionMessage = nil
|
|
isSubmitting = false
|
|
lockAt = round.event.lockAt
|
|
playerCoordinator.prepareForPreview(url: round.media.hlsMasterUrl, startTimeMs: round.media.previewStartMs)
|
|
|
|
analytics.track("round_loaded", attributes: roundAnalyticsAttributes(round))
|
|
analytics.track("preview_started", attributes: roundAnalyticsAttributes(round))
|
|
analytics.track("screen_viewed", attributes: ["screen_name": "round"])
|
|
}
|
|
|
|
private func handleSelection(_ option: SelectionOption) {
|
|
guard phase == .preview, !isSubmitting else {
|
|
return
|
|
}
|
|
|
|
selectedOutcomeID = option.id
|
|
analytics.track("outcome_focused", attributes: ["screen_name": "round", "outcome_id": option.id])
|
|
analytics.track("outcome_selected", attributes: ["screen_name": "round", "outcome_id": option.id])
|
|
}
|
|
|
|
private func confirmSelection() {
|
|
guard phase == .preview, !isSubmitting, let round = repository.currentRound else {
|
|
return
|
|
}
|
|
|
|
guard let selectedOutcomeID, let session = repository.currentSession else {
|
|
actionMessage = localization.string(for: "errors.session_expired")
|
|
return
|
|
}
|
|
|
|
guard let outcomeID = UUID(uuidString: selectedOutcomeID) ?? round.market.outcomes.first?.id else {
|
|
actionMessage = localization.string(for: "errors.generic")
|
|
return
|
|
}
|
|
|
|
if repository.serverNow() >= round.event.lockAt {
|
|
return
|
|
}
|
|
|
|
isSubmitting = true
|
|
actionMessage = nil
|
|
|
|
Task { @MainActor in
|
|
do {
|
|
let request = HermesBetIntentRequest(
|
|
sessionId: session.sessionId,
|
|
eventId: round.event.id,
|
|
marketId: round.market.id,
|
|
outcomeId: outcomeID,
|
|
idempotencyKey: UUID().uuidString,
|
|
clientSentAt: Date()
|
|
)
|
|
|
|
let response = try await repository.submitBetIntent(request)
|
|
|
|
guard response.accepted else {
|
|
actionMessage = localization.string(for: "errors.generic")
|
|
phase = .preview
|
|
isSubmitting = false
|
|
return
|
|
}
|
|
|
|
analytics.track("selection_submitted", attributes: baseSelectionAttributes(selectedOutcomeID))
|
|
analytics.track("selection_accepted", attributes: baseSelectionAttributes(selectedOutcomeID))
|
|
analytics.track("market_locked", attributes: baseSelectionAttributes(selectedOutcomeID).merging(["lock_reason": "manual_selection"]) { _, new in new })
|
|
|
|
phase = .locked
|
|
playerCoordinator.pause()
|
|
|
|
transitionTask?.cancel()
|
|
transitionTask = Task { @MainActor in
|
|
try? await Task.sleep(nanoseconds: 750_000_000)
|
|
guard !Task.isCancelled, phase == .locked else {
|
|
return
|
|
}
|
|
|
|
phase = .reveal
|
|
analytics.track("reveal_started", attributes: roundAnalyticsAttributes(round).merging(baseSelectionAttributes(selectedOutcomeID)) { _, new in new })
|
|
}
|
|
} catch {
|
|
actionMessage = hermesUserFacingErrorMessage(localization: localization, localeCode: localization.localeCode, error: error) ?? localization.string(for: "errors.generic")
|
|
phase = .preview
|
|
}
|
|
|
|
isSubmitting = false
|
|
}
|
|
}
|
|
|
|
private func showResult() {
|
|
guard let round = repository.currentRound, let selectedOutcomeID else {
|
|
return
|
|
}
|
|
|
|
analytics.track("reveal_completed", attributes: roundAnalyticsAttributes(round).merging(baseSelectionAttributes(selectedOutcomeID)) { _, new in new })
|
|
phase = .result
|
|
analytics.track(
|
|
"result_viewed",
|
|
attributes: roundAnalyticsAttributes(round)
|
|
.merging(baseSelectionAttributes(selectedOutcomeID)) { _, new in new }
|
|
.merging(["outcome": winningOutcomeTitle(for: round)]) { _, new in new }
|
|
)
|
|
}
|
|
|
|
private func nextRound() {
|
|
analytics.track("next_round_requested", attributes: ["screen_name": "result"])
|
|
transitionTask?.cancel()
|
|
actionMessage = nil
|
|
|
|
Task { @MainActor in
|
|
do {
|
|
_ = try await repository.refreshRoundFromNetwork()
|
|
} catch {
|
|
actionMessage = hermesUserFacingErrorMessage(localization: localization, localeCode: localization.localeCode, error: error) ?? localization.string(for: "errors.generic")
|
|
}
|
|
}
|
|
}
|
|
|
|
private func roundLoadingState(title: String, subtitle: String) -> some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(title)
|
|
.font(.headline.weight(.semibold))
|
|
.foregroundStyle(HermesTheme.textPrimary)
|
|
Text(subtitle)
|
|
.font(.callout)
|
|
.foregroundStyle(HermesTheme.textSecondary)
|
|
}
|
|
}
|
|
|
|
private func roundErrorState(message: String, retryText: String, onRetry: @escaping () -> Void) -> some View {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text(message)
|
|
.font(.callout)
|
|
.foregroundStyle(HermesTheme.warning)
|
|
|
|
Button {
|
|
onRetry()
|
|
} label: {
|
|
Text(retryText)
|
|
}
|
|
.buttonStyle(HermesSecondaryButtonStyle())
|
|
}
|
|
}
|
|
|
|
private func roundBanner(message: String) -> some View {
|
|
Text(message)
|
|
.font(.callout)
|
|
.foregroundStyle(HermesTheme.warning)
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 10)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(HermesTheme.warning.opacity(0.12))
|
|
.clipShape(RoundedRectangle(cornerRadius: HermesTheme.insetRadius, style: .continuous))
|
|
}
|
|
|
|
private func selectionOptions(for round: HermesRound) -> [SelectionOption] {
|
|
let oddsByOutcomeId = Dictionary(uniqueKeysWithValues: round.oddsVersion.odds.map { ($0.outcomeId, $0) })
|
|
return round.market.outcomes
|
|
.sorted(by: { $0.sortOrder < $1.sortOrder })
|
|
.map { outcome in
|
|
SelectionOption(
|
|
id: outcome.id.uuidString,
|
|
title: outcomeTitle(outcome),
|
|
subtitle: localization.string(for: "round.selection_prompt"),
|
|
odds: oddsByOutcomeId[outcome.id].map { String(format: "%.2f", $0.decimalOdds) } ?? "--"
|
|
)
|
|
}
|
|
}
|
|
|
|
private func outcomeTitle(_ outcome: HermesOutcome) -> String {
|
|
switch outcome.labelKey {
|
|
case "round.home":
|
|
return localization.string(for: "round.home")
|
|
case "round.away":
|
|
return localization.string(for: "round.away")
|
|
default:
|
|
return outcome.outcomeCode.capitalized
|
|
}
|
|
}
|
|
|
|
private func selectedOutcomeTitle(for round: HermesRound) -> String {
|
|
guard let selectedOutcomeID,
|
|
let outcome = round.market.outcomes.first(where: { $0.id.uuidString == selectedOutcomeID }) else {
|
|
return localization.string(for: "round.selection_prompt")
|
|
}
|
|
|
|
return outcomeTitle(outcome)
|
|
}
|
|
|
|
private func winningOutcomeTitle(for round: HermesRound) -> String {
|
|
guard let outcome = round.market.outcomes.first(where: { $0.id == round.settlement.winningOutcomeId }) else {
|
|
return localization.string(for: "round.selection_prompt")
|
|
}
|
|
|
|
return outcomeTitle(outcome)
|
|
}
|
|
|
|
private func formatOdds(_ round: HermesRound) -> String {
|
|
let oddsByOutcomeId = Dictionary(uniqueKeysWithValues: round.oddsVersion.odds.map { ($0.outcomeId, $0) })
|
|
return round.market.outcomes
|
|
.sorted(by: { $0.sortOrder < $1.sortOrder })
|
|
.compactMap { oddsByOutcomeId[$0.id]?.decimalOdds }
|
|
.map { String(format: "%.2f", $0) }
|
|
.joined(separator: " / ")
|
|
}
|
|
|
|
private func phaseLabel(isTimerLocked: Bool) -> String {
|
|
switch phase {
|
|
case .preview:
|
|
if isTimerLocked {
|
|
return localization.string(for: "round.locked_label")
|
|
}
|
|
return localization.string(for: "round.preview_label")
|
|
case .locked:
|
|
return localization.string(for: "round.locked_label")
|
|
case .reveal:
|
|
return localization.string(for: "reveal.title")
|
|
case .result:
|
|
return localization.string(for: "result.title")
|
|
}
|
|
}
|
|
|
|
private static func countdownText(for remaining: TimeInterval) -> String {
|
|
let totalSeconds = max(Int(remaining.rounded(.down)), 0)
|
|
let minutes = totalSeconds / 60
|
|
let seconds = totalSeconds % 60
|
|
return String(format: "%02d:%02d", minutes, seconds)
|
|
}
|
|
|
|
private func baseSelectionAttributes(_ outcomeId: String) -> [String: String] {
|
|
["screen_name": "round", "outcome_id": outcomeId]
|
|
}
|
|
|
|
private func roundAnalyticsAttributes(_ round: HermesRound) -> [String: String] {
|
|
[
|
|
"screen_name": "round",
|
|
"event_id": round.event.id.uuidString,
|
|
"market_id": round.market.id.uuidString,
|
|
]
|
|
}
|
|
}
|