// Copyright 2017 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include <xmlparser/XMLProfileManager.h>

#include <cstdlib>
#include <functional>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif // _WIN32

#include <tinyxml2.h>

#include <fastdds/dds/domain/qos/DomainParticipantFactoryQos.hpp>
#include <fastdds/dds/log/Log.hpp>

#include <xmlparser/XMLTree.h>

using namespace eprosima::fastdds;
using namespace ::xmlparser;

LibrarySettings XMLProfileManager::library_settings_;
std::map<std::string, up_participantfactory_t> XMLProfileManager::participant_factory_profiles_;
dds::DomainParticipantFactoryQos default_participant_factory_qos;
std::map<std::string, up_participant_t> XMLProfileManager::participant_profiles_;
ParticipantAttributes default_participant_attributes;
std::map<std::string, up_publisher_t> XMLProfileManager::publisher_profiles_;
PublisherAttributes default_publisher_attributes;
std::map<std::string, up_subscriber_t> XMLProfileManager::subscriber_profiles_;
SubscriberAttributes default_subscriber_attributes;
std::map<std::string, up_topic_t> XMLProfileManager::topic_profiles_;
TopicAttributes default_topic_attributes;
std::map<std::string, up_requester_t> XMLProfileManager::requester_profiles_;
std::map<std::string, up_replier_t> XMLProfileManager::replier_profiles_;
std::map<std::string, XMLP_ret> XMLProfileManager::xml_files_;
sp_transport_map_t XMLProfileManager::transport_profiles_;
p_dynamictype_map_t XMLProfileManager::dynamic_types_;
BaseNode* XMLProfileManager::root = nullptr;

template<typename T>
struct AttributesTraits;

template<>
struct AttributesTraits<ParticipantAttributes>
{
    static constexpr NodeType node_type = NodeType::PARTICIPANT;
    using NodePtrType = p_node_participant_t;
    using NodeUniquePtrType = up_participant_t;

    static std::string name()
    {
        return "Participant";
    }

};

template<>
struct AttributesTraits<PublisherAttributes>
{
    static constexpr NodeType node_type = NodeType::PUBLISHER;
    using NodePtrType = p_node_publisher_t;
    using NodeUniquePtrType = up_publisher_t;

    static std::string name()
    {
        return "Publisher";
    }

};

template<>
struct AttributesTraits<SubscriberAttributes>
{
    static constexpr NodeType node_type = NodeType::SUBSCRIBER;
    using NodePtrType = p_node_subscriber_t;
    using NodeUniquePtrType = up_subscriber_t;

    static std::string name()
    {
        return "Subscriber";
    }

};

template<>
struct AttributesTraits<TopicAttributes>
{
    static constexpr NodeType node_type = NodeType::TOPIC;
    using NodePtrType = p_node_topic_t;
    using NodeUniquePtrType = up_topic_t;

    static std::string name()
    {
        return "Topic";
    }

};

template<>
struct AttributesTraits<RequesterAttributes>
{
    static constexpr NodeType node_type = NodeType::REQUESTER;
    using NodePtrType = p_node_requester_t;
    using NodeUniquePtrType = up_requester_t;

    static std::string name()
    {
        return "Requester";
    }

};

template<>
struct AttributesTraits<ReplierAttributes>
{
    static constexpr NodeType node_type = NodeType::REPLIER;
    using NodePtrType = p_node_replier_t;
    using NodeUniquePtrType = up_replier_t;

    static std::string name()
    {
        return "Replier";
    }

};

