mail/back/mails/saveMessage.ts

import {
    createRoom,
    registerMessageInRoom,
    isRoomGroup,
    findRoomsFromMessage,
    hasSameMembersAsParent,
    registerThread,
    registerMember,
    getAllMembers,
    getRoomInfo,
} from "../db/saveMessageApp";

import { findRoomByOwner, getAddresseId, getUserIdOfMailbox } from "../db/mail";
import { nbMembers } from "./utils/envelopeUtils";
import logger from "../system/Logger";
import { ImapMessageAttributes } from "imap";
import { Attrs, Envelope, User } from "../interfaces/mail/attrs.interface";

/**
 * take object address and join mailbox and host to return mailbox@host
 */
function createAddress(elt: User): string {
    return `${elt.mailbox}@${elt.host}`;
}

export const roomType = {
    ROOM: 0,
    CHANNEL: 1,
    GROUP: 2,
    DM: 3,
    THREAD: 4,
};

export default class RegisterMessageInApp {
    messageId: number;
    attrs: Attrs;
    envelope: Envelope;
    messageID?: string;
    boxId: number;
    isSeen: boolean;
    ownerId: number;
    userId: number;
    inReplyTo: string;

    constructor(_messageId: number, _attrs: Attrs, _boxId: number) {
        this.messageId = _messageId;
        this.attrs = _attrs;
        if (!this.attrs.envelope) throw new Error("Envelope must exist in attributes");
        this.envelope = this.attrs.envelope;
        this.messageID = this.envelope?.messageId;
        this.boxId = _boxId;
        this.isSeen = this.attrs.flags.includes("\\Seen") ? true : false;
        this.ownerId = -1;
        this.userId = -1;
        this.inReplyTo = "";
    }

    async init() {
        if (this.envelope.from) {
            this.ownerId = await getAddresseId(createAddress(this.envelope.from[0])); // todo use sender or from ?
        } else {
            throw new Error("Envelope must have a 'from' field");
        }
    }

    isDm = () => nbMembers(this.envelope) == 2;

    async isFromUs() {
        if (this.userId == -1) {
            await getUserIdOfMailbox(this.boxId).then((res) => {
                this.userId = res[0]?.user_id;
            });
        }
        return this.ownerId == this.userId;
    }

    async registerMembers(roomId: number) {
        getAllMembers(this.messageId).then((res) => {
            res[0].id.split(",").foreach(async (memberId: number) => {
                await registerMember(roomId, memberId);
            });
        });
    }

    async initiateRoom(owner: number, roomType: number) {
        try {
            const roomId = await createRoom(this.envelope.subject, owner, this.messageId, roomType);
            await registerMessageInRoom(this.messageId, roomId, this.isSeen, this.envelope.date);
            this.registerMembers(roomId);
            return roomId;
        } catch (err) {
            logger.err(err);
        }
    }

    async createOrRegisterOnExistence(owner: number, roomType: number) {
        await findRoomByOwner(owner).then(async (res) => {
            if (res.length == 0) {
                // first message with this sender
                await this.initiateRoom(owner, roomType);
            } else {
                // not a reply, add to the list of message if this sender
                await registerMessageInRoom(this.messageId, res[0].room_id, this.isSeen, this.envelope.date);
            }
        });
    }

    async initiateThread() {
        await createRoom(this.envelope.subject, this.ownerId, this.messageId, roomType.THREAD).then(
            async (roomId: number) => {
                // find parent room infos
                await getRoomInfo(this.inReplyTo).then(async (room) => {
                    // todo room not lenght, reply to transfer ?
                    let root_id = room[0].root_id;
                    if (!root_id) root_id = room[0].room_id;
                    await registerThread(roomId, room[0].room_id, root_id);
                });
                // impl register previous message ?
                await registerMessageInRoom(this.messageId, roomId, this.isSeen, this.envelope.date);
                await this.registerMembers(roomId);
            },
        );
    }

    async createOrRegisterOnMembers(roomId: number) {
        const hasSameMembers = await hasSameMembersAsParent(this.messageId, this.inReplyTo);
        if (hasSameMembers) {
            await registerMessageInRoom(this.messageId, roomId, this.isSeen, this.envelope.date);
        } else {
            await this.initiateThread();
        }
    }

    async save() {
        await this.init();
        if (this.envelope.inReplyTo) {
            this.inReplyTo = this.envelope.inReplyTo;
            this.saveReply();
        } else {
            if (await this.isFromUs()) {
                if (this.isDm()) {
                    // create or add new message to DM
                    if (!this.envelope.to) throw new Error("Who send a DM and put the recipient in cc ?");
                    const userTo = await getAddresseId(createAddress(this.envelope.to[0]));
                    await this.createOrRegisterOnExistence(userTo, roomType.DM);
                } else {
                    // it is not a reply and not a dm
                    // so it is a channel, which can be possibly a group
                    this.initiateRoom(this.ownerId, roomType.ROOM);
                }
            } else {
                await this.createOrRegisterOnExistence(this.ownerId, roomType.ROOM);
            }
        }
    }

    async saveReply() {
        await findRoomsFromMessage(this.inReplyTo).then(async (rooms) => {
            if (rooms.length == 0) {
                // no rooms, so is a transfer
                // todo test if members of transferred message are included
            } else if (rooms.length === 1) {
                // only one room so message is only in a room and not in a thread
                // as a thread is associated to a room
                await isRoomGroup(rooms[0].room_id).then(async (isGroup: boolean) => {
                    if (isGroup) {
                        this.createOrRegisterOnMembers(rooms[0].room_id);
                    } else {
                        // reply from channel
                        // todo
                        // if (sender == owner) { // correction from the original sender
                        //     // leave in the same channel
                        // }
                    }
                });
            } else if (rooms.length > 1) {
                // get the lowest thread (order by room_id)
                const roomId = rooms[rooms.length - 1].room_id;
                this.createOrRegisterOnMembers(roomId);
            }
        });
    }
}