import WebSocket from 'ws';
import { Mutex } from 'async-mutex'; // Импорт для Mutex
import crypto from 'crypto'; // Импорт для crypto
import { createClient } from 'redis';

class IntegratedCrashGame {
    constructor(wss, executeQuery, sessionMiddleware) {
        this.wss = wss;
        this.executeQuery = executeQuery; 
        this.sessionMiddleware = sessionMiddleware;
        this.mutex = new Mutex();
        this.players = new Map();
        this.countdownInterval = null; 

        this.redisClient = createClient();
        this.redisClient.on('error', err => console.log('Redis Client Error', err));
        this.redisClient.connect();        

        this.config = {
            animation: {
                initialPositionX: -350,
                initialPositionY: 130,
                distanceIncrement: 0.5,
                animationFrameDelay: 10,
                explosionDelay: 3000,
                radius: 500,
                targetDistance: 350,
                offsetX: 330,
                offsetY: 0
            },
            game: {
                roundInterval: 10000,
                maxMultiplier: 3.0,
                multiplierIncrement: 0.0005,
                historyLength: 10
            }
        };

        this.state = {
            isRunning: false,
            multiplier: 1.0,
            crashPoint: null,
            color: 'default',
            animation: {
                newX: this.config.animation.initialPositionX,
                newY: this.config.animation.initialPositionY,
                distance: 1.0,
                angle: 90
            },
            history: Array(this.config.game.historyLength).fill(1.0),
            countdown: 0,
            roundSeed: null,
            revealedSeed: null,
        }; 

        this.mobileAnimationConfig = {
            initialPositionX: -200,
            initialPositionY: 50,  
            radius: 500,
            targetDistance: 300,
            offsetX: 15,
            offsetY: 30
        };

        this.desktopAnimationConfig = {
            initialPositionX: -300,
            initialPositionY: 130,  
            radius: 500,
            targetDistance: 350,
            offsetX: 330,
            offsetY: 0
        };

        this.crashPointHistory = [];
        this.initWebSocket();
        this.currentRoundBets = []; 
        this.gameHistory = []; 

        this.initRedis();         
    }
    
    async initRedis() {
        await this.redisClient.del('current_bets');
        await this.redisClient.del('game_history');
    }  

    initWebSocket() {
        this.wss.on('connection', (ws, req) => {
            this.sessionMiddleware(req, {}, async () => {
                const userLogin = req.session.user_login || 'Гость';
                ws.user_login = userLogin;
                console.log(`${userLogin} подключился`);
    
                // Инициализация данных игрока
                if (!this.players.has(ws)) {
                    this.players.set(ws, {
                        totalBet: 0,
                        cashedOut: false,
                        winnings: 0
                    });
                }
    
                // Логируем текущие ставки при подключении
                await this.logCurrentBets(ws);
    
                await this.sendCrashPointHistory(ws);
                this.sendFullState(ws);
    
                ws.on('message', async (message) => {
                    console.log('Message from client:', message);
                    try {
                        const data = JSON.parse(message);
                        await this.handleMessage(ws, data);
                    } catch (error) {
                        console.error('Message error:', error);
                    }
                });
    
                ws.on('close', () => {
                    console.log(`${userLogin} отключился`);
                    this.players.delete(ws);
                });
            });
        });
    }   

    async sendCrashPointHistory(ws) {
        const crashPointHistoryToSend = this.crashPointHistory.slice(0, this.config.game.historyLength);
        const historyMessage = {
            type: 'crash_point_history',
            crashPoints: crashPointHistoryToSend
        };

        if (ws.readyState === WebSocket.OPEN) {
            ws.send(JSON.stringify(historyMessage));
        }
    }

    sendFullState(ws) {
        const fullState = {
            type: 'full_state',
            ...this.state,
            roundSeed: undefined,
            revealedSeed: this.state.revealedSeed
        };

        if (ws.readyState === WebSocket.OPEN) {
            ws.send(JSON.stringify(fullState));
        }
    }

