import { Request, Response } from 'express';
import { Message, OrganizationMember } from '../lib/compat.js';

// Send a message
export const sendMessage = async (req: Request, res: Response) => {
    try {
        const { toUserId, message } = req.body;
        const fromUserId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        if (!organizationId) {
            return res.status(400).json({ error: 'Organização não selecionada.' });
        }

        if (!fromUserId) {
            return res.status(401).json({ error: 'Usuário não autenticado.' });
        }

        if (!toUserId || !message) {
            return res.status(400).json({ error: 'Destinatário e mensagem são obrigatórios.' });
        }

        // Check if there's already a pending (unread) message
        const existingMessage = await Message.findOne({
            organizationId,
            fromUserId,
            toUserId,
            isRead: false,
        });

        if (existingMessage) {
            const updated = await Message.findOneAndUpdate(
                { id: existingMessage.id },
                { message, updatedAt: new Date() }
            );
            return res.json(updated);
        }

        // Create new message
        const newMessage = await Message.create({
            organizationId,
            fromUserId,
            toUserId,
            message,
        });

        res.status(201).json(newMessage);
    } catch (error) {
        console.error('Error sending message:', error);
        res.status(500).json({ error: 'Erro ao enviar mensagem.' });
    }
};

// Get unread messages for current user
export const getUnreadMessages = async (req: Request, res: Response) => {
    try {
        const toUserId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        if (!organizationId) {
            return res.status(400).json({ error: 'Organização não selecionada.' });
        }

        if (!toUserId) {
            return res.status(401).json({ error: 'Usuário não autenticado.' });
        }

        const messages = await Message.find({
            organizationId,
            toUserId,
            isRead: false,
            isArchived: false,
            isDeletedByRecipient: false,
        });

        // Populate sender info
        const messagesWithSender = await Promise.all(
            messages.map(async (msg: any) => {
                const sender = await OrganizationMember.findOne({ userId: msg.fromUserId });
                return {
                    ...msg,
                    fromUser: sender ? { name: sender.name, email: sender.email } : null,
                };
            })
        );

        res.json(messagesWithSender);
    } catch (error) {
        console.error('Error getting unread messages:', error);
        res.status(500).json({ error: 'Erro ao buscar mensagens.' });
    }
};

// Mark message as read
export const markMessageAsRead = async (req: Request, res: Response) => {
    try {
        const { id } = req.params;
        const userId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        if (!userId) return res.status(401).json({ error: 'Usuário não autenticado.' });

        const updated = await Message.findOneAndUpdate(
            { id, organizationId, toUserId: userId },
            { isRead: true, readAt: new Date() }
        );

        if (!updated) {
            return res.status(404).json({ error: 'Mensagem não encontrada.' });
        }

        res.json(updated);
    } catch (error) {
        console.error('Error marking message as read:', error);
        res.status(500).json({ error: 'Erro ao marcar mensagem como lida.' });
    }
};

// Get my pending (unread) sent messages
export const getMyPendingMessages = async (req: Request, res: Response) => {
    try {
        const fromUserId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        if (!fromUserId) return res.status(401).json({ error: 'Usuário não autenticado.' });

        const messages = await Message.find({
            organizationId,
            fromUserId,
            isRead: false,
        });

        // Populate recipient info
        const messagesWithRecipient = await Promise.all(
            messages.map(async (msg: any) => {
                const recipient = await OrganizationMember.findOne({ userId: msg.toUserId });
                return {
                    ...msg,
                    toUser: recipient ? { name: recipient.name, email: recipient.email } : null,
                };
            })
        );

        res.json(messagesWithRecipient);
    } catch (error) {
        console.error('Error getting pending messages:', error);
        res.status(500).json({ error: 'Erro ao buscar mensagens pendentes.' });
    }
};

// Delete a message
export const deleteMessage = async (req: Request, res: Response) => {
    try {
        const { id } = req.params;
        const userId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        const deleted = await Message.findOneAndDelete({
            id,
            organizationId,
            fromUserId: userId,
            isRead: false
        });

        if (!deleted) {
            return res.status(404).json({ error: 'Mensagem não encontrada ou já foi lida.' });
        }

        res.status(204).send();
    } catch (error) {
        console.error('Error deleting message:', error);
        res.status(500).json({ error: 'Erro ao deletar mensagem.' });
    }
};

// Recipient archives a message
export const archiveMessage = async (req: Request, res: Response) => {
    try {
        const { id } = req.params;
        const userId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        const updated = await Message.findOneAndUpdate(
            { id, toUserId: userId, organizationId },
            { isArchived: true, isRead: true }
        );

        if (!updated) return res.status(404).json({ error: 'Mensagem não encontrada.' });
        res.json(updated);
    } catch (error) {
        console.error('Error archiving message:', error);
        res.status(500).json({ error: 'Erro ao arquivar mensagem.' });
    }
};

export const recipientDeleteMessage = async (req: Request, res: Response) => {
    try {
        const { id } = req.params;
        const userId = req.appUser?.id;
        const organizationId = req.headers['x-organization-id'] as string;

        const updated = await Message.findOneAndUpdate(
            { id, toUserId: userId, organizationId },
            { isDeletedByRecipient: true }
        );

        if (!updated) return res.status(404).json({ error: 'Mensagem não encontrada.' });
        res.json({ message: 'Mensagem excluída com sucesso.' });
    } catch (error) {
        console.error('Error deleting message:', error);
        res.status(500).json({ error: 'Erro ao excluir mensagem.' });
    }
};
