server.js

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const path = require('path');
const { MongoClient, ObjectId } = require('mongodb');

const app = express();
const server = http.createServer(app);
const io = new Server(server);

const mongoUri = "mongodb+srv://appsmith:lWKhtZRTstMnBIAs@cluster0.zwfc5.mongodb.net/fileDB";
const client = new MongoClient(mongoUri);
let raceCollection;
let imageCollection; // New collection for images

async function connectDb() {
    try {
        await client.connect();
        const db = client.db("timer");
        raceCollection = db.collection("races");
        imageCollection = db.collection("images"); // Initialize image collection
        console.log("Connected to MongoDB");
    } catch (e) {
        console.error("DB Connection Error", e);
    }
}
connectDb();

app.use(express.static(__dirname));

const rooms = {};

io.on('connection', (socket) => {
    // Get all races (Past from DB, Live from memory)
    socket.on('get-races', async () => {
        const pastRaces = await raceCollection.find({}).sort({ date: -1 }).toArray();
        const liveRaces = Object.keys(rooms).map(id => ({
            roomId: id,
            name: rooms[id].raceName,
            status: 'live'
        }));
        socket.emit('races-list', { past: pastRaces, live: liveRaces });
    });

    // Manager Login
    socket.on('manager-login', (code) => {
        if (code?.trim() === 'HUSKIES77') {
            socket.emit('manager-login-success');
        } else {
            socket.emit('error-msg', 'Invalid Manager Access Code');
        }
    });

    // Manager Delete Race
    socket.on('delete-race', async (raceId) => {
        try {
            await raceCollection.deleteOne({ _id: new ObjectId(raceId) });
            socket.emit('refresh-races');
        } catch (e) { console.error(e); }
    });

    // Get specific race data for editing or viewing results
    socket.on('get-race-data', async (id) => {
        // Check if it's a live room code first
        if (rooms[id]) {
            const room = rooms[id];
            room.managerId = socket.id; // Re-associate manager to new socket ID
            socket.join(id);
            
            // Fetch images for live room splits
            const imageDocs = await imageCollection.find({ roomId: id }).toArray();
            const imagesMap = new Map(imageDocs.map(img => [img.splitId, img.image]));

            const splitsWithImages = (room.allSplits || []).map(split => ({
                ...split,
                image: imagesMap.get(split.id) || null // Re-attach image data
            }));

            socket.emit('race-data-loaded', {
                roomId: id,
                name: room.raceName,
                startList: room.startList || [],
                allSplits: splitsWithImages, // Send splits with images
                raceStartTime: room.startTime,
                raceStopTime: room.stopTime,
                isHeatsEnabled: room.isHeatsEnabled,
                currentHeat: room.currentHeat,
                heatData: room.heatData,
                lapDist: room.lapDist || 400,
                minSplitTime: room.minSplitTime || 5,
                isStopped: room.isStopped
            });
            return;
        }

        try {
            if (ObjectId.isValid(id)) {
                const race = await raceCollection.findOne({ _id: new ObjectId(id) });
                socket.emit('race-data-loaded', race);
            }
        } catch (e) { console.error(e); }
    });

    // Manager Update Race
    socket.on('update-race', async (data) => {
        try {
            // Ensure images are not saved with past race updates
            const { id, name, startList, allSplits, raceStartTime, raceStopTime, lapDist, isHeatsEnabled, heatData } = data; // allSplits from client might have images
            const splitsWithoutImages = allSplits.map(s => ({ ...s, image: null })); // Strip images for permanent storage
            await raceCollection.updateOne({ _id: new ObjectId(id) }, {
                $set: { name, startList: startList, allSplits: splitsWithoutImages, raceStartTime, raceStopTime, lapDist, isHeatsEnabled, heatData }
            });
            socket.emit('refresh-races');
            socket.emit('race-updated-success');
        } catch (e) { console.error(e); }
    });

    // Manager creates a room
    socket.on('create-room', (accessCode, raceName) => {
        if (accessCode?.trim() !== 'HUSKIES77') {
            socket.emit('error-msg', 'Invalid Manager Access Code');
            return;
        }
        const roomId = Math.random().toString(36).substring(2, 8).toUpperCase();
        rooms[roomId] = { 
            managerId: socket.id, 
            raceName: raceName || "Unnamed Race",
            startTime: null, 
            isStopped: false, 
            stopTime: null,
            leaderboard: [],
            isHeatsEnabled: false,
            currentHeat: 1,
            heatData: {},
            startList: [],
            allSplits: [], // Stores splitIds, not full images
            lapDist: 400,
            minSplitTime: 5
        };
        socket.join(roomId);
        socket.emit('room-created', roomId, rooms[roomId].raceName);
    });

    socket.on('toggle-heats', (roomId, enabled) => {
        if (rooms[roomId]) {
            rooms[roomId].isHeatsEnabled = enabled;
            io.to(roomId).emit('heats-toggled', enabled);
        }
    });

    socket.on('set-min-split-time', (roomId, seconds) => {
        if (rooms[roomId]) {
            rooms[roomId].minSplitTime = parseFloat(seconds) || 0;
            io.to(roomId).emit('min-split-time-update', rooms[roomId].minSplitTime);
        }
    });

    socket.on('set-current-heat', (roomId, heatIdx) => {
        if (rooms[roomId]) {
            rooms[roomId].currentHeat = parseInt(heatIdx);
            io.to(roomId).emit('heat-changed', rooms[roomId].currentHeat);
        }
    });

    socket.on('start-race', (roomId) => {
        if (rooms[roomId]) {
            const startTime = Date.now();
            const room = rooms[roomId];
            if (room.isHeatsEnabled) {
                if (!room.heatData[room.currentHeat]) room.heatData[room.currentHeat] = {};
                room.heatData[room.currentHeat].startTime = startTime;
                room.heatData[room.currentHeat].stopTime = null;
            } else {
                room.startTime = startTime;
                room.stopTime = null;
            }
            room.isStopped = false;
            io.to(roomId).emit('race-started', startTime, room.isHeatsEnabled ? room.currentHeat : null);
        }
    });

    socket.on('stop-race', (roomId) => {
        if (rooms[roomId]) {
            const stopTime = Date.now();
            const room = rooms[roomId];
            if (room.isHeatsEnabled) {
                if (room.heatData[room.currentHeat]) {
                    room.heatData[room.currentHeat].stopTime = stopTime;
                }
            } else {
                room.stopTime = stopTime;
            }
            room.isStopped = true;
            io.to(roomId).emit('race-stopped', stopTime, room.isHeatsEnabled ? room.currentHeat : null);
        }
    });

    // Manager ends and saves the race
    socket.on('end-race', async (roomId, raceState) => {
        if (rooms[roomId]) {
            // Strip images before saving to permanent race record
            const splitsWithoutImages = raceState.allSplits.map(s => ({ ...s, image: null }));

            await raceCollection.insertOne({
                name: rooms[roomId].raceName,
                date: new Date(),
                startList: raceState.startList,
                allSplits: splitsWithoutImages, // Save splits without images
                raceStartTime: raceState.raceStartTime,
                raceStopTime: raceState.raceStopTime,
                lapDist: raceState.lapDist,
                minSplitTime: raceState.minSplitTime,
                isHeatsEnabled: raceState.isHeatsEnabled,
                heatData: raceState.heatData
            });
            delete rooms[roomId];
            // Delete all images associated with this race from the temporary image collection
            await imageCollection.deleteMany({ roomId: roomId });
            socket.emit('race-ended-success');
        }
    });

    // Manager resets the race
    socket.on('reset-race', (roomId) => {
        if (rooms[roomId]) {
            rooms[roomId].startTime = null;
            rooms[roomId].isStopped = false;
            rooms[roomId].stopTime = null;
            io.to(roomId).emit('race-reset');
        }
    });

    // Camera joins a room
    socket.on('join-camera', (roomId) => {
        if (rooms[roomId]) {
            socket.join(roomId);
            io.to(rooms[roomId].managerId).emit('camera-status', 'Connected');
            socket.emit('camera-joined', roomId);
            socket.emit('min-split-time-update', rooms[roomId].minSplitTime || 5);
            if (rooms[roomId].startTime) {
                if (rooms[roomId].isStopped) {
                    socket.emit('race-stopped', rooms[roomId].stopTime);
                } else {
                    socket.emit('race-started', rooms[roomId].startTime);
                }
            }
        } else {
            socket.emit('error-msg', 'Invalid Room Code');
        }
    });

    // Viewer joins a room
    socket.on('join-viewer', (roomId) => {
        if (rooms[roomId]) {
            socket.join(roomId);
            socket.emit('viewer-joined', roomId);
            // Request current state from manager for the new viewer
            io.to(rooms[roomId].managerId).emit('request-sync');
        } else {
            socket.emit('error-msg', 'Invalid Room Code');
        }
    });

    // Audio Broadcast & Control
    socket.on('broadcast-audio', (data) => {
        const { roomId, command, target } = data;
        if (rooms[roomId]) {
            if (target === 'camera') {
                socket.to(roomId).emit('play-audio', command);
            } else {
                socket.emit('play-audio', command);
            }

            if (command === 'start') {
                const audioDelay = 1200; // Delay timer start by 1.2s to account for start.mp3 playback
                const startTime = Date.now() + audioDelay;
                const room = rooms[roomId];
                if (room.isHeatsEnabled) {
                    if (!room.heatData[room.currentHeat]) room.heatData[room.currentHeat] = {};
                    room.heatData[room.currentHeat].startTime = startTime;
                    room.heatData[room.currentHeat].stopTime = null;
                } else {
                    room.startTime = startTime;
                    room.stopTime = null;
                }
                room.isStopped = false;
                io.to(roomId).emit('race-started', startTime, room.isHeatsEnabled ? room.currentHeat : null);
            } else if (command === 'false-start') {
                const room = rooms[roomId];
                if (room.isHeatsEnabled) {
                    delete room.heatData[room.currentHeat];
                } else {
                    room.startTime = null;
                }
                room.isStopped = false;
                room.stopTime = null;
                io.to(roomId).emit('race-false-start', room.isHeatsEnabled ? room.currentHeat : null);
            }
        }
    });

    // Relay synced data from Manager to Viewers (broadcast to room)
    socket.on('sync-to-viewers', (data) => {
        if (rooms[data.roomId]) {
            // Update room state in memory (store splitIds, not full images)
            rooms[data.roomId].startList = data.startList;
            rooms[data.roomId].allSplits = data.allSplits.map(s => ({ ...s, image: null })); // Store splits without images
            rooms[data.roomId].raceName = data.name;
            rooms[data.roomId].lapDist = data.lapDist;
            rooms[data.roomId].isStopped = data.isStopped;
        }
        
        // Strip images for viewers to save bandwidth/privacy
        // The client (manager) sends full image data, but viewers don't need it.
        const viewerData = {
            ...data,
            allSplits: (data.allSplits || []).map(s => ({ ...s, image: null }))
        };
        
        socket.to(data.roomId).emit('viewer-update', viewerData);
    });

    // Relay detection from Camera to Manager
    socket.on('detection', async (data) => {
        if (rooms[data.roomId]) {
            const splitId = Date.now() + Math.random(); // Generate a unique ID for the split
            // Store image in imageCollection
            await imageCollection.insertOne({
                _id: new ObjectId(), // MongoDB will generate _id
                roomId: data.roomId,
                splitId: splitId,
                image: data.image,
                timestamp: data.timestamp
            });

            // Update room's allSplits with reference to image
            rooms[data.roomId].allSplits.unshift({
                id: splitId, // Use the generated splitId
                timestamp: data.timestamp,
                runnerNames: [],
                multiMode: false,
                heatIndex: rooms[data.roomId].isHeatsEnabled ? rooms[data.roomId].currentHeat : null
            });

            // Emit to manager with full image data for immediate display
            io.to(rooms[data.roomId].managerId).emit('new-split', {
                splitId: splitId,
                timestamp: data.timestamp,
                image: data.image,
                heatIndex: rooms[data.roomId].isHeatsEnabled ? rooms[data.roomId].currentHeat : null
            });
        }
    });
});

server.listen(3000, () => console.log('TIMERTHING running on http://localhost:3000'));