#include <MESA_prof_load.h>
#include <sc_node_common.h>

/***************************************************** Sid handle *****************************************************/
struct sid_handle * sid_handle_create(uint32_t sid_start, uint32_t sid_end)
{

    if (unlikely(sid_start > sid_end))
    {
        MR_ERROR("The start of the sid is larger than the end of the sid.");
        return NULL;
    }

    uint16_t capacity = sid_end - sid_start + 1;
    if (unlikely(capacity > SC_SID_HANDLE_CAPACITY_MAX))
    {
        MR_ERROR("The capacity of the sid handle is larger than the maximum value.");
        return NULL;
    }

    struct sid_handle * sid_handle = ZMALLOC(sizeof(struct sid_handle));
    MR_VERIFY_MALLOC(sid_handle);

    sid_handle->capacity = capacity;
    sid_handle->sid_start = sid_start;
    sid_handle->sid_end = sid_end;
    return sid_handle;
}

/**
 * @brief Deletes a SID handle.
 *
 * This function frees the memory allocated for the specified SID handle.
 * If the handle is NULL, the function returns immediately without performing
 * any operations. Otherwise, it frees the memory and returns RT_SUCCESS.
 *
 * @param sid_handle A pointer to the sid_handle structure to be deleted.
 *
 * @return RT_SUCCESS if the handle is successfully deleted, or RT_ERR if the handle is NULL.
 */
int sid_handle_delete(struct sid_handle * sid_handle)
{
    if (sid_handle != NULL)
    {
        FREE(sid_handle);
        return RT_SUCCESS;
    }
    return RT_ERR;
}

/**
 * @brief Get the capacity of the SID handle.
 *
 * This function returns the capacity of the specified SID handle.
 * If the handle is NULL, the function returns 0.
 *
 * @param sid_handle A pointer to the sid_handle structure.
 *
 * @return The capacity of the SID handle, or 0 if the handle is NULL.
 */
inline uint16_t sid_handle_capacity_get(struct sid_handle * sid_handle)
{
    assert(sid_handle != NULL);
    return sid_handle->capacity;
}

/**
 * @brief Get the starting SID of the SID handle.
 *
 * This function returns the starting SID of the specified SID handle.
 * If the handle is NULL, the function returns 0.
 *
 * @param sid_handle A pointer to the sid_handle structure.
 *
 * @return The starting SID of the SID handle, or 0 if the handle is NULL.
 */
inline uint32_t sid_handle_sid_start_get(struct sid_handle * sid_handle)
{
    assert(sid_handle != NULL);
    return sid_handle->sid_start;
}

/**
 * @brief Get the ending SID of the SID handle.
 *
 * This function returns the ending SID of the specified SID handle.
 * If the handle is NULL, the function returns 0.
 *
 * @param sid_handle A pointer to the sid_handle structure.
 *
 * @return The ending SID of the SID handle, or 0 if the handle is NULL.
 */
inline uint32_t sid_handle_sid_end_get(struct sid_handle * sid_handle)
{
    assert(sid_handle != NULL);
    return sid_handle->sid_end;
}

/******************************************** Network intersection adapter ********************************************/
/**
 * @brief Retrieves the maximum number of adapters from the configuration.
 *
 * This function loads the maximum number of adapters specified in the configuration file
 * using the provided key. It verifies that the loaded value is valid and does not exceed
 * the predefined maximum limit (`SC_ADAPTERS_MAX`). If the value is valid, it is stored in
 * the `adapters_max_out` output parameter. The function returns `RT_SUCCESS` if the value
 * is successfully retrieved and valid, or `RT_ERR` if an error occurs.
 *
 * @param sc Pointer to the `sc_main` structure containing the configuration file and resources.
 * @param key The key used to retrieve the maximum adapters value from the configuration file.
 * @param adapters_max_out Pointer to where the retrieved maximum adapters value will be stored.
 *
 * @return RT_SUCCESS if the maximum adapters value is successfully retrieved and valid, RT_ERR otherwise.
 */
int adapters_max_get(struct sc_main * sc, const char * key, uint32_t * adapters_max_out)
{
    assert(sc != NULL);
    assert(key != NULL);
    assert(adapters_max_out != NULL);

    uint32_t adapters_max = 0;
    MESA_load_profile_uint_def(sc->local_cfgfile, "limits", key, &adapters_max, 64);

    if (adapters_max == 0)
    {
        MR_ERROR("The '%s' is invalid: %u", key, adapters_max);
        return RT_ERR;
    }
    else if (adapters_max > SC_ADAPTERS_MAX)
    {
        MR_ERROR("The '%s' is larger than the maximum value: %u", key, adapters_max);
        return RT_ERR;
    }

    *adapters_max_out = adapters_max;

    return RT_SUCCESS;
}

void mrb_metadata_pktmbuf_dump(const struct rte_mbuf * m)
{
    char str_metadata[1024] = {};

    struct mrb_metadata * mrb_meta = mrbuf_cz_data(m, MR_NODE_CTRLZONE_ID);

    snprintf(str_metadata, sizeof(str_metadata), METADATA_INFO, mrb_meta->dir, mrb_meta->packet_create_from_nf,
             mrb_meta->health_check, mrb_meta->is_ctrlbuf, mrb_meta->adapter_type, mrb_meta->adapter_id,
             mrb_meta->payload_offset, mrb_meta->user_0, mrb_meta->ef_link_id, mrb_meta->traffic_link_id,
             mrb_meta->ef_peer_index, mrb_meta->port_ingress, mrb_meta->port_egress, mrb_meta->egress_action,
             mrb_meta->session_id, mrb_meta->cur_sid, mrb_meta->sid_list.sids[0], mrb_meta->sid_list.sids[1],
             mrb_meta->sid_list.sids[2], mrb_meta->sid_list.sids[3], mrb_meta->sid_list.sids[4],
             mrb_meta->sid_list.sids[5], mrb_meta->sid_list.sids[6], mrb_meta->sid_list.sids[7],
             mrb_meta->measurement_type);

    MR_ERROR("The pkt metadata: %s", str_metadata);

    rte_pktmbuf_dump(stderr, m, rte_pktmbuf_data_len(m));

    return;
}