/**
 *  Command for displaying help information about registered Acedia's commands.
 *      Copyright 2022-2023 Anton Tarasenko
 *------------------------------------------------------------------------------
 * This file is part of Acedia.
 *
 * Acedia is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3 of the License, or
 * (at your option) any later version.
 *
 * Acedia is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Acedia.  If not, see <https://www.gnu.org/licenses/>.
 */
class ACommandUserGroups extends Command
    dependson(Users_Feature);

protected function BuildData(CommandDataBuilder builder)
{
    builder.Group(P("admin"));
    builder.Summary(P("User groups management."));
    builder.Describe(P("Allows to add/remove user groups and users to these: groups. Changes made"
        @ "by it will always affect current session, but might fail to be saved in case user groups"
        @ "are stored in a database that is either corrupted or in read-only mode."));

    builder.SubCommand(P("list"));
    builder.Describe(P("Lists specified groups along with users that belong to them. If no groups"
        @ "were specified at all - lists all available groups."));
    builder.OptionalParams();
    builder.ParamTextList(P("groups"));

    builder.SubCommand(P("add"));
    builder.Describe(P("Adds a new group"));
    builder.ParamText(P("group_name"));

    builder.SubCommand(P("remove"));
    builder.Describe(P("Removes a group"));
    builder.ParamText(P("group_name"));

    builder.SubCommand(P("addplayer"));
    builder.Describe(P("Adds new user to the group, specified by the player selector. Can add"
        @ "several players at once. Allows to also optionally specify annotation (human-readable"
        @ "name) that can be thought of as a `comment`. If annotation isn't specified current"
        @ "nickname will be used as one."));
    builder.ParamText(P("group_name"));
    builder.ParamPlayers(P("player_selector"));
    builder.OptionalParams();
    builder.ParamText(P("annotation"));

    builder.SubCommand(P("removeplayer"));
    builder.Describe(P("Removes user from the group, specified by player selector."
        @ "Can remove several players at once."));
    builder.ParamText(P("group_name"));
    builder.ParamPlayers(P("player_selector"));

    builder.SubCommand(P("adduser"));
    builder.Describe(P("Adds new user to the group. Allows to also optionally specify annotation"
        @ "(human-readable name) that can be thought of as a `comment`."));
    builder.ParamText(P("group_name"));
    builder.ParamText(P("user_id"));
    builder.OptionalParams();
    builder.ParamText(P("annotation"));

    builder.SubCommand(P("removeuser"));
    builder.Describe(P("Removes user from the group. User can be specified by both user's id or"
        @ "annotation, with id taking priority."));
    builder.ParamText(P("group_name"));
    builder.ParamText(P("user_name"));

    builder.Option(P("force"));
    builder.Describe(P("Allows to force usage of invalid user IDs."));
}

protected function Executed(CallData arguments, EPlayer instigator, CommandPermissions permissions)
{
    local bool      forceOption;
    local Text      groupName, userID, userName, annotation;
    local ArrayList players, groups;

    groupName   = arguments.parameters.GetText(P("group_name"));
    //  For parameters named `user_id`, can only be ID
    userID      = arguments.parameters.GetText(P("user_id"));
    //  For parameters named `user_id`, can be either ID or annotation
    userName    = arguments.parameters.GetText(P("user_name"));
    annotation  = arguments.parameters.GetText(P("annotation"));
    //  An array of players that can be specified for some commands
    players     = arguments.parameters.GetArrayList(P("player_selector"));
    groups      = arguments.parameters.GetArrayList(P("groups"));
    forceOption = arguments.options.HasKey(P("force"));
    if (arguments.subCommandName.IsEmpty()) {
        DisplayUserGroups();
    }
    else if (arguments.subCommandName.Compare(P("list"), SCASE_SENSITIVE)) {
        DisplayUserGroupsWithUsers(groups);
    }
    else if (arguments.subCommandName.Compare(P("add"), SCASE_SENSITIVE)) {
        AddGroup(groupName);
    }
    else if (arguments.subCommandName.Compare(P("remove"), SCASE_SENSITIVE)) {
        RemoveGroup(groupName);
    }
    else if (arguments.subCommandName.Compare(P("adduser"), SCASE_SENSITIVE)) {
        AddOrAnnotateUser(groupName, userID, annotation, forceOption);
    }
    else if (arguments.subCommandName.Compare(P("removeuser"), SCASE_SENSITIVE))
    {
        RemoveUser(groupName, userName);
    }
    else if (arguments.subCommandName.Compare(P("addplayer"), SCASE_SENSITIVE)) {
        AddOrAnnotatePlayers(groupName, players, annotation);
    }
    else if (arguments.subCommandName
        .Compare(P("removeplayer"), SCASE_SENSITIVE))
    {
        RemovePlayers(groupName, players);
    }
    _.memory.Free(groupName);
    _.memory.Free(userID);
    _.memory.Free(userName);
    _.memory.Free(annotation);
    _.memory.Free(players);
    _.memory.Free(groups);
}