template <typename AttributesType>
XMLP_ret fill_attributes_from_xml(
        const std::string& xml,
        AttributesType& atts,
        const std::function<bool(typename AttributesTraits<AttributesType>::NodePtrType)>& node_filter,
        bool fulfill_xsd)
{
    using Traits = AttributesTraits<AttributesType>;

    up_base_node_t root_node;
    XMLP_ret loaded_ret = XMLParser::loadXML(xml.c_str(), xml.size(), root_node);

    if (!root_node || loaded_ret != XMLP_ret::XML_OK)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing string");
        return XMLP_ret::XML_ERROR;
    }

    // Process node function
    auto process_node = [&](const up_base_node_t& node_to_process, AttributesType& atts)
            {
                // If node type doesn't match, skip
                if (Traits::node_type != node_to_process->getType())
                {
                    return XMLP_ret::XML_NOK;
                }

                // Cast the node to the expected type
                typename Traits::NodePtrType node = dynamic_cast<typename Traits::NodePtrType>(node_to_process.get());
                if (!node)
                {
                    EPROSIMA_LOG_ERROR(XMLPARSER, "Error casting node");
                    return XMLP_ret::XML_ERROR;
                }

                // If node doesn't match the filter, skip
                if (!node_filter(node))
                {
                    return XMLP_ret::XML_NOK;
                }

                // Retrieve node data
                typename Traits::NodeUniquePtrType node_data = node->getData();
                if (!node_data)
                {
                    EPROSIMA_LOG_ERROR(XMLPARSER, "Error retrieving node data");
                    return XMLP_ret::XML_ERROR;
                }

                // Fill attributes
                atts = *node_data;
                return XMLP_ret::XML_OK;
            };

    // Recursive function to process the root node and its children
    std::function<XMLP_ret(const up_base_node_t&, AttributesType&)> process_node_recursive;
    process_node_recursive =
            [&process_node, &process_node_recursive](const up_base_node_t& node_to_process, AttributesType& atts)
            {
                XMLP_ret ret = process_node(node_to_process, atts);
                if (XMLP_ret::XML_OK == ret || XMLP_ret::XML_ERROR == ret)
                {
                    return ret;
                }

                for (auto&& child: node_to_process->getChildren())
                {
                    ret = process_node_recursive(child, atts);
                    if (XMLP_ret::XML_OK == ret || XMLP_ret::XML_ERROR == ret)
                    {
                        return ret;
                    }
                }
                return XMLP_ret::XML_NOK;
            };

    std::reference_wrapper<up_base_node_t> node_to_process = root_node;
    if (fulfill_xsd)
    {
        if (NodeType::ROOT == root_node->getType())
        {
            for (auto&& child: root_node->getChildren())
            {
                if (NodeType::PROFILES == child->getType())
                {
                    node_to_process = child;
                    break;
                }
            }
        }

        // Abort if profiles tag is not found according to XSD
        if (NodeType::PROFILES != node_to_process.get()->getType())
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "Provided XML literal does not contain profiles");
            return XMLP_ret::XML_ERROR;
        }
    }

    if (XMLP_ret::XML_OK == process_node_recursive(node_to_process, atts))
    {
        return XMLP_ret::XML_OK;
    }

    EPROSIMA_LOG_ERROR(XMLPARSER, Traits::name() << " profile not found");
    return XMLP_ret::XML_ERROR;
}

template <typename AttributesType>
XMLP_ret fill_attributes_from_xml(
        const std::string& xml,
        AttributesType& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    auto node_filter = [&profile_name](typename AttributesTraits<AttributesType>::NodePtrType node) -> bool
            {
                if (!profile_name.empty())
                {
                    auto it = node->getAttributes().find(PROFILE_NAME);
                    return (it != node->getAttributes().end() && it->second == profile_name);
                }
                return true;
            };
    return fill_attributes_from_xml(xml, atts, node_filter, fulfill_xsd);
}

template <typename AttributesType>
XMLP_ret fill_default_attributes_from_xml(
        const std::string& xml,
        AttributesType& atts,
        bool fulfill_xsd)
{
    auto node_filter = [](typename AttributesTraits<AttributesType>::NodePtrType node) -> bool
            {
                auto it = node->getAttributes().find(DEFAULT_PROF);
                return (it != node->getAttributes().end() && it->second == "true");
            };
    return fill_attributes_from_xml(xml, atts, node_filter, fulfill_xsd);
}

XMLP_ret XMLProfileManager::fillParticipantAttributes(
        const std::string& profile_name,
        ParticipantAttributes& atts,
        bool log_error)
{
    part_map_iterator_t it = participant_profiles_.find(profile_name);
    if (it == participant_profiles_.end())
    {
        if (log_error)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        }
        return XMLP_ret::XML_ERROR;
    }
    atts = *(it->second);
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::fill_participant_attributes_from_xml(
        const std::string& xml,
        ParticipantAttributes& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    return fill_attributes_from_xml<ParticipantAttributes>(xml, atts, fulfill_xsd, profile_name);
}

XMLP_ret XMLProfileManager::fill_default_participant_attributes_from_xml(
        const std::string& xml,
        ParticipantAttributes& atts,
        bool fulfill_xsd)
{
    return fill_default_attributes_from_xml<ParticipantAttributes>(xml, atts, fulfill_xsd);
}

