server.js

const express = require("express");
const cors = require("cors");
const path = require("path");

const app = express();
const port = process.env.PORT || 3001;

// Middleware
app.use(cors());
app.use(express.json());
app.use(express.static("public"));

// Game state management
class GameSession {
  constructor() {
    this.currentSession = null;
    this.portStates = new Map(); // port number -> {status: 'up'|'down', timestamp: Date}
    this.activePorts = new Set(); // Currently monitored ports
    this.gameStartTime = null;
    this.gameEndTime = null;
    this.isGameActive = false;

    // Initialize all 24 ports as 'down'
    for (let i = 1; i <= 24; i++) {
      this.portStates.set(i, {
        status: "down",
        timestamp: new Date(),
      });
    }
  }

  startNewGame(targetPorts) {
    this.currentSession = Date.now().toString();
    this.activePorts = new Set(targetPorts);
    this.gameStartTime = new Date();
    this.gameEndTime = null;
    this.isGameActive = true;

    // Reset all ports to down
    for (let i = 1; i <= 24; i++) {
      this.portStates.set(i, {
        status: "down",
        timestamp: new Date(),
      });
    }

    console.log(
      `🎮 New game started with ports: ${Array.from(this.activePorts).join(
        ", "
      )}`
    );
    return this.currentSession;
  }

  togglePort(portNumber) {
    if (!this.portStates.has(portNumber)) {
      throw new Error(`Invalid port number: ${portNumber}`);
    }

    const currentState = this.portStates.get(portNumber);
    const newStatus = currentState.status === "up" ? "down" : "up";

    this.portStates.set(portNumber, {
      status: newStatus,
      timestamp: new Date(),
    });

    console.log(`🔌 Port ${portNumber} switched ${newStatus.toUpperCase()}`);

    // Check if game should end
    if (this.isGameActive && this.checkGameComplete()) {
      this.endGame();
    }

    return {
      port: portNumber,
      status: newStatus,
      timestamp: this.portStates.get(portNumber).timestamp,
    };
  }

  checkGameComplete() {
    if (!this.isGameActive || this.activePorts.size === 0) return false;

    for (const port of this.activePorts) {
      if (this.portStates.get(port).status !== "up") {
        return false;
      }
    }
    return true;
  }

  endGame() {
    if (!this.isGameActive) return null;

    this.gameEndTime = new Date();
    this.isGameActive = false;
    const duration = this.gameEndTime - this.gameStartTime;

    console.log(`🏁 Game completed in ${duration}ms`);

    return {
      sessionId: this.currentSession,
      startTime: this.gameStartTime,
      endTime: this.gameEndTime,
      duration: duration,
      completedPorts: Array.from(this.activePorts),
    };
  }

  getGameState() {
    const portsArray = [];
    for (let i = 1; i <= 24; i++) {
      const portState = this.portStates.get(i);
      portsArray.push({
        port: i,
        status: portState.status,
        isTarget: this.activePorts.has(i),
        timestamp: portState.timestamp,
      });
    }

    return {
      sessionId: this.currentSession,
      isGameActive: this.isGameActive,
      startTime: this.gameStartTime,
      endTime: this.gameEndTime,
      targetPorts: Array.from(this.activePorts),
      ports: portsArray,
      completedTargets: Array.from(this.activePorts).filter(
        (port) => this.portStates.get(port).status === "up"
      ).length,
      totalTargets: this.activePorts.size,
    };
  }
}

// Global game session instance
const gameSession = new GameSession();

// Routes

/**
 * GET /api/health
 * Health check endpoint
 */
app.get("/api/health", (req, res) => {
  res.json({
    status: "ok",
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
  });
});

/**
 * POST /api/game/start
 * Start a new game session with target ports
 * Body: { targetPorts: [1, 5, 8, 12, 15, 18, 20, 22, 3, 7, 11, 24] }
 */
app.post("/api/game/start", (req, res) => {
  try {
    const { targetPorts } = req.body;

    // Validation
    if (!Array.isArray(targetPorts)) {
      return res.status(400).json({
        error: "targetPorts must be an array",
      });
    }

    if (targetPorts.length === 0 || targetPorts.length > 24) {
      return res.status(400).json({
        error: "targetPorts must contain 1-24 ports",
      });
    }

    // Validate port numbers
    const invalidPorts = targetPorts.filter(
      (port) => !Number.isInteger(port) || port < 1 || port > 24
    );

    if (invalidPorts.length > 0) {
      return res.status(400).json({
        error: `Invalid port numbers: ${invalidPorts.join(
          ", "
        )}. Ports must be 1-24.`,
      });
    }

    // Remove duplicates
    const uniquePorts = [...new Set(targetPorts)];

    const sessionId = gameSession.startNewGame(uniquePorts);

    res.json({
      success: true,
      sessionId,
      targetPorts: uniquePorts,
      message: `Game started with ${uniquePorts.length} target ports`,
    });
  } catch (error) {
    console.error("Error starting game:", error);
    res.status(500).json({
      error: "Failed to start game",
      details: error.message,
    });
  }
});