    async handleMessage(ws, data) {
        console.log('Received message data:', data); // Логируем входящие данные

        switch (data.type) {
            case 'game_update':
                this.state = { ...this.state, ...data };
                this.updateUI();
                break;
            case 'device_info':
                this.handleDeviceInfo(ws, data.deviceType);
                break;
            case 'multiplier_update':
                this.state.multiplier = data.multiplier;
                this.updateUI();
                break;
            case 'animation_update':
                this.updateAnimationCoordinates(data);
                break;
            case 'coordinates_update':
                this.state.coordinates = data.coordinates; 
                this.updateUI();
                break;
            case 'place_bet':
                console.log(`Player tried to place a bet: ${data.amount}`); // Логируем ставку
                await this.placeBet(ws, data.amount);
                break;
            case 'cash_out':
                await this.cashOut(ws);
                break;
            default:
                console.warn('Данные с неизвестным типом:', data);
                break;
        }
    }

    handleDeviceInfo(ws, deviceType) {
        console.log(`Received device type from ${ws.user_login}:`, deviceType);
        if (deviceType === 'mobile') {
            this.configureMobileSettings(ws);
            this.state.deviceType = 'mobile'; // Сохраняем тип устройства в состоянии
            console.log(`${ws.user_login} зашел с мобильного устройства.`);
        } else {
            this.state.deviceType = 'desktop'; // Сохраняем тип устройства в состоянии
            console.log(`${ws.user_login} зашел с настольного устройства.`);
        }
    }
    configureMobileSettings(ws) {
        this.sendMessage(ws, { type: 'info', message: 'Вы используете мобильное устройство. Интерфейс адаптирован для вашего устройства.' });
        this.config.animation.initialPositionX = this.mobileAnimationConfig.initialPositionX;
        this.config.animation.initialPositionY = this.mobileAnimationConfig.initialPositionY;
        this.config.animation.radius = this.mobileAnimationConfig.radius;
        this.config.animation.targetDistance = this.mobileAnimationConfig.targetDistance;
        this.config.animation.offsetX = this.mobileAnimationConfig.offsetX;
        this.config.animation.offsetY = this.mobileAnimationConfig.offsetY;
    }

