#include <FreeRTOS.h>
#include <portable.h>
#include <semphr.h>
#include <stdint.h>
#include <stdlib.h>
#include <task.h>

#include "ff.h"

/* Dynamic memory allocation */
#if FF_USE_LFN == 3

/**
 * @brief Allocate a memory block with 512-byte alignment.
 *
 * This function is used to allocate a memory block with a specified size and
 * ensure that the allocated memory is aligned to a 512-byte boundary. It is
 * designed to work with the FreeRTOS operating system.
 *
 * @param msize The size of the memory block to allocate, in bytes.
 * @return A pointer to the allocated memory block, or NULL if the allocation
 * fails.
 */
void *ff_memalloc(UINT msize)
{
    /* Use osAllocAlign alloc 512 bytes aligned buf */
    /* FreeRTOS */
    return pvPortMallocAligned(msize, 512);
}

/**
 * @brief Free a previously allocated memory block.
 *
 * This function is used to free a memory block that was previously allocated
 * using the `ff_memalloc` function. It uses the FreeRTOS API `vPortFree` to
 * release the memory.
 *
 * @param mblock A pointer to the memory block to be freed.
 */
void ff_memfree(void *mblock)
{
    /* Free the memory block with POSIX API */
    /* FreeRTOS */
    vPortFree(mblock);
}

#endif

/* Mutal exclusion */
#if FF_FS_REENTRANT

/**
 * @brief Create a synchronization object for a specific volume.
 *
 * This function is used to create a synchronization object (mutex semaphore)
 * for a given volume. It is designed to work with the FreeRTOS operating
 * system.
 *
 * @param vol The volume number for which the synchronization object is created.
 * @param sobj A pointer to the synchronization object handle.
 * @return Returns 1 if the synchronization object is created successfully, 0
 * otherwise.
 */
int ff_cre_syncobj(BYTE vol, FF_SYNC_t *sobj)
{
    /* FreeRTOS */
    *sobj = (FF_SYNC_t)xSemaphoreCreateMutex();
    return (int)(*sobj != NULL);
}

/**
 * @brief Delete a synchronization object.
 *
 * This function is called in the `f_mount()` function to delete a
 * synchronization object that was previously created with the
 * `ff_cre_syncobj()` function.
 *
 * @param sobj A pointer to the synchronization object to be deleted.
 * @return Returns 1 to indicate successful deletion. If 0 is returned, the
 * `f_mount()` function fails with `FR_INT_ERR`.
 */
int ff_del_syncobj(FF_SYNC_t sobj)
{
    /* FreeRTOS */
    vSemaphoreDelete(sobj);
    return 1;
}

/**
 * @brief Request a grant to access the volume.
 *
 * This function is called on entering file functions to lock the volume.
 * It attempts to take the semaphore associated with the volume within the
 * specified timeout. If the semaphore is successfully taken within the timeout,
 * it means the access to the volume is granted.
 *
 * @param sobj A pointer to the synchronization object (semaphore) for the
 * volume.
 * @return Returns 1 if the semaphore is successfully taken within the timeout,
 * 0 otherwise. When a 0 is returned, the file function fails with FR_TIMEOUT.
 */
int ff_req_grant(FF_SYNC_t sobj)
{
    /* FreeRTOS */
    return (int)(xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);
}

/**
 * @brief Release the grant to access the volume.
 *
 * This function is called on leaving file functions to unlock the volume.
 * It releases the semaphore associated with the volume, allowing other tasks to
 * access it.
 *
 * @param sobj A pointer to the synchronization object (semaphore) for the
 * volume.
 */
void ff_rel_grant(FF_SYNC_t sobj)
{
    /* FreeRTOS */
    xSemaphoreGive(sobj);
}

#endif