private function bool ValidateGroupExistence(BaseText groupName)
{
    if (_.users.IsGroupExisting(groupName)) {
        return true;
    }
    callerConsole
        .Write(P("Group "))
        .UseColorOnce(_.color.TextEmphasis)
        .Write(groupName)
        .UseColorOnce(_.color.TextFailure)
        .Write(P(" doesn't exists"))
        .WriteLine(P("!"));
    return false;
}

private function bool ValidateUserID(BaseText textUserID)
{
    local int i;

    if (textUserID == none) {
        return false;
    }
    if (textUserID.IsEmpty())
    {
        callerConsole.WriteLine(F("Valid User ID"
            @ "{$TextFailure shouldn't be empty},"
            @ "use {$TextEmphasis --force} flag if you want to enforce"
            @ "using it."));
        return false;
    }
    for (i = 0; i < textUserID.GetLength(); i += 1)
    {
        if (!_.text.IsDigit(textUserID.GetCharacter(i)))
        {
            callerConsole.WriteLine(F("Valid User ID"
                @ "{$TextFailure should consist only of digits},"
                @ "use {$TextEmphasis --force} flag if you want"
                @ "to enforce using it."));
            return false;
        }
    }
    return true;
}

private function bool TryAddingUserID(
    BaseText    groupName,
    UserID      userID,
    BaseText    userSpecifiedID)
{
    if (_.users.IsUserIDInGroup(userID, groupName))
    {
        callerConsole
            .Write(P("User id specified as "))
            .UseColorOnce(_.color.Gray)
            .Write(userSpecifiedID)
            .UseColorOnce(_.color.TextFailure)
            .Write(P(" is already in the group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P("!"));
    }
    else if (_.users.AddUserIDToGroup(userID, groupName))
    {
        callerConsole
            .Write(F("{$TextPositive Added} user id specified as "))
            .UseColorOnce(_.color.Gray)
            .Write(userSpecifiedID)
            .Write(P(" to the group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P("!"));
    }
    else
    {
        callerConsole
            .UseColorOnce(_.color.TextFailure)
            .Write(P("Failed (for unknown reason)"))
            .Write(P(" to add user id "))
            .UseColorOnce(_.color.Gray).Write(userSpecifiedID)
            .Write(P(" to the group "))
            .UseColorOnce(_.color.TextEmphasis).Write(groupName)
            .WriteLine(P("!"));
        return false;
    }
    return true;
}

private function DisplayAnnotation(
    BaseText userSpecifiedName,
    BaseText groupName,
    BaseText annotation)
{
    callerConsole
        .Write(P("Annotation for user id specified as "))
        .UseColorOnce(_.color.Gray)
        .Write(userSpecifiedName)
        .UseColorOnce(_.color.TextPositive)
        .Write(P(" in the group "))
        .UseColorOnce(_.color.TextEmphasis)
        .Write(groupName)
        .Write(P(" is set to "))
        .UseColorOnce(_.color.TextNeutral)
        .WriteLine(annotation);
}

private function AddOrAnnotateUser(
    BaseText    groupName,
    BaseText    textUserID,
    BaseText    annotation,
    bool        forceOption)
{
    local UserID id;

    if (groupName == none)                              return;
    if (textUserID == none)                             return;
    if (!ValidateGroupExistence(groupName))             return;
    if (!forceOption && !ValidateUserID(textUserID))    return;

    id = UserID(_.memory.Allocate(class'UserID'));
    id.Initialize(textUserID);
    if (!TryAddingUserID(groupName, id, textUserID) || annotation == none)
    {
        _.memory.Free(id);
        return;
    }
    _.users.SetAnnotationForUserID(groupName, id, annotation);
    _.memory.Free(id);
    DisplayAnnotation(textUserID, groupName, annotation);
}

private function AddOrAnnotatePlayers(
    BaseText    groupName,
    ArrayList   players,
    BaseText    annotation)
{
    local int       i;
    local BaseText  playerName, nextAnnotation;
    local EPlayer   nextPlayer;
    local UserID    nextID;

    if (groupName == none)                  return;
    if (players == none)                    return;
    if (!ValidateGroupExistence(groupName)) return;

    for (i = 0; i < players.GetLength(); i += 1)
    {
        nextPlayer = EPlayer(players.GetItem(i));
        if (nextPlayer == none) {
            continue;
        }
        playerName  = nextPlayer.GetName();
        nextID      = nextPlayer.GetUserID();
        if (TryAddingUserID(groupName, nextID, playerName))
        {
            if (annotation == none) {
                nextAnnotation = playerName;
            }
            else {
                nextAnnotation = annotation;
            }
            _.users.SetAnnotationForUserID(groupName, nextID, nextAnnotation);
            DisplayAnnotation(playerName, groupName, nextAnnotation);
            _.memory.Free(nextID);
            nextAnnotation = none;
        }
        _.memory.Free(nextPlayer);
        _.memory.Free(playerName);
        _.memory.Free(nextID);
        nextPlayer  = none;
        playerName  = none;
        nextID      = none;
    }
}

private function TryRemovingUserID(
    BaseText    groupName,
    UserID      idToRemove,
    BaseText    userSpecifiedName)
{
    local Text idAsText;

    idAsText = idToRemove.GetUniqueID();
    if (_.users.RemoveUserIDFromGroup(idToRemove, groupName))
    {
        callerConsole
            .Write(F("{$TextNegative Removed} user "))
            .UseColorOnce(_.color.Gray)
            .Write(userSpecifiedName)
            .Write(P(" (with id "))
            .UseColorOnce(_.color.Gray)
            .Write(idAsText)
            .Write(P(") from the group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P("!"));
    }
    else
    {
        callerConsole
            .UseColorOnce(_.color.TextFailure)
            .Write(P("Failed (for unknown reason)"))
            .Write(P("to remove user with id "))
            .UseColorOnce(_.color.Gray)
            .Write(idAsText)
            .Write(P(" from the group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P("."));
    }
    _.memory.Free(idAsText);
}

private function bool RemoveUsersByAnnotation(
    BaseText groupName,
    BaseText userName)
{
    local int   i;
    local bool  removedUser;
    local array<Users_Feature.AnnotatedUserID> annotatedUsers;

    annotatedUsers = _.users.GetAnnotatedGroupMembers(groupName);
    for (i = 0; i < annotatedUsers.length; i += 1)
    {
        if (userName.Compare(annotatedUsers[i].annotation, SCASE_INSENSITIVE))
        {
            TryRemovingUserID(groupName, annotatedUsers[i].id, userName);
            removedUser = true;
        }
    }
    for (i = 0; i < annotatedUsers.length; i += 1)
    {
        _.memory.Free(annotatedUsers[i].id);
        _.memory.Free(annotatedUsers[i].annotation);
    }
    return removedUser;
}

private function RemoveUser(BaseText groupName, BaseText userName)
{
    local bool      matchedUserName;
    local UserID    idFromName;

    if (groupName == none)                  return;
    if (userName == none)                   return;
    if (!ValidateGroupExistence(groupName)) return;

    idFromName = UserID(_.memory.Allocate(class'UserID'));
    idFromName.Initialize(userName);
    if (    idFromName.IsInitialized()
        &&  _.users.IsUserIDInGroup(idFromName, groupName))
    {
        TryRemovingUserID(groupName, idFromName, userName);
        matchedUserName = true;
    }
    else {
        matchedUserName = RemoveUsersByAnnotation(groupName, userName);
    }
    _.memory.Free(idFromName);
    if (!matchedUserName)
    {
        callerConsole
            .Write(P("User "))
            .UseColorOnce(_.color.Gray)
            .Write(userName)
            .UseColorOnce(_.color.TextFailure)
            .Write(P(" doesn't belong to the group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P("!"));
    }
}

private function RemovePlayers(BaseText groupName, ArrayList players)
{
    local int       i;
    local Text      playerName;
    local EPlayer   nextPlayer;
    local UserID    nextID;

    if (groupName == none)                  return;
    if (players == none)                    return;
    if (!ValidateGroupExistence(groupName)) return;

    for (i = 0; i < players.GetLength(); i += 1)
    {
        nextPlayer = EPlayer(players.GetItem(i));
        if (nextPlayer == none) {
            continue;
        }
        playerName  = nextPlayer.GetName();
        nextID      = nextPlayer.GetUserID();
        if (!_.users.IsUserIDInGroup(nextID, groupName))
        {
            callerConsole
                .Write(P("Player "))
                .UseColorOnce(_.color.Gray)
                .Write(playerName)
                .Write(F(" {$TextFailure doesn't belong} to the group "))
                .UseColorOnce(_.color.TextEmphasis)
                .Write(groupName)
                .WriteLine(P("!"));
        }
        else {
            TryRemovingUserID(groupName, nextID, playerName);
        }
        _.memory.Free(nextPlayer);
        _.memory.Free(playerName);
        _.memory.Free(nextID);
        nextPlayer  = none;
        playerName  = none;
        nextID      = none;
    }
}

private function AddGroup(BaseText groupName)
{
    if (_.users.IsGroupExisting(groupName))
    {
        callerConsole
            .Write(P("Group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .UseColorOnce(_.color.TextNegative)
            .Write(P(" already exists"))
            .WriteLine(P("!"));
        return;
    }
    if (_.users.AddGroup(groupName))
    {
        callerConsole
            .Write(P("Group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .UseColorOnce(_.color.TextPositive)
            .Write(P(" was added"))
            .WriteLine(P("!"));
    }
    else
    {
        callerConsole
            .UseColorOnce(_.color.TextFailure)
            .Write(P("Cannot add"))
            .Write(P(" group with a name "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P(" for unknown reason."));
    }
}

private function RemoveGroup(BaseText groupName)
{
    if (!_.users.IsGroupExisting(groupName))
    {
        callerConsole
            .Write(P("Group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .UseColorOnce(_.color.TextNegative)
            .Write(P(" doesn't exists"))
            .WriteLine(P("!"));
        return;
    }
    if (_.users.RemoveGroup(groupName))
    {
        callerConsole
            .Write(P("Group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .UseColorOnce(_.color.TextPositive)
            .Write(P(" was removed"))
            .WriteLine(P("!"));
    }
    else
    {
        callerConsole
            .UseColorOnce(_.color.TextFailure)
            .Write(P("Cannot remove"))
            .Write(P(" group "))
            .UseColorOnce(_.color.TextEmphasis)
            .Write(groupName)
            .WriteLine(P(" for unknown reason."));
    }
}

private function DisplayUserGroups()
{
    local int           i;
    local array<Text>   availableGroups;

    if (!ValidateUsersFeature()) {
        return;
    }
    availableGroups = _.users.GetAvailableGroups();
    if (availableGroups.length <= 0)
    {
        callerConsole.WriteLine(F("{$TextNegative No user groups}"
            @ "currently available."));
        return;
    }
    callerConsole
        .UseColorOnce(_.color.TextEmphasis)
        .Write(P("Available user groups"))
        .Write(P(": "));
    for (i = 0; i < availableGroups.length; i += 1)
    {
        if (i > 0) {
            callerConsole.Write(P(", "));
        }
        callerConsole.Write(availableGroups[i]);
    }
    callerConsole.Flush();
    _.memory.FreeMany(availableGroups);
}

private function bool ValidateUsersFeature()
{
    if (class'Users_Feature'.static.IsEnabled()) {
        return true;
    }
    callerConsole
        .UseColorOnce(_.color.TextFailure)
        .WriteLine(P("`Users_Feature` is currently disabled."));
    return false;
}

private function bool IsGroupSpecified(
    ArrayList   specifiedGroups,
    BaseText    groupToCheck)
{
    local int   i;
    local int   length;
    local Text  nextGroup;

    if (groupToCheck == none)       return false;
    if (specifiedGroups == none)    return true;
    length = groupToCheck.GetLength();
    if (length <= 0)                return true;

    for (i = 0; i < length; i += 1)
    {
        nextGroup = specifiedGroups.GetText(i);
        if (groupToCheck.Compare(nextGroup, SCASE_INSENSITIVE))
        {
            nextGroup.FreeSelf();
            return true;
        }
        _.memory.Free(nextGroup);
    }
    return false;
}

private function DisplayUserGroupsWithUsers(ArrayList specifiedGroups)
{
    local int           i;
    local bool          displayedGroup;
    local array<Text>   availableGroups;

    if (!ValidateUsersFeature()) {
        return;
    }
    availableGroups = _.users.GetAvailableGroups();
    if (availableGroups.length <= 0)
    {
        callerConsole.WriteLine(F("{$TextNegative No user groups}"
            @ "currently available."));
        return;
    }
    for (i = 0; i < availableGroups.length; i += 1)
    {
        if (IsGroupSpecified(specifiedGroups, availableGroups[i]))
        {
            displayedGroup = true;
            callerConsole
                .Write(P("User group "))
                .UseColorOnce(_.color.TextEmphasis)
                .Write(availableGroups[i])
                .WriteLine(P(":"));
            DisplayUsersFor(availableGroups[i]);
        }
    }
    callerConsole.Flush();
    _.memory.FreeMany(availableGroups);
    if (!displayedGroup && specifiedGroups != none) {
        callerConsole.WriteLine(F("{$TextFailure No valid groups} specified!"));
    }
}

private function DisplayUsersFor(Text groupName)
{
    local int                                   i;
    local Text                                  nextID;
    local array<Users_Feature.AnnotatedUserID>  annotatedUsers;

    annotatedUsers = _.users.GetAnnotatedGroupMembers(groupName);
    if (annotatedUsers.length <= 0)
    {
        callerConsole.WriteBlock(P("No users"));
        return;
    }
    for (i = 0; i < annotatedUsers.length; i += 1)
    {
        if (annotatedUsers[i].id == none) {
            continue;
        }
        nextID = annotatedUsers[i].id.GetUniqueID();
        if (annotatedUsers[i].annotation != none)
        {
            callerConsole
                .Write(nextID)
                .UseColorOnce(_.color.TextNeutral)
                .Write(P(" aka "))
                .WriteBlock(annotatedUsers[i].annotation);
        }
        else {
            callerConsole.WriteBlock(nextID);
        }
        _.memory.Free(nextID);
    }
    for (i = 0; i < annotatedUsers.length; i += 1)
    {
        _.memory.Free(annotatedUsers[i].id);
        _.memory.Free(annotatedUsers[i].annotation);
    }
}

defaultproperties {
    preferredName = "usergroups"
}