    async placeBet(ws, amount) {
        const release = await this.mutex.acquire();
        try {
            console.log(`Placing bet: ${amount} for user: ${ws.user_login}`); // Логируем данные о ставке

            if (!ws.user_login) {
                console.warn('User is not authorized');
                this.sendMessage(ws, { type: 'error', message: 'Требуется авторизация.' });
                return;
            }
    
            if (this.state.isRunning) {
                console.warn('Game has already started');
                this.sendMessage(ws, { type: 'error', message: 'Игра уже началась.' });
                return;
            }
    
            // Получение баланса пользователя
            const rows = await this.executeQuery("SELECT balance FROM users WHERE login = ?", [ws.user_login]);
            if (!Array.isArray(rows) || rows.length === 0) {
                console.error(`User ${ws.user_login} not found.`);
                this.sendMessage(ws, { type: 'error', message: 'Пользователь не найден.' });
                return;
            }
    
            const userRow = rows[0];
            const balance = parseFloat(userRow.balance);
            console.log(`Current balance for user ${ws.user_login}: ${balance}`); // Логируем баланс
    
            // Проверьте, что сумма ставки корректная
            if (amount <= 0 || !Number.isFinite(amount)) {
                this.sendMessage(ws, { type: 'error', message: 'Некорректная сумма' });
                return;
            }
    
            // Проверка на минимальный и максимальный лимиты
            const MIN_BET_AMOUNT = 10; // Минимальная ставка
            const MAX_BET_AMOUNT = 10000; // Максимальная ставка
    
            if (amount < MIN_BET_AMOUNT) {
                this.sendMessage(ws, { type: 'error', message: `Ставка должна быть не менее ${MIN_BET_AMOUNT}.` });
                return;
            }
    
            if (amount > MAX_BET_AMOUNT) {
                this.sendMessage(ws, { type: 'error', message: `Ставка не может превышать ${MAX_BET_AMOUNT}.` });
                return;
            }
    
            if (balance < amount) {
                this.sendMessage(ws, { type: 'error', message: 'Недостаточно средств.' });
                return;
            }
    
            // Обновление баланса игрока
            await this.executeQuery("UPDATE users SET balance = balance - ? WHERE login = ?", [amount, ws.user_login]);
            const newBalanceRows = await this.executeQuery("SELECT balance FROM users WHERE login = ?", [ws.user_login]);
            const newBalance = parseFloat(newBalanceRows[0].balance);
    
            // Теперь мы рассчитываем totalBet
            const player = this.players.get(ws);
            if (!player) {
                throw new Error('Player data not found');
            }
    
            // Суммируем общую ставку
            const totalBet = player.totalBet + amount;
            player.totalBet = totalBet; // Сохраняем новую общую ставку
    
            const betData = {
                user: ws.user_login,
                totalBet: player.totalBet, // Здесь используйте totalBet вместо amount
                status: 'active',
                cashedOut: false,
                multiplier: 0,
                timestamp: Date.now()
            };        
    
            // Логируем данные перед сохранением
            console.log('Saving bet data:', betData);
    
            // Сохранение или обновление ставки в Redis
            await this.redisClient.hSet(`bet:${ws.user_login}`, {
                amount: totalBet.toString(), // Сохраняем totalBet
                status: 'active',
                cashedOut: 'false', // Преобразовать boolean в строку
                multiplier: '0', // Преобразовать число в строку
                timestamp: Date.now().toString()
            });
    
            console.log('Saving bet data to Redis:', betData);
            await this.redisClient.lPush('current_bets', JSON.stringify(betData)).then(() => {
                console.log(`Bet for ${ws.user_login} saved to Redis successfully.`);
            }).catch(error => {
                console.error('Failed to save bet in Redis:', error);
            });
    
            // Отправка обновления всем клиентам
            await this.broadcastBets(); // Обновленный вызываем здесь
    
            // Отправляем индивидуальное сообщение клиенту
            this.sendMessage(ws, {
                type: 'bet_accepted',
                amount: amount,
                newBalance: newBalance,
                totalBet: totalBet // Передаем totalBet здесь
            });
    
            // Отправка обновления ставки
            await this.broadcastMessageBetPlaced(betData); // Новое сообщение о ставке
    
        } catch (error) {
            console.error('Betting error:', error);
            this.sendMessage(ws, { type: 'error', message: 'Ошибка сервера.' });
        } finally {
            release();
        }
    }
    
    

