import { Server, Socket } from 'socket.io';
import jwt from 'jsonwebtoken';
import mongoose from 'mongoose';
import { getRoomKeyForUsers } from '../../lib/chat-helper';
import {
  resolveConversationScanObjectId,
  type ResolveConversationScanOptions,
} from '../../lib/resolveChatScanId';
import ConversationModel from '../../models/Conversation';
import MessageModel from '../../models/Messages';
import ScanModel from '../../models/Scan';
import GuestUserModel from '../../models/GuestUser';
import { validateGuestToken } from '../../utils/GuestTokenUtils';
import { getConversationsOptimized } from '../../utils/SocketUtil';
import { NotificationService } from '../../controllers/notification/NotificationService';
import { NotificationUtils } from '../../utils/NotificationUtils';
import LocationModel from '../../models/Location';
import { ILocationModel } from '../../types';
import { humanizeClientError } from '../../utils/humanReadableError';

interface SocketData {
  userId: string | null;
  email: string | null;
  role: string | null;
}

interface JwtPayload {
  userId: string;
  email: string;
  role: string;
}

function resolveScanOptsForGuest(
  socket: Socket,
  qrcode_id?: string
): ResolveConversationScanOptions | undefined {
  if (socket.data.role !== 'guest') {
    return undefined;
  }
  const opts: ResolveConversationScanOptions = { forAnonymousUser: true };
  if (qrcode_id?.trim()) {
    opts.qrcode_id = qrcode_id.trim();
  }
  return opts;
}

function isGuestAnonSocket(socket: Socket): boolean {
  return socket.data.role === 'guest';
}

function getSocketRoomForPair(
  a: string,
  b: string,
  conversation: { scan_id?: unknown },
  resolvedScanIdForRoom?: string | null
): string {
  const sid =
    conversation.scan_id != null
      ? String(conversation.scan_id)
      : resolvedScanIdForRoom || undefined;
  return getRoomKeyForUsers(a, b, sid);
}

