server.js

/* ============================================================
   MapVexa — Custom Server (Next.js + Socket.io)
   Runs Next.js alongside a WebSocket server for multiplayer.
   ============================================================ */

const { createServer } = require('node:http');
const next = require('next');
const { Server } = require('socket.io');
const Database = require('better-sqlite3');
const fs = require('fs');
const path = require('path');

const dev = process.env.NODE_ENV !== 'production';
const hostname = 'localhost';
const port = process.env.PORT || 3000;

// Initialize Next.js
const app = next({ dev, hostname, port });
const handler = app.getRequestHandler();

// Initialize Database
const db = new Database('mapvexa.db');
db.pragma('journal_mode = WAL');

// Simple schema setup
db.exec(`
  CREATE TABLE IF NOT EXISTS users (
    id TEXT PRIMARY KEY,
    username TEXT NOT NULL,
    passwordHash TEXT,
    xp INTEGER DEFAULT 0,
    level INTEGER DEFAULT 1,
    streak INTEGER DEFAULT 0,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );
  
  CREATE TABLE IF NOT EXISTS friends (
    user_id TEXT,
    friend_id TEXT,
    status TEXT DEFAULT 'pending',
    PRIMARY KEY (user_id, friend_id)
  );
  
  CREATE TABLE IF NOT EXISTS curated_locations (
    id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    countryCode TEXT NOT NULL,
    countryName TEXT NOT NULL,
    lat REAL NOT NULL,
    lon REAL NOT NULL,
    imageUrl TEXT NOT NULL
  );
`);

// Seed curated locations if empty
const locCount = db.prepare('SELECT COUNT(*) as count FROM curated_locations').get().count;
if (locCount === 0) {
  try {
    const locationsPath = path.join(__dirname, 'public', 'curated_locations.json');
    const locationsData = JSON.parse(fs.readFileSync(locationsPath, 'utf-8'));
    
    const insertLoc = db.prepare(`
      INSERT INTO curated_locations (id, name, countryCode, countryName, lat, lon, imageUrl)
      VALUES (@id, @name, @countryCode, @countryName, @lat, @lon, @imageUrl)
    `);
    
    const insertMany = db.transaction((locations) => {
      for (const loc of locations) {
        insertLoc.run(loc);
      }
    });
    
    insertMany(locationsData);
    console.log(`[DB] Seeded ${locationsData.length} curated locations into the database.`);
  } catch (err) {
    console.error('[DB] Failed to seed curated locations:', err.message);
  }
}

app.prepare().then(() => {
  const httpServer = createServer(handler);
  
  const io = new Server(httpServer, {
    cors: {
      origin: "*",
      methods: ["GET", "POST"]
    }
  });

  // Multiplayer State
  const rooms = new Map();

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

    // Join a room
    socket.on('join-room', (roomId, user) => {
      socket.join(roomId);
      console.log(`[Socket] User ${user?.username} joined room ${roomId}`);
      
      if (!rooms.has(roomId)) {
        rooms.set(roomId, {
          id: roomId,
          players: [],
          state: 'waiting',
          gameMode: 'capital-challenge',
          round: 1
        });
      }
      
      const room = rooms.get(roomId);
      if (!room.players.find(p => p.id === (user?.id || socket.id))) {
        room.players.push({
          id: user?.id || socket.id,
          socketId: socket.id,
          username: user?.username || 'Guest',
          score: 0,
          ready: false
        });
      }
      
      io.to(roomId).emit('room-update', room);
    });

    // Chat messages
    socket.on('send-chat', (roomId, message) => {
      io.to(roomId).emit('chat-message', message);
    });

    socket.on('disconnect', () => {
      console.log(`[Socket] User disconnected: ${socket.id}`);
      // Simple cleanup for MVP
      for (const [roomId, room] of rooms.entries()) {
        const playerIndex = room.players.findIndex(p => p.socketId === socket.id);
        if (playerIndex !== -1) {
          room.players.splice(playerIndex, 1);
          if (room.players.length === 0) {
            rooms.delete(roomId);
          } else {
            io.to(roomId).emit('room-update', room);
          }
        }
      }
    });
  });

  httpServer
    .once('error', (err) => {
      console.error(err);
      process.exit(1);
    })
    .listen(port, () => {
      console.log(`> Ready on http://${hostname}:${port}`);
    });
});