mail/back/db/saveMessageApp.ts

import { transformEmojis } from "../utils/string";
import { db, execQueryAsync, execQueryAsyncWithId, execQuery } from "./db";
import { queryFromId, queryToId, queryCcId } from "./utils/addressQueries";

export async function getAllMembers(messageId: number) {
    const query = `
        SELECT GROUP_CONCAT(address.address_id) AS is
        FROM address
        INNER JOIN address_field ON 
            address_field.address_id = address.address_id AND
            address_field.message_id = ?
        GROUP BY address_field.message_id
    `;
    const values = [messageId];
    return await execQueryAsync(query, values);
}

export async function registerMember(roomId: number, memberId: number) {
    const query = `INSERT IGNORE INTO app_room_member (room_id, member_id) VALUES (?, ?)`;
    const values = [roomId, memberId];
    return await execQueryAsync(query, values);
}

export async function createRoom(
    roomName: string | null | undefined,
    ownerId: number,
    messageId: number,
    roomType: number,
) {
    if (!roomName) roomName = "No room name";
    roomName = transformEmojis(roomName);
    const query = `INSERT IGNORE INTO app_room (room_name, owner_id, message_id, room_type) VALUES (?, ?, ?, ?)`;
    const values = [roomName.substring(0, 255), ownerId, messageId, roomType];
    return await execQueryAsyncWithId(query, values);
}

// todo date not good
export async function registerMessageInRoom(
    messageId: number,
    roomId: number,
    isSeen: boolean,
    idate: string | undefined | null,
) {
    if (!idate) idate = new Date().toString();
    const query = `INSERT IGNORE INTO app_room_message (message_id, room_id) VALUES (?, ?)`;
    const values = [messageId, roomId];
    await execQueryAsync(query, values);

    updateLastUpdateRoom(roomId, idate);
    // if (!isSeen) {
    //     incrementNotSeenRoom(roomId);
    // }
}

export function updateLastUpdateRoom(roomId: number, idate: string) {
    const query = `UPDATE app_room SET lastUpdate = ? WHERE room_id = ?`;
    const values = [idate, roomId];
    execQuery(query, values);
}

export function incrementNotSeenRoom(roomId: number) {
    // todo
}

export async function getRoomInfo(messageID: string): Promise<{ room_id: number; root_id: number }[]> {
    const query = `
        SELECT 
            app_room.room_id
            app_thread.root_id
        FROM app_room
        LEFT JOIN app_thread ON app_thread.room_id = app_room.room_id
        INNER JOIN app_room_message ON  app_room_message.room_id = app_room.room_id
        INNER JOIN message ON message.message_id = app_room_message.message_id
        WHERE message.messageID = ?
    `;
    const values = [messageID];
    return await execQueryAsync(query, values);
}

export async function registerThread(roomId: number, parentId: number, rootId: number) {
    const query = `INSERT IGNORE INTO app_thread (room_id, parent_id, root_id) VALUES (?, ?, ?)`;
    const values = [roomId, parentId, rootId];
    return await execQueryAsync(query, values);
}

export async function isRoomGroup(roomId: number): Promise<boolean> {
    return new Promise((resolve, reject) => {
        const query = `SELECT isGroup FROM app_room WHERE room_id = '${roomId}'`;
        db.query(query, (err, results, fields) => {
            if (err) reject(err);
            resolve(results[0].isGroup);
        });
    });
}

export async function findRoomsFromMessage(messageID: string) {
    // todo find message in room not started
    const query = `SELECT room_id FROM app_room_message WHERE message_id = ? ORDER BY room_id`;
    const values = [messageID];
    return await execQueryAsync(query, values);
}

export async function hasSameMembersAsParent(messageId: number, messageID: string) {
    const query1 = `
        SELECT 
            GROUP_CONCAT(fromT.address_id) AS fromA,
            GROUP_CONCAT(toT.address_id) AS toA,
            GROUP_CONCAT(ccT.address_id) AS ccA
        FROM message msg
        ${queryFromId} fromT ON msg.message_id = fromT.message_id
        ${queryToId} toT ON msg.message_id = toT.message_id
        ${queryCcId} ccT ON msg.message_id = ccT.message_id
        WHERE msg.message_id = ?
    `;
    const values1 = [messageId];
    let addressesMsg1 = await execQueryAsync(query1, values1);

    const query2 = `
        SELECT 
            GROUP_CONCAT(fromT.address_id) AS fromA,
            GROUP_CONCAT(toT.address_id) AS toA,
            GROUP_CONCAT(ccT.address_id) AS ccA
        FROM message msg
        ${queryFromId} fromT ON msg.message_id = fromT.message_id
        ${queryToId} toT ON msg.message_id = toT.message_id
        ${queryCcId} ccT ON msg.message_id = ccT.message_id
        WHERE msg.messageID = ?
    `;
    const values2 = [messageID];
    let addressesMsg2 = await execQueryAsync(query2, values2);

    addressesMsg1 = addressesMsg1[0]?.fromA
        ?.split(",")
        .concat(addressesMsg1[0]?.toA?.split(","))
        .concat(addressesMsg1[0]?.ccA?.split(","));
    addressesMsg2 = addressesMsg2[0]?.fromA
        ?.split(",")
        .concat(addressesMsg2[0]?.toA?.split(","))
        .concat(addressesMsg2[0]?.ccA?.split(","));

    return (
        addressesMsg1.length == addressesMsg2.length &&
        addressesMsg1.reduce((a, b) => a && addressesMsg2.includes(b), true)
    );
}