/**
 * GET /api/game/status
 * Get current game state
 */
app.get("/api/game/status", (req, res) => {
  try {
    const gameState = gameSession.getGameState();
    res.json(gameState);
  } catch (error) {
    console.error("Error getting game status:", error);
    res.status(500).json({
      error: "Failed to get game status",
      details: error.message,
    });
  }
});

/**
 * POST /api/port/toggle/:portNumber
 * Toggle a specific port on/off
 */
app.post("/api/port/toggle/:portNumber", (req, res) => {
  try {
    const portNumber = parseInt(req.params.portNumber);

    if (!Number.isInteger(portNumber) || portNumber < 1 || portNumber > 24) {
      return res.status(400).json({
        error: "Invalid port number. Must be 1-24.",
      });
    }

    const result = gameSession.togglePort(portNumber);

    // Check if game just completed
    const gameState = gameSession.getGameState();

    res.json({
      success: true,
      port: result,
      gameComplete: !gameState.isGameActive && gameState.endTime !== null,
      gameState: gameState,
    });
  } catch (error) {
    console.error("Error toggling port:", error);
    res.status(500).json({
      error: "Failed to toggle port",
      details: error.message,
    });
  }
});

/**
 * POST /api/port/set/:portNumber/:status
 * Set a specific port to up or down
 */
app.post("/api/port/set/:portNumber/:status", (req, res) => {
  try {
    const portNumber = parseInt(req.params.portNumber);
    const targetStatus = req.params.status.toLowerCase();

    if (!Number.isInteger(portNumber) || portNumber < 1 || portNumber > 24) {
      return res.status(400).json({
        error: "Invalid port number. Must be 1-24.",
      });
    }

    if (!["up", "down"].includes(targetStatus)) {
      return res.status(400).json({
        error: 'Status must be "up" or "down"',
      });
    }

    const currentState = gameSession.portStates.get(portNumber);

    // Only toggle if current status is different
    if (currentState.status !== targetStatus) {
      const result = gameSession.togglePort(portNumber);

      const gameState = gameSession.getGameState();

      res.json({
        success: true,
        port: result,
        gameComplete: !gameState.isGameActive && gameState.endTime !== null,
        gameState: gameState,
      });
    } else {
      res.json({
        success: true,
        port: {
          port: portNumber,
          status: currentState.status,
          timestamp: currentState.timestamp,
        },
        message: `Port ${portNumber} already ${targetStatus}`,
        gameComplete: false,
        gameState: gameSession.getGameState(),
      });
    }
  } catch (error) {
    console.error("Error setting port status:", error);
    res.status(500).json({
      error: "Failed to set port status",
      details: error.message,
    });
  }
});

/**
 * POST /api/game/reset
 * Reset/end current game
 */
app.post("/api/game/reset", (req, res) => {
  try {
    const result = gameSession.endGame();

    // Reset to initial state
    const newSession = new GameSession();
    Object.assign(gameSession, newSession);

    res.json({
      success: true,
      message: "Game reset successfully",
      lastGameResult: result,
    });
  } catch (error) {
    console.error("Error resetting game:", error);
    res.status(500).json({
      error: "Failed to reset game",
      details: error.message,
    });
  }
});

/**
 * GET /api/ports
 * Get all port statuses
 */
app.get("/api/ports", (req, res) => {
  try {
    const ports = [];
    for (let i = 1; i <= 24; i++) {
      const portState = gameSession.portStates.get(i);
      ports.push({
        port: i,
        status: portState.status,
        isTarget: gameSession.activePorts.has(i),
        timestamp: portState.timestamp,
      });
    }

    res.json({
      ports,
      totalPorts: 24,
      activePorts: Array.from(gameSession.activePorts),
      timestamp: new Date().toISOString(),
    });
  } catch (error) {
    console.error("Error getting ports:", error);
    res.status(500).json({
      error: "Failed to get ports",
      details: error.message,
    });
  }
});

