import statusCode from "../utils/statusCodes";
import { Response } from "express";
import { getMessageUid, getUserOfMailbox } from "../db/utils/mail";
import emailManager from "../mails/EmailManager";
import logger from "../system/Logger";
import Message from "../mails/message/Message";
import Room from "../mails/room/Room";

export default class MessageAbl {
    static async changeFlag(body, res: Response, isDelete: boolean) {
        const { mailboxId, messageId, flag } = body;
        const message = new Message().setMessageId(messageId);

        try {
            await message.useUid();
        } catch (err) {
            res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
        }

        try {
            await message.useMailbox(mailboxId);
        } catch (err) {
            res.status(statusCode.NOT_FOUND).send({ error: "Not account for this mailbox." });
        }

        try {
            if (isDelete) {
                await message.mailbox.removeFlag(message.uid.toString(), flag);
            } else {
                await message.mailbox.addFlag(message.uid.toString(), flag);
            }
        } catch (err) {
            res.status(statusCode.METHOD_FAILURE).send({ error: err });
        }
        res.status(statusCode.OK).send();
    }

    static async addFlag(body, res: Response) {
        await MessageAbl.changeFlag(body, res, false);
    }

    static async removeFlag(body, res: Response) {
        await MessageAbl.changeFlag(body, res, true);
    }

    static deleteRemoteOnly = async (body, res: Response) => {
        const { mailboxId, messageId } = body;
        const message = new Message().setMessageId(messageId);

        try {
            await message.useUid();
        } catch (error) {
            logger.err(error);
            res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
            return;
        }

        try {
            await message.useMailbox(mailboxId);
        } catch (error) {
            res.status(statusCode.NOT_FOUND).send({ error: "Not account for this mailbox." });
            return;
        }

        try {
            await message.mailbox.addFlag(message.uid.toString(), ["\\Deleted"]);
            await message.mailbox.moveToTrash(message.uid.toString(), (err) => {
                throw err;
            });
        } catch (err) {
            logger.log(err);
            res.status(statusCode.METHOD_FAILURE).send({ error: err });
            return;
        }

        res.status(statusCode.OK).send();
    };

    static deleteEverywhere = async (body, res: Response) => {
        const { mailboxId, messageId } = body;
        const message = new Message().setMessageId(messageId);
        await message.useFlags();

        try {
            await message.useUid();
        } catch (error) {
            logger.err(error);
            res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
            return;
        }

        // if message not deleted remotly, delete it
        if (!message.isDeleted) {
            try {
                await message.useMailbox(mailboxId);
            } catch (error) {
                res.status(statusCode.NOT_FOUND).send({ error: "Not account for this mailbox." });
                return;
            }

            try {
                await message.mailbox.addFlag(message.uid.toString(), ["\\Deleted"]);
                await message.mailbox.moveToTrash(message.uid.toString(), (err) => {
                    throw err;
                });
            } catch (err) {
                logger.log(err);
                res.status(statusCode.METHOD_FAILURE).send({ error: err });
                return;
            }
        }

        const room = await new Room().setRoomIdOnMessageId(messageId);
        try {
            await message.delete();
            if (room.roomId && room.shouldDelete()) {
                await room.delete();
                res.status(statusCode.OK).json({ deleteRoom: true }).send();
                return;
            }
        } catch (err) {
            res.status(statusCode.METHOD_FAILURE).send({ error: err });
            return;
        }
        res.status(statusCode.OK).send();
    };
}