export default function initSocket(io: Server) {
  //  ============= SOCKET HANDSHAKE =================
  io.use(async (socket: Socket, next) => {
    try {
      const tokenParam = socket.handshake.query?.publicToken;
      const token = Array.isArray(tokenParam) ? tokenParam[0] : tokenParam || '';

      console.log(`==========================================`);
      console.log(token, 'This is Socket Token');
      console.log(socket.handshake);
      console.log(`==========================================`);

      if (token) {
        const secret = process.env.JWT_SECRET;
        if (!secret) {
          console.error('JWT_SECRET is not defined');
          return next(new Error('Internal server error'));
        }

        const payload = jwt.verify(token, secret) as any;

        console.log(payload, 'This is Socket Payload');

        // Validate JWT payload structure
        if (typeof payload !== 'object' || payload === null) {
          console.error('Invalid JWT payload structure');
          return next(new Error('Authentication error: Invalid token'));
        }

        if (payload.type === 'guest') {
          // Prefer stable guestUserId in JWT so rotating guest_token (new JWT each scan) still authenticates
          let guestUser: any = null;
          const guestUserId = payload.guestUserId as string | undefined;
          if (guestUserId && mongoose.Types.ObjectId.isValid(guestUserId)) {
            guestUser = await GuestUserModel.findById(guestUserId);
          }
          if (!guestUser) {
            guestUser = await GuestUserModel.findOne({ guest_token: token });
          }
          if (guestUser) {
            socket.data.userId = guestUser._id.toString();
            socket.data.email = null;
            socket.data.role = 'guest';
          } else {
            socket.data.userId = null;
          }
        } else {
          // For non-guest tokens, ensure essential fields exist
          if (!payload.userId) {
            console.error('JWT missing required userId field');
            return next(new Error('Authentication error: Invalid token'));
          }
          socket.data.userId = payload?.userId ?? null;
          socket.data.email = payload?.email ?? null;
          socket.data.role = payload?.role ?? null;
        }
      } else {
        socket.data.userId = null;
      }
      return next();
    } catch (err) {
      console.warn('Socket auth error:', err);

      // Type guard to check if err is an Error object
      if (err instanceof Error) {
        // Properly handle JWT errors - specifically reject invalid signatures
        if (err.name === 'JsonWebTokenError' || err.name === 'TokenExpiredError') {
          console.error('JWT Authentication failed:', err.message);
          return next(new Error('Authentication error: Invalid token'));
        }
      }

      // For other errors, still allow connection but set userId to null
      socket.data.userId = null;
      return next();
    }
  });

  // ========== SOCKET CONNECTION ====================
  io.on('connection', (socket: Socket) => {
    console.log('Socket connected:', {
      socketId: socket.id,
      userId: socket.data.userId,
    });

    // ============ DISCONNECT ===================
    socket.on('disconnect', reason => {
      console.log('Socket disconnected:', {
        socketId: socket.id,
        userId: socket.data.userId,
        reason,
      });
    });

    // ============ JOIN ROOM ===================
    socket.on(
      'join_room',
      async (
        {
          otherUserId,
          scan_id,
          qrcode_id,
          conversation_id,
          conversationId,
        }: {
          otherUserId: string;
          scan_id?: string;
          /** Guest/anonymous only — scopes scan resolution to this QR. */
          qrcode_id?: string;
          conversation_id?: string;
          conversationId?: string;
        },
        callback?: (response: any) => void
      ) => {
        try {
          const conversationIdRaw =
            conversation_id?.trim() || conversationId?.trim() || null;

          console.log('join_room: Event received', {
            socketId: socket.id,
            myId: socket.data.userId,
            otherUserId,
            scan_id,
            qrcode_id,
            conversation_id: conversationIdRaw,
          });

          const myId = socket.data.userId;
          if (!myId || !otherUserId) {
            console.warn('join_room: Missing required parameters', {
              socketId: socket.id,
              myId,
              otherUserId,
            });
            if (callback && typeof callback === 'function') {
              callback({
                success: false,
                error: 'Missing user ID or otherUserId',
              });
            }
            return;
          }

          if (myId === otherUserId) {
            throw Error('Cannot join room with yourself');
          }

          const a = String(myId);
          const b = String(otherUserId);
          const participants = [a, b];

          let scanObjectId: mongoose.Types.ObjectId | null = null;
          let conversation = null as InstanceType<typeof ConversationModel> | null;

          if (conversationIdRaw) {
            conversation = await ConversationModel.findOne({
              _id: conversationIdRaw,
              participants: myId,
            });
            if (!conversation) {
              if (callback && typeof callback === 'function') {
                callback({
                  success: false,
                  error: 'Conversation not found or you are not a participant',
                });
              }
              return;
            }
            if (conversation.scan_id != null) {
              scanObjectId = new mongoose.Types.ObjectId(String(conversation.scan_id));
            }
          } else {
            scanObjectId = await resolveConversationScanObjectId(
              scan_id,
              myId,
              otherUserId,
              resolveScanOptsForGuest(socket, qrcode_id)
            );

            const guestAnon = isGuestAnonSocket(socket);

            if (guestAnon && !scanObjectId) {
              const latestGuest = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: true,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestGuest?.scan_id) {
                conversation = latestGuest;
                scanObjectId = new mongoose.Types.ObjectId(String(latestGuest.scan_id));
              }
            }

            if (!conversation) {
              conversation = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                scan_id: scanObjectId,
              });
            }

            if (!conversation && !guestAnon && !scanObjectId) {
              const latestReg = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: false,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestReg?.scan_id) {
                conversation = latestReg;
                scanObjectId = new mongoose.Types.ObjectId(String(latestReg.scan_id));
              }
            }

            if (!conversation) {
              if (!scanObjectId) {
                if (callback && typeof callback === 'function') {
                  callback({
                    success: false,
                    error: guestAnon
                      ? 'Anonymous chat needs scan_id or qrcode_id, or pass conversation_id from an existing thread'
                      : 'Pass conversation_id to reopen a thread, or scan_id / qrcode_id for a new scan-scoped chat',
                  });
                }
                return;
              }
              console.log(
                'join_room: No existing conversation found, creating new one',
                {
                  participants,
                  scan_id: scanObjectId,
                  anonymous: guestAnon,
                }
              );
              conversation = await ConversationModel.create({
                participants,
                scan_id: scanObjectId,
                anonymous: guestAnon,
              });
              console.log('join_room: Created new conversation', {
                conversationId: conversation._id,
                participants: conversation.participants,
                scan_id: conversation.scan_id,
              });
            } else {
              console.log('join_room: Using existing conversation', {
                conversationId: conversation._id,
                participants: conversation.participants,
                scan_id: conversation.scan_id,
              });
            }
          }

          if (conversation.scan_id != null) {
            scanObjectId = new mongoose.Types.ObjectId(String(conversation.scan_id));
          }

          const room = getSocketRoomForPair(
            a,
            b,
            conversation,
            scanObjectId ? String(scanObjectId) : null
          );
          socket.join(room);
          console.log('join_room: Socket joined room successfully', {
            socketId: socket.id,
            room,
            conversationId: conversation._id,
            participants: conversation.participants,
            scan_id: conversation.scan_id,
          });

          // Fetch messages for this conversation with aggregate to check both User and GuestUser
          const messages = await MessageModel.aggregate([
            {
              $match: {
                conversation_id: conversation._id,
              },
            },
            {
              $sort: { createdAt: 1 },
            },
            {
              $lookup: {
                from: 'users',
                localField: 'sender_id',
                foreignField: '_id',
                as: 'userSender',
              },
            },
            {
              $lookup: {
                from: 'guest_users',
                localField: 'sender_id',
                foreignField: '_id',
                as: 'guestSender',
              },
            },
            {
              $addFields: {
                sender_id: {
                  $cond: {
                    if: { $gt: [{ $size: '$userSender' }, 0] },
                    then: {
                      _id: { $arrayElemAt: ['$userSender._id', 0] },
                      name: {
                        $concat: [
                          {
                            $ifNull: [
                              { $arrayElemAt: ['$userSender.first_name', 0] },
                              '',
                            ],
                          },
                          ' ',
                          {
                            $ifNull: [
                              { $arrayElemAt: ['$userSender.last_name', 0] },
                              '',
                            ],
                          },
                        ],
                      },
                      email: { $arrayElemAt: ['$userSender.email', 0] },
                      profilePicture: {
                        $arrayElemAt: ['$userSender.profile_picture', 0],
                      },
                      type: 'user',
                    },
                    else: {
                      $cond: {
                        if: { $gt: [{ $size: '$guestSender' }, 0] },
                        then: {
                          _id: { $arrayElemAt: ['$guestSender._id', 0] },
                          name: { $arrayElemAt: ['$guestSender.name', 0] },
                          email: null,
                          profilePicture: null,
                          type: 'guest',
                        },
                        else: null,
                      },
                    },
                  },
                },
              },
            },
            {
              $project: {
                userSender: 0,
                guestSender: 0,
              },
            },
          ]);

          console.log('join_room: Fetched messages', {
            conversationId: conversation._id,
            messageCount: messages.length,
          });

          // Fetch scan + scan-tagged messages for UI (current QR/scan when provided, else conversation scan)
          const scanIdForUi =
            scanObjectId ??
            (conversation.scan_id != null
              ? new mongoose.Types.ObjectId(String(conversation.scan_id))
              : null);

          let populatedScan = null;
          let scanMessages = [];
          if (scanIdForUi) {
            const scan = await ScanModel.findById(scanIdForUi)
              .populate('qrcode_id')
              .populate('scanned_by', 'name email profilePicture')
              .lean();

            // Fetch messages associated with this scan with aggregate to check both User and GuestUser
            scanMessages = await MessageModel.aggregate([
              {
                $match: {
                  scan_id: scanIdForUi,
                },
              },
              {
                $sort: { createdAt: 1 },
              },
              {
                $lookup: {
                  from: 'users',
                  localField: 'sender_id',
                  foreignField: '_id',
                  as: 'userSender',
                },
              },
              {
                $lookup: {
                  from: 'guest_users',
                  localField: 'sender_id',
                  foreignField: '_id',
                  as: 'guestSender',
                },
              },
              {
                $addFields: {
                  sender_id: {
                    $cond: {
                      if: { $gt: [{ $size: '$userSender' }, 0] },
                      then: {
                        _id: { $arrayElemAt: ['$userSender._id', 0] },
                        name: {
                          $concat: [
                            {
                              $ifNull: [
                                { $arrayElemAt: ['$userSender.first_name', 0] },
                                '',
                              ],
                            },
                            ' ',
                            {
                              $ifNull: [
                                { $arrayElemAt: ['$userSender.last_name', 0] },
                                '',
                              ],
                            },
                          ],
                        },
                        email: { $arrayElemAt: ['$userSender.email', 0] },
                        profilePicture: {
                          $arrayElemAt: ['$userSender.profile_picture', 0],
                        },
                        type: 'user',
                      },
                      else: {
                        $cond: {
                          if: { $gt: [{ $size: '$guestSender' }, 0] },
                          then: {
                            _id: { $arrayElemAt: ['$guestSender._id', 0] },
                            name: { $arrayElemAt: ['$guestSender.name', 0] },
                            email: null,
                            profilePicture: null,
                            type: 'guest',
                          },
                          else: null,
                        },
                      },
                    },
                  },
                },
              },
              {
                $project: {
                  userSender: 0,
                  guestSender: 0,
                },
              },
            ]);

            populatedScan = {
              ...scan,
              messages: scanMessages,
            };

            console.log('join_room: Fetched scan with messages', {
              scanId: scanIdForUi,
              scanMessageCount: scanMessages.length,
            });
          }

          // Send acknowledgment with room, conversation, messages, and scan details
          if (callback && typeof callback === 'function') {
            const response = {
              success: true,
              room,
              conversationId: conversation._id,
              participants: conversation.participants,
              scan_id: conversation.scan_id,
              messages,
              scan: populatedScan,
            };
            console.log('join_room: Sending success callback', {
              room,
              conversationId: conversation._id,
              messageCount: messages.length,
              messages,
              scanMessageCount: scanMessages.length,
            });
            callback(response);
          }
        } catch (err) {
          console.error('join_room: Error occurred', {
            socketId: socket.id,
            error: err instanceof Error ? err.message : 'Unknown error',
            stack: err instanceof Error ? err.stack : undefined,
          });
          if (callback && typeof callback === 'function') {
            callback({
              success: false,
              error: humanizeClientError(
                err,
                'Something went wrong while joining the chat. Please try again.'
              ),
            });
          }
        }
      }
    );

    // ============ GET MESSAGES ===================
    socket.on(
      'get_messages',
      async ({
        otherUserId,
        scan_id,
        qrcode_id,
        conversation_id,
        conversationId,
      }: {
        otherUserId?: string;
        scan_id?: string;
        qrcode_id?: string;
        conversation_id?: string;
        conversationId?: string;
      }) => {
        try {
          const myId = socket.data.userId;
          const conversationIdRaw =
            conversation_id?.trim() || conversationId?.trim() || null;

          console.log('get_messages: Event received', {
            socketId: socket.id,
            myId,
            otherUserId: otherUserId ?? null,
            scan_id: scan_id ?? null,
            qrcode_id: qrcode_id ?? null,
            conversation_id: conversation_id?.trim() ?? null,
            conversationId: conversationId?.trim() ?? null,
            conversationIdResolved: conversationIdRaw,
          });

          if (!myId) {
            console.warn('get_messages: Missing user ID');
            return;
          }
          if (!conversationIdRaw && !otherUserId) {
            console.warn('get_messages: Need otherUserId or conversation_id');
            socket.emit('messages_error', {
              error: 'otherUserId or conversation_id is required',
            });
            return;
          }

          let conversation = null as InstanceType<typeof ConversationModel> | null;

          if (conversationIdRaw) {
            conversation = await ConversationModel.findOne({
              _id: conversationIdRaw,
              participants: myId,
            });
          } else {
            const a = String(myId);
            const b = String(otherUserId);
            const participants = [a, b];
            let scanObjectId = await resolveConversationScanObjectId(
              scan_id,
              myId,
              otherUserId!,
              resolveScanOptsForGuest(socket, qrcode_id)
            );

            const guestAnon = isGuestAnonSocket(socket);

            if (guestAnon && !scanObjectId) {
              const latestGuest = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: true,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestGuest?.scan_id) {
                conversation = latestGuest;
                scanObjectId = new mongoose.Types.ObjectId(String(latestGuest.scan_id));
              }
            }

            if (!conversation) {
              conversation = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                scan_id: scanObjectId,
              });
            }

            if (!conversation && !guestAnon && !scanObjectId) {
              const latestReg = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: false,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestReg) {
                conversation = latestReg;
              }
            }

            if (guestAnon && !conversation) {
              socket.emit('messages_error', {
                error:
                  'Anonymous chat needs scan_id or qrcode_id, or pass conversation_id from an existing thread',
              });
              return;
            }
          }

          if (!conversation) {
            console.log('get_messages: No conversation found', {
              socketId: socket.id,
              myId,
              conversationIdResolved: conversationIdRaw,
              otherUserId: otherUserId ?? null,
            });
            socket.emit('messages_retrieved', {
              conversation_id: null,
              messages: [],
            });
            return;
          }

          // Fetch all messages for this conversation
          const messages = await MessageModel.find({
            conversation_id: conversation._id,
          })
            .sort({ createdAt: -1 }) // newest first
            .lean();

          console.log('get_messages: Retrieved', {
            socketId: socket.id,
            myId,
            conversationId: String(conversation._id),
            scan_id: conversation.scan_id != null ? String(conversation.scan_id) : null,
            messageCount: messages.length,
          });

          socket.emit('messages_retrieved', {
            conversation_id: String(conversation._id),
            messages: messages,
          });
        } catch (err) {
          console.error('get_messages error:', err);
          socket.emit('messages_error', { error: 'Failed to retrieve messages' });
        }
      }
    );

    // ============ GET ROOM MESSAGE COUNT ===================
    socket.on(
      'get_room_message_count',
      async ({
        otherUserId,
        conversationId,
        conversation_id,
        scan_id,
        qrcode_id,
      }: {
        otherUserId?: string;
        conversationId?: string;
        conversation_id?: string;
        scan_id?: string;
        qrcode_id?: string;
      }) => {
        try {
          const myId = socket.data.userId;
          if (!myId) {
            console.warn('get_room_message_count: Missing user ID');
            return;
          }

          const conversationIdRaw =
            conversation_id?.trim() || conversationId?.trim() || null;

          let conversation = null as InstanceType<typeof ConversationModel> | null;

          if (conversationIdRaw) {
            conversation = await ConversationModel.findOne({
              _id: conversationIdRaw,
              participants: myId,
            });
          } else if (otherUserId) {
            const a = String(myId);
            const b = String(otherUserId);
            const participants = [a, b];
            let scanObjectId = await resolveConversationScanObjectId(
              scan_id,
              myId,
              otherUserId,
              resolveScanOptsForGuest(socket, qrcode_id)
            );

            const guestAnon = isGuestAnonSocket(socket);

            if (guestAnon && !scanObjectId) {
              const latestGuest = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: true,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestGuest?.scan_id) {
                conversation = latestGuest;
                scanObjectId = new mongoose.Types.ObjectId(String(latestGuest.scan_id));
              }
            }

            if (!conversation) {
              conversation = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                scan_id: scanObjectId,
              });
            }

            if (!conversation && !guestAnon && !scanObjectId) {
              const latestReg = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: false,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestReg) {
                conversation = latestReg;
              }
            }
          } else {
            console.warn(
              'get_room_message_count: Missing conversation id and otherUserId'
            );
            socket.emit('room_message_count_error', {
              error: 'conversation_id / conversationId or otherUserId is required',
            });
            return;
          }

          if (!conversation) {
            console.warn('get_room_message_count: Conversation not found');
            socket.emit('room_message_count', {
              conversation_id: conversationIdRaw || null,
              totalCount: 0,
              unreadCount: 0,
            });
            return;
          }

          const conversationIdStr = conversation._id.toString();

          const totalCount = await MessageModel.countDocuments({
            conversation_id: conversation._id,
          });

          const unreadCount = await MessageModel.countDocuments({
            conversation_id: conversation._id,
            sender_id: { $ne: myId },
            readBy: { $ne: myId },
          });

          socket.emit('room_message_count', {
            conversation_id: conversationIdStr,
            totalCount,
            unreadCount,
          });
        } catch (err) {
          const e: any = err;
          console.error(
            'get_room_message_count error:',
            e && e.message ? e.message : e
          );
          socket.emit('room_message_count_error', {
            error: 'Failed to get room message count',
            details: e?.message,
          });
        }
      }
    );

    // ============ SEND MESSAGE ===================
    socket.on(
      'send_message',
      async (payload: {
        otherUserId: string;
        content: string;
        scan_id?: string;
        /** Guest/anonymous only — scopes scan resolution to this QR. */
        qrcode_id?: string;
        conversation_id?: string;
        /** Same as conversation_id; some clients send camelCase. */
        conversationId?: string;
        sender_display?: string;
        longitude?: number;
        latitude?: number;
      }) => {
        try {
          const myId = socket.data.userId;
          console.log(socket?.data, 'This is Socket');

          if (!myId) {
            console.warn('send_message: Missing user ID');
            return;
          }

          const {
            otherUserId,
            content,
            sender_display,
            longitude,
            latitude,
            scan_id,
            qrcode_id,
            conversation_id,
            conversationId,
          } = payload;

          if (!otherUserId) {
            console.warn('send_message: Missing required parameters');
            return;
          }

          // ============ CREATE LOCATION ==================
          let location: any = null;
          if (longitude && latitude) {
            location = await (
              LocationModel as unknown as ILocationModel
            ).createWithGeocode(latitude, longitude);
          }

          const a = String(myId);
          const b = String(otherUserId);
          const participants = [a, b];

          const conversationIdRaw =
            conversation_id?.trim() || conversationId?.trim() || null;

          let resolvedScanId: mongoose.Types.ObjectId | null = null;
          let conversation = null as InstanceType<typeof ConversationModel> | null;

          if (conversationIdRaw) {
            conversation = await ConversationModel.findOne({
              _id: conversationIdRaw,
              participants: myId,
            });
          } else {
            resolvedScanId = await resolveConversationScanObjectId(
              scan_id,
              myId,
              otherUserId,
              resolveScanOptsForGuest(socket, qrcode_id)
            );

            const guestAnon = isGuestAnonSocket(socket);

            if (guestAnon && !resolvedScanId) {
              const latestWithScan = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                anonymous: true,
                scan_id: { $ne: null },
              })
                .sort({ updatedAt: -1 })
                .exec();
              if (latestWithScan?.scan_id) {
                conversation = latestWithScan;
                resolvedScanId = new mongoose.Types.ObjectId(
                  String(latestWithScan.scan_id)
                );
              }
            }

            if (!conversation) {
              if (guestAnon && !resolvedScanId) {
                console.warn(
                  'send_message: Anonymous send needs conversation_id, or scan_id/qrcode_id, or an existing guest conversation with scan_id in DB'
                );
                return;
              }
              conversation = await ConversationModel.findOne({
                participants: { $all: participants, $size: 2 },
                scan_id: resolvedScanId,
              });
            }

            if (!conversation) {
              if (resolvedScanId == null) {
                console.warn(
                  'send_message: Cannot create scan-scoped conversation without scan_id / qrcode_id'
                );
                return;
              }
              console.log('send_message: Creating new conversation');
              conversation = await ConversationModel.create({
                participants,
                scan_id: resolvedScanId,
                anonymous: guestAnon,
              });
            }
          }

          if (!conversation) {
            console.warn('send_message: Conversation not found or access denied');
            return;
          }

          if (conversation.scan_id != null) {
            resolvedScanId = new mongoose.Types.ObjectId(String(conversation.scan_id));
          }

          // create and save message
          const messageDoc = new MessageModel({
            conversation_id: conversation._id,
            sender_id: myId,
            sender_display: sender_display || null,
            content: content.trim(),
            location_id: location?._id || null,
            ...(resolvedScanId != null ? { scan_id: resolvedScanId } : {}),
          });

          const savedMessage = await messageDoc.save();

          // update conversation last_message
          conversation.last_message = savedMessage._id;
          await conversation.save();

          const roomScanId =
            conversation.scan_id != null
              ? String(conversation.scan_id)
              : resolvedScanId != null
                ? String(resolvedScanId)
                : scan_id || undefined;
          const room = getSocketRoomForPair(a, b, conversation, roomScanId || null);

          console.log(`============== THIS IS ROOM ==============`);
          console.log(room);
          console.log(`============== THIS IS ROOM ==============`);

          socket.join(room);

          // ============ CREATE NOTIFICATION ================
          try {
            await NotificationUtils.createMessageNotification(
              otherUserId,
              'New Message',
              content,
              `/dashboard/notifications`,
              conversation?.scan_id?.toString()
                ? conversation.scan_id.toString()
                : undefined
            );
          } catch (error) {
            // Log error but don't necessarily throw - notifications are often non-critical
            console.error('Notification failed:', error);
          }

          // Emit to room (both participants)
          io.to(room).emit('new_message', {
            conversation_id: String(conversation._id),
            message: {
              _id: savedMessage._id,
              conversation_id: savedMessage.conversation_id,
              sender_id: savedMessage.sender_id,
              sender_display: savedMessage.sender_display,
              content: savedMessage.content,
              createdAt: savedMessage.createdAt,
              updatedAt: savedMessage.updatedAt,
              location: location,
            },
          });
        } catch (err) {
          console.error('send_message error:', err);
        }
      }
    );

    // ============ MARK AS READ ===================
    socket.on(
      'mark_as_read',
      async ({
        conversationId,
        messageIds,
      }: {
        conversationId: string;
        messageIds: string[];
      }) => {
        try {
          const myId = socket.data.userId;
          if (!myId || !conversationId) {
            console.warn('mark_as_read: Missing user ID or conversationId');
            return;
          }

          // Verify the user is a participant in the conversation
          const conversation = await ConversationModel.findOne({
            _id: conversationId,
            participants: myId,
          });

          if (!conversation) {
            console.warn(
              'mark_as_read: Conversation not found or user not participant'
            );
            return;
          }

          // Update messages as read
          await MessageModel.updateMany(
            {
              _id: { $in: messageIds },
              conversation_id: conversationId,
            },
            {
              $addToSet: { readBy: myId },
              $set: { is_read: true },
            }
          );

          // Notify other participants in the conversation
          const otherParticipants = conversation.participants
            .map((participantId: mongoose.Types.ObjectId) => participantId.toString())
            .filter((participantId: string) => participantId !== myId);

          // Emit to all participants that messages were read
          otherParticipants.forEach((otherUserId: string) => {
            const room = getSocketRoomForPair(
              String(myId),
              String(otherUserId),
              conversation
            );
            io.to(room).emit('messages_read', {
              conversation_id: conversationId,
              messageIds,
              readBy: myId,
              readAt: new Date(),
            });
          });
        } catch (err) {
          console.error('mark_as_read error:', err);
        }
      }
    );

    // ============ MARK CONVERSATION AS READ ===================
    socket.on(
      'mark_conversation_read',
      async ({ conversationId }: { conversationId: string }) => {
        try {
          const myId = socket.data.userId;
          if (!myId || !conversationId) {
            console.warn('mark_conversation_read: Missing user ID or conversationId');
            return;
          }

          // Verify the user is a participant in the conversation
          const conversation = await ConversationModel.findOne({
            _id: conversationId,
            participants: myId,
          });

          if (!conversation) {
            console.warn(
              'mark_conversation_read: Conversation not found or user not participant'
            );
            return;
          }

          // Mark all unread messages in conversation as read
          const result = await MessageModel.updateMany(
            {
              conversation_id: conversationId,
              sender_id: { $ne: myId }, // Don't mark own messages as read
              readBy: { $ne: myId }, // Only update if not already read by this user
            },
            {
              $addToSet: { readBy: myId },
              $set: { isRead: true },
            }
          );

          // Notify other participants
          const otherParticipants = conversation.participants
            .map((participantId: mongoose.Types.ObjectId) => participantId.toString())
            .filter((participantId: string) => participantId !== myId);

          otherParticipants.forEach((otherUserId: string) => {
            const room = getSocketRoomForPair(
              String(myId),
              String(otherUserId),
              conversation
            );
            io.to(room).emit('conversation_read', {
              conversation_id: conversationId,
              readBy: myId,
              readAt: new Date(),
              messageCount: result.modifiedCount,
            });
          });
        } catch (err) {
          console.error('mark_conversation_read error:', err);
        }
      }
    );

    // ============ GET MY ROOMS ===================
    socket.on('get_my_rooms', async () => {
      console.log('get_my_rooms event triggered:', {
        socketId: socket.id,
        userId: socket.data.userId,
      });

      try {
        const myId = socket.data.userId;
        if (!myId) {
          console.log('get_my_rooms: Missing user ID');
          socket.emit('my_rooms_error', { error: 'Unauthorized' });
          return;
        }

        // Batched rooms; scan uses Conversation.withScanPopulate + last_message.scan_id fallback (SocketUtil)
        const conversations = await getConversationsOptimized(myId);

        console.log('get_my_rooms: Found conversations:', {
          userId: myId,
          count: conversations.length,
        });

        console.log('get_my_rooms: Sending rooms to user:', {
          userId: myId,
          roomsCount: conversations?.length,
        });

        console.log(`=========== THIS IS ROOM RETRIVED ================`);
        console.log(conversations);
        console.log(`=========== THIS IS ROOM RETRIVED ================`);

        // Emit the rooms back to the requesting socket
        socket.emit('my_rooms_retrieved', {
          success: true,
          rooms: conversations,
        });
      } catch (err) {
        const e: any = err;
        console.error('get_my_rooms error:', e && e.message ? e.message : e);
        socket.emit('my_rooms_error', {
          error: 'Failed to retrieve rooms',
          details: e?.message,
        });
      }
    });
    // ============ GET ROOM INFO ===================
    socket.on(
      'get_room_info',
      async ({ conversationId }: { conversationId: string }) => {
        console.log('get_room_info event triggered:', {
          socketId: socket.id,
          userId: socket.data.userId,
          conversationId,
        });

        try {
          const myId = socket.data.userId;
          if (!myId || !conversationId) {
            console.log('get_room_info: Missing user ID or conversationId');
            socket.emit('room_info_error', { error: 'Missing parameters' });
            return;
          }

          // Find the conversation
          const conversation = await ConversationModel.findOne({
            _id: conversationId,
            participants: myId,
          });

          if (!conversation) {
            console.log(
              'get_room_info: Conversation not found or user not participant'
            );
            socket.emit('room_info_er ror', { error: 'Conversation not found' });
            return;
          }

          // Convert participants to strings properly
          const participantStrings = conversation.participants.map(
            (participant: mongoose.Types.ObjectId) =>
              participant.toString ? participant.toString() : String(participant)
          );

          // Get the other participant
          const otherParticipant = participantStrings.find(
            (participantId: string) => participantId !== myId
          );

          if (!otherParticipant) {
            socket.emit('room_info_error', { error: 'Other participant not found' });
            return;
          }

          const room = getSocketRoomForPair(
            String(myId),
            String(otherParticipant),
            conversation
          );

          // Get last message details if available
          let lastMessageDetails = null;
          if (conversation.last_message) {
            const lastMessage = (await MessageModel.findById(
              conversation.last_message
            ).lean()) as any;
            if (lastMessage) {
              lastMessageDetails = {
                _id: lastMessage._id.toString(),
                content: lastMessage.content,
                sender_id: lastMessage.sender_id?.toString() || '',
                createdAt: lastMessage.createdAt,
              };
            }
          }

          const roomInfo = {
            conversation_id: conversation._id.toString(),
            room,
            participants: participantStrings,
            other_user_id: otherParticipant,
            last_message: lastMessageDetails,
            updatedAt: conversation.updatedAt,
            createdAt: conversation.createdAt,
          };

          console.log('get_room_info: Sending room info:', {
            userId: myId,
            conversationId,
          });

          socket.emit('room_info_retrieved', {
            success: true,
            room: roomInfo,
          });
        } catch (err) {
          const e: any = err;
          console.error('get_room_info error:', e && e.message ? e.message : e);
          socket.emit('room_info_error', {
            error: 'Failed to retrieve room info',
            details: e?.message,
          });
        }
      }
    );

    // ============ TYPING START ===================
    socket.on(
      'typing_start',
      async ({ conversationId }: { conversationId: string }) => {
        console.log('typing_start event triggered:', {
          socketId: socket.id,
          userId: socket.data.userId,
          conversationId,
        });
        try {
          const myId = socket.data.userId;
          if (!myId || !conversationId) {
            console.log('typing_start: Missing user ID or conversationId');
            return;
          }

          // Verify the user is a participant in the conversation
          const conversation = await ConversationModel.findOne({
            _id: conversationId,
            participants: myId,
          });

          if (!conversation) {
            console.log('typing_start: Conversation not found or user not participant');
            return;
          }

          // Notify other participants in the conversation
          const otherParticipants = conversation.participants
            .map((participantId: mongoose.Types.ObjectId) => participantId.toString())
            .filter((participantId: string) => participantId !== myId);

          console.log('Typing - Other participants:', otherParticipants);

          // Emit to all other participants that user started typing
          otherParticipants.forEach((otherUserId: string) => {
            const room = getSocketRoomForPair(
              String(myId),
              String(otherUserId),
              conversation
            );
            console.log('Emitting typing_start to room:', room);

            socket.to(room).emit('user_typing', {
              conversation_id: conversationId,
              userId: myId,
              isTyping: true,
            });
          });
        } catch (err) {
          const e: any = err;
          console.error('typing_start error:', e && e.message ? e.message : e);
        }
      }
    );

    // ============ TYPING STOP ===================
    socket.on('typing_stop', async ({ conversationId }: { conversationId: string }) => {
      console.log('typing_stop event triggered:', {
        socketId: socket.id,
        userId: socket.data.userId,
        conversationId,
      });
      try {
        const myId = socket.data.userId;
        if (!myId || !conversationId) {
          console.log('typing_stop: Missing user ID or conversationId');
          return;
        }

        // Verify the user is a participant in the conversation
        const conversation = await ConversationModel.findOne({
          _id: conversationId,
          participants: myId,
        });

        if (!conversation) {
          console.log('typing_stop: Conversation not found or user not participant');
          return;
        }

        // Notify other participants in the conversation
        const otherParticipants = conversation.participants
          .map((participantId: mongoose.Types.ObjectId) => participantId.toString())
          .filter((participantId: string) => participantId !== myId);

        console.log('Typing stop - Other participants:', otherParticipants);

        // Emit to all other participants that user stopped typing
        otherParticipants.forEach((otherUserId: string) => {
          const room = getSocketRoomForPair(
            String(myId),
            String(otherUserId),
            conversation
          );
          console.log('Emitting typing_stop to room:', room);

          socket.to(room).emit('user_typing', {
            conversation_id: conversationId,
            userId: myId,
            isTyping: false,
          });
        });
      } catch (err) {
        const e: any = err;
        console.error('typing_stop error:', e && e.message ? e.message : e);
      }
    });

    // ============ EDIT MESSAGE ===================
    socket.on(
      'edit_message',
      async (payload: {
        messageId: string;
        newContent: string;
        conversationId?: string;
      }) => {
        console.log('edit_message event triggered:', {
          socketId: socket.id,
          userId: socket.data.userId,
          payload,
        });
        try {
          const myId = socket.data.userId;
          const { messageId, newContent, conversationId } = payload;

          if (!myId || !messageId || !newContent || !newContent.trim()) {
            console.log('edit_message: Missing required parameters');
            socket.emit('edit_message_error', { error: 'Missing required parameters' });
            return;
          }

          // Find the message
          const message = await MessageModel.findById(messageId);

          if (!message) {
            console.log('edit_message: Message not found');
            socket.emit('edit_message_error', { error: 'Message not found' });
            return;
          }

          // Verify the user is the sender of the message
          if (message.sender_id?.toString() !== myId) {
            console.log('edit_message: User is not the sender of this message');
            socket.emit('edit_message_error', {
              error: 'You can only edit your own messages',
            });
            return;
          }

          // Check if message is too old to edit (optional: 15 minutes limit)
          const messageAge = Date.now() - message.createdAt.getTime();
          const editTimeLimit = 15 * 60 * 1000; // 15 minutes in milliseconds

          if (messageAge > editTimeLimit) {
            console.log('edit_message: Message is too old to edit');
            socket.emit('edit_message_error', { error: 'Message is too old to edit' });
            return;
          }

          // Update the message
          const oldContent = message.content;
          message.content = newContent.trim();
          message.edited = true;

          const updatedMessage = await message.save();

          console.log('edit_message: Message updated successfully:', {
            socketId: socket.id,
            messageId,
            oldContent,
            newContent: updatedMessage.content,
          });

          // If conversationId is not provided, find it from the message
          const targetConversationId =
            conversationId || message.conversation_id.toString();

          // Find the conversation to get participants
          const conversation = await ConversationModel.findById(targetConversationId);

          if (!conversation) {
            console.log('edit_message: Conversation not found');
            socket.emit('edit_message_error', { error: 'Conversation not found' });
            return;
          }

          // Notify all participants in the conversation
          const participants = conversation.participants.map(
            (participantId: mongoose.Types.ObjectId) => participantId.toString()
          );

          participants.forEach((participantId: string) => {
            if (participantId === String(myId)) {
              return;
            }
            const room = getSocketRoomForPair(
              String(myId),
              String(participantId),
              conversation
            );
            console.log('Emitting message_edited to room:', room);

            io.to(room).emit('message_edited', {
              conversation_id: targetConversationId,
              message: {
                _id: updatedMessage._id,
                conversation_id: updatedMessage.conversation_id,
                sender_id: updatedMessage.sender_id,
                sender_display: updatedMessage.sender_display,
                content: updatedMessage.content,
                edited: updatedMessage.edited,
                createdAt: updatedMessage.createdAt,
                updatedAt: updatedMessage.updatedAt,
              },
              editedBy: myId,
              editedAt: updatedMessage.updatedAt,
            });
          });

          // Also emit success to the sender
          socket.emit('edit_message_success', {
            messageId: updatedMessage._id,
            newContent: updatedMessage.content,
            editedAt: updatedMessage.updatedAt,
          });
        } catch (err) {
          const e: any = err;
          console.error('edit_message error:', e && e.message ? e.message : e);
          socket.emit('edit_message_error', {
            error: 'Failed to edit message',
            details: e?.message,
          });
        }
      }
    );
  });
}
