HikeMap/server.js

const WebSocket = require('ws');
const http = require('http');
const express = require('express');
const path = require('path');
const fs = require('fs').promises;

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server({ server });

// Middleware to parse raw body for KML
app.use(express.text({ type: 'application/xml', limit: '10mb' }));

// Serve static files - prioritize data directory for default.kml
app.get('/default.kml', async (req, res) => {
    try {
        // Try to serve from data directory first (mounted volume)
        const dataPath = path.join('/app/data', 'default.kml');
        await fs.access(dataPath);
        console.log('Serving default.kml from data directory');
        res.sendFile(dataPath);
    } catch (err) {
        // Fall back to app directory
        const appPath = path.join(__dirname, 'default.kml');
        console.log('Serving default.kml from app directory');
        res.sendFile(appPath);
    }
});

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

// Store connected users
const users = new Map();

// Store geocaches
let geocaches = [];

// Geocache file path
const getGeocachePath = async () => {
    let dataDir = __dirname;
    try {
        await fs.access('/app/data');
        dataDir = '/app/data';
    } catch (err) {
        // Use local directory if /app/data doesn't exist
    }
    return path.join(dataDir, 'geocaches.json');
};

// Load geocaches from file
const loadGeocaches = async () => {
    try {
        const geocachePath = await getGeocachePath();
        const data = await fs.readFile(geocachePath, 'utf8');
        geocaches = JSON.parse(data);
        console.log(`Loaded ${geocaches.length} geocaches from file`);
    } catch (err) {
        if (err.code === 'ENOENT') {
            console.log('No geocaches file found, starting fresh');
        } else {
            console.error('Error loading geocaches:', err);
        }
        geocaches = [];
    }
};

// Save geocaches to file
const saveGeocaches = async () => {
    try {
        const geocachePath = await getGeocachePath();
        await fs.writeFile(geocachePath, JSON.stringify(geocaches, null, 2), 'utf8');
        console.log(`Saved ${geocaches.length} geocaches to file`);
    } catch (err) {
        console.error('Error saving geocaches:', err);
    }
};

// KML save endpoint
app.post('/save-kml', async (req, res) => {
    try {
        const kmlContent = req.body;
        // Always use data directory when it exists (Docker), otherwise local
        let dataDir = __dirname;
        try {
            await fs.access('/app/data');
            dataDir = '/app/data';
            console.log('Using data directory for save');
        } catch (err) {
            console.log('Using app directory for save');
        }
        const defaultKmlPath = path.join(dataDir, 'default.kml');

        // Create backup with timestamp
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
        const backupPath = path.join(dataDir, `default.kml.backup.${timestamp}`);

        try {
            // Try to backup existing file
            const existingContent = await fs.readFile(defaultKmlPath, 'utf8');
            await fs.writeFile(backupPath, existingContent);
            console.log(`Backed up existing KML to: ${backupPath}`);
        } catch (err) {
            // No existing file to backup, that's OK
            console.log('No existing default.kml to backup');
        }

        // Write new content
        await fs.writeFile(defaultKmlPath, kmlContent, 'utf8');
        console.log('Saved new default.kml');

        // Clean up old backups (keep only last 10)
        const files = await fs.readdir(dataDir);
        const backupFiles = files
            .filter(f => f.startsWith('default.kml.backup.'))
            .sort()
            .reverse();

        for (let i = 10; i < backupFiles.length; i++) {
            await fs.unlink(path.join(dataDir, backupFiles[i]));
            console.log(`Deleted old backup: ${backupFiles[i]}`);
        }

        res.json({
            success: true,
            message: 'Tracks saved to server successfully',
            backup: backupPath.split('/').pop()
        });
    } catch (err) {
        console.error('Error saving KML:', err);
        res.status(500).send('Failed to save: ' + err.message);
    }
});

// Generate random user ID
function generateUserId() {
    return Math.random().toString(36).substring(7);
}

// Broadcast to all clients except sender
function broadcast(data, senderId) {
    const message = JSON.stringify(data);
    wss.clients.forEach(client => {
        if (client.readyState === WebSocket.OPEN && client.userId !== senderId) {
            client.send(message);
        }
    });
}

