rentall-app/backend/routes/messages.js

const express = require('express');
const { Message, User } = require('../models');
const { authenticateToken } = require('../middleware/auth');
const logger = require('../utils/logger');
const { emitNewMessage, emitMessageRead } = require('../sockets/messageSocket');
const router = express.Router();

// Get all messages for the current user (inbox)
router.get('/', authenticateToken, async (req, res) => {
  try {
    const messages = await Message.findAll({
      where: { receiverId: req.user.id },
      include: [
        {
          model: User,
          as: 'sender',
          attributes: ['id', 'firstName', 'lastName', 'profileImage']
        }
      ],
      order: [['createdAt', 'DESC']]
    });

    const reqLogger = logger.withRequestId(req.id);
    reqLogger.info("Messages inbox fetched", {
      userId: req.user.id,
      messageCount: messages.length
    });

    res.json(messages);
  } catch (error) {
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.error("Messages inbox fetch failed", {
      error: error.message,
      stack: error.stack,
      userId: req.user.id
    });
    res.status(500).json({ error: error.message });
  }
});

// Get sent messages
router.get('/sent', authenticateToken, async (req, res) => {
  try {
    const messages = await Message.findAll({
      where: { senderId: req.user.id },
      include: [
        {
          model: User,
          as: 'receiver',
          attributes: ['id', 'firstName', 'lastName', 'profileImage']
        }
      ],
      order: [['createdAt', 'DESC']]
    });

    const reqLogger = logger.withRequestId(req.id);
    reqLogger.info("Sent messages fetched", {
      userId: req.user.id,
      messageCount: messages.length
    });

    res.json(messages);
  } catch (error) {
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.error("Sent messages fetch failed", {
      error: error.message,
      stack: error.stack,
      userId: req.user.id
    });
    res.status(500).json({ error: error.message });
  }
});

// Get a single message with replies
router.get('/:id', authenticateToken, async (req, res) => {
  try {
    const message = await Message.findOne({
      where: { 
        id: req.params.id,
        [require('sequelize').Op.or]: [
          { senderId: req.user.id },
          { receiverId: req.user.id }
        ]
      },
      include: [
        {
          model: User,
          as: 'sender',
          attributes: ['id', 'firstName', 'lastName', 'profileImage']
        },
        {
          model: User,
          as: 'receiver',
          attributes: ['id', 'firstName', 'lastName', 'profileImage']
        },
        {
          model: Message,
          as: 'replies',
          include: [{
            model: User,
            as: 'sender',
            attributes: ['id', 'firstName', 'lastName', 'profileImage']
          }]
        }
      ]
    });

    if (!message) {
      return res.status(404).json({ error: 'Message not found' });
    }

    // Mark as read if user is the receiver
    const wasUnread = message.receiverId === req.user.id && !message.isRead;
    if (wasUnread) {
      await message.update({ isRead: true });

      // Emit socket event to sender for real-time read receipt
      const io = req.app.get('io');
      if (io) {
        emitMessageRead(io, message.senderId, {
          messageId: message.id,
          readAt: new Date().toISOString(),
          readBy: req.user.id
        });
      }
    }

    const reqLogger = logger.withRequestId(req.id);
    reqLogger.info("Message fetched", {
      userId: req.user.id,
      messageId: req.params.id,
      markedAsRead: wasUnread
    });

    res.json(message);
  } catch (error) {
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.error("Message fetch failed", {
      error: error.message,
      stack: error.stack,
      userId: req.user.id,
      messageId: req.params.id
    });
    res.status(500).json({ error: error.message });
  }
});

// Send a new message
router.post('/', authenticateToken, async (req, res) => {
  try {
    const { receiverId, subject, content, parentMessageId } = req.body;

    // Check if receiver exists
    const receiver = await User.findByPk(receiverId);
    if (!receiver) {
      return res.status(404).json({ error: 'Receiver not found' });
    }

    // Prevent sending messages to self
    if (receiverId === req.user.id) {
      return res.status(400).json({ error: 'Cannot send messages to yourself' });
    }

    const message = await Message.create({
      senderId: req.user.id,
      receiverId,
      subject,
      content,
      parentMessageId
    });

    const messageWithSender = await Message.findByPk(message.id, {
      include: [{
        model: User,
        as: 'sender',
        attributes: ['id', 'firstName', 'lastName', 'profileImage']
      }]
    });

    // Emit socket event to receiver for real-time notification
    const io = req.app.get('io');
    if (io) {
      emitNewMessage(io, receiverId, messageWithSender.toJSON());
    }

    const reqLogger = logger.withRequestId(req.id);
    reqLogger.info("Message sent", {
      senderId: req.user.id,
      receiverId: receiverId,
      messageId: message.id,
      isReply: !!parentMessageId
    });

    res.status(201).json(messageWithSender);
  } catch (error) {
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.error("Message send failed", {
      error: error.message,
      stack: error.stack,
      senderId: req.user.id,
      receiverId: req.body.receiverId
    });
    res.status(500).json({ error: error.message });
  }
});

// Mark message as read
router.put('/:id/read', authenticateToken, async (req, res) => {
  try {
    const message = await Message.findOne({
      where: { 
        id: req.params.id,
        receiverId: req.user.id
      }
    });

    if (!message) {
      return res.status(404).json({ error: 'Message not found' });
    }

    await message.update({ isRead: true });

    // Emit socket event to sender for real-time read receipt
    const io = req.app.get('io');
    if (io) {
      emitMessageRead(io, message.senderId, {
        messageId: message.id,
        readAt: new Date().toISOString(),
        readBy: req.user.id
      });
    }

    const reqLogger = logger.withRequestId(req.id);
    reqLogger.info("Message marked as read", {
      userId: req.user.id,
      messageId: req.params.id
    });

    res.json(message);
  } catch (error) {
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.error("Message mark as read failed", {
      error: error.message,
      stack: error.stack,
      userId: req.user.id,
      messageId: req.params.id
    });
    res.status(500).json({ error: error.message });
  }
});

// Get unread message count
router.get('/unread/count', authenticateToken, async (req, res) => {
  try {
    const count = await Message.count({
      where: { 
        receiverId: req.user.id,
        isRead: false
      }
    });
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.info("Unread message count fetched", {
      userId: req.user.id,
      unreadCount: count
    });

    res.json({ count });
  } catch (error) {
    const reqLogger = logger.withRequestId(req.id);
    reqLogger.error("Unread message count fetch failed", {
      error: error.message,
      stack: error.stack,
      userId: req.user.id
    });
    res.status(500).json({ error: error.message });
  }
});

module.exports = router;