SkillManagerComponentPluginUser.cpp

#include "SkillManagerComponentPluginUser.h"

#include <IceUtil/Optional.h>

#include <ArmarXCore/core/logging/Logging.h>

#include "RobotAPI/libraries/skills/core/FluxioProfile.h"
#include "RobotAPI/libraries/skills/core/FluxioProvider.h"
#include "RobotAPI/libraries/skills/core/error/Exception.h"
#include "RobotAPI/libraries/skills/manager/SkillManagerComponentPlugin.h"
#include <RobotAPI/interface/skills/SkillManagerInterface.h>

namespace armarx
{
    SkillManagerComponentPluginUser::SkillManagerComponentPluginUser()
    {
        addPlugin(plugin);
    }

    void
    SkillManagerComponentPluginUser::addProvider(const skills::manager::dto::ProviderInfo& info,
                                                 const Ice::Current&)
    {
        auto i = skills::ProviderInfo::FromIce(info);
        this->plugin->addProvider(i);
    }

    void
    SkillManagerComponentPluginUser::removeProvider(
        const skills::manager::dto::ProviderID& provider,
        const Ice::Current&)
    {
        auto i = skills::ProviderID::FromIce(provider);
        this->plugin->removeProvider(i);
    }

    skills::manager::dto::SkillStatusUpdate
    SkillManagerComponentPluginUser::executeSkill(
        const skills::manager::dto::SkillExecutionRequest& info,
        const Ice::Current&)
    {
        auto e = skills::SkillExecutionRequest::FromIce(info);
        return this->plugin->executeSkill(e).toManagerIce();
    }

    skills::manager::dto::SkillExecutionID
    SkillManagerComponentPluginUser::executeSkillAsync(
        const skills::manager::dto::SkillExecutionRequest& info,
        const Ice::Current& current)
    {
        auto e = skills::SkillExecutionRequest::FromIce(info);
        return this->plugin->executeSkillAsync(e).toManagerIce();
    }

    skills::provider::dto::ParameterUpdateResult
    SkillManagerComponentPluginUser::updateSkillParameters(
        const skills::manager::dto::SkillExecutionID& info,
        const aron::data::dto::DictPtr& params,
        const Ice::Current& current)
    {
        skills::provider::dto::ParameterUpdateResult ret;
        auto a = armarx::aron::data::Dict::FromAronDictDTO(params);
        auto e = skills::SkillExecutionID::FromIce(info);
        ret.success = this->plugin->updateSkillParameters(e, a);
        return ret;
    }

    skills::provider::dto::AbortSkillResult
    SkillManagerComponentPluginUser::abortSkill(const skills::manager::dto::SkillExecutionID& id,
                                                const Ice::Current& current)
    {
        skills::provider::dto::AbortSkillResult ret;
        auto i = skills::SkillExecutionID::FromIce(id);
        ret.success = this->plugin->abortSkill(i);
        return ret;
    }

    skills::provider::dto::AbortSkillResult
    SkillManagerComponentPluginUser::abortSkillAsync(
        const skills::manager::dto::SkillExecutionID& id,
        const Ice::Current& /*unused*/)
    {
        skills::provider::dto::AbortSkillResult ret;
        auto i = skills::SkillExecutionID::FromIce(id);
        ret.success = this->plugin->abortSkillAsync(i);
        return ret;
    }

    void
    SkillManagerComponentPluginUser::updateStatusForSkill(
        const skills::provider::dto::SkillStatusUpdate& statusUpdate,
        const skills::callback::dto::ProviderID& pid,
        const Ice::Current&)
    {
        (void)statusUpdate;
        (void)pid;
        // If you want to use the status, implement this method!
    }

    skills::manager::dto::SkillDescriptionMap
    SkillManagerComponentPluginUser::getSkillDescriptions(const Ice::Current& current)
    {
        skills::manager::dto::SkillDescriptionMap ret;

        auto m = this->plugin->getSkillDescriptions();

        for (const auto& [k, v] : m)
        {
            ret.insert({k.toManagerIce(), v.toManagerIce()});
        }

        return ret;
    }

    IceUtil::Optional<skills::manager::dto::SkillDescription>
    SkillManagerComponentPluginUser::getSkillDescription(const skills::manager::dto::SkillID& id,
                                                         const Ice::Current& current)
    {
        auto e = skills::SkillID::FromIce(id);
        auto o = this->plugin->getSkillDescription(e);
        if (o.has_value())
        {
            return o->toManagerIce();
        }
        return {};
    }

