"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.handleConnection = void 0;
const database_js_1 = require("../config/database.js");
const rateLimiter_js_1 = require("../middleware/rateLimiter.js");
const chatService_js_1 = require("../services/chatService.js");
const messageService_js_1 = require("../services/messageService.js");
const handleConnection = async (io, socket) => {
    console.log(`User connected: ${socket.user.username} (${socket.user.id})`);
    await updateUserOnlineStatus(socket.userId, true);
    await joinUserRooms(socket);
    socket.on("send_message", (data) => handleSendMessage(io, socket, data));
    socket.on("react_to_message", (data) => handleReactToMessage(io, socket, data));
    socket.on("join_room", (roomId) => handleJoinRoom(socket, roomId));
    socket.on("leave_room", (roomId) => handleLeaveRoom(socket, roomId));
    socket.on("disconnect", () => handleDisconnect(socket));
};
exports.handleConnection = handleConnection;
const updateUserOnlineStatus = async (userId, isOnline) => {
    try {
        await database_js_1.prisma.user.update({
            where: { id: userId },
            data: {
                isOnline,
                lastSeen: new Date(),
            },
        });
    }
    catch (error) {
        console.error(`Error updating user online status: ${error}`);
    }
};
const joinUserRooms = async (socket) => {
    try {
        const userRooms = await database_js_1.prisma.chatRoomMember.findMany({
            where: { userId: socket.userId },
            include: { room: true },
        });
        userRooms.forEach(async (member) => {
            await socket.join(member.roomId);
            socket.to(member.roomId).emit("user_online", {
                userId: socket.userId,
                username: socket.user.username,
            });
        });
    }
    catch (error) {
        console.error(`Error joining user rooms: ${error}`);
    }
};
const handleSendMessage = async (io, socket, data) => {
    try {
        if (!(0, rateLimiter_js_1.checkMessageRateLimit)(socket))
            return;
        const isMember = await chatService_js_1.ChatService.checkRoomMembership(socket.userId, data.roomId);
        if (!isMember) {
            socket.emit("error", { message: "Not authorized to send messages to this room" });
            return;
        }
        const result = await messageService_js_1.MessageService.sendMessage(socket.userId, data);
        if (result.success) {
            io.to(data.roomId).emit("new_message", result.data);
        }
        else {
            socket.emit("error", { message: "Failed to send message" });
        }
    }
    catch (error) {
        console.error(`Error handling send message: ${error}`);
        socket.emit("error", { message: "Failed to send message" });
    }
};
const handleReactToMessage = async (io, socket, data) => {
    try {
        const result = await messageService_js_1.MessageService.reactToMessage(socket.userId, data);
        if (result.success) {
            const message = await database_js_1.prisma.message.findUnique({
                where: { id: data.messageId },
                select: { roomId: true },
            });
            if (message) {
                io.to(message.roomId).emit("message_reaction_updated", result.data);
            }
        }
        else {
            socket.emit("error", { message: result.error });
        }
    }
    catch (error) {
        console.error(`Error handling react to message: ${error}`);
        socket.emit("error", { message: "Failed to react to message" });
    }
};
const handleJoinRoom = async (socket, roomId) => {
    await socket.join(roomId);
};
const handleLeaveRoom = async (socket, roomId) => {
    await socket.leave(roomId);
};
const handleDisconnect = async (socket) => {
    console.log(`User disconnected: ${socket.user.username}`);
    await updateUserOnlineStatus(socket.userId, false);
    try {
        const userRooms = await database_js_1.prisma.chatRoomMember.findMany({
            where: {
                userId: socket.userId,
            },
        });
        userRooms.forEach((member) => {
            socket.to(member.roomId).emit("user_offline", {
                userId: socket.userId,
                username: socket.user.username,
            });
        });
    }
    catch (error) {
        console.error(`Error handling user disconnect: ${error}`);
    }
};