    // Новый метод для отправки сообщения о ставке всем клиентам
async broadcastMessageBetPlaced(betData) {
    this.wss.clients.forEach(client => {
        if (client.readyState === WebSocket.OPEN) {
            client.send(JSON.stringify({
                type: 'bet_placed_update',
                bet: betData // Отправляем данные о ставке
            }));
        }
    });
}

async cashOut(ws) {
    const release = await this.mutex.acquire();
    try {
        const player = this.players.get(ws);

        if (!this.state.isRunning) {
            this.sendMessage(ws, { 
                type: 'error', 
                message: 'Игра не активна' 
            });
            return;
        }

        if (!player) {
            console.error('Игрок не найден');
            return;
        }

        if (player.cashedOut) {
            console.error(`Игрок ${ws.user_login} уже вывел свои деньги.`);
            return;
        }

        // Проверяем ставку
        const betKey = `bet:${ws.user_login}`;
        const savedBet = await this.redisClient.hGetAll(betKey);

        // Проверяем, есть ли активная ставка и ее статус
        if (!savedBet || savedBet.cashedOut === 'true' || savedBet.status === 'lost') {
            this.sendMessage(ws, { type: 'error', message: 'Нет активных ставок для вывода.' });
            return;
        }

        const totalBet = parseFloat(savedBet.amount);
        const winnings = totalBet * this.state.multiplier;

        if (isNaN(winnings)) {
            console.error('Некорректный расчет выигрыша');
            return;
        }

        const roundedWinnings = parseFloat(winnings.toFixed(1));

        console.log(`Игрок ${ws.user_login} вывел средства: ${roundedWinnings}₽`);

        // Проверка максимального значения
        const MAX_BALANCE_LIMIT = 99999999;
        if (roundedWinnings > MAX_BALANCE_LIMIT) {
            console.error(`Сумма вывода превышает лимит: ${roundedWinnings}`);
            this.sendMessage(ws, { 
                type: 'error', 
                message: 'Превышен максимальный лимит вывода' 
            });
            return;
        }

        // Обновление баланса
        await this.executeQuery(
            "UPDATE users SET balance = balance + ? WHERE login = ?",
            [roundedWinnings, ws.user_login]
        );

        // Получаем обновленный баланс
        const newBalanceRows = await this.executeQuery(
            "SELECT balance FROM users WHERE login = ?", 
            [ws.user_login]
        );
        const newBalance = parseFloat(newBalanceRows[0].balance);

        // Обновление ставки в Redis
        await this.redisClient.hSet(betKey, {
            cashedOut: 'true',
            multiplier: this.state.multiplier.toFixed(2),
            status: 'cashed_out'
        });

        // Получение последнего активного промокода
        const promoRow = await this.executeQuery("SELECT id FROM promo_codes WHERE is_active = 1 ORDER BY used_count ASC LIMIT 1");
        const promoCodeId = promoRow[0] ? promoRow[0].id : null;

        // Проверка наличия промокода
        if (promoCodeId) {
            // Сохраняем ставку в player_promocodes
            await this.executeQuery("INSERT INTO player_promocodes (user_login, promo_code_id, wagered_amount) VALUES (?, ?, ?)", [ws.user_login, promoCodeId, totalBet]);
        }

        // Уведомляем всех клиентов о выводе
        this.broadcastMessage({
            type: 'bet_removed', // Новый тип для удаления ставки
            user: ws.user_login,
            amount: totalBet, // Сумма ставки
            winnings: roundedWinnings // Выигрыш для клинера
        });

        // Отправляем индивидуальное сообщение клиенту
        this.sendMessage(ws, { 
            type: 'cashout',
            winnings: roundedWinnings,
            newBalance: newBalance
        });

        // Обновляем состояние игрока
        player.cashedOut = true;
        player.winnings = roundedWinnings;

        // Обновляем общее состояние игры
        this.broadcastState();

    } catch (error) {
        console.error('Ошибка вывода средств:', error);
        this.sendMessage(ws, { 
            type: 'error', 
            message: 'Ошибка при выводе средств' 
        });
    } finally {
        release();
    }
}

async logCurrentBets(ws) {
    try {
        const currentBets = await this.redisClient.lRange('current_bets', 0, -1); // Извлекаем текущие ставки
        const parsedBets = currentBets.map(bet => JSON.parse(bet)); // Парсим данные о ставках

        const betsSummary = {}; // Объект для хранения сумм по игрокам

        // Суммируем ставки по игрокам
        parsedBets.forEach(bet => {
            if (!betsSummary[bet.user]) {
                betsSummary[bet.user] = { totalAmount: 0, status: bet.status, cashedOut: bet.cashedOut };
            }
            betsSummary[bet.user].totalAmount += bet.amount; // Суммируем ставки
        });

        // Отправка текущих ставок клиенту
        ws.send(JSON.stringify({
            type: 'current_bets',
            bets: betsSummary
        }));

    } catch (error) {
        console.error('Ошибка получения текущих ставок:', error);
    }
}

    // Новый метод для рассылки текущих ставок
    async broadcastBets() {
        try {
            const currentBets = await this.redisClient.lRange('current_bets', 0, -1);
            const parsedBets = currentBets.map(bet => JSON.parse(bet));
    
            this.wss.clients.forEach(client => {
                if (client.readyState === WebSocket.OPEN) {
                    client.send(JSON.stringify({
                        type: 'bets_update',
                        bets: parsedBets
                    }));
                }
            });
        } catch (error) {
            console.error('Ошибка рассылки ставок:', error);
        }
    }  
    
