/*
 * Copyright (c) 2017 Simon Goldschmidt
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * This file is part of the lwIP TCP/IP stack.
 *
 * Author: Simon Goldschmidt <goldsimon@gmx.de>
 *
 */

/* lwIP includes. */
#include "FreeRTOS.h"
#include "lwip/debug.h"
#include "lwip/def.h"
#include "lwip/mem.h"
#include "lwip/stats.h"
#include "lwip/sys.h"
#include "lwip/tcpip.h"
#include "semphr.h"
#include "task.h"

/** Set this to 1 if you want the stack size passed to sys_thread_new() to be
 * interpreted as number of stack words (FreeRTOS-like).
 * Default is that they are interpreted as byte count (lwIP-like).
 */
#ifndef LWIP_FREERTOS_THREAD_STACKSIZE_IS_STACKWORDS
#define LWIP_FREERTOS_THREAD_STACKSIZE_IS_STACKWORDS 0
#endif

/** Set this to 1 to use a mutex for SYS_ARCH_PROTECT() critical regions.
 * Default is 0 and locks interrupts/scheduler for SYS_ARCH_PROTECT().
 */
#ifndef LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
#define LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX 0
#endif

/** Set this to 1 to include a sanity check that SYS_ARCH_PROTECT() and
 * SYS_ARCH_UNPROTECT() are called matching.
 */
#ifndef LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
#define LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK 0
#endif

/** Set this to 1 to let sys_mbox_free check that queues are empty when freed */
#ifndef LWIP_FREERTOS_CHECK_QUEUE_EMPTY_ON_FREE
#define LWIP_FREERTOS_CHECK_QUEUE_EMPTY_ON_FREE 0
#endif

/** Set this to 1 to enable core locking check functions in this port.
 * For this to work, you'll have to define LWIP_ASSERT_CORE_LOCKED()
 * and LWIP_MARK_TCPIP_THREAD() correctly in your lwipopts.h! */
#ifndef LWIP_FREERTOS_CHECK_CORE_LOCKING
#define LWIP_FREERTOS_CHECK_CORE_LOCKING 1
#endif

/** Set this to 0 to implement sys_now() yourself, e.g. using a hw timer.
 * Default is 1, where FreeRTOS ticks are used to calculate back to ms.
 */
#ifndef LWIP_FREERTOS_SYS_NOW_FROM_FREERTOS
#define LWIP_FREERTOS_SYS_NOW_FROM_FREERTOS 1
#endif

#if !configSUPPORT_DYNAMIC_ALLOCATION
#error "lwIP FreeRTOS port requires configSUPPORT_DYNAMIC_ALLOCATION"
#endif
#if !INCLUDE_vTaskDelay
#error "lwIP FreeRTOS port requires INCLUDE_vTaskDelay"
#endif
#if !INCLUDE_vTaskSuspend
#error "lwIP FreeRTOS port requires INCLUDE_vTaskSuspend"
#endif
#if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX || !LWIP_COMPAT_MUTEX
#if !configUSE_MUTEXES
#error "lwIP FreeRTOS port requires configUSE_MUTEXES"
#endif
#endif

#if SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
static SemaphoreHandle_t sys_arch_protect_mutex;
#endif
#if SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
static sys_prot_t sys_arch_protect_nesting;
#endif

/* Initialize this module (see description in sys.h) */
void sys_init(void)
{
#if SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
    /* initialize sys_arch_protect global mutex */
    sys_arch_protect_mutex = xSemaphoreCreateRecursiveMutex();
    LWIP_ASSERT("failed to create sys_arch_protect mutex", sys_arch_protect_mutex != NULL);
#endif /* SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
}

#if configUSE_16_BIT_TICKS == 1
#error This port requires 32 bit ticks or timer overflow will fail
#endif

#if LWIP_FREERTOS_SYS_NOW_FROM_FREERTOS
u32_t sys_now(void)
{
    return xTaskGetTickCount() * portTICK_PERIOD_MS;
}
#endif

u32_t sys_jiffies(void)
{
    return xTaskGetTickCount();
}

#if SYS_LIGHTWEIGHT_PROT

sys_prot_t sys_arch_protect(void)
{
#if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
    BaseType_t ret;
    LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);

    ret = xSemaphoreTakeRecursive(sys_arch_protect_mutex, portMAX_DELAY);
    LWIP_ASSERT("sys_arch_protect failed to take the mutex", ret == pdTRUE);
#else  /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
    taskENTER_CRITICAL();
#endif /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
#if LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
    {
        /* every nested call to sys_arch_protect() returns an increased number */
        sys_prot_t ret = sys_arch_protect_nesting;
        sys_arch_protect_nesting++;
        LWIP_ASSERT("sys_arch_protect overflow", sys_arch_protect_nesting > ret);
        return ret;
    }
