import statusCode from "../utils/statusCodes";
import { Response } from "express";
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 async deleteRemoteUtil(message: Message, mailboxId: number, res, isFull: boolean): Promise<boolean> {
        try {
            await message.useUid();
        } catch (error) {
            logger.err(error);
            res.status(statusCode.NOT_FOUND).send({ error: "Message uid not found." });
            return false;
        }

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

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

        if (isFull) {
            res.status(statusCode.OK).send();
        }
        return true;
    }

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

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

        try {
            await message.useFlags();
        } catch (err) {
            res.status(statusCode.METHOD_FAILURE).send({ error: err });
            logger.err(err);
            return;
        }

        // if message not deleted remotly, delete it
        if (!message.isDeleted) {
            const success = await MessageAbl.deleteRemoteUtil(message, mailboxId, res, false);
            if (!success) {
                return;
            }
        }

        const room = await new Room().setRoomIdOnMessageId(messageId);
        try {
            await message.delete();
            if (room.roomId && await 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();
    };
}