commandExecutor.js

const databaseManager = require("./mongoose");
const commandHelper = require("./commandHelper");

/**
 * @module commandExecutor
 * @category Core
 * @description Executes commands interpreted from dataTranslator.
 * */

async function getAllMembers(data, targetGroupID)
{
    const targetGroup = await databaseManager.findGroupByGroupID(targetGroupID);

    let outputMessage = "";
    outputMessage = "There are currently " + targetGroup.users.length + " users that joined the group " + targetGroup.groupName + ". Those users are: ";
    const groupUsers = targetGroup.users;
    let connectedUsers = "";
    let disconnectedUsers = "";
    for(let i = 0; i < groupUsers.length; ++i)
    {
        if(groupUsers[i].connected)
        {
            connectedUsers += "\n- " + groupUsers[i].nickname;
            continue;
        }
        disconnectedUsers += "\n- " + groupUsers[i].nickname;
    }

    outputMessage += "\n\nConnected members:";
    outputMessage += connectedUsers;
    if(disconnectedUsers !== "")
    {
        outputMessage += "\n\nDisconnected members:";
        outputMessage += disconnectedUsers;
    }
    data.text = outputMessage;
    return data;
}

async function VerifyAndExecuteGetAllMembers(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);
    const groups = await databaseManager.findGroupsByUserID(userMediaID);

    const templateOptions = commandHelper.getGroupIDsWithCondition(userDatabase.connectedGroups, groups,  true);

    return await commandHelper.executeCommandOnGroup(data.message, getAllMembers,
        {
            "type":"talkToGroup",
            "command":"AL",
            "options":templateOptions
        }, data, userDatabase, userMediaID);
}

async function ExecuteDisconnectFromGroup(data, targetGroupID, userMediaID)
{
    const targetGroup = await databaseManager.findGroupByGroupID(targetGroupID);
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    await databaseManager.modifyConnectedUserToGroupByGroupID(targetGroup._id, userDatabase._id, false);
    await databaseManager.removeConnectGroupOfUserBYMediaID(userMediaID, targetGroupID);

    data.text = "Disconnected from group " + targetGroup.groupName + ".\nYou will no longer receive messages from this group."
    return data;
}
async function VerifyAndExecuteDisconnectFromGroup(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);
    const groups = await databaseManager.findGroupsByUserID(userMediaID);

    const templateOptions = commandHelper.getGroupIDsWithCondition(userDatabase.connectedGroups, groups,  true);

    return await commandHelper.executeCommandOnGroup(data.message, ExecuteDisconnectFromGroup,{
        "type":"talkToGroup",
        "command":"DI",
        "options":templateOptions
    }, data, userDatabase, userMediaID);
}
async function ExecuteNotACommand(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);
    const userState = userDatabase.state;

    if(userState === "sendingToGroup")
    {
        data.text = data.message;
        data.targetGroup = userDatabase.target;
    }
    else if(userState === "sendingToUser")
    {
        data.text = data.message;
        data.userTarget = userDatabase.userTarget;
        data.targetGroup = userDatabase.target;
    }
    else
        data.text = "Could not recognize command.\nType !help for information on available commands.";

    return data;
}

async function ExecuteQuitSession(data, userMediaID)
{
    const userState = await databaseManager.findStateByMediaID(userMediaID);

    if(userState === "sendingToGroup")
    {
        await databaseManager.changeUserStateByMediaID(userMediaID, "");

        const targetGroup = await databaseManager.findGroupTargetByMediaID(userMediaID);

        const groupName = await databaseManager.findGroupNameByGroupID(targetGroup);
        data.text = "session with group " + groupName + " was closed.";
    }
    else if(userState === "sendingToUser")
    {
	    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

        await databaseManager.changeUserStateByMediaID(userMediaID, "sendingToGroup");
        await databaseManager.changeMemberGroupTargetByMediaID(userMediaID, "");
        const targetUser = await databaseManager.findUserByUserID(userDatabase.userTarget);
        const group = await databaseManager.findGroupByGroupID(userDatabase.target);
        const userNickname = databaseManager.findUserNicknameByUserIDInGroup(group, targetUser._id.toString());
        data.text = "Private session with " + userNickname + " closed. Messages will now be sent to everyone in the group " + group.groupName + ".\ntype \"!quitSession\" to close the " +
            "session and use other commands.";
    }
    else
    {
        data.text = "You are currently not connected to a group.";
    }

    return data;
}