#else
    return 1;
#endif
}

void sys_arch_unprotect(sys_prot_t pval)
{
#if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
    BaseType_t ret;
#endif
#if LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
    LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting > 0);
    sys_arch_protect_nesting--;
    LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting == pval);
#endif

#if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
    LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);

    ret = xSemaphoreGiveRecursive(sys_arch_protect_mutex);
    LWIP_ASSERT("sys_arch_unprotect failed to give the mutex", ret == pdTRUE);
#else  /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
    taskEXIT_CRITICAL();
#endif /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
    LWIP_UNUSED_ARG(pval);
}

#endif /* SYS_LIGHTWEIGHT_PROT */

void sys_arch_msleep(u32_t delay_ms)
{
    TickType_t delay_ticks = delay_ms / portTICK_PERIOD_MS;
    vTaskDelay(delay_ticks);
}

#if !LWIP_COMPAT_MUTEX

/* Create a new mutex*/
err_t sys_mutex_new(sys_mutex_t * mutex)
{
    LWIP_ASSERT("mutex != NULL", mutex != NULL);

    mutex->mut = xSemaphoreCreateRecursiveMutex();
    if (mutex->mut == NULL)
    {
        SYS_STATS_INC(mutex.err);
        return ERR_MEM;
    }
    SYS_STATS_INC_USED(mutex);
    return ERR_OK;
}

void sys_mutex_lock(sys_mutex_t * mutex)
{
    BaseType_t ret;
    LWIP_ASSERT("mutex != NULL", mutex != NULL);
    LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);

    ret = xSemaphoreTakeRecursive(mutex->mut, portMAX_DELAY);
    LWIP_ASSERT("failed to take the mutex", ret == pdTRUE);
}

void sys_mutex_unlock(sys_mutex_t * mutex)
{
    BaseType_t ret;
    LWIP_ASSERT("mutex != NULL", mutex != NULL);
    LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);

    ret = xSemaphoreGiveRecursive(mutex->mut);
    LWIP_ASSERT("failed to give the mutex", ret == pdTRUE);
}

void sys_mutex_free(sys_mutex_t * mutex)
{
    LWIP_ASSERT("mutex != NULL", mutex != NULL);
    LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);

    SYS_STATS_DEC(mutex.used);
    vSemaphoreDelete(mutex->mut);
    mutex->mut = NULL;
}

#endif /* !LWIP_COMPAT_MUTEX */

err_t sys_sem_new(sys_sem_t * sem, u8_t initial_count)
{
    LWIP_ASSERT("sem != NULL", sem != NULL);
    LWIP_ASSERT("initial_count invalid (not 0 or 1)", (initial_count == 0) || (initial_count == 1));

    sem->sem = xSemaphoreCreateBinary();
    if (sem->sem == NULL)
    {
        SYS_STATS_INC(sem.err);
        return ERR_MEM;
    }
    SYS_STATS_INC_USED(sem);

    if (initial_count == 1)
    {
        BaseType_t ret = xSemaphoreGive(sem->sem);
        LWIP_ASSERT("sys_sem_new: initial give failed", ret == pdTRUE);
    }
    return ERR_OK;
}

void sys_sem_signal(sys_sem_t * sem)
{
    BaseType_t ret;
    LWIP_ASSERT("sem != NULL", sem != NULL);
    LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);

    ret = xSemaphoreGive(sem->sem);
    /* queue full is OK, this is a signal only... */
    LWIP_ASSERT("sys_sem_signal: sane return value", (ret == pdTRUE) || (ret == errQUEUE_FULL));
}

u32_t sys_arch_sem_wait(sys_sem_t * sem, u32_t timeout_ms)
{
    BaseType_t ret;
    LWIP_ASSERT("sem != NULL", sem != NULL);
    LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);

    if (!timeout_ms)
    {
        /* wait infinite */
        ret = xSemaphoreTake(sem->sem, portMAX_DELAY);
        LWIP_ASSERT("taking semaphore failed", ret == pdTRUE);
    }
    else
    {
        TickType_t timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
        ret                      = xSemaphoreTake(sem->sem, timeout_ticks);
        if (ret == errQUEUE_EMPTY)
        {
            /* timed out */
            return SYS_ARCH_TIMEOUT;
        }
        LWIP_ASSERT("taking semaphore failed", ret == pdTRUE);
    }

    /* Old versions of lwIP required us to return the time waited.
       This is not the case any more. Just returning != SYS_ARCH_TIMEOUT
       here is enough. */
    return 1;
}

void sys_sem_free(sys_sem_t * sem)
{
    LWIP_ASSERT("sem != NULL", sem != NULL);
    LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);

    SYS_STATS_DEC(sem.used);
    vSemaphoreDelete(sem->sem);
    sem->sem = NULL;
}