XMLP_ret XMLProfileManager::fillPublisherAttributes(
        const std::string& profile_name,
        PublisherAttributes& atts,
        bool log_error)
{
    publ_map_iterator_t it = publisher_profiles_.find(profile_name);
    if (it == publisher_profiles_.end())
    {
        if (log_error)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        }
        return XMLP_ret::XML_ERROR;
    }
    atts = *(it->second);
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::fill_publisher_attributes_from_xml(
        const std::string& xml,
        PublisherAttributes& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    return fill_attributes_from_xml<PublisherAttributes>(xml, atts, fulfill_xsd, profile_name);
}

XMLP_ret XMLProfileManager::fill_default_publisher_attributes_from_xml(
        const std::string& xml,
        PublisherAttributes& atts,
        bool fulfill_xsd)
{
    return fill_default_attributes_from_xml<PublisherAttributes>(xml, atts, fulfill_xsd);
}

XMLP_ret XMLProfileManager::fillSubscriberAttributes(
        const std::string& profile_name,
        SubscriberAttributes& atts,
        bool log_error)
{
    subs_map_iterator_t it = subscriber_profiles_.find(profile_name);
    if (it == subscriber_profiles_.end())
    {
        if (log_error)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        }
        return XMLP_ret::XML_ERROR;
    }
    atts = *(it->second);
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::fill_subscriber_attributes_from_xml(
        const std::string& xml,
        SubscriberAttributes& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    return fill_attributes_from_xml<SubscriberAttributes>(xml, atts, fulfill_xsd, profile_name);
}

XMLP_ret XMLProfileManager::fill_default_subscriber_attributes_from_xml(
        const std::string& xml,
        SubscriberAttributes& atts,
        bool fulfill_xsd)
{
    return fill_default_attributes_from_xml<SubscriberAttributes>(xml, atts, fulfill_xsd);
}

XMLP_ret XMLProfileManager::fillTopicAttributes(
        const std::string& profile_name,
        TopicAttributes& atts)
{
    topic_map_iterator_t it = topic_profiles_.find(profile_name);
    if (it == topic_profiles_.end())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        return XMLP_ret::XML_ERROR;
    }
    atts = *(it->second);
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::fill_topic_attributes_from_xml(
        const std::string& xml,
        TopicAttributes& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    return fill_attributes_from_xml<TopicAttributes>(xml, atts, fulfill_xsd, profile_name);
}

XMLP_ret XMLProfileManager::fill_default_topic_attributes_from_xml(
        const std::string& xml,
        TopicAttributes& atts,
        bool fulfill_xsd)
{
    return fill_default_attributes_from_xml<TopicAttributes>(xml, atts, fulfill_xsd);
}

XMLP_ret XMLProfileManager::fillRequesterAttributes(
        const std::string& profile_name,
        RequesterAttributes& atts)
{
    requester_map_iterator_t it = requester_profiles_.find(profile_name);
    if (it == requester_profiles_.end())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        return XMLP_ret::XML_ERROR;
    }
    atts = *(it->second);
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::fill_requester_attributes_from_xml(
        const std::string& xml,
        RequesterAttributes& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    return fill_attributes_from_xml<RequesterAttributes>(xml, atts, fulfill_xsd, profile_name);
}

XMLP_ret XMLProfileManager::fill_default_requester_attributes_from_xml(
        const std::string& xml,
        RequesterAttributes& atts,
        bool fulfill_xsd)
{
    return fill_default_attributes_from_xml<RequesterAttributes>(xml, atts, fulfill_xsd);
}

XMLP_ret XMLProfileManager::fillReplierAttributes(
        const std::string& profile_name,
        ReplierAttributes& atts)
{
    replier_map_iterator_t it = replier_profiles_.find(profile_name);
    if (it == replier_profiles_.end())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        return XMLP_ret::XML_ERROR;
    }
    atts = *(it->second);
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::fill_replier_attributes_from_xml(
        const std::string& xml,
        ReplierAttributes& atts,
        bool fulfill_xsd,
        const std::string& profile_name)
{
    return fill_attributes_from_xml<ReplierAttributes>(xml, atts, fulfill_xsd, profile_name);
}