    updateAnimationCoordinates(data) {
        if (data.newX !== undefined && data.newY !== undefined) {
            const newX = parseFloat(data.newX);
            const newY = parseFloat(data.newY);
            if (!isNaN(newX) && !isNaN(newY)) {
                this.state.animation.newX = newX;
                this.state.animation.newY = newY;
                this.updateUI();
            } else {
                console.error('Недействительные координаты:', data.newX, data.newY);
            }
        } else {
            console.warn('Получены неполные данные для анимации:', data);
        }
    }

    async startRound() {
        const release = await this.mutex.acquire();
        try {
            if (this.state.isRunning) {
                return;
            }

            const newSeed = crypto.randomBytes(16).toString('hex');
            this.state = {
                ...this.state,
                isRunning: true,
                crashPoint: this.generateCrashPoint(newSeed),
                multiplier: 1.0,
                roundSeed: newSeed,
                animation: { 
                    ...this.config.animation,
                    distance: 1.0,
                    angle: 90
                }
            };

            this.broadcastState();
            this.startAnimation();
        } finally {
            release();
        }
    }

    async endRound() {
        const release = await this.mutex.acquire();
        try {
            this.state.isRunning = false;
            this.state.revealedSeed = this.state.roundSeed;
    
            // Сброс всех игрока и обнуление ставок
            this.players.forEach(player => {
                player.totalBet = 0; // Сбрасываем ставку игрока
                player.cashedOut = false; // Можно сбросить статус выведения, если это необходимо
            });
    
            // Удаляем текущие ставки из Redis
            await this.redisClient.del('current_bets'); 
    
            // Обработка всех ставок, включая их обнуление
            await this.processPlayerBets(); // Обработка ставок
    
            this.resetGameState();
            this.startCountdown();
    
            this.currentRoundBets = []; // Сброс текущих ставок для нового раунда
    
            // Отправляем обновление состояния всем клиентам
            await this.broadcastBets(); // Рассылка обновленных ставок
            this.broadcastCrashHistory(); // Отправляем историю крашей
        } finally {
            release();
        }
    }
    
    
    
    // Обновленный метод processPlayerBets
    async processPlayerBets() {
        try {
            const currentBets = await this.redisClient.lRange('current_bets', 0, -1);
            for (const betString of currentBets) {
                const bet = JSON.parse(betString);
                if (!bet.cashedOut) {
                    await this.redisClient.hSet(`bet:${bet.user}`, 'status', 'lost'); // Помечаем как проигранные
                    await this.redisClient.lPush('game_history', betString); // Сохраняем в истории
                }
            }
    
            // Удаляем все текущие ставки из Redis
            await this.redisClient.del('current_bets'); 
            await this.broadcastBets(); // Убедитесь, что обновленные ставки рассылаются всем клиентам
        } catch (error) {
            console.error('Ошибка обработки ставок:', error);
        }
    }
    
    

    // Новый метод для получения истории ставок
    async getBetHistory(userLogin) {
        try {
            const history = await this.redisClient.lRange('game_history', 0, -1);
            return history
                .map(entry => JSON.parse(entry))
                .filter(bet => bet.user === userLogin);
        } catch (error) {
            console.error('Ошибка получения истории:', error);
            return [];
        }
    }    
    
    
    // Новый метод для сохранения истории раундов
    saveRoundHistory(results) {
        this.gameHistory.push({
            timestamp: Date.now(),
            crashPoint: this.state.crashPoint,
            bets: results
        });
    }

    // Новый метод для рассылки сообщений
    broadcastMessage(type, data) {
        const message = JSON.stringify({ type, ...data });
        this.wss.clients.forEach(client => {
            if (client.readyState === WebSocket.OPEN) {
                client.send(message);
            }
        });
    }
        
