ysnrfd_messenger/BACKUP4/backend/src/controllers/messageController.js

const Message = require('../models/Message');
const Conversation = require('../models/Conversation');

exports.sendMessage = async (req, res) => {
  try {
    const { conversationId, content, type = 'text', attachment, replyTo } = req.body;
    const userId = req.user.userId;

    // Check if user is part of conversation
    const conversation = await Conversation.findOne({
      _id: conversationId,
      'participants.user': userId
    });

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

    // Create message
    const message = new Message({
      conversation: conversationId,
      sender: userId,
      content,
      type,
      attachment,
      replyTo,
      status: 'sent'
    });

    await message.save();
    await message.populate('sender', 'username displayName avatar status');
    if (replyTo) {
      await message.populate('replyTo');
    }

    // Update conversation's updatedAt and lastMessage
    conversation.updatedAt = new Date();
    conversation.lastMessage = message._id;
    await conversation.save();

    res.status(201).json({
      message: 'Message sent successfully',
      message: message
    });
  } catch (error) {
    console.error('❌ Send message error:', error);
    res.status(500).json({ error: 'Server error sending message' });
  }
};

exports.editMessage = async (req, res) => {
  try {
    const { messageId } = req.params;
    const { content } = req.body;
    const userId = req.user.userId;

    const message = await Message.findOne({
      _id: messageId,
      sender: userId
    });

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

    // Prevent editing messages older than 15 minutes
    const fifteenMinutesAgo = new Date(Date.now() - 15 * 60 * 1000);
    if (message.createdAt < fifteenMinutesAgo) {
      return res.status(400).json({ error: 'Messages can only be edited within 15 minutes of sending' });
    }

    // Save edit history
    message.edits.push({
      content: message.content,
      editedAt: new Date()
    });

    message.content = content;
    message.isEdited = true;
    message.updatedAt = new Date();

    await message.save();
    await message.populate('sender', 'username displayName avatar status');

    res.json({
      message: 'Message updated successfully',
      message: message
    });
  } catch (error) {
    console.error('❌ Edit message error:', error);
    res.status(500).json({ error: 'Server error editing message' });
  }
};

exports.deleteMessage = async (req, res) => {
  try {
    const { messageId } = req.params;
    const userId = req.user.userId;

    const message = await Message.findOne({
      _id: messageId,
      sender: userId
    });

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

    // Soft delete
    message.isDeleted = true;
    message.deletedAt = new Date();
    message.content = 'This message was deleted';
    message.attachment = null;

    await message.save();

    res.json({ message: 'Message deleted successfully' });
  } catch (error) {
    console.error('❌ Delete message error:', error);
    res.status(500).json({ error: 'Server error deleting message' });
  }
};

exports.reactToMessage = async (req, res) => {
  try {
    const { messageId } = req.params;
    const { emoji } = req.body;
    const userId = req.user.userId;

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

    // Check if user already reacted with this emoji
    const existingReactionIndex = message.reactions.findIndex(
      reaction => reaction.user.toString() === userId && reaction.emoji === emoji
    );

    if (existingReactionIndex > -1) {
      // Remove reaction
      message.reactions.splice(existingReactionIndex, 1);
    } else {
      // Add reaction
      message.reactions.push({
        user: userId,
        emoji,
        createdAt: new Date()
      });
    }

    await message.save();
    await message.populate('reactions.user', 'username displayName');

    res.json({
      message: 'Reaction updated successfully',
      reactions: message.reactions
    });
  } catch (error) {
    console.error('❌ React to message error:', error);
    res.status(500).json({ error: 'Server error updating reaction' });
  }
};

exports.markAsRead = async (req, res) => {
  try {
    const { messageId } = req.params;
    const userId = req.user.userId;

    const message = await Message.findByIdAndUpdate(
      messageId,
      {
        $addToSet: { readBy: { user: userId, readAt: new Date() } }
      },
      { new: true }
    );

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

    // Update user's last read in conversation
    await Conversation.updateOne(
      {
        _id: message.conversation,
        'participants.user': userId
      },
      {
        $set: {
          'participants.$.lastRead': new Date()
        }
      }
    );

    res.json({ message: 'Message marked as read' });
  } catch (error) {
    console.error('❌ Mark as read error:', error);
    res.status(500).json({ error: 'Server error marking message as read' });
  }
};