err_t sys_mbox_new(sys_mbox_t * mbox, int size)
{
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("size > 0", size > 0);

    /*
     *  FALSE-POSITIVE: CID 34515: Wrong sizeof argument
     *  Reason:
     *     sizeof(void *) is used intentionally to find the size of a pointer.
     */
    mbox->mbx = (void *) xQueueCreate((UBaseType_t) size, sizeof(void *));
    if (mbox->mbx == NULL)
    {
        SYS_STATS_INC(mbox.err);
        return ERR_MEM;
    }
    SYS_STATS_INC_USED(mbox);
    return ERR_OK;
}

void sys_mbox_post(sys_mbox_t * mbox, void * msg)
{
    BaseType_t ret;
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);

    ret = xQueueSendToBack(mbox->mbx, &msg, portMAX_DELAY);
    LWIP_ASSERT("mbox post failed", ret == pdTRUE);
}

err_t sys_mbox_trypost(sys_mbox_t * mbox, void * msg)
{
    BaseType_t ret;
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);

    ret = xQueueSendToBack(mbox->mbx, &msg, 0);
    if (ret == pdTRUE)
    {
        return ERR_OK;
    }
    else
    {
        LWIP_ASSERT("mbox trypost failed", ret == errQUEUE_FULL);
        SYS_STATS_INC(mbox.err);
        return ERR_MEM;
    }
}

err_t sys_mbox_trypost_fromisr(sys_mbox_t * mbox, void * msg)
{
    BaseType_t ret;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);

    ret = xQueueSendToBackFromISR(mbox->mbx, &msg, &xHigherPriorityTaskWoken);
    if (ret == pdTRUE)
    {
        if (xHigherPriorityTaskWoken == pdTRUE)
        {
            return ERR_NEED_SCHED;
        }
        return ERR_OK;
    }
    else
    {
        LWIP_ASSERT("mbox trypost failed", ret == errQUEUE_FULL);
        SYS_STATS_INC(mbox.err);
        return ERR_MEM;
    }
}

u32_t sys_arch_mbox_fetch(sys_mbox_t * mbox, void ** msg, u32_t timeout_ms)
{
    BaseType_t ret;
    void * msg_dummy;
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);

    if (!msg)
    {
        msg = &msg_dummy;
    }

    if (!timeout_ms)
    {
        /* wait infinite */
        ret = xQueueReceive(mbox->mbx, &(*msg), portMAX_DELAY);
        LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);
    }
    else
    {
        TickType_t timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
        ret                      = xQueueReceive(mbox->mbx, &(*msg), timeout_ticks);
        if (ret == errQUEUE_EMPTY)
        {
            /* timed out */
            *msg = NULL;
            return SYS_ARCH_TIMEOUT;
        }
        LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);
    }

    /* Old versions of lwIP required us to return the time waited.
       This is not the case any more. Just returning != SYS_ARCH_TIMEOUT
       here is enough. */
    return 1;
}

u32_t sys_arch_mbox_tryfetch(sys_mbox_t * mbox, void ** msg)
{
    BaseType_t ret;
    void * msg_dummy;
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);

    if (!msg)
    {
        msg = &msg_dummy;
    }

    ret = xQueueReceive(mbox->mbx, &(*msg), 0);
    if (ret == errQUEUE_EMPTY)
    {
        *msg = NULL;
        return SYS_MBOX_EMPTY;
    }
    LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);

    /* Old versions of lwIP required us to return the time waited.
       This is not the case any more. Just returning != SYS_ARCH_TIMEOUT
       here is enough. */
    return 1;
}

void sys_mbox_free(sys_mbox_t * mbox)
{
    LWIP_ASSERT("mbox != NULL", mbox != NULL);
    LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);

#if LWIP_FREERTOS_CHECK_QUEUE_EMPTY_ON_FREE
    {
        UBaseType_t msgs_waiting = uxQueueMessagesWaiting(mbox->mbx);
        LWIP_ASSERT("mbox quence not empty", msgs_waiting == 0);

        if (msgs_waiting != 0)
        {
            SYS_STATS_INC(mbox.err);
        }
    }
#endif

    vQueueDelete(mbox->mbx);

    SYS_STATS_DEC(mbox.used);
}