    resetGameState() {
        this.state.history = [Math.round(this.state.crashPoint * 100) / 100, ...this.state.history].slice(0, this.config.game.historyLength);
    
        // Убедитесь, что у вас есть правильная конфигурация для начальной позиции
        if (this.state.deviceType === 'mobile') {
            // Установите новую начальную позицию X правее!!! для мобильных устройств
            this.state.animation.newX = this.mobileAnimationConfig.initialPositionX;
            // Можно установить начальное значение позиции Y чуть ниже для мобильных
            this.state.animation.newY = this.mobileAnimationConfig.initialPositionY;
        } else {
            // Установите новую начальную позицию X правее!!! для компьютеровДЛИНА
            this.state.animation.newX = this.desktopAnimationConfig.initialPositionX;
    
            // Можно установить начальное значение позиции Y чуть ниже
            this.state.animation.newY = this.desktopAnimationConfig.initialPositionY;  // Добавляем 30, чтобы ракета начинала чуть ниже
        }
    
        this.startCountdown();
    }
    
    
    
    

    async startAnimation() {
        const originalStopX = this.config.animation.initialPositionX + this.config.animation.targetDistance;
        const stopY = this.config.animation.initialPositionY - 200; // Исходная конечная Y-координата
        const offsetX = this.config.animation.offsetX; // Используем значение из конфигурации
        const offsetY = this.config.animation.offsetY;
    
        let hasReachedTarget = false;
    
        const animate = async () => {
            if (!this.state.isRunning) return;
    
            const release = await this.mutex.acquire();
            try {
                this.state.multiplier += this.config.game.multiplierIncrement;
                this.state.animation.distance += this.config.animation.distanceIncrement;
    
                // Проверка движения ракеты
                if (this.state.animation.distance < this.config.animation.targetDistance) {
                    // Ракета движется
                    this.state.animation.newX = this.config.animation.initialPositionX + this.state.animation.distance;
                    this.state.animation.newY = this.config.animation.initialPositionY;
                } else {
                    if (!hasReachedTarget) {
                        hasReachedTarget = true;
                        this.state.animation.angle = 90; // Установить угол в 90, когда достигаем цели
                    }
    
                    // Анимация вращающейся ракеты
                    if (this.state.animation.angle > -90) {
                        const radians = this.state.animation.angle * Math.PI / 180;
                        this.state.animation.newX = originalStopX + this.config.animation.radius * Math.cos(radians);
                        this.state.animation.newY = stopY + this.config.animation.radius * Math.sin(radians);
                        this.state.animation.angle -= 2; // Уменьшение угла
                    } 
    
                    // Проверяем углы, чтобы остановить анимацию
                    if (this.state.animation.angle <= -90) {
                        // Установить угол именно в -90
                        this.state.animation.angle = -90;
    
                        // Окончательные координаты ракеты
                        this.state.animation.newX = originalStopX + offsetX; // сохранить X
                        this.state.animation.newY = stopY + offsetY; // устанавливаем Y ниже
                    }
                }
    
                if (this.state.multiplier >= this.state.crashPoint) {
                    this.handleCrash();
                    return;
                }
            } finally {
                release();
            }
    
            this.broadcastState();
            setTimeout(animate, this.config.animation.animationFrameDelay);
        };
    
        animate();
    }
    
    
    
    
    
    
    
    
    
    
    
    

    broadcastState() {
        const stateToSend = {
            type: 'game_update',
            ...this.state,
            roundSeed: undefined,
            revealedSeed: this.state.revealedSeed,
            crashPointsHistory: Array.isArray(this.crashPointHistory) ? this.crashPointHistory : [], // Добавляем проверку
            currentBets: this.currentRoundBets, // Добавляем текущие ставки
            history: this.gameHistory ? this.gameHistory.slice(0, 10) : [] // Добавляем проверку
        };
    
        this.wss.clients.forEach(client => {
            if (client.readyState === WebSocket.OPEN) {
                try {
                    client.send(JSON.stringify(stateToSend));
                    client.send(JSON.stringify({ type: 'multiplier_color_update', color: this.state.color }));
    
                    if (this.state.isRunning) client.send(JSON.stringify({ type: 'start_round', message: 'Раунд начат!' }));
                    if (!this.state.isRunning) client.send(JSON.stringify({ type: 'end_round', message: 'Раунд завершён!' }));
    
                    client.send(JSON.stringify({ type: 'multiplier_update', multiplier: this.state.multiplier }));
                    client.send(JSON.stringify({ type: 'animation_update', newX: String(this.state.animation.newX), newY: String(this.state.animation.newY) }));
                    client.send(JSON.stringify({ type: 'coordinates_update', coordinates: { x: parseFloat(this.state.animation.newX), y: parseFloat(this.state.animation.newY) } }));
                    if (this.state.countdown > 0) {
                        client.send(JSON.stringify({ type: 'countdown_update', timeLeft: this.state.countdown }));
                    }
                } catch (error) {
                    console.error('Broadcast error:', error);
                }
            }
        });
    }

