import { AttrsWithEnvelope, User } from "../../../interfaces/mail/attrs.interface";
import { RoomType } from "../../../mails/message/saveMessage";
import { getMembers } from "../../../mails/utils/envelopeUtils";
import { hasSameElements } from "../../../utils/array";
import { generateUsers, UserTest } from "../test-attrsUtils";

interface Room {
    room_id: number;
    room_name: string;
    owner_id: number;
    message_id: number;
    room_type: RoomType;
    notSeen: number;
    lastUpdate: string;
    members?: UserTest[];
    is_thread?: boolean;
    parent_id?: number;
    root_id?: number;
}

export default class saveMessageDatabase {
    rooms: Room[];
    roomId: number;
    messages: { attrs: AttrsWithEnvelope; message_id: number }[];
    room_message: { room_id: number; message_id: number }[];
    users: UserTest[];

    constructor(_users) {
        this.rooms = [];
        this.messages = [];
        this.room_message = [];
        this.users = generateUsers(5); // todo
        this.roomId = 0;
    }

    clear() {
        this.rooms = [];
        this.messages = [];
        this.room_message = [];
        this.roomId = 0;
    }

    _findRoomById = (roomId: number): Room => {
        return this.rooms.find((room) => room.room_id === roomId);
    };

    _findUserByMailbox = (mailbox: string): UserTest => {
        return this.users.find((user) => user.user.mailbox === mailbox);
    };

    createRoom = (
        roomName: string | null | undefined,
        ownerId: number,
        messageId: number,
        roomType: RoomType,
    ): Promise<number> => {
        this.rooms.push({
            room_id: this.roomId,
            room_name: roomName,
            owner_id: ownerId,
            message_id: messageId,
            room_type: roomType,
            notSeen: 0,
            lastUpdate: "0",
        });
        this.roomId++;
        return Promise.resolve(this.roomId - 1);
    };

    registerMessageInRoom = (messageId: number, roomId: number, idate: string | undefined | null): Promise<void> => {
        this.room_message.push({ message_id: messageId, room_id: roomId });
        return Promise.resolve();
    };

    getRoomType = (roomId: number): Promise<{ room_type: number }[]> => {
        return new Promise((resolve, reject) => {
            resolve([{ room_type: this.rooms.find((room) => room.room_id == roomId).room_type }]);
        });
    };

    findRoomsFromMessage = (messageID: string): Promise<{ room_id: number }[]> => {
        return new Promise((resolve, reject) => {
            const rooms = this.rooms.filter((room) => room.message_id.toString() === messageID);
            const res: { room_id: number }[] = [];
            rooms.forEach((room) => {
                res.push({ room_id: room.room_id });
            });
            resolve(res);
        });
    };

    hasSameMembersAsParent = (messageId: number, messageID: string): Promise<boolean> => {
        const msg1 = this.messages.find((message) => message.attrs.envelope.messageId === messageID);
        const msg2 = this.messages.find((message) => message.message_id === messageId);
        const members1 = getMembers(msg1.attrs.envelope);
        const members2 = getMembers(msg2.attrs.envelope);
        let ids1 = [];
        let ids2 = [];
        members1.forEach((member) => ids1.push(this._findUserByMailbox(member.mailbox).id));
        members2.forEach((member) => ids2.push(this._findUserByMailbox(member.mailbox).id));
        return Promise.resolve(hasSameElements(ids1, ids2));
    };

    registerThread = async (roomId: number, parentId: number, rootId: number) => {
        const room = this._findRoomById(roomId);
        room.is_thread = true;
        room.parent_id = parentId;
        room.root_id = rootId;
    };

    registerMember = (roomId: number, memberId: number): Promise<any> => {
        const room = this._findRoomById(roomId);
        if (!room.members) room.members = [];
        room.members.push(this.users.find((user) => user.id == memberId));
        return Promise.resolve(true);
    };

    getAllMembers = (messageId: number): Promise<any> => {
        const message = this.messages.find((message) => message.message_id === messageId);
        let res = "";
        getMembers(message.attrs.envelope).forEach((member) => {
            res += this.users.find((user) => user.user.mailbox === member.mailbox).id + ",";
        });
        res = res.substring(0, res.length - 1);
        return Promise.resolve([{ id: res }]);
    };

    getThreadInfo = (messageID: string): Promise<{ room_id: number; root_id: number }[]> => {
        const room = this.rooms.find((room) => room.message_id.toString() === messageID);
        return Promise.resolve([{ room_id: room.room_id, root_id: room.root_id }]);
    };

    getThreadInfoOnId = (threadId: number): Promise<{ room_id: number; root_id: number }[]> => {
        const room = this._findRoomById(threadId);
        return Promise.resolve([{ room_id: room.root_id, root_id: room.root_id }]);
    };

    incrementNotSeenRoom = (roomId: number): Promise<void> => {
        const room = this._findRoomById(roomId);
        if (room) room.notSeen++; // todo
        return Promise.resolve();
    };

    findRoomByOwner = (ownerId: number): Promise<{ room_id: number }[]> => {
        return new Promise((resolve, reject) => {
            const rooms = this.rooms.filter((room) => room.owner_id === ownerId);
            const res = [];
            rooms.forEach((room) => {
                res.push({ room_id: room.room_id });
            });
            resolve(res);
        });
    };

    getAddresseId = (email: string, name?: string): Promise<number> => {
        const match = this.users.find((user) => user.user.mailbox + "@" + user.user.host == email);
        return new Promise((resolve, reject) => resolve(match?.id));
    };

    getUserIdOfMailbox = (boxId: number): Promise<{ user_id: number }[]> => {
        return new Promise((resolve, rejects) => resolve([{ user_id: this.users[0].id }]));
    };
}