// CLIENT: emit with a callback (the acknowledgment)
socket.emit('send-message', { text: 'Hello!' }, (response) => {
  if (response.ok) {
    console.log('Message saved with ID:', response.id);
    markMessageAsSent(response.id); // show a checkmark in the UI
  } else {
    console.error('Failed to send:', response.error);
    showRetryOption();
  }
});

// SERVER: receive and call the callback when done
socket.on('send-message', async (data, callback) => {
  try {
    const message = await db.messages.create({
      text: data.text,
      userId: socket.userId,
      timestamp: new Date()
    });

    // Broadcast to the room (minus the sender)
    socket.broadcast.to(socket.currentRoom).emit('new-message', message);

    // Confirm success to the sender
    callback({ ok: true, id: message.id });
  } catch (error) {
    callback({ ok: false, error: error.message });
  }
});

const jwt = require('jsonwebtoken');

// Middleware: verify JWT before allowing connection
io.use(async (socket, next) => {
  try {
    const token = socket.handshake.auth.token;

    if (!token) {
      return next(new Error('Authentication required'));
    }

    const payload = jwt.verify(token, process.env.JWT_SECRET);
    const user = await db.users.findById(payload.userId);

    if (!user) {
      return next(new Error('User not found'));
    }

    // Attach user data to the socket for use in all handlers
    socket.userId = user.id;
    socket.username = user.username;

    next(); // allow the connection
  } catch {
    next(new Error('Invalid token'));
  }
});

// All handlers now have socket.userId and socket.username available
io.on('connection', (socket) => {
  console.log(`${socket.username} connected`);
});

const socket = io('http://localhost:3001', {
  auth: {
    token: localStorage.getItem('auth-token')
  }
});

// Handle connection rejection
socket.on('connect_error', (error) => {
  if (error.message === 'Authentication required') {
    redirectToLogin();
  }
});

// Utility: wrap async event handlers to catch unexpected errors
function asyncHandler(fn) {
  return function (...args) {
    Promise.resolve(fn.apply(this, args)).catch((err) => {
      console.error('Unhandled socket error:', err);
      const callback = args[args.length - 1];
      if (typeof callback === 'function') {
        callback({ ok: false, error: 'Internal server error' });
      }
    });
  };
}

io.on('connection', (socket) => {
  socket.on('send-message', asyncHandler(async (data, callback) => {
    const message = await db.messages.create(data);
    callback({ ok: true, id: message.id });
  }));
});

function createRateLimiter(maxPerSecond) {
  return function (socket, next) {
    let count = 0;
    const interval = setInterval(() => { count = 0; }, 1000);

    const original = socket.onevent;
    socket.onevent = function (packet) {
      if (++count > maxPerSecond) {
        socket.emit('error', { message: 'Too many requests. Slow down.' });
        return;
      }
      original.call(this, packet);
    };

    socket.on('disconnect', () => clearInterval(interval));
    next();
  };
}

// Max 10 events per second per client
io.use(createRateLimiter(10));

npm install @socket.io/redis-adapter ioredis

const { createAdapter } = require('@socket.io/redis-adapter');
const { createClient } = require('ioredis');

const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

io.adapter(createAdapter(pubClient, subClient));

// Rooms now work transparently across all server instances