// Serve a simple control panel for testing
app.get("/", (req, res) => {
  res.send(`
    <!DOCTYPE html>
    <html>
    <head>
        <title>SNMP Game Server Control Panel</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 40px; }
            .port-grid { display: grid; grid-template-columns: repeat(6, 1fr); gap: 10px; margin: 20px 0; }
            .port { padding: 10px; border: 1px solid #ccc; text-align: center; cursor: pointer; border-radius: 4px; }
            .port.up { background-color: #4CAF50; color: white; }
            .port.down { background-color: #f44336; color: white; }
            .port.target { border: 3px solid #2196F3; }
            .controls { margin: 20px 0; }
            button { padding: 10px 20px; margin: 5px; cursor: pointer; }
            #status { margin: 20px 0; padding: 10px; background: #f5f5f5; }
        </style>
    </head>
    <body>
        <h1>🎮 SNMP Game Server Control Panel</h1>
        
        <div class="controls">
            <button onclick="startRandomGame()">🎲 Start Random Game (12 ports)</button>
            <button onclick="resetGame()">🔄 Reset Game</button>
            <button onclick="refreshStatus()">🔍 Refresh Status</button>
        </div>

        <div id="status"></div>
        
        <h2>Port States (Click to Toggle)</h2>
        <div class="port-grid" id="portGrid"></div>

        <script>
            async function refreshStatus() {
                try {
                    const response = await fetch('/api/game/status');
                    const data = await response.json();
                    
                    document.getElementById('status').innerHTML = \`
                        <strong>Game Status:</strong> \${data.isGameActive ? '🟢 Active' : '🔴 Inactive'}<br>
                        <strong>Session:</strong> \${data.sessionId || 'None'}<br>
                        <strong>Target Ports:</strong> \${data.targetPorts?.join(', ') || 'None'}<br>
                        <strong>Completed:</strong> \${data.completedTargets || 0}/\${data.totalTargets || 0}<br>
                        \${data.endTime ? \`<strong>Duration:</strong> \${new Date(data.endTime) - new Date(data.startTime)}ms\` : ''}
                    \`;
                    
                    updatePortGrid(data.ports);
                } catch (error) {
                    console.error('Error refreshing status:', error);
                }
            }

            function updatePortGrid(ports) {
                const grid = document.getElementById('portGrid');
                grid.innerHTML = '';
                
                ports.forEach(port => {
                    const div = document.createElement('div');
                    div.className = \`port \${port.status}\${port.isTarget ? ' target' : ''}\`;
                    div.textContent = \`Port \${port.port}\`;
                    div.onclick = () => togglePort(port.port);
                    grid.appendChild(div);
                });
            }

            async function togglePort(portNumber) {
                try {
                    const response = await fetch(\`/api/port/toggle/\${portNumber}\`, { method: 'POST' });
                    const data = await response.json();
                    
                    if (data.gameComplete) {
                        alert('🏁 Game Complete!');
                    }
                    
                    refreshStatus();
                } catch (error) {
                    console.error('Error toggling port:', error);
                }
            }

            async function startRandomGame() {
                const allPorts = Array.from({length: 24}, (_, i) => i + 1);
                const shuffled = allPorts.sort(() => Math.random() - 0.5);
                const targetPorts = shuffled.slice(0, 12);
                
                try {
                    const response = await fetch('/api/game/start', {
                        method: 'POST',
                        headers: { 'Content-Type': 'application/json' },
                        body: JSON.stringify({ targetPorts })
                    });
                    
                    if (response.ok) {
                        refreshStatus();
                    }
                } catch (error) {
                    console.error('Error starting game:', error);
                }
            }

            async function resetGame() {
                try {
                    await fetch('/api/game/reset', { method: 'POST' });
                    refreshStatus();
                } catch (error) {
                    console.error('Error resetting game:', error);
                }
            }

            // Initial load
            refreshStatus();
            
            // Auto-refresh every 2 seconds during active games
            setInterval(refreshStatus, 2000);
        </script>
    </body>
    </html>
  `);
});

// Error handling middleware
app.use((error, req, res, next) => {
  console.error("Unhandled error:", error);
  res.status(500).json({
    error: "Internal server error",
    details: error.message,
  });
});

// 404 handler
app.use((req, res) => {
  res.status(404).json({
    error: "Endpoint not found",
    availableEndpoints: [
      "GET /api/health",
      "POST /api/game/start",
      "GET /api/game/status",
      "POST /api/port/toggle/:portNumber",
      "POST /api/port/set/:portNumber/:status",
      "POST /api/game/reset",
      "GET /api/ports",
      "GET / (Control Panel)",
    ],
  });
});

app.listen(port, () => {
  console.log(`🚀 SNMP Game Server running at http://localhost:${port}`);
  console.log(`🎮 Control Panel: http://localhost:${port}`);
  console.log(`📡 API Base URL: http://localhost:${port}/api`);
  console.log("\n📋 Available Endpoints:");
  console.log("   POST /api/game/start - Start new game");
  console.log("   GET  /api/game/status - Get game state");
  console.log("   POST /api/port/toggle/:port - Toggle port");
  console.log("   POST /api/port/set/:port/:status - Set port status");
  console.log("   POST /api/game/reset - Reset game");
  console.log("   GET  /api/ports - Get all ports");
});

module.exports = app;