XMLP_ret XMLProfileManager::fill_default_replier_attributes_from_xml(
        const std::string& xml,
        ReplierAttributes& atts,
        bool fulfill_xsd)
{
    return fill_default_attributes_from_xml<ReplierAttributes>(xml, atts, fulfill_xsd);
}

void XMLProfileManager::getDefaultParticipantAttributes(
        ParticipantAttributes& participant_attributes)
{
    participant_attributes = default_participant_attributes;
}

void XMLProfileManager::getDefaultPublisherAttributes(
        PublisherAttributes& publisher_attributes)
{
    publisher_attributes = default_publisher_attributes;
}

XMLP_ret XMLProfileManager::fillDomainParticipantFactoryQos(
        const std::string& profile_name,
        dds::DomainParticipantFactoryQos& qos,
        bool log_error)
{
    part_factory_map_iterator_t it = participant_factory_profiles_.find(profile_name);
    if (it == participant_factory_profiles_.end())
    {
        if (log_error)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "Profile '" << profile_name << "' not found");
        }
        return XMLP_ret::XML_ERROR;
    }
    qos = *(it->second);
    return XMLP_ret::XML_OK;
}

void XMLProfileManager::getDefaultDomainParticipantFactoryQos(
        dds::DomainParticipantFactoryQos& qos)
{
    qos = default_participant_factory_qos;
}

void XMLProfileManager::getDefaultSubscriberAttributes(
        SubscriberAttributes& subscriber_attributes)
{
    subscriber_attributes = default_subscriber_attributes;
}

void XMLProfileManager::getDefaultTopicAttributes(
        TopicAttributes& topic_attributes)
{
    topic_attributes = default_topic_attributes;
}

void XMLProfileManager::loadDefaultXMLFile()
{
    // Try to load the default XML file set with an environment variable.
#ifdef _WIN32
    char file_path[MAX_PATH];
    char absolute_path[MAX_PATH];
    char current_directory[MAX_PATH];
    char** filename = {nullptr};
    size_t size = MAX_PATH;
    if (getenv_s(&size, file_path, size, DEFAULT_FASTDDS_ENV_VARIABLE) == 0 && size > 0)
    {
        // Use absolute path to ensure the file is loaded only once
        if (GetFullPathName(file_path, MAX_PATH, absolute_path, filename) == 0)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "GetFullPathName failed " << GetLastError());
        }
        else
        {
            loadXMLFile(absolute_path);
        }
    }

    // Should take into account '\0'
    char skip_xml[2];
    size = 2;

    // Try to load the default XML file if variable does not exist or is not set to '1'
    if (!(getenv_s(&size, skip_xml, size, SKIP_DEFAULT_XML_FILE) == 0 && skip_xml[0] == '1'))
    {
        // Try to load the default XML file.
        if (GetCurrentDirectory(MAX_PATH, current_directory) == 0)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "GetCurrentDirectory failed " << GetLastError());
        }
        else
        {
            strcat_s(current_directory, MAX_PATH, "\\");
            strcat_s(current_directory, MAX_PATH, DEFAULT_FASTDDS_PROFILES);
            loadXMLFile(current_directory, true);
        }
    }
#else
    char absolute_path[PATH_MAX];

    if (const char* file_path = std::getenv(DEFAULT_FASTDDS_ENV_VARIABLE))
    {
        char* res = realpath(file_path, absolute_path);
        if (res)
        {
            loadXMLFile(absolute_path);
        }
        else
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "realpath failed " << std::strerror(errno));
        }
    }

    const char* skip_xml = std::getenv(SKIP_DEFAULT_XML_FILE);

    // Try to load the default XML file if variable does not exist or is not set to '1'
    if (!(skip_xml != nullptr && skip_xml[0] == '1'))
    {
        if (getcwd(absolute_path, PATH_MAX) == NULL)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "getcwd failed " << std::strerror(errno));
        }
        else
        {
            strcat(absolute_path, "/");
            strcat(absolute_path, DEFAULT_FASTDDS_PROFILES);
            loadXMLFile(absolute_path, true);
        }
    }

#endif // ifdef _WIN32
}

XMLP_ret XMLProfileManager::loadXMLProfiles(
        tinyxml2::XMLElement& profiles)
{
    up_base_node_t root_node;
    if (strcmp(profiles.Name(), PROFILES) != 0)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "<profiles> element not found");
        return XMLP_ret::XML_ERROR;
    }

    if (XMLParser::loadXMLProfiles(profiles, root_node) == XMLP_ret::XML_OK)
    {
        EPROSIMA_LOG_INFO(XMLPARSER, "Node parsed successfully");
        return XMLProfileManager::extractProfiles(std::move(root_node), "-XML Node-");
    }
    else
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing profiles");
        return XMLP_ret::XML_ERROR;
    }
}

