//
// Created by WolverinDEV on 26/02/2021.
//

#include "./InstanceHandler.h"
#include "./groups/GroupManager.h"

using namespace ts;
using namespace ts::server;

permission::v2::PermissionFlaggedValue InstancePermissionHelper::calculate_permission(
        permission::PermissionType permission,
        ClientDbId cldbid,
        ClientType type,
        ChannelId channel,
        bool granted,
        std::shared_ptr<CalculateCache> cache
) const {
    auto result = this->calculate_permissions({permission}, cldbid, type, channel, granted, cache);
    if(result.empty()) return {0, false};
    return result.front().second;
}

std::vector<std::pair<permission::PermissionType, permission::v2::PermissionFlaggedValue> > InstancePermissionHelper::calculate_permissions(
        const std::deque<permission::PermissionType> &permissions,
        ClientDbId cldbid,
        ClientType /* type */,
        ChannelId /* channel */,
        bool granted,
        std::shared_ptr<CalculateCache> /* cache */
) const {
    std::vector<std::pair<permission::PermissionType, permission::v2::PermissionFlaggedValue>> result{};

    /* TODO: Use same algorithm as on normal servers */
    std::vector<std::shared_ptr<groups::ServerGroup>> assigned_groups{};
    {
        using groups::GroupAssignmentCalculateMode;
        using groups::GroupCalculateMode;

        auto group_manager = this->instance->group_manager();
        auto& assignment_manager = group_manager->assignments();

        auto assignments = assignment_manager.server_groups_of_client(GroupAssignmentCalculateMode::GLOBAL, cldbid);
        if(assignments.empty()) {
            assignments.push_back(this->instance->properties()[property::SERVERINSTANCE_GUEST_SERVERQUERY_GROUP].as_save<GroupId>());
        }

        assigned_groups.reserve(assignments.size());
        for(const auto& group_id : assignments) {
            auto group = group_manager->server_groups()->find_group(GroupCalculateMode::GLOBAL, group_id);
            if(!group) {
                continue;
            }

            assigned_groups.push_back(std::move(group));
        }
    }

    for(const auto& permission : permissions) {
        permission::v2::PermissionFlaggedValue value{0, false};

        for(const auto &gr : assigned_groups){
            auto group_permissions = gr->permissions();
            auto flagged_permissions = granted ? group_permissions->permission_granted_flagged(permission) : group_permissions->permission_value_flagged(permission);
            if(flagged_permissions.has_value) {
                if(!value.has_value || flagged_permissions.value > value.value || flagged_permissions.value == -1) {
                    value = flagged_permissions;
                }
            }
        }

        result.emplace_back(permission, value);
    }

    return result;
}