async function ExecuteGetConnectedGroups(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    let text = "";
    userDatabase.connectedGroups.forEach(connectedGroup => {
        const foundGroup = userDatabase.groups.find(group => group.groupID.toString() === connectedGroup.toString())
        console.log("found : ", foundGroup);
        if(foundGroup !== undefined)
            text += "\n  - " + foundGroup.groupName;
    });
    if(text === "")
        data.text = "You are not connected to any groups.";
    else
        data.text = "You are connected to the groups:" + text;

    return data;
}

async function ExecuteOpenSessionToGroup(data, targetGroupID, userMediaID)
{
    const targetGroup = await databaseManager.findGroupByGroupID(targetGroupID);

    await databaseManager.changeUserStateByMediaID(userMediaID, "sendingToGroup")
    await databaseManager.changeGroupTargetByMediaID(userMediaID, targetGroup._id);
    data.text = "Opened session to group " + targetGroup.groupName + ".\ntype \"!quitSession\" to close the " +
        "session and use other commands.";
    return data;
}

async function ExecuteOpenSessionToMember(data, targetMemberID, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    const targetGroup = await databaseManager.findGroupByGroupID(userDatabase.target);
    const targetMemberNickNameInGroup = await databaseManager.findUserNicknameByUserIDInGroup(targetGroup, targetMemberID);

    await databaseManager.changeUserStateByID(userDatabase._id, "sendingToUser");
    await databaseManager.changeMemberGroupTargetByMediaID(userMediaID, targetMemberID);

    data.text = "Opened session to user " + targetMemberNickNameInGroup + ".\ntype \"quitSession\" to close the " +
        "session to the user and talk to everyone in the group.";
    return data;
}
async function VerifyAndExecuteOpenSessionToMember(data, userDatabase, userMediaID)
{
    const targetGroup = await databaseManager.findGroupByGroupID(userDatabase.target);

    if(!targetGroup)
    {
        console.error("could not find target group to opensession to member with.");
        return;
    }

    const groupUsers = targetGroup.users;

    let templateOptions = commandHelper.getGroupMemberNickNamesAndIDsWithCondition(groupUsers, true);

    //removes the sender from the possible options
    for(let index = 0; index < templateOptions.length; ++index)
    {
        if(templateOptions[index].optionValue.toString() === userDatabase._id.toString())
        {
            templateOptions.splice(index, 1);
        }
    }

    return await commandHelper.executeCommandOnGroupMember(data.message, ExecuteOpenSessionToMember,
        {
        "type":"talkToGroup",
        "command":"DS",
        "options":templateOptions
    }, data, targetGroup, userDatabase._id, userMediaID);
}

async function VerifyAndExecuteOpenSessionToGroup(data, userDatabase, userMediaID)
{
    const groups = await databaseManager.findGroupsByUserID(userMediaID);

    const templateOptions = commandHelper.getGroupIDsWithCondition(userDatabase.connectedGroups, groups,  true);

    return await commandHelper.executeCommandOnGroup(data.message, ExecuteOpenSessionToGroup, {
        "type":"talkToGroup",
        "command":"SE",
        "options":templateOptions
    }, data, userDatabase, userMediaID);
}
async function ExecuteOpenSession(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    if(userDatabase.state === "sendingToUser")
    {
        data.text = "Session with a user is already opened.";
        return data;
    }
    //If user is in a session to a group, open a session to a user
    if(userDatabase.state === "sendingToGroup")
        return await VerifyAndExecuteOpenSessionToMember(data,userDatabase, userMediaID);

    return await VerifyAndExecuteOpenSessionToGroup(data, userDatabase, userMediaID);

}

async function ExecuteSendingToGroupMessage(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    data.text = data.message;
    data.targetGroup = userDatabase.target;
}

async function ExecuteSendingToUser(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    data.text = data.message;
    data.userTarget = userDatabase.userTarget;
    data.targetGroup = userDatabase.target;
}

async function ExecuteConnectToGroup(data, targetGroupID, userMediaID)
{
    const targetGroup = await databaseManager.findGroupByGroupID(targetGroupID);
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);

    await databaseManager.addConnectedGroupToUserByMediaID(userMediaID, targetGroupID.toString());
    await databaseManager.modifyConnectedUserToGroupByGroupID(targetGroupID, userDatabase._id, true);

    data.text = "\nConnected to group " + targetGroup.groupName + ".";

    if(targetGroup.messages !== undefined)
    {
        for(let i = targetGroup.users.find(user => user.userID.toString() === userDatabase._id.toString()).readMessageIndex; i < targetGroup.messages.length; ++i)
        {
            data.text += "\n" + targetGroup.messages[i];
        }
    }
    return data;
}
async function VerifyAndExecuteConnectToGroup(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);
    const groups = await databaseManager.findGroupsByUserID(userMediaID);

    const templateOptions = commandHelper.getGroupIDsWithCondition(userDatabase.connectedGroups, groups,  false);

    return await commandHelper.executeCommandOnGroup(data.message, ExecuteConnectToGroup,
        {
            "type":"talkToGroup",
            "command":"CO",
            "options":templateOptions
        }, data, userDatabase, userMediaID)
}