XMLP_ret XMLProfileManager::loadXMLDynamicTypes(
        tinyxml2::XMLElement& types)
{
    return XMLParser::loadXMLDynamicTypes(types);
}

XMLP_ret XMLProfileManager::loadXMLNode(
        tinyxml2::XMLDocument& doc)
{
    up_base_node_t root_node;
    XMLP_ret parse_ret;
    XMLP_ret loaded_ret = XMLParser::loadXML(doc, root_node);

    if (!root_node)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing node");
        return XMLP_ret::XML_ERROR;
    }

    EPROSIMA_LOG_INFO(XMLPARSER, "Node parsed successfully");

    if (NodeType::PROFILES == root_node->getType())
    {
        parse_ret = XMLProfileManager::extractProfiles(std::move(root_node), "-XML Node-");
        if (parse_ret == XMLP_ret::XML_OK && loaded_ret != XMLP_ret::XML_OK)
        {
            return XMLP_ret::XML_NOK;
        }
        else
        {
            return parse_ret;
        }
    }

    if (NodeType::ROOT == root_node->getType())
    {
        for (auto&& child: root_node->getChildren())
        {
            if (NodeType::PROFILES == child.get()->getType())
            {
                parse_ret = XMLProfileManager::extractProfiles(std::move(child), "-XML Node-");
                if (parse_ret == XMLP_ret::XML_OK && loaded_ret != XMLP_ret::XML_OK)
                {
                    return XMLP_ret::XML_NOK;
                }
                else
                {
                    return parse_ret;
                }
            }
        }
    }

    return XMLP_ret::XML_ERROR;
}

XMLP_ret XMLProfileManager::loadXMLFile(
        const std::string& filename)
{
    return loadXMLFile(filename, false);
}

XMLP_ret XMLProfileManager::loadXMLFile(
        const std::string& filename,
        bool is_default)
{
    if (filename.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error loading XML file, filename empty");
        return XMLP_ret::XML_ERROR;
    }

    xmlfile_map_iterator_t it = xml_files_.find(filename);
    if (it != xml_files_.end() && XMLP_ret::XML_OK == it->second)
    {
        EPROSIMA_LOG_INFO(XMLPARSER, "XML file '" << filename << "' already parsed");
        return XMLP_ret::XML_OK;
    }

    up_base_node_t root_node;
    XMLP_ret loaded_ret = XMLParser::loadXML(filename, root_node, is_default);
    if (!root_node || loaded_ret != XMLP_ret::XML_OK)
    {
        if (!is_default)
        {
            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing '" << filename << "'");
        }
        xml_files_.emplace(filename, XMLP_ret::XML_ERROR);
        return XMLP_ret::XML_ERROR;
    }

    EPROSIMA_LOG_INFO(XMLPARSER, "File '" << filename << "' parsed successfully");

    if (NodeType::ROOT == root_node->getType())
    {
        for (auto&& child: root_node->getChildren())
        {
            if (NodeType::PROFILES == child.get()->getType())
            {
                return XMLProfileManager::extractProfiles(std::move(child), filename);
            }
        }
        return loaded_ret;
    }
    else if (NodeType::PROFILES == root_node->getType())
    {
        return XMLProfileManager::extractProfiles(std::move(root_node), filename);
    }

    return loaded_ret;
}

XMLP_ret XMLProfileManager::loadXMLString(
        const char* data,
        size_t length)
{
    up_base_node_t root_node;
    XMLP_ret loaded_ret = XMLParser::loadXML(data, length, root_node);
    if (!root_node || loaded_ret != XMLP_ret::XML_OK)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing string");
        return XMLP_ret::XML_ERROR;
    }

    if (NodeType::ROOT == root_node->getType())
    {
        for (auto&& child: root_node->getChildren())
        {
            if (NodeType::PROFILES == child.get()->getType())
            {
                return XMLProfileManager::extractProfiles(std::move(child), "inmem");
            }
        }
        return loaded_ret;
    }
    else if (NodeType::PROFILES == root_node->getType())
    {
        return XMLProfileManager::extractProfiles(std::move(root_node), "inmem");
    }

    return loaded_ret;
}