    IceUtil::Optional<skills::manager::dto::SkillStatusUpdate>
    SkillManagerComponentPluginUser::getSkillExecutionStatus(
        const skills::manager::dto::SkillExecutionID& executionId,
        const Ice::Current& current)
    {
        auto e = skills::SkillExecutionID::FromIce(executionId);
        auto o = this->plugin->getSkillExecutionStatus(e);
        if (o.has_value())
        {
            return o->toManagerIce();
        }
        return {};
    }

    skills::manager::dto::SkillStatusUpdateMap
    SkillManagerComponentPluginUser::getSkillExecutionStatuses(const Ice::Current& current)
    {
        skills::manager::dto::SkillStatusUpdateMap ret;

        auto m = this->plugin->getSkillExecutionStatuses();

        for (const auto& [k, v] : m)
        {
            ret.insert({k.toManagerIce(), v.toManagerIce()});
        }

        return ret;
    }

    //****************************//
    //** Fluxio related methods **//
    //****************************//

    IceUtil::Optional<std::string>
    SkillManagerComponentPluginUser::executeFluxioSkill(const std::string& skillId,
                                                        const Ice::Current& current)
    {
        const auto& res = this->plugin->executeFluxioSkill(skillId);
        if (res != nullptr)
        {
            return res->id;
        }

        return {};
    }

    void
    SkillManagerComponentPluginUser::abortFluxioSkill(const std::string& executionId, const Ice::Current& current)
    {
        this->plugin->abortFluxioSkill(executionId);
    }

    IceUtil::Optional<skills::manager::dto::FluxioSkillStatusUpdateList>
    SkillManagerComponentPluginUser::getFluxioSkillExecutionStatus(const std::string& executionId,
                                                                   const Ice::Current& current)
    {
        auto l = this->plugin->getFluxioSkillExecutionStatus(executionId);
        if (!l.has_value())
        {
            ARMARX_WARNING << "Error getting FluxioSkillExecutionStatus";
            return {};
        }

        skills::manager::dto::FluxioSkillStatusUpdateList ret;

        for (const auto& s : l.value())
        {
            ret.push_back(s.toManagerIce());
        }

        return ret;
    }

    skills::manager::dto::FluxioSkillList
    SkillManagerComponentPluginUser::getSkillList(const Ice::Current& current)
    {
        skills::manager::dto::FluxioSkillList ret;

        auto l = this->plugin->getSkillList();

        for (const auto& s : l)
        {
            const auto& skill = s.toManagerIce();

            if (!skill.has_value())
            {
                ARMARX_WARNING << "SkillManagerComponentPluginUser::getSkillList: Skill with id "
                               << s.id << " could not be converted";
                continue;
            }

            ret.push_back(*skill);
        }

        return ret;
    }

    IceUtil::Optional<skills::manager::dto::FluxioSkill>
    SkillManagerComponentPluginUser::getSkill(const std::string& id, const Ice::Current& current)
    {
        auto result = this->plugin->getSkill(id);

        if (result.isSuccess())
        {
            const auto& skill = result.getResult().toManagerIce();
            if (skill.has_value())
            {
                return *skill;
            }
        }
        return {};
    }

    bool
    SkillManagerComponentPluginUser::updateSkill(const std::string& userId,
                                                 const skills::manager::dto::FluxioSkill& skill,
                                                 const Ice::Current& current)
    {
        this->plugin->getSkillList();
        std::map<std::string, skills::FluxioSkill>& skillsMap = this->plugin->fluxioDC.skills;
        std::map<std::string, skills::FluxioProvider>& providersMap =
            this->plugin->fluxioDC.providers;
        std::map<std::string, skills::FluxioProfile>& profilesMap = this->plugin->fluxioDC.profiles;

        // Check if the skill exists
        const auto& s = skillsMap.find(skill.id);
        if (s == skillsMap.end())
        {
            ARMARX_WARNING << "SkillManagerComponentPluginUser::updateSkill: Skill with id "
                           << skill.id << " not found";
            return false;
        }

        // Check if the user has the mutex for the skill
        auto res = this->plugin->getSkillMutex(skill.id, userId); 
        if (!res.isSuccess())
        {
            ARMARX_WARNING << "SkillManagerComponentPluginUser::updateSkill: User " << userId
                           << res.getError().getReason().append("User does not have Mutex for this Skill") << skill.id;
            return false;
        }

        return s->second.updateFromIce(skill, providersMap, profilesMap, skillsMap);
    }

    void
    SkillManagerComponentPluginUser::removeSkill(const std::string& id, const Ice::Current& current)
    {
        this->plugin->removeSkill(id);
    }

    bool
    SkillManagerComponentPluginUser::getSkillMutex(const std::string& skillId,
                                                   const std::string& userId,
                                                   const Ice::Current& current)
    {
        return this->plugin->getSkillMutex(skillId, userId);
    }