sys_thread_t sys_thread_new(const char * name, lwip_thread_fn thread, void * arg, int stacksize, int prio)
{
    TaskHandle_t rtos_task;
    BaseType_t ret;
    sys_thread_t lwip_thread;
    size_t rtos_stacksize;

    LWIP_ASSERT("invalid stacksize", stacksize > 0);
#if LWIP_FREERTOS_THREAD_STACKSIZE_IS_STACKWORDS
    rtos_stacksize = (size_t) stacksize;
#else
    rtos_stacksize = (size_t) stacksize / sizeof(StackType_t);
#endif

    /* lwIP's lwip_thread_fn matches FreeRTOS' TaskFunction_t, so we can pass the
       thread function without adaption here. */
    ret = xTaskCreate(thread, name, (configSTACK_DEPTH_TYPE) rtos_stacksize, arg, prio, &rtos_task);
    LWIP_ASSERT("task creation failed", ret == pdTRUE);

    lwip_thread.thread_handle = rtos_task;
    return lwip_thread;
}

#if LWIP_NETCONN_SEM_PER_THREAD
#if configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0

sys_sem_t * sys_arch_netconn_sem_get(void)
{
    void * ret;
    TaskHandle_t task = xTaskGetCurrentTaskHandle();
    LWIP_ASSERT("task != NULL", task != NULL);

    ret = pvTaskGetThreadLocalStoragePointer(task, 0);
    return ret;
}

void sys_arch_netconn_sem_alloc(void)
{
    void * ret;
    TaskHandle_t task = xTaskGetCurrentTaskHandle();
    LWIP_ASSERT("task != NULL", task != NULL);

    ret = pvTaskGetThreadLocalStoragePointer(task, 0);
    if (ret == NULL)
    {
        sys_sem_t * sem;
        err_t err;
        /* need to allocate the memory for this semaphore */
        sem = mem_malloc(sizeof(sys_sem_t));
        LWIP_ASSERT("sem != NULL", sem != NULL);
        err = sys_sem_new(sem, 0);
        LWIP_ASSERT("err == ERR_OK", err == ERR_OK);
        LWIP_ASSERT("sem invalid", sys_sem_valid(sem));
        vTaskSetThreadLocalStoragePointer(task, 0, sem);
    }
}

void sys_arch_netconn_sem_free(void)
{
    void * ret;
    TaskHandle_t task = xTaskGetCurrentTaskHandle();
    LWIP_ASSERT("task != NULL", task != NULL);

    ret = pvTaskGetThreadLocalStoragePointer(task, 0);
    if (ret != NULL)
    {
        sys_sem_t * sem = ret;
        sys_sem_free(sem);
        mem_free(sem);
        vTaskSetThreadLocalStoragePointer(task, 0, NULL);
    }
}

#else /* configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 */
#error LWIP_NETCONN_SEM_PER_THREAD needs configNUM_THREAD_LOCAL_STORAGE_POINTERS
#endif /* configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 */

#endif /* LWIP_NETCONN_SEM_PER_THREAD */

#if LWIP_FREERTOS_CHECK_CORE_LOCKING
#if LWIP_TCPIP_CORE_LOCKING

/** Flag the core lock held. A counter for recursive locks. */
static u8_t lwip_core_lock_count;
static TaskHandle_t lwip_core_lock_holder_thread;

void sys_lock_tcpip_core(void)
{
    sys_mutex_lock(&lock_tcpip_core);
    if (lwip_core_lock_count == 0)
    {
        lwip_core_lock_holder_thread = xTaskGetCurrentTaskHandle();
    }
    lwip_core_lock_count++;
}

void sys_unlock_tcpip_core(void)
{
    lwip_core_lock_count--;
    if (lwip_core_lock_count == 0)
    {
        lwip_core_lock_holder_thread = 0;
    }
    sys_mutex_unlock(&lock_tcpip_core);
}

#endif /* LWIP_TCPIP_CORE_LOCKING */

#if !NO_SYS
static TaskHandle_t lwip_tcpip_thread;
#endif

void sys_mark_tcpip_thread(void)
{
#if !NO_SYS
    lwip_tcpip_thread = xTaskGetCurrentTaskHandle();
#endif
}

void sys_check_core_locking(void)
{
    /* Embedded systems should check we are NOT in an interrupt context here */
    /* E.g. core Cortex-M3/M4 ports:
           configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );

       Instead, we use more generic FreeRTOS functions here, which should fail from ISR: */
    taskENTER_CRITICAL();
    taskEXIT_CRITICAL();

#if !NO_SYS
    if (lwip_tcpip_thread != 0)
    {
        TaskHandle_t current_thread = xTaskGetCurrentTaskHandle();

#if LWIP_TCPIP_CORE_LOCKING
        LWIP_ASSERT("Function called without core lock",
                    current_thread == lwip_core_lock_holder_thread && lwip_core_lock_count > 0);
#else  /* LWIP_TCPIP_CORE_LOCKING */
        LWIP_ASSERT("Function called from wrong thread", current_thread == lwip_tcpip_thread);
#endif /* LWIP_TCPIP_CORE_LOCKING */
    }
#endif /* !NO_SYS */
}

#endif /* LWIP_FREERTOS_CHECK_CORE_LOCKING*/