// Clean up disconnected user
function removeUser(userId) {
    if (users.has(userId)) {
        users.delete(userId);
        broadcast({ type: 'userDisconnected', userId }, null);
        console.log(`User ${userId} disconnected. Active users: ${users.size}`);
    }
}

wss.on('connection', (ws) => {
    const userId = generateUserId();
    ws.userId = userId;

    console.log(`User ${userId} connected. Active users: ${users.size + 1}`);

    // Send user their ID, current visible users, and geocaches
    ws.send(JSON.stringify({
        type: 'init',
        userId: userId,
        users: Array.from(users.entries())
            .filter(([id, data]) => data.visible !== false) // Only send visible users
            .map(([id, data]) => ({
                userId: id,
                ...data
            }))
    }));

    // Send all geocaches
    if (geocaches.length > 0) {
        ws.send(JSON.stringify({
            type: 'geocachesInit',
            geocaches: geocaches
        }));
    }

    ws.on('message', (message) => {
        try {
            const data = JSON.parse(message);

            if (data.type === 'location') {
                // Store user location with icon info
                users.set(userId, {
                    lat: data.lat,
                    lng: data.lng,
                    accuracy: data.accuracy,
                    icon: data.icon,
                    color: data.color,
                    visible: data.visible !== false, // default to true if not specified
                    timestamp: Date.now()
                });

                // Broadcast to other users (including visibility status)
                broadcast({
                    type: 'userLocation',
                    userId: userId,
                    lat: data.lat,
                    lng: data.lng,
                    accuracy: data.accuracy,
                    icon: data.icon,
                    color: data.color,
                    visible: data.visible !== false
                }, userId);
            } else if (data.type === 'iconUpdate') {
                // Update user's icon
                const userData = users.get(userId) || {};
                userData.icon = data.icon;
                userData.color = data.color;
                users.set(userId, userData);

                // Broadcast icon update to other users if we have location and are visible
                if (userData.lat && userData.lng && userData.visible !== false) {
                    broadcast({
                        type: 'userLocation',
                        userId: userId,
                        lat: userData.lat,
                        lng: userData.lng,
                        accuracy: userData.accuracy || 100,
                        icon: data.icon,
                        color: data.color,
                        visible: true
                    }, userId);
                }
            } else if (data.type === 'geocacheUpdate') {
                // Handle geocache creation/update
                if (data.geocache) {
                    const existingIndex = geocaches.findIndex(g => g.id === data.geocache.id);
                    if (existingIndex >= 0) {
                        // Update existing geocache
                        geocaches[existingIndex] = data.geocache;
                    } else {
                        // Add new geocache
                        geocaches.push(data.geocache);
                    }

                    // Save to file
                    saveGeocaches();

                    // Broadcast to all other users
                    broadcast({
                        type: 'geocacheUpdate',
                        geocache: data.geocache
                    }, userId);
                }
            } else if (data.type === 'geocacheDelete') {
                // Handle geocache deletion
                if (data.geocacheId) {
                    const index = geocaches.findIndex(g => g.id === data.geocacheId);
                    if (index > -1) {
                        geocaches.splice(index, 1);

                        // Save to file
                        saveGeocaches();

                        // Broadcast deletion to all other users
                        broadcast({
                            type: 'geocacheDelete',
                            geocacheId: data.geocacheId
                        }, userId);
                    }
                }
            }
        } catch (err) {
            console.error('Error processing message:', err);
        }
    });

    ws.on('close', () => {
        removeUser(userId);
    });

    ws.on('error', (err) => {
        console.error(`WebSocket error for user ${userId}:`, err);
        removeUser(userId);
    });

    // Heartbeat to detect disconnected clients
    ws.isAlive = true;
    ws.on('pong', () => {
        ws.isAlive = true;
    });
});

// Periodic cleanup of stale connections
const heartbeatInterval = setInterval(() => {
    wss.clients.forEach(ws => {
        if (ws.isAlive === false) {
            removeUser(ws.userId);
            return ws.terminate();
        }
        ws.isAlive = false;
        ws.ping();
    });
}, 30000);

wss.on('close', () => {
    clearInterval(heartbeatInterval);
});

const PORT = process.env.PORT || 8080;
server.listen(PORT, async () => {
    console.log(`Server running on port ${PORT}`);
    console.log(`Open http://localhost:${PORT} to view the map`);

    // Load geocaches on startup
    await loadGeocaches();
});