XMLP_ret XMLProfileManager::extractProfiles(
        up_base_node_t profiles,
        const std::string& filename)
{
    assert(profiles != nullptr);

    unsigned int profile_count = 0u;

    XMLP_ret ret = XMLP_ret::XML_OK;
    for (auto&& profile: profiles->getChildren())
    {
        if (NodeType::DOMAINPARTICIPANT_FACTORY == profile->getType())
        {
            if (XMLP_ret::XML_OK == extractDomainParticipantFactoryProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
        else if (NodeType::PARTICIPANT == profile->getType())
        {
            if (XMLP_ret::XML_OK == extractParticipantProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
        else if (NodeType::PUBLISHER == profile.get()->getType())
        {
            if (XMLP_ret::XML_OK == extractPublisherProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
        else if (NodeType::SUBSCRIBER == profile.get()->getType())
        {
            if (XMLP_ret::XML_OK == extractSubscriberProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
        else if (NodeType::TOPIC == profile.get()->getType())
        {
            if (XMLP_ret::XML_OK == extractTopicProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
        else if (NodeType::REQUESTER == profile.get()->getType())
        {
            if (XMLP_ret::XML_OK == extractRequesterProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
        else if (NodeType::REPLIER == profile.get()->getType())
        {
            if (XMLP_ret::XML_OK == extractReplierProfile(profile, filename))
            {
                ++profile_count;
            }
            else
            {
                ret = XMLP_ret::XML_NOK;
            }
        }
    }

    profile_count += static_cast<unsigned int>(transport_profiles_.size()); // Count transport profiles

    if (profile_count == 0)
    {
        EPROSIMA_LOG_ERROR(XMLProfileManager, "Could not extract any profile");
        ret = XMLP_ret::XML_ERROR;
    }

    xml_files_.emplace(filename, ret);

    return ret;
}

XMLP_ret XMLProfileManager::extractDomainParticipantFactoryProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    static_cast<void>(filename);
    std::string profile_name = "";

    p_node_participantfactory_t node_factory = dynamic_cast<p_node_participantfactory_t>(profile.get());
    node_att_map_cit_t it = node_factory->getAttributes().find(PROFILE_NAME);
    if (it == node_factory->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<part_factory_map_iterator_t, bool> emplace = participant_factory_profiles_.emplace(profile_name,
                    node_factory->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    it = node_factory->getAttributes().find(DEFAULT_PROF);
    if (it != node_factory->getAttributes().end() && it->second == "true") // Set as default profile
    {
        default_participant_factory_qos = *(emplace.first->second.get());
    }
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::extractParticipantProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    (void)(filename);
    std::string profile_name = "";

    p_node_participant_t node_part = dynamic_cast<p_node_participant_t>(profile.get());
    node_att_map_cit_t it = node_part->getAttributes().find(PROFILE_NAME);
    if (it == node_part->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<part_map_iterator_t, bool> emplace = participant_profiles_.emplace(profile_name, node_part->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    it = node_part->getAttributes().find(DEFAULT_PROF);
    if (it != node_part->getAttributes().end() && it->second == "true") // Set as default profile
    {
        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
        default_participant_attributes = *(emplace.first->second.get());
    }
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::extractPublisherProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    (void)(filename);
    std::string profile_name = "";

    p_node_publisher_t node_part = dynamic_cast<p_node_publisher_t>(profile.get());
    node_att_map_cit_t it = node_part->getAttributes().find(PROFILE_NAME);
    if (it == node_part->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<publ_map_iterator_t, bool> emplace = publisher_profiles_.emplace(profile_name, node_part->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    it = node_part->getAttributes().find(DEFAULT_PROF);
    if (it != node_part->getAttributes().end() && it->second == "true") // Set as default profile
    {
        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
        default_publisher_attributes = *(emplace.first->second.get());
    }
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::extractSubscriberProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    (void)(filename);
    std::string profile_name = "";

    p_node_subscriber_t node_part = dynamic_cast<p_node_subscriber_t>(profile.get());
    node_att_map_cit_t it = node_part->getAttributes().find(PROFILE_NAME);
    if (it == node_part->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<subs_map_iterator_t, bool> emplace = subscriber_profiles_.emplace(profile_name, node_part->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    it = node_part->getAttributes().find(DEFAULT_PROF);
    if (it != node_part->getAttributes().end() && it->second == "true") // Set as default profile
    {
        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
        default_subscriber_attributes = *(emplace.first->second.get());
    }
    return XMLP_ret::XML_OK;
}

bool XMLProfileManager::insertTransportById(
        const std::string& transport_id,
        sp_transport_t transport)
{
    if (transport_profiles_.find(transport_id) == transport_profiles_.end())
    {
        transport_profiles_[transport_id] = transport;
        return true;
    }
    EPROSIMA_LOG_ERROR(XMLPARSER,
            "Error adding the transport " << transport_id << ". There is other transport with the same id");
    return false;
}

const LibrarySettings& XMLProfileManager::library_settings()
{
    return library_settings_;
}

void XMLProfileManager::library_settings(
        const LibrarySettings& library_settings)
{
    library_settings_ = library_settings;
}

sp_transport_t XMLProfileManager::getTransportById(
        const std::string& transport_id)
{
    if (transport_profiles_.find(transport_id) != transport_profiles_.end())
    {
        return transport_profiles_[transport_id];
    }
    return nullptr;
}

bool XMLProfileManager::insertDynamicTypeBuilderByName(
        const std::string& type_name,
        const eprosima::fastdds::dds::DynamicTypeBuilder::_ref_type& type)
{
    if (dynamic_types_.find(type_name) == dynamic_types_.end())
    {
        dynamic_types_.emplace(std::make_pair(type_name, type));
        return true;
    }
    EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding the type " << type_name << ". There is other type with the same name.");
    return false;
}

XMLP_ret XMLProfileManager::getDynamicTypeBuilderByName(
        eprosima::fastdds::dds::DynamicTypeBuilder::_ref_type& dynamic_type,
        const std::string& type_name)
{
    if (dynamic_types_.find(type_name) != dynamic_types_.end())
    {
        dynamic_type = dynamic_types_[type_name];
        return XMLP_ret::XML_OK;
    }

    return XMLP_ret::XML_ERROR;
}

XMLP_ret XMLProfileManager::extractTopicProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    (void)(filename);
    std::string profile_name = "";

    p_node_topic_t node_topic = dynamic_cast<p_node_topic_t>(profile.get());
    node_att_map_cit_t it = node_topic->getAttributes().find(PROFILE_NAME);
    if (it == node_topic->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<topic_map_iterator_t, bool> emplace = topic_profiles_.emplace(profile_name, node_topic->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    it = node_topic->getAttributes().find(DEFAULT_PROF);
    if (it != node_topic->getAttributes().end() && it->second == "true")
    {
        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
        default_topic_attributes = *(emplace.first->second.get());
    }
    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::extractRequesterProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    (void)(filename);
    std::string profile_name = "";

    p_node_requester_t node_requester = dynamic_cast<p_node_requester_t>(profile.get());
    node_att_map_cit_t it = node_requester->getAttributes().find(PROFILE_NAME);
    if (it == node_requester->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<requester_map_iterator_t, bool> emplace = requester_profiles_.emplace(profile_name,
                    node_requester->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    return XMLP_ret::XML_OK;
}

XMLP_ret XMLProfileManager::extractReplierProfile(
        up_base_node_t& profile,
        const std::string& filename)
{
    (void)(filename);
    std::string profile_name = "";

    p_node_replier_t node_replier = dynamic_cast<p_node_replier_t>(profile.get());
    node_att_map_cit_t it = node_replier->getAttributes().find(PROFILE_NAME);
    if (it == node_replier->getAttributes().end() || it->second.empty())
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
        return XMLP_ret::XML_ERROR;
    }

    profile_name = it->second;

    std::pair<replier_map_iterator_t, bool> emplace = replier_profiles_.emplace(profile_name, node_replier->getData());
    if (false == emplace.second)
    {
        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
        return XMLP_ret::XML_ERROR;
    }

    return XMLP_ret::XML_OK;
}

void XMLProfileManager::DeleteInstance()
{
    participant_factory_profiles_.clear();
    participant_profiles_.clear();
    publisher_profiles_.clear();
    subscriber_profiles_.clear();
    requester_profiles_.clear();
    replier_profiles_.clear();
    topic_profiles_.clear();
    xml_files_.clear();
    transport_profiles_.clear();
    dynamic_types_.clear();
}