#include "profinet_slot.hpp"

ProfinetSlot::ProfinetSlot ( uint16_t slot_nbr ) : 
                             m_slot_nbr(slot_nbr),
                             m_module_ptr(nullptr)                         
{

}


bool ProfinetSlot::pullModule(ProfinetServiceData& pnet_data)
{
    int result = pnet_pull_module (pnet_data.pnet_ptr, pnet_data.api, m_slot_nbr);
    
    m_module_ptr = nullptr;

    return (result == 0);
}

bool ProfinetSlot::plugModule(ProfinetServiceData& pnet_data, std::shared_ptr<ProfinetModule>& module_ptr)
{
    /// Сначала отключаем модуль
    pullModule(pnet_data);

    /// Затем подключаем модуль
    int result = pnet_plug_module (pnet_data.pnet_ptr, pnet_data.api, m_slot_nbr, module_ptr->m_id);

    if (result == 0)
    {
        m_module_ptr = module_ptr;
    }

    return (m_module_ptr != nullptr);
}

bool ProfinetSlot::addSubslot(std::shared_ptr<ProfinetSubslot>& subslot_ptr)
{
    if (subslot_ptr == nullptr)
        return false;
    
    if (m_module_ptr == nullptr)
        return false;

    subslot_ptr->setSlotNumber(m_slot_nbr);
    subslot_ptr->setModuleId(m_module_ptr->m_id);
    
    m_subslots[subslot_ptr->m_subslot_nbr] = subslot_ptr;

    return true;
}

std::shared_ptr<ProfinetSubslot> ProfinetSlot::addSubslot(uint16_t subslot_nbr)
{
    std::shared_ptr<ProfinetSubslot> subslot_ptr(nullptr);

    if (m_subslots.count(subslot_nbr))
    {
        subslot_ptr = m_subslots[subslot_nbr];
    }
    else
    {
        subslot_ptr = std::make_shared<ProfinetSubslot>(subslot_nbr, m_slot_nbr, m_module_ptr->m_id);
    }

    if (subslot_ptr != nullptr)
    {
        m_subslots[subslot_nbr] = subslot_ptr;
    }

    return subslot_ptr;
}

std::shared_ptr<ProfinetSubslot> ProfinetSlot::getSubslotPtr(uint16_t subslot_nbr)
{
    /// Проверка наличия подслота в конфигурации
    if (!m_subslots.count(subslot_nbr))
    {
        return nullptr;
    }

    return m_subslots[subslot_nbr];
}

std::shared_ptr<ProfinetModule> ProfinetSlot::getModulePtr()
{
    return m_module_ptr;
}