    void
    SkillManagerComponentPluginUser::deleteSkillMutex(const std::string& skillId,
                                                      const std::string& userId,
                                                      const Ice::Current& current)
    {
        this->plugin->deleteSkillMutex(skillId, userId);
    }

    void
    SkillManagerComponentPluginUser::removeSkillParameter(const std::string& userId,
                                                          const std::string& skillId,
                                                          const std::string& parameterId,
                                                          const Ice::Current& current)
    {
        this->plugin->removeSkillParameter(userId, skillId, parameterId);
    }

    skills::manager::dto::FluxioProfileList
    SkillManagerComponentPluginUser::getProfileList(const Ice::Current& current)
    {
        skills::manager::dto::FluxioProfileList ret;

        auto l = this->plugin->getProfileList();

        for (const auto& profile : l)
        {
            ret.push_back(profile.toManagerIce());
        }

        return ret;
    }

    IceUtil::Optional<skills::manager::dto::FluxioProfile>
    SkillManagerComponentPluginUser::getProfile(const std::string& id, const Ice::Current& current)
    {
        auto profile = this->plugin->getProfile(id);

        if (profile.has_value())
        {
            return profile->toManagerIce();
        }
        return {};
    }

    skills::manager::dto::FluxioProfile
    SkillManagerComponentPluginUser::createProfile(
        const skills::manager::dto::FluxioProfile& profile,
        const Ice::Current& current)
    {
        std::map<std::string, skills::FluxioProfile>& profilesMap = this->plugin->fluxioDC.profiles;

        return this->plugin->createProfile(skills::FluxioProfile::FromIce(profile, profilesMap))
            .toManagerIce();
    }

    void
    SkillManagerComponentPluginUser::updateProfile(
        const skills::manager::dto::FluxioProfile& profile,
        const Ice::Current& current)
    {
        std::map<std::string, skills::FluxioProfile>& profilesMap = this->plugin->fluxioDC.profiles;

        this->plugin->updateProfile(skills::FluxioProfile::FromIce(profile, profilesMap));
    }

    skills::manager::dto::FluxioProviderList
    SkillManagerComponentPluginUser::getProviderList(const Ice::Current& current)
    {
        skills::manager::dto::FluxioProviderList ret;

        auto l = this->plugin->getProviderList();

        for (const auto& s : l)
        {
            ret.push_back(s.toManagerIce());
        }

        return ret;
    }

    IceUtil::Optional<skills::manager::dto::FluxioProvider>
    SkillManagerComponentPluginUser::getProvider(const std::string& id, const Ice::Current& current)
    {
        auto provider = this->plugin->getProvider(id);

        if (provider.has_value())
        {
            return provider->toManagerIce();
        }
        return {};
    }

    IceUtil::Optional<skills::manager::dto::FluxioSkillList>
    SkillManagerComponentPluginUser::getSkillsOfProvider(const std::string& id,
                                                         const Ice::Current& current)
    {
        skills::manager::dto::FluxioSkillList ret;

        auto l = this->plugin->getSkillsOfProvider(id);

        if (!l.has_value())
        {
            return {};
        }

        for (const auto& s : *l)
        {
            const auto& skill = s.toManagerIce();

            if (!skill.has_value())
            {
                ARMARX_WARNING
                    << "SkillManagerComponentPluginUser::getSkillsOfProvider: Skill with id "
                    << s.id << " could not be converted";
                continue;
            }

            ret.push_back(*skill);
        }

        return ret;
    }

    IceUtil::Optional<skills::manager::dto::FluxioSkill>
    SkillManagerComponentPluginUser::addSkillToProvider(
        const std::string& userId,
        const std::string& providerId,
        const skills::manager::dto::FluxioSkill& skill,
        const Ice::Current& current)
    {
        this->plugin->getSkillList();
        std::map<std::string, skills::FluxioSkill>& skillsMap = this->plugin->fluxioDC.skills;
        std::map<std::string, skills::FluxioProvider>& providersMap =
            this->plugin->fluxioDC.providers;
        std::map<std::string, skills::FluxioProfile>& profilesMap = this->plugin->fluxioDC.profiles;

        auto skillBO = skills::FluxioSkill::FromIce(skill, providersMap, profilesMap, skillsMap);
        if (!skillBO.has_value())
        {
            ARMARX_WARNING << "Skill with id " << skill.id << " could not be converted";
            return {};
        }

        auto s = this->plugin->addSkillToProvider(userId, providerId, *skillBO);
        if (s.has_value())
        {
            const auto& ret = s->toManagerIce();
            if (ret.has_value())
            {
                return *ret;
            }
        }

        ARMARX_WARNING << "Skill with id " << skill.id << " could not be added to provider with id "
                       << providerId;
        return {};
    }
} // namespace armarx