server.js

// server.js — Static-Server (Frontend) + WebSocket-Server für den Online-Modus.
// Der Server ist autoritativ: er hält den Spielzustand pro Raum und validiert
// jeden Zug mit derselben Engine wie der Client.
import express from "express";
import http from "node:http";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { WebSocketServer } from "ws";
import { genCode, newGame, tryMove } from "./rooms.js";

const __dirname = path.dirname(fileURLToPath(import.meta.url));

export function startServer(port = process.env.PORT || 3000) {
  const app = express();
  app.use(express.static(path.join(__dirname, "public")));
  app.get("/health", (_req, res) => res.json({ status: "ok" }));

  const server = http.createServer(app);
  const wss = new WebSocketServer({ server });

  // roomId -> { id, game, names:{1,2}, players:{1:ws|null, 2:ws|null} }
  const rooms = new Map();

  const send = (ws, msg) => {
    if (ws && ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
  };
  const broadcast = (room, msg) => {
    send(room.players[1], msg);
    send(room.players[2], msg);
  };
  const stateMsg = (room, frames) => ({
    type: "state",
    frames: frames || [room.game.board],
    current: room.game.current,
    moves: room.game.moves,
    gameOver: room.game.gameOver,
    winner: room.game.winner,
    names: room.names,
    connected: { 1: !!room.players[1], 2: !!room.players[2] },
  });

  wss.on("connection", (ws) => {
    ws.roomId = null;
    ws.player = null;

    ws.on("message", (data) => {
      let msg;
      try { msg = JSON.parse(data); } catch { return; }

      if (msg.type === "create") {
        let id;
        do { id = genCode(); } while (rooms.has(id));
        const room = {
          id,
          size: msg.size,
          game: newGame(msg.size),
          names: { 1: (msg.name || "Spieler 1").slice(0, 20), 2: "Spieler 2" },
          players: { 1: ws, 2: null },
        };
        rooms.set(id, room);
        ws.roomId = id;
        ws.player = 1;
        send(ws, { type: "joined", roomId: id, player: 1 });
        send(ws, stateMsg(room));

      } else if (msg.type === "join") {
        const id = (msg.roomId || "").toUpperCase().trim();
        const room = rooms.get(id);
        if (!room) { send(ws, { type: "error", message: "Raum nicht gefunden" }); return; }
        const slot2 = room.players[2];
        if (slot2 && slot2.readyState === slot2.OPEN) {
          send(ws, { type: "error", message: "Raum ist voll" });
          return;
        }
        room.players[2] = ws;
        room.names[2] = (msg.name || "Spieler 2").slice(0, 20);
        ws.roomId = id;
        ws.player = 2;
        send(ws, { type: "joined", roomId: id, player: 2 });
        broadcast(room, stateMsg(room));

      } else if (msg.type === "move") {
        const room = rooms.get(ws.roomId);
        if (!room) return;
        if (!(room.players[1] && room.players[2])) {
          send(ws, { type: "error", message: "Warte auf Mitspieler" });
          return;
        }
        const result = tryMove(room.game, ws.player, msg.r, msg.c);
        if (result.error) { send(ws, { type: "error", message: result.error }); return; }
        broadcast(room, stateMsg(room, result.frames));

      } else if (msg.type === "restart") {
        const room = rooms.get(ws.roomId);
        if (!room) return;
        room.game = newGame(room.game.board.length); // gleiche Feldgröße beibehalten
        broadcast(room, stateMsg(room));

      } else if (msg.type === "rename") {
        const room = rooms.get(ws.roomId);
        if (!room || !ws.player) return;
        room.names[ws.player] = (msg.name || `Spieler ${ws.player}`).slice(0, 20);
        broadcast(room, stateMsg(room));
      }
    });

    ws.on("close", () => {
      const room = rooms.get(ws.roomId);
      if (!room) return;
      if (ws.player && room.players[ws.player] === ws) room.players[ws.player] = null;
      if (!room.players[1] && !room.players[2]) {
        rooms.delete(room.id); // leerer Raum wird aufgeräumt
        return;
      }
      broadcast(room, stateMsg(room)); // verbleibender Spieler sieht "getrennt"
    });
  });

  server.listen(port, () => {
    const p = server.address().port;
    console.log(`Lawine läuft auf http://localhost:${p}`);
  });
  return server;
}

// Nur automatisch starten, wenn direkt ausgeführt (nicht beim Import in Tests).
const invoked = process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
if (invoked) startServer();