server.js

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const path = require('path');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
    cors: {
        origin: "*",
        methods: ["GET", "POST"]
    }
});

// Serve static files
app.use(express.static(path.join(__dirname)));

// Game rooms storage
const gameRooms = new Map();

class GameRoom {
    constructor(roomId) {
        this.roomId = roomId;
        this.players = [];
        this.gameState = {
            currentPlayer: 1,
            round: 1,
            maxRounds: 10,
            scores: { player1: 0, player2: 0 },
            gamePhase: 'waiting', // waiting, showing-target, placing-needle, scored
            targetAngle: 0,
            targetRange: 20,
            needleAngle: 0,
            isGameStarted: false
        };
    }

    addPlayer(socket, playerName) {
        if (this.players.length >= 2) {
            return false; // Room is full
        }

        const playerNumber = this.players.length + 1;
        const player = {
            socket: socket,
            id: socket.id,
            name: playerName || `Player ${playerNumber}`,
            playerNumber: playerNumber
        };

        this.players.push(player);
        socket.join(this.roomId);
        
        console.log(`Player ${player.name} joined room ${this.roomId}`);
        
        // Notify all players in the room (send only serializable data)
        this.broadcastToRoom('player-joined', {
            player: { name: player.name, playerNumber: player.playerNumber },
            playerCount: this.players.length,
            gameState: { ...this.gameState }
        });

        // If room is full, prepare to start game
        if (this.players.length === 2) {
            this.gameState.isGameStarted = true;
            this.broadcastToRoom('game-ready', {
                players: this.getSerializablePlayers(),
                gameState: { ...this.gameState }
            });
        }

        return { 
            id: player.id, 
            name: player.name, 
            playerNumber: player.playerNumber 
        };
    }

    getSerializablePlayers() {
        return this.players.map(p => ({ 
            name: p.name, 
            playerNumber: p.playerNumber 
        }));
    }

    removePlayer(socketId) {
        const playerIndex = this.players.findIndex(p => p.id === socketId);
        if (playerIndex === -1) return false;

        const removedPlayer = this.players.splice(playerIndex, 1)[0];
        console.log(`Player ${removedPlayer.name} left room ${this.roomId}`);

        // Reset game if a player leaves
        this.gameState.isGameStarted = false;
        this.resetGame();

        this.broadcastToRoom('player-left', {
            player: { name: removedPlayer.name, playerNumber: removedPlayer.playerNumber },
            playerCount: this.players.length,
            gameState: { ...this.gameState }
        });

        return true;
    }

    startRound() {
        this.gameState.gamePhase = 'target-shown';
        this.generateTargetPosition();
        
        this.broadcastToRoom('round-started', {
            targetAngle: this.gameState.targetAngle,
            targetRange: this.gameState.targetRange,
            gameState: { ...this.gameState }
        });
    }

    generateTargetPosition() {
        this.gameState.targetAngle = 10 + Math.random() * 160;
        console.log(`Room ${this.roomId}: Target angle: ${this.gameState.targetAngle}°`);
    }

    showTarget() {
        // This is now called when the guide player enables needle placement
        this.gameState.gamePhase = 'placing-needle';
        
        this.broadcastToRoom('target-hidden', {
            gameState: { ...this.gameState }
        });
    }

    hideTarget() {
        this.gameState.gamePhase = 'placing-needle';
        
        this.broadcastToRoom('target-hidden', {
            gameState: { ...this.gameState }
        });
    }

    placeNeedle(needleAngle) {
        console.log(`Room ${this.roomId}: Placing needle at ${needleAngle}°, target was ${this.gameState.targetAngle}°`);
        this.gameState.needleAngle = needleAngle;
        
        // Calculate score
        const angleDifference = Math.abs(needleAngle - this.gameState.targetAngle);
        let points = 0;
        let message = '';
        
        // Zones are defined as total ranges, but we need to check half-ranges from center
        // 5° zone = ±2.5° from center
        // 15° zone = ±7.5° from center
        // 25° zone = ±12.5° from center
        if (angleDifference <= 2.5) {
            points = 5;
            message = 'Parfait!';
        } else if (angleDifference <= 7.5) {
            points = 3;
            message = 'Très bien!';
        } else if (angleDifference <= 12.5) {
            points = 1;
            message = 'Pas mal!';
        } else {
            points = 0;
            message = 'Manqué!';
        }

        console.log(`Room ${this.roomId}: Angle difference: ${angleDifference}°, Points: ${points}`);

        // Update score
        this.gameState.scores[`player${this.gameState.currentPlayer}`] += points;
        this.gameState.gamePhase = 'scored';

        this.broadcastToRoom('needle-placed', {
            needleAngle: needleAngle,
            targetAngle: this.gameState.targetAngle,
            points: points,
            message: message,
            angleDifference: angleDifference,
            gameState: { ...this.gameState }
        });
        
        console.log(`Room ${this.roomId}: Score updated and needle-placed event sent`);
    }