async function ExecuteGetConnectedMembers(data, targetGroupID)
{
    const targetGroup = await databaseManager.findGroupByGroupID(targetGroupID);

    const connectedUsers = await databaseManager.findConnectedMembersByGroupID(targetGroupID);
    data.text = "There are currently " + connectedUsers.length + " users currently connected to the group " + targetGroup.groupName + ". Those users are: ";

    for(let i = 0; i < connectedUsers.length; ++i)
    {
        data.text += "\n" +  connectedUsers[i].nickname;
    }
    return data;
}

async function VerifyAndExecuteGetConnectedMembers(data, userMediaID)
{
    const userDatabase = await databaseManager.findUserByMediaID(userMediaID);
    const groups = await databaseManager.findGroupsByUserID(userMediaID);

    const templateOptions = commandHelper.getGroupIDsWithCondition(userDatabase.connectedGroups, groups,  true);

    return await commandHelper.executeCommandOnGroup(data.message,ExecuteGetConnectedMembers,
        {
            "type":"talkToGroup",
            "command":"CM",
            "options":templateOptions
        }, data, userDatabase, userMediaID);
}

async function ExecuteQuitGroup(data, userMediaID)
{
    //TODO not yet implemented
    /**
     *        const targetGroup = await databaseManager.findGroupByGroupID(buttonValue);
     *
     *        //verify and remove each member that could be in a private session  with the user in the group.
     *        const connectedUsers = await databaseManager.findConnectedMembersByGroupID(targetGroup._id);
     *        const userDatabase = await databaseManager.findUserByMediaID(userMediaID);
     *        connectedUsers.forEach(user => async function(){
     * 			const userData = await databaseManager.findUserByUserID(user._id);
     *
     * 			if(userData.userTarget === userDatabase._id.toString())
     * 			{
     * 				await databaseManager.changeUserStateByID(userData._id, "sendingToGroup");
     * 				await databaseManager.changeMemberGroupTargetByUserID(userData._id, "");
     * 			}
     * 		})
     *        const userNickname = await databaseManager.findUserNicknameByUserIDInGroup(targetGroup, userDatabase._id);
     *        data.text = userNickname + " has left the group " + targetGroup.groupName + ".";
     */
}
async function VerifyAndExecuteQuitGroup(data, userMediaID)
{
    //TODO not yet implemetned
    /**
     *        const templateOptions = commandHelper.getGroupIDsButtonTemplateFormat(groups);
     *
     *        data = await commandHelper.executeCommandOnGroup(serverData.text,async function(targetGroup){
     * 				//verify and remove each member that could be in a private session  with the user in the group.
     * 				const connectedUsers = await databaseManager.findConnectedMembersByGroupID(targetGroup._id);
     * 				connectedUsers.forEach(user => async function(){
     * 					const userData = await databaseManager.findUserByUserID(user._id);
     *
     * 					if(userData.userTarget === userDatabase._id.toString())
     * 					{
     * 						await databaseManager.changeUserStateByID(userData._id, "sendingToGroup");
     * 						await databaseManager.changeMemberGroupTargetByUserID(userData._id, "");
     * 					}
     * 				})
     * 				const userNickname = await findUserNicknameByUserIDInGroup(targetGroup, userDatabase._id);
     * 				data.text = userNickname + " has left the group " + targetGroup.groupName + ".";
     *
     * 				return data;
     * 			},
     *            {
     * 				"type":"talkToGroup",
     * 				"command":"QT",
     * 				"options":templateOptions
     * 			}, data, userMediaID);
     */
}
module.exports = {getAllMembers, ExecuteOpenSession, VerifyAndExecuteGetAllMembers, ExecuteNotACommand, ExecuteQuitSession, ExecuteGetConnectedGroups, ExecuteSendingToGroupMessage, ExecuteSendingToUser, VerifyAndExecuteDisconnectFromGroup, VerifyAndExecuteConnectToGroup, VerifyAndExecuteGetConnectedMembers, VerifyAndExecuteQuitGroup, ExecuteOpenSessionToMember, ExecuteOpenSessionToGroup, ExecuteDisconnectFromGroup, ExecuteConnectToGroup, ExecuteGetConnectedMembers, ExecuteQuitGroup}