#include "lwip/opt.h"
#include "lwip/sys.h"
#include "arch/sys_arch.h"

#include <string.h>

static char pcQueueMemoryPool[MAX_QUEUES * sizeof(TQ_DESCR)];
static OS_MEM *pQueueMem;

mem_ptr_t lwip_null = 0xffffffff;
void *pvNullPointer = &lwip_null;

static OS_STK task_tcpip_stk[TCPIP_THREAD_STACKSIZE];

void sys_init(void)
{
    uint8_t ucErr;
    pQueueMem = OSMemCreate((void*)pcQueueMemoryPool, MAX_QUEUES, sizeof(TQ_DESCR), &ucErr);
}

err_t sys_sem_new(sys_sem_t *sem, u8_t count)
{
    uint8_t err;
    *sem = OSSemCreate((u16_t)count);
    if (*sem == ((sys_sem_t)0)) {
        return ERR_MEM;
    }
    OSEventNameSet(*sem,(uint8_t *)"LWIP Sem",&err);
    return ERR_OK;
}

void sys_sem_signal(sys_sem_t *sem)
{
    OSSemPost(*sem);
}

u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
    uint8_t ucErr;
	uint32_t ucos_timeout, timeout_new; 
	if(	timeout!=0) 
	{
		ucos_timeout = (timeout * OS_TICKS_PER_SEC) / 1000;
		if(ucos_timeout < 1)
		ucos_timeout = 1;
	}else ucos_timeout = 0; 
	timeout = OSTimeGet();  
	OSSemPend (*sem,(u16_t)ucos_timeout, (u8_t *)&ucErr);
 	if(ucErr == OS_ERR_TIMEOUT)timeout=SYS_ARCH_TIMEOUT;	
	else
	{     
 		timeout_new = OSTimeGet(); 
		if (timeout_new>=timeout) timeout_new = timeout_new - timeout;
		else timeout_new = 0xffffffff - timeout + timeout_new;
 		timeout = (timeout_new*1000/OS_TICKS_PER_SEC + 1);
	}
	return timeout;
}

void sys_sem_free(sys_sem_t *sem)
{
    uint8_t Err;
    OSSemDel(*sem, OS_DEL_ALWAYS, &Err);
    *sem = NULL;
}

#ifndef sys_sem_valid

int sys_sem_valid(sys_sem_t *sem)
{
    OS_SEM_DATA  sem_data;
	return (OSSemQuery (*sem,&sem_data) == OS_ERR_NONE )? 1:0;
}
#endif

#ifndef sys_sem_set_invalid

void sys_sem_set_invalid(sys_sem_t *sem)
{
    *sem = ((sys_sem_t)0);
}
#endif

err_t sys_mbox_new(sys_mbox_t *mbox, int  size)
{
    uint8_t Err;
    if(size > MAX_QUEUE_ENTRIES) {
        size = MAX_QUEUE_ENTRIES;
    }
    *mbox = (sys_mbox_t)OSMemGet(pQueueMem, &Err);
    if( Err == OS_ERR_NONE) {   
        (*mbox)->pQ = OSQCreate(&((*mbox)->pvQEntries[0]), size);
        if ((*mbox)->pQ != ((OS_EVENT *)0)) {
            return ERR_OK;
        } else {
            OSMemPut(pQueueMem, mbox);
        }
    } 
    return ERR_MEM;
    
}

void sys_mbox_post(sys_mbox_t *mbox, void *msg)
{
    if(!msg) {
        msg = (void*)&pvNullPointer;
    }
    while (OS_ERR_NONE != OSQPost((*mbox)->pQ, msg));
}

err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{   
    INT8U err;
    if(!msg) {
        msg = (void*)&pvNullPointer;
    }
    err = OSQPost((*mbox)->pQ, msg);
    if (err == OS_ERR_NONE) {
        return ERR_OK;
    }
    return ERR_MEM;
}

u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
    u8_t ucErr;
	u32_t ucos_timeout,timeout_new;
	void *temp;
	sys_mbox_t m_box=*mbox;
	if(timeout!=0)
	{
		ucos_timeout=(timeout*OS_TICKS_PER_SEC)/1000;
		if(ucos_timeout<1)ucos_timeout=1;
	}else ucos_timeout = 0; 
	timeout = OSTimeGet();
	temp=OSQPend(m_box->pQ,(u16_t)ucos_timeout,&ucErr);
	if(msg!=NULL)
	{	
		if(temp==(void*)&pvNullPointer)*msg = NULL;
 		else *msg=temp;
	}    
	if(ucErr==OS_ERR_TIMEOUT)timeout=SYS_ARCH_TIMEOUT;
	else
	{
		LWIP_ASSERT("OSQPend ",ucErr==OS_ERR_NONE); 
		timeout_new=OSTimeGet();
		if (timeout_new>timeout) timeout_new = timeout_new - timeout;
		else timeout_new = 0xffffffff - timeout + timeout_new; 
		timeout=timeout_new*1000/OS_TICKS_PER_SEC + 1; 
	}
	return timeout; 
}

#ifndef sys_arch_mbox_tryfetch
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
    return sys_arch_mbox_fetch(mbox,msg,1);
}
#endif

void sys_mbox_free(sys_mbox_t *mbox)
{
    u8_t Err;
    OSQFlush((*mbox)->pQ);
    OSQDel((*mbox)->pQ, OS_DEL_ALWAYS, &Err);
    OSMemPut(pQueueMem, *mbox);
    *mbox = (sys_mbox_t)0;
}

#ifndef sys_mbox_valid
int sys_mbox_valid(sys_mbox_t *mbox)
{
	sys_mbox_t m_box=*mbox;
	u8_t ucErr;
	int ret;
	OS_Q_DATA q_data;
	memset(&q_data,0,sizeof(OS_Q_DATA));
	ucErr = OSQQuery (m_box->pQ,&q_data);
	ret = (ucErr < 2 && (q_data.OSNMsgs < q_data.OSQSize)) ? 1 : 0;
	return ret;
}
#endif

#ifndef sys_mbox_set_invalid
void sys_mbox_set_invalid(sys_mbox_t *mbox)
{
    *mbox = ((sys_mbox_t)0);
}
#endif

sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg,
                            int stacksize, int prio)
{
    CPU_SR_ALLOC();
    arg = arg;
    stacksize = stacksize;
    if (0 == strcmp(name, TCPIP_THREAD_NAME)) {
        OS_ENTER_CRITICAL();
        OSTaskCreateExt((void (*)(void *)) thread,           /* Create the start task                                */
                        (void           *) 0,
                        (OS_STK         *)&task_tcpip_stk[TCPIP_THREAD_STACKSIZE - 1],
                        (INT8U           ) prio,
                        (INT16U          ) prio,
                        (OS_STK         *)&task_tcpip_stk[0],
                        (INT32U          ) TCPIP_THREAD_STACKSIZE,
                        (void           *) 0,
                        (INT16U          )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
        OS_EXIT_CRITICAL();
    } else {
        prio = 0;
    }
    return prio;
}

u32_t sys_now(void)
{
	u32_t ucos_time, lwip_time;
	ucos_time=OSTimeGet();
	lwip_time=(ucos_time*1000/OS_TICKS_PER_SEC+1);
	return lwip_time;
}

sys_prot_t sys_arch_protect(void)
{
    return OS_CPU_SR_Save();
}

void sys_arch_unprotect(sys_prot_t pval)
{
    OS_CPU_SR_Restore(pval);
}