games_app/prediqo_mobile/lib/features/prediction/bloc/prediction_bloc.dart

1602 lines
57 KiB
Dart
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import 'dart:async';
import 'dart:math' as math;
import 'package:equatable/equatable.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../../core/errors/app_exception.dart';
import '../../../core/realtime/game_socket_service.dart';
import '../../../core/utils/amount_utils.dart';
import '../../../data/models/prediction_models.dart';
import '../../../data/repositories/prediction_repository_impl.dart';
import '../../../data/repositories/wallet_repository_impl.dart';
import '../../../domain/repositories/prediction_repository.dart';
import '../../support/utils/support_ui_gate.dart';
import '../utils/candle_interval_cache.dart';
import '../utils/prediction_history_filter_store.dart';
import '../utils/server_adjusted_countdown.dart';
part 'prediction_event.dart';
part 'prediction_state.dart';
/// `Bloc` processes events **concurrently** by default. `PredictionRefreshTick`
/// does an `await`ed HTTP round-trip, so a slow response can resolve *after* a
/// later tick already started/finished — an old, in-flight refresh clobbering
/// state a newer one already updated. Sequential processing (à la
/// `bloc_concurrency`'s `sequential()`, implemented inline to avoid the extra
/// dependency) guarantees ticks are fully handled one at a time, in order.
EventTransformer<E> _sequential<E>() {
return (events, mapper) => events.asyncExpand(mapper);
}
class PredictionBloc extends Bloc<PredictionEvent, PredictionState> {
PredictionBloc(this._repo, this._socket, this._walletRepo) : super(const PredictionState.initial()) {
on<PredictionLoadRequested>(_onLoad, transformer: _sequential());
on<PredictionIntervalChanged>(_onIntervalChanged);
on<PredictionStakeSelected>(_onStakeSelected);
on<PredictionDirectionSelected>(_onDirectionSelected);
on<PredictionStakeAccountChanged>(_onStakeAccountChanged);
on<PredictionPlayModeChanged>(_onPlayModeChanged);
on<PredictionMultiLevelSelected>(_onMultiLevelSelected);
on<PredictionMultiDirectionToggled>(_onMultiDirectionToggled);
on<PredictionPlaceBetRequested>(_onPlaceBet);
on<PredictionPlaceMultiBetRequested>(_onPlaceMultiBet);
on<PredictionAutoSaveRequested>(_onAutoSave);
on<PredictionRefreshTick>(_onRefreshTick, transformer: _sequential());
on<PredictionWsMessageReceived>(_onWsMessage);
on<PredictionSocketStatusChanged>(_onSocketStatusChanged);
on<PredictionHistoryPageRequested>(_onHistoryPage, transformer: _sequential());
on<PredictionHistoryFilterChanged>(_onHistoryFilterChanged);
on<PredictionCandlesOlderRequested>(_onOlderCandles);
on<PredictionCandlesReloadRequested>(_onCandlesReload, transformer: _sequential());
on<PredictionPaused>(_onPaused);
on<PredictionResumed>(_onResumed);
on<PredictionAppResumed>(_onAppResumed, transformer: _sequential());
on<PredictionBalancesRefreshRequested>(_onBalancesRefresh);
on<PredictionFeedbackConsumed>((event, emit) {
emit(state.copyWith(clearError: true, betPlaced: false));
});
_socket.addListener(_handleSocketMessage);
_socket.addStatusListener(_handleSocketStatus);
}
final PredictionRepository _repo;
final GameSocketService _socket;
final WalletRepositoryImpl _walletRepo;
Timer? _pollTimer;
bool _screenActive = false;
int _multiPollTicks = 0;
int _healthyPollSkips = 0;
int _lastFullStateSyncMs = 0;
static const historyPageSize = 5;
static const _pollJitterRatio = 0.12;
final historyFilterStore = PredictionHistoryFilterStore();
final candleIntervalCache = CandleIntervalCache();
String _historyKey({
int? intervalMinutes,
required String? wallet,
required String? status,
}) =>
PredictionHistoryFilterStore.key(
intervalMinutes: intervalMinutes ?? state.selectedIntervalMinutes,
wallet: wallet,
status: status,
);
bool _isCurrentHistoryContext({
required int intervalMinutes,
String? wallet,
String? status,
}) =>
state.selectedIntervalMinutes == intervalMinutes &&
state.historyWalletFilter == wallet &&
state.historyStatusFilter == status;
void _rememberHistory(
List<PredictionModel> items, {
required int page,
required int totalPages,
int? intervalMinutes,
String? wallet,
String? status,
}) {
historyFilterStore.put(
_historyKey(
intervalMinutes: intervalMinutes,
wallet: wallet ?? state.historyWalletFilter,
status: status ?? state.historyStatusFilter,
),
PredictionHistoryFilterPage(
items: items,
page: page,
totalPages: totalPages,
),
);
}
int _chartPageSizeForMinutes(int intervalMinutes) {
IntervalModel? meta;
for (final i in state.gameState?.intervals ?? const <IntervalModel>[]) {
if (i.intervalMinutes == intervalMinutes) {
meta = i;
break;
}
}
final limit = meta?.chartCandleLimit ??
state.gameState?.interval.chartCandleLimit ??
80;
return limit.clamp(20, 200);
}
void _rememberCandles(
int intervalMinutes,
List<OhlcCandleModel> items,
bool hasMore,
) {
if (items.isEmpty) return;
candleIntervalCache.put(
intervalMinutes,
CandleIntervalPage(items: items, hasMore: hasMore),
);
}
List<PredictionModel> _applyLiveHistoryOverlays(List<PredictionModel> items) {
final liveMulti = state.gameState?.userMultiBet;
final liveBet = state.gameState?.userBet;
var next = items;
if (liveMulti != null) {
next = _historyWithMultiProgress(next, liveMulti);
}
if (liveBet != null) {
next = _historyWithPrediction(next, liveBet);
}
return next;
}
Future<PredictionsPageModel> _fetchHistoryPage(
int page, {
int? intervalMinutes,
String? wallet,
String? status,
}) {
return _repo.getMyBets(
page: page,
pageSize: historyPageSize,
intervalMinutes: intervalMinutes ?? state.selectedIntervalMinutes,
stakeAccountKind: wallet ?? state.historyWalletFilter,
status: status ?? state.historyStatusFilter,
);
}
Future<void> _refreshHistoryFromServer(
Emitter<PredictionState> emit, {
int page = 1,
bool append = false,
bool showSpinnerIfEmpty = true,
}) async {
final interval = state.selectedIntervalMinutes;
final wallet = state.historyWalletFilter;
final status = state.historyStatusFilter;
if (append || (showSpinnerIfEmpty && state.history.isEmpty)) {
emit(state.copyWith(isLoadingHistory: true, clearHistoryError: true));
} else {
emit(state.copyWith(clearHistoryError: true));
}
try {
final result = await _fetchHistoryPage(
page,
intervalMinutes: interval,
wallet: wallet,
status: status,
);
if (!_isCurrentHistoryContext(
intervalMinutes: interval,
wallet: wallet,
status: status,
)) {
return;
}
final merged = append
? [
...state.history,
...result.items.where((item) => state.history.every((h) => h.id != item.id)),
]
: result.items;
final items = append ? merged : _applyLiveHistoryOverlays(merged);
final reachedEnd = append && result.items.isEmpty;
final nextPage = reachedEnd ? state.historyPage : result.page;
final nextTotal = reachedEnd ? state.historyTotalPages : result.totalPages;
_rememberHistory(
items,
page: nextPage,
totalPages: nextTotal,
intervalMinutes: interval,
wallet: wallet,
status: status,
);
emit(state.copyWith(
history: items,
historyPage: nextPage,
historyTotalPages: nextTotal,
isLoadingHistory: false,
clearHistoryError: true,
));
} catch (e) {
if (_isCurrentHistoryContext(
intervalMinutes: interval,
wallet: wallet,
status: status,
)) {
emit(state.copyWith(
isLoadingHistory: false,
historyError: e.toString().replaceFirst('Exception: ', ''),
));
}
}
}
bool _matchesHistoryFilters(PredictionModel p) {
if (state.historyWalletFilter != null &&
p.stakeAccountKind != state.historyWalletFilter) {
return false;
}
if (state.historyStatusFilter != null && p.status != state.historyStatusFilter) {
return false;
}
return true;
}
void _handleSocketMessage(Map<String, dynamic> msg) {
if (!_screenActive) return;
add(PredictionWsMessageReceived(msg));
}
void _handleSocketStatus(GameSocketConnectionState status) {
if (!_screenActive) return;
add(PredictionSocketStatusChanged(status));
}
@override
Future<void> close() {
_pollTimer?.cancel();
_socket.removeListener(_handleSocketMessage);
_socket.removeStatusListener(_handleSocketStatus);
return super.close();
}
void _stopPolling() {
_pollTimer?.cancel();
_pollTimer = null;
}
void _startPolling() {
_stopPolling();
if (!_screenActive) return;
final hasActiveMulti = state.gameState?.userMultiBet != null;
final autoOn = state.gameState?.autoSettings?.enabled == true;
// Auto bets are placed server-side without always relying on WS; poll often enough
// to surface pending predictions in Recent predictions quickly.
final Duration interval;
if (autoOn || hasActiveMulti) {
interval = const Duration(seconds: 3);
} else if (_socket.isEnabled && state.isRealtimeHealthy) {
interval = const Duration(seconds: 8);
} else if (_socket.isEnabled) {
interval = const Duration(seconds: 4);
} else {
interval = const Duration(seconds: 2);
}
void scheduleNext() {
if (!_screenActive) return;
final baseMs = interval.inMilliseconds;
final jitterMs = (baseMs * _pollJitterRatio).round();
final offset = jitterMs <= 0
? 0
: math.Random().nextInt(jitterMs * 2 + 1) - jitterMs;
final nextMs = math.max(1000, baseMs + offset);
_pollTimer = Timer(Duration(milliseconds: nextMs), () {
if (!_screenActive) return;
add(const PredictionRefreshTick());
scheduleNext();
});
}
scheduleNext();
}
void _onPaused(PredictionPaused event, Emitter<PredictionState> emit) {
_screenActive = false;
SupportUiGate.predictionScreenActive = false;
_stopPolling();
_healthyPollSkips = 0;
}
void _onSocketStatusChanged(
PredictionSocketStatusChanged event,
Emitter<PredictionState> emit,
) {
// Support sheet open: ignore transient game-WS drops so the Live badge
// does not flash "Reconnecting…" over a healthy Predict session.
if (SupportUiGate.holdsGameRealtime &&
event.status != GameSocketConnectionState.connected &&
state.isRealtimeHealthy) {
return;
}
final nextRealtime = switch (event.status) {
GameSocketConnectionState.connected => PredictionRealtimeStatus.live,
GameSocketConnectionState.connecting => PredictionRealtimeStatus.syncing,
GameSocketConnectionState.reconnecting => PredictionRealtimeStatus.reconnecting,
GameSocketConnectionState.stale => PredictionRealtimeStatus.reconnecting,
GameSocketConnectionState.disconnected => PredictionRealtimeStatus.polling,
};
final wasHealthy = state.isRealtimeHealthy;
emit(state.copyWith(
wsConnected: event.status == GameSocketConnectionState.connected,
realtimeStatus: nextRealtime,
));
_startPolling();
if (event.status != GameSocketConnectionState.connected) {
_healthyPollSkips = 0;
}
if (!wasHealthy && event.status == GameSocketConnectionState.connected) {
add(const PredictionRefreshTick(forceGameState: true));
add(const PredictionBalancesRefreshRequested());
add(const PredictionHistoryPageRequested(1));
// Missed candle.append frames leave price cliffs until a full reload;
// replace the local series from HTTP after every reconnect.
add(const PredictionCandlesReloadRequested());
}
}
Future<void> _onResumed(PredictionResumed event, Emitter<PredictionState> emit) async {
_screenActive = true;
SupportUiGate.predictionScreenActive = true;
add(const PredictionLoadRequested(ifStale: true));
}
/// Live badge status — holds "live" while Support is open on this screen.
PredictionRealtimeStatus _realtimeStatus({
required PredictionRealtimeStatus whenDisconnected,
}) {
if (SupportUiGate.holdsGameRealtime &&
state.realtimeStatus == PredictionRealtimeStatus.live) {
return PredictionRealtimeStatus.live;
}
if (_socket.isConnected) return PredictionRealtimeStatus.live;
return whenDisconnected;
}
static const _freshSyncMs = 5000;
void _ensureRealtime([int? intervalMinutes]) {
if (!_socket.isEnabled) return;
unawaited(_socket.connect());
_socket.subscribe(intervalMinutes ?? state.selectedIntervalMinutes);
}
Future<T?> _soft<T>(Future<T> future) async {
try {
return await future;
} catch (_) {
return null;
}
}
/// True root fix for "countdown stuck until I leave and reopen the page":
/// mobile OSes suspend Dart `Timer`s and can silently drop the WebSocket
/// while backgrounded (screen lock, app switcher, incoming call, long time
/// on the page with the screen off) — none of which fires `onDone`, so
/// [GameSocketService.isConnected] keeps reporting healthy. Nothing was
/// listening for the app returning to the foreground, so the zombie
/// connection / disrupted poll schedule silently lingered until the user
/// manually left and reopened the prediction screen (which forces a fresh
/// `_onLoad`). Wiring [PredictionAppResumed] to `AppLifecycleState.resumed`
/// (see `_PredictionScreenState.didChangeAppLifecycleState`) closes that gap
/// without requiring any user action.
Future<void> _onAppResumed(
PredictionAppResumed event,
Emitter<PredictionState> emit,
) async {
if (!_screenActive) return;
if (SupportUiGate.holdsGameRealtime) {
// Support sheet / IME lifecycle — refresh via poll, do not tear WS down.
_startPolling();
add(const PredictionRefreshTick(forceGameState: true));
return;
}
if (_socket.isEnabled) {
// Prefer a soft check: opening Support / IME can fake a resume and a
// hard forceReconnect briefly shows "Reconnecting…" despite a healthy WS.
await _socket.reconnectAfterBackground();
}
// Old recursive Timer chain may have been suspended mid-flight; restart
// it fresh instead of trusting whatever was already scheduled.
_startPolling();
add(const PredictionRefreshTick(forceGameState: true));
}
Future<void> _onBalancesRefresh(PredictionBalancesRefreshRequested event, Emitter<PredictionState> emit) async {
final labels = await _loadBalances(state.gameState?.config.walletTypeCode);
emit(state.copyWith(
mainBalanceLabel: labels.mainLabel,
bonusBalanceLabel: labels.bonusLabel,
testBalanceLabel: labels.testLabel,
mainAvailable: labels.main,
bonusAvailable: labels.bonus,
testAvailable: labels.test,
));
}
Future<
({
String mainLabel,
String bonusLabel,
String testLabel,
double main,
double bonus,
double test,
})> _loadBalances(String? walletTypeCode) async {
try {
final balances = await _walletRepo.getBalances();
if (balances.isEmpty) {
return (
mainLabel: '—',
bonusLabel: '—',
testLabel: '—',
main: 0.0,
bonus: 0.0,
test: 0.0,
);
}
final code = walletTypeCode ?? 'USDT_TRC20';
final match = balances.where((b) => b.walletType.code == code);
final b = match.isNotEmpty ? match.first : balances.first;
final symbol = _shortSymbol(b.walletType.code);
final decimals = b.walletType.decimals;
final main = _rawToDouble(b.available, decimals);
final bonus = _rawToDouble(b.bonusAvailable, decimals);
final test = _rawToDouble(b.testAvailable, decimals);
return (
mainLabel: '${rawAmountToHuman(b.available, decimals)} $symbol',
bonusLabel: '${rawAmountToHuman(b.bonusAvailable, decimals)} $symbol',
testLabel: '${rawAmountToHuman(b.testAvailable, decimals)} $symbol',
main: main,
bonus: bonus,
test: test,
);
} catch (_) {
return (
mainLabel: '—',
bonusLabel: '—',
testLabel: '—',
main: 0.0,
bonus: 0.0,
test: 0.0,
);
}
}
double _rawToDouble(String raw, int decimals) {
final human = rawAmountToHuman(raw, decimals);
return double.tryParse(human) ?? 0;
}
static const insufficientBalanceCode = 'insufficient_balance';
String? _insufficientBalanceError() {
// Balances not loaded yet — let the API validate.
if (state.mainBalanceLabel == '—' &&
state.bonusBalanceLabel == '—' &&
state.testBalanceLabel == '—') {
return null;
}
if (state.selectedStake <= state.selectedWalletAvailable) return null;
return '$insufficientBalanceCode:${state.stakeAccountKind.apiValue}';
}
/// Re-emit even when the message text is unchanged (Equatable would skip otherwise).
void _emitError(Emitter<PredictionState> emit, String message) {
if (state.errorMessage == message) {
emit(state.copyWith(clearError: true));
}
emit(state.copyWith(errorMessage: message));
}
String _shortSymbol(String code) {
final upper = code.toUpperCase();
if (upper.startsWith('USDT')) return 'USDT';
if (upper.contains('_')) return upper.split('_').first;
return upper;
}
StakeAccountKind _parseStakeKind(String value) {
switch (value) {
case 'bonus':
return StakeAccountKind.bonus;
case 'test':
return StakeAccountKind.test;
default:
return StakeAccountKind.main;
}
}
Future<void> _onLoad(PredictionLoadRequested event, Emitter<PredictionState> emit) async {
final nowMs = DateTime.now().millisecondsSinceEpoch;
if (event.ifStale &&
state.gameState != null &&
state.candles.isNotEmpty &&
nowMs - _lastFullStateSyncMs < _freshSyncMs) {
_ensureRealtime(state.selectedIntervalMinutes);
_startPolling();
return;
}
final keepExistingUi = state.gameState != null;
if (!keepExistingUi) {
emit(state.copyWith(status: PredictionStatus.loading, clearError: true));
} else {
emit(state.copyWith(clearError: true));
}
_ensureRealtime(state.selectedIntervalMinutes);
try {
final interval = state.selectedIntervalMinutes;
final historyWallet = state.historyWalletFilter;
final historyStatus = state.historyStatusFilter;
final pageSize = _chartPageSizeForMinutes(interval);
final stateFuture = _repo.getState(intervalMinutes: interval);
final candlesOutcome = _repo
.getCandlesPage(
intervalMinutes: interval,
limit: pageSize,
)
.then<({CandlesPageModel? page, Object? error})>(
(page) => (page: page, error: null),
onError: (Object e, StackTrace _) => (page: null, error: e),
);
final historyFuture = _soft(_fetchHistoryPage(
1,
intervalMinutes: interval,
wallet: historyWallet,
status: historyStatus,
));
final balancesFuture = _soft(_loadBalances(state.gameState?.config.walletTypeCode));
final gameState = await stateFuture;
_ensureRealtime(gameState.selectedIntervalMinutes);
// Apply the HTTP snapshot once, through stabilize. Later progressive
// emits must only patch candles / history / balances — re-applying this
// captured snapshot after WS has opened the next cycle is what caused
// 55s → 0s → 52s → 0s after the first-load optimization.
final applied = _stabilizeGameStateRound(
previous: state.gameState,
incoming: gameState,
);
if (state.gameState == null) {
emit(_readyFromGameState(
applied,
candles: state.candles,
isLoadingCandles: state.candles.isEmpty,
));
} else {
emit(state.copyWith(
status: PredictionStatus.ready,
gameState: applied,
selectedIntervalMinutes: applied.selectedIntervalMinutes,
wsConnected: _socket.isConnected,
realtimeStatus: _realtimeStatus(
whenDisconnected: _socket.isEnabled
? PredictionRealtimeStatus.syncing
: PredictionRealtimeStatus.polling,
),
));
}
final candles = await candlesOutcome;
if (state.selectedIntervalMinutes != gameState.selectedIntervalMinutes) {
return;
}
if (candles.error == null && candles.page != null) {
_rememberCandles(
gameState.selectedIntervalMinutes,
candles.page!.items,
candles.page!.hasMore,
);
emit(state.copyWith(
status: PredictionStatus.ready,
candles: candles.page!.items,
hasMoreOlderCandles: candles.page!.hasMore,
isLoadingOlderCandles: false,
clearCandlesError: true,
));
} else if (candles.error != null) {
emit(state.copyWith(
status: PredictionStatus.ready,
isLoadingOlderCandles: false,
candlesError: candles.error.toString().replaceFirst('Exception: ', ''),
));
}
final history = await historyFuture;
final labels = await balancesFuture;
if (_isCurrentHistoryContext(
intervalMinutes: interval,
wallet: historyWallet,
status: historyStatus,
) &&
history != null) {
final historyItems = _applyLiveHistoryOverlays(history.items);
_rememberHistory(
historyItems,
page: history.page,
totalPages: history.totalPages,
intervalMinutes: interval,
wallet: historyWallet,
status: historyStatus,
);
emit(state.copyWith(
history: historyItems,
historyPage: history.page,
historyTotalPages: history.totalPages,
clearHistoryError: true,
mainBalanceLabel: labels?.mainLabel,
bonusBalanceLabel: labels?.bonusLabel,
testBalanceLabel: labels?.testLabel,
mainAvailable: labels?.main,
bonusAvailable: labels?.bonus,
testAvailable: labels?.test,
));
} else {
if (_isCurrentHistoryContext(
intervalMinutes: interval,
wallet: historyWallet,
status: historyStatus,
) &&
history == null &&
state.history.isEmpty) {
emit(state.copyWith(
isLoadingHistory: false,
historyError: AppException.connectionFailedMessage,
mainBalanceLabel: labels?.mainLabel,
bonusBalanceLabel: labels?.bonusLabel,
testBalanceLabel: labels?.testLabel,
mainAvailable: labels?.main,
bonusAvailable: labels?.bonus,
testAvailable: labels?.test,
));
} else if (labels != null) {
emit(state.copyWith(
mainBalanceLabel: labels.mainLabel,
bonusBalanceLabel: labels.bonusLabel,
testBalanceLabel: labels.testLabel,
mainAvailable: labels.main,
bonusAvailable: labels.bonus,
testAvailable: labels.test,
));
}
}
_lastFullStateSyncMs = DateTime.now().millisecondsSinceEpoch;
_healthyPollSkips = 0;
_startPolling();
} catch (e) {
emit(state.copyWith(
status: keepExistingUi ? PredictionStatus.ready : PredictionStatus.error,
errorMessage: keepExistingUi ? state.errorMessage : e.toString(),
wsConnected: _socket.isConnected,
realtimeStatus: _realtimeStatus(
whenDisconnected: _socket.isEnabled
? PredictionRealtimeStatus.polling
: PredictionRealtimeStatus.syncing,
),
));
}
}
PredictionState _readyFromGameState(
GameStateModel gameState, {
required List<OhlcCandleModel> candles,
bool hasMoreOlder = true,
bool isLoadingCandles = false,
List<PredictionModel>? history,
int? historyPage,
int? historyTotalPages,
({
String mainLabel,
String bonusLabel,
String testLabel,
double main,
double bonus,
double test,
})? labels,
}) {
final auto = gameState.autoSettings;
final multi = gameState.userMultiBet;
final stakeKind = multi != null
? _parseStakeKind(multi.stakeAccountKind)
: (auto?.enabled == true)
? _parseStakeKind(auto!.stakeAccountKind)
: state.stakeAccountKind;
final nextStake = state.status == PredictionStatus.initial
? (auto?.enabled == true && auto!.stakeDisplay > 0
? auto.stakeDisplay
: _defaultStake(gameState.config))
: state.selectedStake;
return state.copyWith(
status: PredictionStatus.ready,
gameState: _stabilizeGameStateRound(
previous: state.gameState,
incoming: gameState,
),
candles: candles,
hasMoreOlderCandles: hasMoreOlder,
isLoadingOlderCandles: isLoadingCandles,
history: history,
historyPage: historyPage,
historyTotalPages: historyTotalPages,
selectedIntervalMinutes: gameState.selectedIntervalMinutes,
selectedStake: nextStake,
multiSequence: _initialMultiSequence(gameState),
selectedMultiLevel: gameState.multiLevels.isNotEmpty
? gameState.multiLevels.first
: state.selectedMultiLevel,
playMode: gameState.userMultiBet != null
? PredictionPlayMode.multi
: (auto?.enabled == true ? PredictionPlayMode.auto : state.playMode),
stakeAccountKind: stakeKind,
mainBalanceLabel: labels?.mainLabel,
bonusBalanceLabel: labels?.bonusLabel,
testBalanceLabel: labels?.testLabel,
mainAvailable: labels?.main,
bonusAvailable: labels?.bonus,
testAvailable: labels?.test,
wsConnected: _socket.isConnected,
realtimeStatus: _realtimeStatus(
whenDisconnected: _socket.isEnabled
? PredictionRealtimeStatus.syncing
: PredictionRealtimeStatus.polling,
),
);
}
Future<void> _onIntervalChanged(PredictionIntervalChanged event, Emitter<PredictionState> emit) async {
final prevInterval = state.selectedIntervalMinutes;
final minutes = event.minutes;
final gs = state.gameState;
final cachedHistory = historyFilterStore.peek(
_historyKey(
intervalMinutes: minutes,
wallet: state.historyWalletFilter,
status: state.historyStatusFilter,
),
);
final cachedCandles = candleIntervalCache.peek(minutes);
emit(state.copyWith(
selectedIntervalMinutes: minutes,
candles: cachedCandles?.items ?? const [],
hasMoreOlderCandles: cachedCandles?.hasMore ?? true,
isLoadingOlderCandles: cachedCandles == null,
clearCandlesError: true,
history: cachedHistory?.items ?? const [],
historyPage: cachedHistory?.page ?? 1,
historyTotalPages: cachedHistory?.totalPages ?? 1,
isLoadingHistory: cachedHistory == null,
clearHistoryError: cachedHistory != null,
gameState: gs?.copyWith(
selectedIntervalMinutes: minutes,
clearRound: true,
clearUserBet: true,
),
));
if (_socket.isEnabled && _socket.isConnected) {
if (prevInterval != minutes) {
_socket.unsubscribe(prevInterval);
}
_socket.subscribe(minutes);
}
try {
final pageSize = _chartPageSizeForMinutes(minutes);
final stateFuture = _repo.getState(intervalMinutes: minutes);
final candlesOutcome = _repo
.getCandlesPage(
intervalMinutes: minutes,
limit: pageSize,
)
.then<({CandlesPageModel? page, Object? error})>(
(page) => (page: page, error: null),
onError: (Object e, StackTrace _) => (page: null, error: e),
);
final gameState = await stateFuture;
if (state.selectedIntervalMinutes != minutes) return;
final applied = _stabilizeGameStateRound(
previous: state.gameState,
incoming: gameState,
);
emit(state.copyWith(
status: PredictionStatus.ready,
gameState: applied,
selectedIntervalMinutes: applied.selectedIntervalMinutes,
wsConnected: _socket.isConnected,
realtimeStatus: _realtimeStatus(
whenDisconnected: _socket.isEnabled
? PredictionRealtimeStatus.syncing
: PredictionRealtimeStatus.polling,
),
));
final candles = await candlesOutcome;
if (state.selectedIntervalMinutes != minutes) return;
if (candles.error == null && candles.page != null) {
_rememberCandles(minutes, candles.page!.items, candles.page!.hasMore);
emit(state.copyWith(
candles: candles.page!.items,
hasMoreOlderCandles: candles.page!.hasMore,
isLoadingOlderCandles: false,
clearCandlesError: true,
));
} else if (candles.error != null) {
emit(state.copyWith(
isLoadingOlderCandles: false,
candlesError: candles.error.toString().replaceFirst('Exception: ', ''),
));
}
_lastFullStateSyncMs = DateTime.now().millisecondsSinceEpoch;
_healthyPollSkips = 0;
_startPolling();
await _refreshHistoryFromServer(
emit,
page: 1,
showSpinnerIfEmpty: cachedHistory == null,
);
} catch (e) {
if (state.selectedIntervalMinutes != minutes) return;
emit(state.copyWith(
errorMessage: e.toString().replaceFirst('Exception: ', ''),
));
}
}
void _onStakeSelected(PredictionStakeSelected event, Emitter<PredictionState> emit) {
emit(state.copyWith(selectedStake: event.stake));
}
void _onDirectionSelected(PredictionDirectionSelected event, Emitter<PredictionState> emit) {
emit(state.copyWith(selectedDirection: event.direction));
}
void _onStakeAccountChanged(PredictionStakeAccountChanged event, Emitter<PredictionState> emit) {
emit(state.copyWith(stakeAccountKind: event.kind));
}
void _onPlayModeChanged(PredictionPlayModeChanged event, Emitter<PredictionState> emit) {
emit(state.copyWith(playMode: event.mode));
}
void _onMultiLevelSelected(PredictionMultiLevelSelected event, Emitter<PredictionState> emit) {
final level = event.level;
emit(state.copyWith(
selectedMultiLevel: level,
multiSequence: List.filled(level.candleCount, 'long'),
));
}
void _onMultiDirectionToggled(PredictionMultiDirectionToggled event, Emitter<PredictionState> emit) {
final seq = List<String>.from(state.multiSequence);
if (event.index < 0 || event.index >= seq.length) return;
seq[event.index] = seq[event.index] == 'long' ? 'short' : 'long';
emit(state.copyWith(multiSequence: seq));
}
Future<void> _onPlaceBet(PredictionPlaceBetRequested event, Emitter<PredictionState> emit) async {
final gs = state.gameState;
if (gs == null) return;
final balanceError = _insufficientBalanceError();
if (balanceError != null) {
_emitError(emit, balanceError);
return;
}
emit(state.copyWith(isPlacingBet: true, clearError: true));
try {
await _repo.placeBet(
direction: state.selectedDirection,
stakeAmount: state.selectedStake,
intervalMinutes: gs.selectedIntervalMinutes,
stakeAccountKind: state.stakeAccountKind.apiValue,
);
// Toast only for this user-initiated success — never from WS/poll echoes.
emit(state.copyWith(isPlacingBet: false, betPlaced: true));
add(const PredictionBalancesRefreshRequested());
add(const PredictionLoadRequested());
} catch (e) {
emit(state.copyWith(isPlacingBet: false));
_emitError(emit, e.toString());
}
}
Future<void> _onPlaceMultiBet(PredictionPlaceMultiBetRequested event, Emitter<PredictionState> emit) async {
final gs = state.gameState;
final level = state.selectedMultiLevel;
if (gs == null || level == null) return;
final balanceError = _insufficientBalanceError();
if (balanceError != null) {
_emitError(emit, balanceError);
return;
}
emit(state.copyWith(isPlacingBet: true, clearError: true));
try {
await _repo.placeMultiBet(
level: level.level,
sequence: state.multiSequence,
stakeAmount: state.selectedStake,
intervalMinutes: gs.selectedIntervalMinutes,
stakeAccountKind: state.stakeAccountKind.apiValue,
);
emit(state.copyWith(isPlacingBet: false, betPlaced: true));
add(const PredictionBalancesRefreshRequested());
add(const PredictionLoadRequested());
} catch (e) {
emit(state.copyWith(isPlacingBet: false));
_emitError(emit, e.toString());
}
}
Future<void> _onAutoSave(PredictionAutoSaveRequested event, Emitter<PredictionState> emit) async {
final enabling = event.body['enabled'] == true;
if (enabling) {
final balanceError = _insufficientBalanceError();
if (balanceError != null) {
_emitError(emit, balanceError);
return;
}
}
emit(state.copyWith(isSavingAuto: true, clearError: true));
try {
final saved = await _repo.saveAutoSettings(event.body);
final gs = state.gameState;
if (gs != null) {
emit(state.copyWith(
isSavingAuto: false,
gameState: gs.copyWith(autoSettings: saved),
stakeAccountKind: _parseStakeKind(saved.stakeAccountKind),
selectedStake: saved.stakeDisplay > 0 ? saved.stakeDisplay : state.selectedStake,
playMode: PredictionPlayMode.auto,
clearError: saved.autoBetError == null,
errorMessage: saved.autoBetError,
betPlaced: saved.autoBetPlaced,
));
} else {
emit(state.copyWith(
isSavingAuto: false,
clearError: saved.autoBetError == null,
errorMessage: saved.autoBetError,
betPlaced: saved.autoBetPlaced,
));
}
if (saved.autoBetPlaced) {
add(const PredictionBalancesRefreshRequested());
add(const PredictionLoadRequested());
} else if (saved.enabled) {
_startPolling();
add(const PredictionHistoryPageRequested(1));
}
} catch (e) {
emit(state.copyWith(isSavingAuto: false));
_emitError(emit, e.toString());
}
}
Future<void> _onRefreshTick(PredictionRefreshTick event, Emitter<PredictionState> emit) async {
if (!_screenActive || state.status != PredictionStatus.ready) return;
try {
final interval = state.selectedIntervalMinutes;
final wsOk = _socket.isEnabled && _socket.isConnected;
final hasActiveMulti = state.gameState?.userMultiBet != null;
final autoOn = state.gameState?.autoSettings?.enabled == true;
final prevUserBetId = state.gameState?.userBet?.id;
final prevLastAuto = state.gameState?.autoSettings?.lastAutoBetAt;
final nowMs = DateTime.now().millisecondsSinceEpoch;
// Phase boundary (0s / ≤1s): never skip `/state` — healthy-WS skips were
// leaving the UI stuck at 0s for ~8–20s then jumping mid next window.
final phaseBoundary =
countdownNeedsStateResync(state.gameState?.round, clientNowMs: nowMs);
final shouldDoSafetyStateSync =
!event.forceGameState &&
wsOk &&
!hasActiveMulti &&
!autoOn &&
(_healthyPollSkips >= 2 || nowMs - _lastFullStateSyncMs >= 20000);
// Skip full state polls only when WS is healthy AND there's nothing that
// needs frequent HTTP sync (auto placement / multi progress / new window).
if (wsOk &&
!hasActiveMulti &&
!autoOn &&
!event.forceGameState &&
!phaseBoundary &&
!shouldDoSafetyStateSync) {
_healthyPollSkips++;
final labels = await _loadBalances(state.gameState?.config.walletTypeCode);
final gs = state.gameState;
final round = gs?.round;
final nextBet = _userBetForRound(gs?.userBet, round);
emit(state.copyWith(
gameState: gs == null || identical(nextBet, gs.userBet)
? gs
: gs.copyWith(userBet: nextBet, clearUserBet: nextBet == null),
mainBalanceLabel: labels.mainLabel,
bonusBalanceLabel: labels.bonusLabel,
testBalanceLabel: labels.testLabel,
mainAvailable: labels.main,
bonusAvailable: labels.bonus,
testAvailable: labels.test,
wsConnected: true,
realtimeStatus: PredictionRealtimeStatus.live,
));
return;
}
_healthyPollSkips = 0;
final gameState = await _repo.getState(
intervalMinutes: interval,
force: event.forceGameState || phaseBoundary,
);
final labels = await _loadBalances(gameState.config.walletTypeCode);
final multi = gameState.userMultiBet;
var history = state.history;
if (multi != null) {
history = _historyWithMultiProgress(history, multi);
}
final userBet = gameState.userBet;
if (userBet != null) {
history = _historyWithPrediction(history, userBet);
}
final userBetChanged = userBet?.id != prevUserBetId;
final autoPlaced =
gameState.autoSettings?.lastAutoBetAt != null &&
gameState.autoSettings?.lastAutoBetAt != prevLastAuto;
emit(state.copyWith(
gameState: _stabilizeGameStateRound(
previous: state.gameState,
incoming: gameState,
forceRound: event.forceGameState,
),
mainBalanceLabel: labels.mainLabel,
bonusBalanceLabel: labels.bonusLabel,
testBalanceLabel: labels.testLabel,
mainAvailable: labels.main,
bonusAvailable: labels.bonus,
testAvailable: labels.test,
wsConnected: _socket.isConnected ||
(SupportUiGate.holdsGameRealtime && state.isRealtimeHealthy),
realtimeStatus: _realtimeStatus(
whenDisconnected: _socket.isEnabled
? PredictionRealtimeStatus.reconnecting
: PredictionRealtimeStatus.polling,
),
history: history,
stakeAccountKind: multi != null
? _parseStakeKind(multi.stakeAccountKind)
: state.stakeAccountKind,
));
_rememberHistory(history, page: state.historyPage, totalPages: state.historyTotalPages);
_lastFullStateSyncMs = nowMs;
if (hasActiveMulti || multi != null || autoOn || userBetChanged || autoPlaced) {
_multiPollTicks++;
if (userBetChanged || autoPlaced || _multiPollTicks % 2 == 0) {
add(const PredictionHistoryPageRequested(1));
}
_startPolling();
} else {
_multiPollTicks = 0;
}
if (_socket.isEnabled && !_socket.isConnected) {
await _socket.connect();
if (_socket.isConnected) {
_socket.subscribe(interval);
_startPolling();
}
}
} catch (_) {}
}
void _onWsMessage(PredictionWsMessageReceived event, Emitter<PredictionState> emit) {
final gs = state.gameState;
if (gs == null) return;
final msg = event.message;
final type = msg['type'] as String?;
final msgInterval = (msg['intervalMinutes'] as num?)?.toInt();
// Ignore realtime events for intervals we are not viewing.
if (msgInterval != null &&
msgInterval != state.selectedIntervalMinutes &&
type != 'connected' &&
type != 'subscribed') {
return;
}
switch (type) {
case 'connected':
emit(state.copyWith(
wsConnected: true,
realtimeStatus: PredictionRealtimeStatus.live,
));
break;
case 'subscribed':
if (msgInterval != null && msgInterval != state.selectedIntervalMinutes) {
return;
}
final snapshot = msg['snapshot'];
if (snapshot is Map<String, dynamic>) {
final next = _stabilizeGameStateRound(
previous: state.gameState,
incoming: GameStateModel.fromJson(snapshot),
);
var history = state.history;
if (next.userMultiBet != null) {
history = _historyWithMultiProgress(history, next.userMultiBet!);
}
if (next.userBet != null) {
history = _historyWithPrediction(history, next.userBet!);
}
emit(state.copyWith(
gameState: next,
selectedIntervalMinutes: next.selectedIntervalMinutes,
wsConnected: true,
realtimeStatus: PredictionRealtimeStatus.live,
history: history,
stakeAccountKind: next.userMultiBet != null
? _parseStakeKind(next.userMultiBet!.stakeAccountKind)
: state.stakeAccountKind,
));
_rememberHistory(history, page: state.historyPage, totalPages: state.historyTotalPages);
if (next.autoSettings?.enabled == true) {
_startPolling();
}
}
break;
case 'round.updated':
case 'round.settled':
final roundVersions = msg['versions'];
// Do not advance the ETag on settle before `/state` — that caused 304
// loops while the UI was stuck at secondsToBettingStart: 0.
if (type == 'round.updated' && roundVersions is Map<String, dynamic>) {
PredictionRepositoryImpl.mergeCachedStateVersions(
state.selectedIntervalMinutes,
round: roundVersions['round'] is num
? (roundVersions['round'] as num).toInt()
: null,
);
}
final round = msg['round'];
if (round is Map<String, dynamic>) {
final incomingRound = RoundModel.fromJson(round);
if (!isIncomingRoundStale(gs.round, incomingRound)) {
final parsed = mergeRound(gs.round, incomingRound);
final prevStatus = gs.round?.status;
final prevRoundId = gs.round?.id;
// Timer-only WS ticks must not remount countdown / overwrite UI state.
if (roundUiChanged(gs.round, parsed)) {
final nextBet = _userBetForRound(gs.userBet, parsed);
emit(state.copyWith(
gameState: gs.copyWith(
round: parsed,
userBet: nextBet,
clearUserBet: nextBet == null,
),
));
// New open window: clear stale lock + sync server state.
final openedBetting = parsed.status == 'betting' && prevStatus != 'betting';
final roundChanged = prevRoundId != null && prevRoundId != parsed.id;
if (openedBetting || (roundChanged && parsed.status == 'betting')) {
add(const PredictionRefreshTick(forceGameState: true));
if (gs.autoSettings?.enabled == true) {
add(const PredictionHistoryPageRequested(1));
}
}
}
}
}
if (type == 'round.settled') {
// Candle + next window arrive via candle.append / round.updated.
// Force `/state` without the settle ETag so clients leave 0s promptly.
PredictionRepositoryImpl.invalidateStateCache(
state.selectedIntervalMinutes,
);
add(const PredictionBalancesRefreshRequested());
add(const PredictionHistoryPageRequested(1));
add(const PredictionRefreshTick(forceGameState: true));
add(const PredictionCandlesReloadRequested());
}
break;
case 'multi.updated':
final multiVersions = msg['versions'];
if (multiVersions is Map<String, dynamic>) {
PredictionRepositoryImpl.mergeCachedStateVersions(
state.selectedIntervalMinutes,
bet: multiVersions['bet'] is num
? (multiVersions['bet'] as num).toInt()
: null,
);
}
final multi = msg['userMultiBet'];
if (multi is Map<String, dynamic>) {
final parsed = MultiCandlePredictionModel.fromJson(multi);
final history = _historyWithMultiProgress(state.history, parsed);
emit(state.copyWith(
gameState: gs.copyWith(userMultiBet: parsed),
history: history,
playMode: PredictionPlayMode.multi,
stakeAccountKind: _parseStakeKind(parsed.stakeAccountKind),
));
_rememberHistory(history, page: state.historyPage, totalPages: state.historyTotalPages);
_startPolling();
} else if (multi == null) {
emit(state.copyWith(gameState: gs.copyWith(clearUserMultiBet: true)));
add(const PredictionHistoryPageRequested(1));
_startPolling();
}
break;
case 'candle.append':
final candle = msg['candle'];
if (candle is Map<String, dynamic>) {
final c = OhlcCandleModel.fromJson(candle);
final existing = state.candles;
if (existing.isNotEmpty) {
final last = existing.last;
final intervalMs =
state.selectedIntervalMinutes * 60 * 1000;
// More than ~1.5 intervals between bars ⇒ we missed WS frames.
if (c.openMs - last.openMs > (intervalMs * 3) ~/ 2) {
add(const PredictionCandlesReloadRequested());
break;
}
}
emit(state.copyWith(candles: _mergeCandles(existing, [c])));
}
break;
case 'bet.accepted':
final betVersions = msg['versions'];
if (betVersions is Map<String, dynamic>) {
PredictionRepositoryImpl.mergeCachedStateVersions(
state.selectedIntervalMinutes,
bet: betVersions['bet'] is num
? (betVersions['bet'] as num).toInt()
: null,
auto: betVersions['auto'] is num
? (betVersions['auto'] as num).toInt()
: null,
);
}
final betRaw = msg['bet'];
if (betRaw is Map<String, dynamic>) {
final bet = PredictionModel.fromJson(betRaw);
final history = _historyWithPrediction(state.history, bet);
final GameStateModel nextGs;
if (bet.isMulti) {
nextGs = gs.copyWith(
userMultiBet: MultiCandlePredictionModel(
id: bet.id,
level: bet.level ?? bet.sequenceDirections.length,
sequenceDirections: bet.sequenceDirections,
sequenceStep: bet.sequenceStep,
stakeDisplay: bet.stakeDisplay,
status: bet.status,
payoutDisplay: bet.payoutDisplay,
intervalMinutes: bet.intervalMinutes,
stakeAccountKind: bet.stakeAccountKind,
),
clearUserBet: true,
);
} else if (gs.round != null &&
bet.roundId != null &&
bet.roundId!.isNotEmpty &&
bet.roundId != gs.round!.id) {
// Bet is for another round — ignore for the active lock.
nextGs = gs;
} else {
nextGs = gs.copyWith(userBet: bet);
}
final auto = gs.autoSettings;
final nextAuto = (bet.isAuto && auto != null)
? AutoSettingsModel(
enabled: auto.enabled,
direction: auto.direction,
stakeDisplay: auto.stakeDisplay,
mode: auto.mode,
periodMinutes: auto.periodMinutes,
stakeAccountKind: auto.stakeAccountKind,
intervalSeconds: auto.intervalSeconds,
lastAutoBetAt: DateTime.now().toIso8601String(),
autoBetPlaced: false,
autoBetError: null,
)
: auto;
// Update UI/history only — do not toast here (WS echoes / auto rounds /
// other-interval bets caused false "Prediction placed" messages).
emit(state.copyWith(
gameState: nextAuto != null ? nextGs.copyWith(autoSettings: nextAuto) : nextGs,
history: history,
stakeAccountKind: bet.isMulti
? _parseStakeKind(bet.stakeAccountKind)
: state.stakeAccountKind,
));
_rememberHistory(history, page: state.historyPage, totalPages: state.historyTotalPages);
}
add(const PredictionBalancesRefreshRequested());
add(const PredictionHistoryPageRequested(1));
break;
case 'auto.updated':
final autoVersions = msg['versions'];
if (autoVersions is Map<String, dynamic>) {
PredictionRepositoryImpl.mergeCachedStateVersions(
state.selectedIntervalMinutes,
auto: autoVersions['auto'] is num
? (autoVersions['auto'] as num).toInt()
: null,
);
}
final autoRaw = msg['autoSettings'];
if (autoRaw is Map<String, dynamic>) {
final current = gs.autoSettings;
final merged = AutoSettingsModel(
enabled: autoRaw['enabled'] as bool? ?? current?.enabled ?? false,
direction: autoRaw['direction'] as String? ?? current?.direction,
stakeDisplay: (autoRaw['stakeDisplay'] as num?)?.toDouble() ??
current?.stakeDisplay ??
0,
mode: autoRaw['mode'] as String? ?? current?.mode ?? 'each_round',
periodMinutes: (autoRaw['periodMinutes'] as num?)?.toInt() ??
current?.periodMinutes ??
state.selectedIntervalMinutes,
stakeAccountKind: autoRaw['stakeAccountKind'] as String? ??
current?.stakeAccountKind ??
'main',
intervalSeconds: (autoRaw['intervalSeconds'] as num?)?.toInt() ??
current?.intervalSeconds,
lastAutoBetAt: autoRaw['lastAutoBetAt'] as String? ?? current?.lastAutoBetAt,
autoBetPlaced:
autoRaw['autoBetPlaced'] as bool? ?? current?.autoBetPlaced ?? false,
autoBetError:
autoRaw['autoBetError'] as String? ?? current?.autoBetError,
);
emit(state.copyWith(gameState: gs.copyWith(autoSettings: merged)));
_startPolling();
}
break;
default:
break;
}
}
Future<void> _onHistoryPage(PredictionHistoryPageRequested event, Emitter<PredictionState> emit) async {
await _refreshHistoryFromServer(
emit,
page: event.page,
append: event.append,
showSpinnerIfEmpty: !event.append,
);
}
Future<void> _onHistoryFilterChanged(
PredictionHistoryFilterChanged event,
Emitter<PredictionState> emit,
) async {
final cached = historyFilterStore.peek(
_historyKey(
wallet: event.walletFilter,
status: event.statusFilter,
),
);
emit(state.copyWith(
historyWalletFilter: event.walletFilter,
historyStatusFilter: event.statusFilter,
clearHistoryWalletFilter: event.walletFilter == null,
clearHistoryStatusFilter: event.statusFilter == null,
history: cached?.items ?? const [],
historyPage: cached?.page ?? 1,
historyTotalPages: cached?.totalPages ?? 1,
isLoadingHistory: cached == null,
));
await _refreshHistoryFromServer(
emit,
page: 1,
showSpinnerIfEmpty: cached == null,
);
}
Future<void> _onOlderCandles(PredictionCandlesOlderRequested event, Emitter<PredictionState> emit) async {
if (state.candles.isEmpty ||
state.isLoadingOlderCandles ||
!state.hasMoreOlderCandles) {
return;
}
emit(state.copyWith(isLoadingOlderCandles: true, clearCandlesError: true));
try {
final oldest = state.candles.first;
final pageSize = (state.gameState?.interval.chartCandleLimit ?? 80).clamp(20, 200);
final page = await _repo.getCandlesPage(
intervalMinutes: state.selectedIntervalMinutes,
beforeOpenMs: oldest.openMs,
limit: pageSize,
);
final merged = _mergeCandles(page.items, state.candles);
_rememberCandles(
state.selectedIntervalMinutes,
merged,
page.hasMore,
);
emit(state.copyWith(
candles: merged,
hasMoreOlderCandles: page.hasMore,
isLoadingOlderCandles: false,
clearCandlesError: true,
));
} catch (e) {
emit(state.copyWith(
isLoadingOlderCandles: false,
candlesError: e.toString().replaceFirst('Exception: ', ''),
));
}
}
Future<void> _onCandlesReload(
PredictionCandlesReloadRequested event,
Emitter<PredictionState> emit,
) async {
emit(state.copyWith(
isLoadingOlderCandles: true,
clearCandlesError: true,
));
try {
final pageSize =
(state.gameState?.interval.chartCandleLimit ?? 80).clamp(20, 200);
final page = await _repo.getCandlesPage(
intervalMinutes: state.selectedIntervalMinutes,
limit: pageSize,
);
_rememberCandles(
state.selectedIntervalMinutes,
page.items,
page.hasMore,
);
emit(state.copyWith(
candles: page.items,
hasMoreOlderCandles: page.hasMore,
isLoadingOlderCandles: false,
clearCandlesError: true,
));
} catch (e) {
emit(state.copyWith(
isLoadingOlderCandles: false,
candlesError: e.toString().replaceFirst('Exception: ', ''),
));
}
}
static PredictionModel? _userBetForRound(PredictionModel? bet, RoundModel? round) {
if (bet == null || round == null) return null;
return bet.belongsToRound(round) ? bet : null;
}
static List<OhlcCandleModel> _mergeCandles(
List<OhlcCandleModel> a,
List<OhlcCandleModel> b,
) {
if (a.isEmpty) return List<OhlcCandleModel>.from(b);
if (b.isEmpty) return List<OhlcCandleModel>.from(a);
final map = <int, OhlcCandleModel>{};
for (final c in a) {
map[c.openMs] = c;
}
for (final c in b) {
map[c.openMs] = c;
}
final merged = map.values.toList()
..sort((x, y) => x.openMs.compareTo(y.openMs));
return merged;
}
double _defaultStake(PredictConfigModel config) {
if (config.stakeAmounts.isNotEmpty) return config.stakeAmounts.first;
return config.minStakeAmount;
}
/// Keep countdown stable: reject older cycles, merge absolute deadlines,
/// and ignore timer-only round ticks.
GameStateModel _stabilizeGameStateRound({
required GameStateModel? previous,
required GameStateModel incoming,
bool forceRound = false,
}) {
final incomingRound = incoming.round;
if (incomingRound == null) return incoming;
if (isIncomingRoundStale(previous?.round, incomingRound)) {
return incoming.copyWith(round: previous!.round);
}
final merged = mergeRound(previous?.round, incomingRound);
if (!forceRound &&
previous?.round != null &&
!roundUiChanged(previous!.round, merged)) {
return incoming.copyWith(round: previous.round);
}
return incoming.copyWith(round: merged);
}
List<String> _initialMultiSequence(GameStateModel gs) {
final level = gs.multiLevels.isNotEmpty ? gs.multiLevels.first : null;
if (level == null) return const ['long', 'long'];
return List.filled(level.candleCount, 'long');
}
/// Patch history rows with live multi-candle step/status so the list updates
/// without waiting for a full HTTP history reload.
List<PredictionModel> _historyWithMultiProgress(
List<PredictionModel> history,
MultiCandlePredictionModel multi,
) {
var found = false;
final updated = history.map((p) {
if (p.id != multi.id) return p;
found = true;
return PredictionModel(
id: multi.id,
direction: multi.sequenceDirections.isNotEmpty
? multi.sequenceDirections.first
: p.direction,
stakeDisplay: multi.stakeDisplay,
status: multi.status,
payoutDisplay: multi.payoutDisplay,
createdAt: p.createdAt,
stakeAccountKind: p.stakeAccountKind,
isAuto: p.isAuto,
predictionMode: 'multi_candle',
level: multi.level,
sequenceDirections: multi.sequenceDirections,
sequenceStep: multi.sequenceStep,
intervalMinutes: multi.intervalMinutes,
);
}).toList();
if (found) return updated;
final live = PredictionModel(
id: multi.id,
direction: multi.sequenceDirections.isNotEmpty
? multi.sequenceDirections.first
: 'long',
stakeDisplay: multi.stakeDisplay,
status: multi.status,
payoutDisplay: multi.payoutDisplay,
createdAt: DateTime.now().toIso8601String(),
stakeAccountKind: multi.stakeAccountKind,
predictionMode: 'multi_candle',
level: multi.level,
sequenceDirections: multi.sequenceDirections,
sequenceStep: multi.sequenceStep,
intervalMinutes: multi.intervalMinutes,
);
if (!_matchesHistoryFilters(live)) return history;
return [live, ...history];
}
/// Ensure a single/auto prediction appears at the top of Recent predictions.
List<PredictionModel> _historyWithPrediction(
List<PredictionModel> history,
PredictionModel bet,
) {
if (!_matchesHistoryFilters(bet)) return history;
final without = history.where((p) => p.id != bet.id).toList();
return [bet, ...without];
}
}