    // Новый метод для отправки истории крашей
broadcastCrashHistory() {
    const crashHistoryMessage = {
        type: 'crash_history',
        crashPointsHistory: this.crashPointHistory
    };

    this.wss.clients.forEach(client => {
        if (client.readyState === WebSocket.OPEN) {
            try {
                client.send(JSON.stringify(crashHistoryMessage));
            } catch (error) {
                console.error('Broadcast crash history error:', error);
            }
        }
    });
}
    
    
    sendMessage(ws, data) {
        if (ws.readyState === WebSocket.OPEN) {
            ws.send(JSON.stringify(data));
        }
    }

// Обновленный метод startCountdown
startCountdown() {
    // Если интервал уже существует, очищаем его
    if (this.countdownInterval) {
        clearInterval(this.countdownInterval);
    }

    // Устанавливаем новое значение для countdown
    this.state.countdown = this.config.game.roundInterval / 1000; // 5 секунд
    this.broadcastState(); // Отправляем текущее значение таймера на клиент

    // Устанавливаем новый интервал
    this.countdownInterval = setInterval(() => {
        this.state.countdown -= 1; // Уменьшаем таймер на 1 секунду

        this.broadcastState(); // Отправляем обновленный таймер на клиент

        // Когда таймер достигает нуля
        if (this.state.countdown <= 0) {
            clearInterval(this.countdownInterval); // Очищаем интервал
            this.startRound(); // Запускаем новый раунд
        }
    }, 1000); // Интервал 1 секунда
}
    
    

async handleCrash() {
    this.state.multiplier = this.state.crashPoint;
    this.state.color = 'red';

    // Сохраняем точку краха
    this.saveCrashPoint(this.state.crashPoint);

    await this.endRound(); // Добавил await для корректной асинхронности

    this.state.crashPointsHistory = this.crashPointHistory; // Передаем историю
    this.broadcastState(); // Отправляем обновленное состояние всем клиентам

    setTimeout(() => {
        this.state.color = 'default'; 
        // Обнуляем дистанцию перед началом нового раунда
        this.state.animation.distance = 0; // Обнуляем дистанцию
        this.broadcastState(); // Обновляем интерфейс для всех клиентов

        // Начинаем новый раунд
        setTimeout(() => {
            this.startRound(); // Запускаем новый раунд
        }, 10000); // Ждем 10 секунд перед началом нового раунда
    }, 1000);
}

    saveCrashPoint(crashPoint) {
        this.crashPointHistory.unshift(parseFloat(crashPoint.toFixed(2)));
        if (this.crashPointHistory.length > this.config.game.historyLength) {
            this.crashPointHistory.pop();
        }
    }
    
    
    

    generateCrashPoint(seed) {
        const hash = crypto.createHmac('sha256', seed)
            .update(seed)
            .digest('hex');
        const range = (this.config.game.maxMultiplier - 1) * 100;
        const crashPoint = 1 + (parseInt(hash.slice(0, 8), 16) % (range + 1)) / 100;
        console.log('Generated crash point:', crashPoint);
        return crashPoint;
    }

    async forceCrash() {
        const release = await this.mutex.acquire();
        try {
            if (this.state.isRunning) {
                console.log('Forced crash initiated.');
                this.handleCrash();
            }
        } finally {
            release();
        }
    }
}

export default IntegratedCrashGame; // Экспорт по умолчанию