    nextTurn() {
        // Switch player or advance round
        if (this.gameState.currentPlayer === 1) {
            this.gameState.currentPlayer = 2;
        } else {
            this.gameState.currentPlayer = 1;
            this.gameState.round++;
        }

        if (this.gameState.round > this.gameState.maxRounds) {
            this.endGame();
            return;
        }

        this.gameState.gamePhase = 'waiting';
        this.gameState.needleAngle = 90; // Reset needle

        this.broadcastToRoom('turn-changed', {
            gameState: { ...this.gameState }
        });
    }

    endGame() {
        this.gameState.gamePhase = 'ended';
        const winner = this.gameState.scores.player1 > this.gameState.scores.player2 ? 1 : 
                      this.gameState.scores.player2 > this.gameState.scores.player1 ? 2 : 0;

        this.broadcastToRoom('game-ended', {
            winner: winner,
            scores: { ...this.gameState.scores },
            gameState: { ...this.gameState }
        });
    }

    newGame() {
        this.resetGame();
        this.broadcastToRoom('game-reset', {
            gameState: { ...this.gameState }
        });
    }

    resetGame() {
        this.gameState = {
            currentPlayer: 1,
            round: 1,
            maxRounds: 10,
            scores: { player1: 0, player2: 0 },
            gamePhase: 'waiting',
            targetAngle: 0,
            targetRange: 20,
            needleAngle: 90,
            isGameStarted: this.players.length === 2
        };
    }

    broadcastToRoom(event, data) {
        io.to(this.roomId).emit(event, data);
    }

    isEmpty() {
        return this.players.length === 0;
    }
}

// Socket.io connection handling
io.on('connection', (socket) => {
    console.log(`User connected: ${socket.id}`);

    socket.on('join-room', (data) => {
        const { roomId, playerName, maxRounds } = data;
        
        // Create room if it doesn't exist
        if (!gameRooms.has(roomId)) {
            const room = new GameRoom(roomId);
            // Set max rounds if provided (only for room creator)
            if (maxRounds) {
                room.gameState.maxRounds = maxRounds;
            }
            gameRooms.set(roomId, room);
        }

        const room = gameRooms.get(roomId);
        const player = room.addPlayer(socket, playerName);

        if (!player) {
            socket.emit('room-full');
            return;
        }

        socket.emit('joined-room', {
            roomId: roomId,
            player: player,
            gameState: { ...room.gameState }
        });
    });

    socket.on('start-round', () => {
        const room = findPlayerRoom(socket.id);
        if (room && room.gameState.isGameStarted) {
            room.startRound();
        }
    });

    socket.on('show-target', () => {
        const room = findPlayerRoom(socket.id);
        if (room && room.gameState.gamePhase === 'showing-target') {
            room.showTarget();
        }
    });



    socket.on('place-needle', (data) => {
        const room = findPlayerRoom(socket.id);
        console.log('Place needle event received. Room phase:', room?.gameState.gamePhase, 'Needle angle:', data.needleAngle);
        
        // Allow needle placement in both target-shown and placing-needle phases
        if (room && (room.gameState.gamePhase === 'placing-needle' || room.gameState.gamePhase === 'target-shown')) {
            room.placeNeedle(data.needleAngle);
        } else {
            console.log('Cannot place needle - wrong phase or no room');
        }
    });

    socket.on('next-turn', () => {
        const room = findPlayerRoom(socket.id);
        if (room && room.gameState.gamePhase === 'scored') {
            room.nextTurn();
        }
    });

    socket.on('new-game', () => {
        const room = findPlayerRoom(socket.id);
        if (room) {
            room.newGame();
        }
    });

    socket.on('disconnect', () => {
        console.log(`User disconnected: ${socket.id}`);
        
        const room = findPlayerRoom(socket.id);
        if (room) {
            room.removePlayer(socket.id);
            
            // Clean up empty rooms
            if (room.isEmpty()) {
                gameRooms.delete(room.roomId);
                console.log(`Room ${room.roomId} deleted (empty)`);
            }
        }
    });
});

function findPlayerRoom(socketId) {
    for (const room of gameRooms.values()) {
        if (room.players.find(p => p.id === socketId)) {
            return room;
        }
    }
    return null;
}

// API endpoint to get room info (optional, for debugging)
app.get('/api/rooms', (req, res) => {
    const roomsInfo = Array.from(gameRooms.entries()).map(([roomId, room]) => ({
        roomId,
        playerCount: room.players.length,
        gamePhase: room.gameState.gamePhase,
        round: room.gameState.round
    }));
    res.json(roomsInfo);
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
    console.log(`Half-Circle multiplayer server running on port ${PORT}`);
    console.log(`Game available at: http://localhost:${PORT}`);
});