/*
 * eventreg.c - CC31xx/CC32xx Host Driver Implementation
 *
 * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/ 
 * 
 * 
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions 
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer.
 *
 *    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.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 *  "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 COPYRIGHT 
 *  OWNER OR CONTRIBUTORS 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.
 *
*/

/*****************************************************************************/
/* Include files                                                             */
/*****************************************************************************/
#include <ti/drivers/net/wifi/simplelink.h>
#include <ti/drivers/net/wifi/eventreg.h>


typedef void (*_pSlDeviceFatalErrorEvtHdlr_t)(SlDeviceFatal_t *pSlFatalErrorEvent);
typedef void (*_pSlDeviceGeneralEvtHdlr_t)(SlDeviceEvent_t *pSlDeviceEvent);
typedef void (*_pSlWlanEvtHdlr)(SlWlanEvent_t* pSlWlanEvent);
typedef void (*_pSlNetAppEvtHdlr)(SlNetAppEvent_t* pSlNetAppEvent);
typedef void (*_pSlSockEvtHdlr)(SlSockEvent_t* pSlSockEvent);
typedef void (*_pSlNetAppHttpServerHdlr)(SlNetAppHttpServerEvent_t *pSlHttpServerEvent, SlNetAppHttpServerResponse_t *pSlHttpServerResponse);
typedef void (*_pSlNetAppRequestHdlr)(SlNetAppRequest_t *pNetAppRequest, SlNetAppResponse_t *pNetAppResponse);
typedef void (*_pSlNetAppRequestMemFree)(_u8 *buffer);
typedef void (*_pSlSocketTriggerEventHandler)(SlSockTriggerEvent_t* pSlSockTriggerEvent);


typedef _i32 (*_pSlPropogationDeviceFatalErrorEvtHdlr_t)(SlDeviceFatal_t *pSlFatalErrorEvent);
typedef _i32 (*_pSlPropogationDeviceGeneralEvtHdlr_t)(SlDeviceEvent_t *pSlDeviceEvent);
typedef _i32 (*_pSlPropogationWlanEvtHdlr)(SlWlanEvent_t* pSlWlanEvent);
typedef _i32 (*_pSlPropogationNetAppEvtHdlr)(SlNetAppEvent_t* pSlNetAppEvent);
typedef _i32 (*_pSlPropogationSockEvtHdlr)(SlSockEvent_t* pSlSockEvent);
typedef _i32 (*_pSlPropogationNetAppHttpServerHdlr)(SlNetAppHttpServerEvent_t *pSlHttpServerEvent, SlNetAppHttpServerResponse_t *pSlHttpServerResponse);
typedef _i32 (*_pSlPropogationNetAppRequestHdlr)(SlNetAppRequest_t *pNetAppRequest, SlNetAppResponse_t *pNetAppResponse);
typedef _i32 (*_pSlPropogationNetAppRequestMemFree)(_u8 *buffer);
typedef _i32 (*_pSlPropogationSocketTriggerEventHandler)(SlSockTriggerEvent_t* pSlSockTriggerEvent);

#ifdef SL_RUNTIME_EVENT_REGISTERATION

void* g_UserEvents[SL_NUM_OF_EVENT_TYPES] = {0};
SlEventsListNode_t* g_LibsEvents[SL_NUM_OF_EVENT_TYPES] = {0};

#endif


_i32 _SlIsEventRegistered(SlEventHandler_e EventHandlerType)
{
#ifdef SL_RUNTIME_EVENT_REGISTERATION
	if( (NULL != g_LibsEvents[EventHandlerType]) || (NULL != g_UserEvents[EventHandlerType]) )
	{
		return 1;
	}
#endif
	if(SL_EVENT_HDL_MEM_FREE == EventHandlerType)
	{
#ifdef slcb_NetAppRequestMemFree
		return 1;
#endif
	}
	if(SL_EVENT_HDL_SOCKET_TRIGGER == EventHandlerType)
	{
#ifdef slcb_SocketTriggerEventHandler
		return 1;
#endif
	}

	return 0;
}

#ifdef SL_RUNTIME_EVENT_REGISTERATION

_i32 sl_RegisterEventHandler(SlEventHandler_e EventHandlerType , void* EventHandler)
{
	g_UserEvents[EventHandlerType] = EventHandler;
	return 0;
}

_i32 sl_RegisterLibsEventHandler(SlEventHandler_e EventHandlerType , SlEventsListNode_t* EventHandlerNode)
{
	EventHandlerNode->next = NULL;

	if(g_LibsEvents[EventHandlerType] == NULL)
	{
		g_LibsEvents[EventHandlerType] = EventHandlerNode;
	}
	else
	{
		SlEventsListNode_t* currentNode = g_LibsEvents[EventHandlerType];
		while(currentNode->next != NULL)
		{
			currentNode = currentNode->next;
		}

		currentNode->next = EventHandlerNode;
	}
	return 0;
}

_i32 sl_UnregisterLibsEventHandler(SlEventHandler_e EventHandlerType , SlEventsListNode_t* EventHandlerNode)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[EventHandlerType];
	SlEventsListNode_t* lastNode = g_LibsEvents[EventHandlerType];
	int count = 0;
	while(currentNode != NULL)
	{
		if(EventHandlerNode == currentNode)
		{
			if(count == 0)
			{
				g_LibsEvents[EventHandlerType] = g_LibsEvents[EventHandlerType]->next;
			}
			else
			{
				lastNode->next = currentNode->next;
			}
			return 0;
		}

		if(count != 0)
		{
			lastNode = lastNode->next;
		}
		count++;
		currentNode = currentNode->next;
	}

	return SL_RET_CODE_EVENT_LINK_NOT_FOUND;
}


/* Event handlers section */
void _SlDeviceFatalErrorEvtHdlr(SlDeviceFatal_t *pSlFatalErrorEvent)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_FATAL_ERROR];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationDeviceFatalErrorEvtHdlr_t)(currentNode->event))(pSlFatalErrorEvent))
		{
			return;
		}
		currentNode = currentNode->next;
	}

	if (NULL != g_UserEvents[SL_EVENT_HDL_FATAL_ERROR])
	{
		((_pSlDeviceFatalErrorEvtHdlr_t)g_UserEvents[SL_EVENT_HDL_FATAL_ERROR])(pSlFatalErrorEvent);
	}

#ifdef slcb_DeviceFatalErrorEvtHdlr
	else
	{
		slcb_DeviceFatalErrorEvtHdlr(pSlFatalErrorEvent);
	}
#endif
}


void _SlDeviceGeneralEvtHdlr(SlDeviceEvent_t *pSlDeviceEvent)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_DEVICE_GENERAL];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationDeviceGeneralEvtHdlr_t)(currentNode->event))(pSlDeviceEvent))
		{
			return;
		}
		currentNode = currentNode->next;
	}

	if (NULL != g_UserEvents[SL_EVENT_HDL_DEVICE_GENERAL])
	{
		((_pSlDeviceGeneralEvtHdlr_t)g_UserEvents[SL_EVENT_HDL_DEVICE_GENERAL])(pSlDeviceEvent);
	}
#ifdef slcb_DeviceGeneralEvtHdlr
	else
	{
		slcb_DeviceGeneralEvtHdlr(pSlDeviceEvent);
	}
#endif
}


void _SlWlanEvtHdlr(SlWlanEvent_t* pSlWlanEvent)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_WLAN];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationWlanEvtHdlr)(currentNode->event))(pSlWlanEvent))
		{
			return;
		}
		currentNode = currentNode->next;
	}

	if (NULL != g_UserEvents[SL_EVENT_HDL_WLAN])
	{
		((_pSlWlanEvtHdlr)g_UserEvents[SL_EVENT_HDL_WLAN])(pSlWlanEvent);
	}
#ifdef slcb_WlanEvtHdlr
	else
	{
		slcb_WlanEvtHdlr(pSlWlanEvent);
	}
#endif
}


void _SlNetAppEvtHdlr(SlNetAppEvent_t* pSlNetAppEvent)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_NETAPP];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppEvtHdlr)(currentNode->event))(pSlNetAppEvent))
		{
			return;
		}
		currentNode = currentNode->next;
	}
	if (NULL != g_UserEvents[SL_EVENT_HDL_NETAPP])
	{
		((_pSlNetAppEvtHdlr)g_UserEvents[SL_EVENT_HDL_NETAPP])(pSlNetAppEvent);
	}
#ifdef slcb_NetAppEvtHdlr
	else
	{
		slcb_NetAppEvtHdlr(pSlNetAppEvent);
	}
#endif
}


void _SlSockEvtHdlr(SlSockEvent_t* pSlSockEvent)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_SOCKET];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationSockEvtHdlr)(currentNode->event))(pSlSockEvent))
		{
			return;
		}
		currentNode = currentNode->next;
	}
	if (NULL != g_UserEvents[SL_EVENT_HDL_SOCKET])
	{
		((_pSlSockEvtHdlr)g_UserEvents[SL_EVENT_HDL_SOCKET])(pSlSockEvent);
	}

#ifdef slcb_SockEvtHdlr
	else
	{
		slcb_SockEvtHdlr(pSlSockEvent);
	}
#endif
}


void _SlNetAppHttpServerHdlr(SlNetAppHttpServerEvent_t *pSlHttpServerEvent, SlNetAppHttpServerResponse_t *pSlHttpServerResponse)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_HTTP_SERVER];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppHttpServerHdlr)(currentNode->event))(pSlHttpServerEvent,pSlHttpServerResponse))
		{
			return;
		}
		currentNode = currentNode->next;
	}
	if (NULL != g_UserEvents[SL_EVENT_HDL_HTTP_SERVER])
	{
		((_pSlNetAppHttpServerHdlr)g_UserEvents[SL_EVENT_HDL_HTTP_SERVER])(pSlHttpServerEvent,pSlHttpServerResponse);
	}
#ifdef slcb_NetAppHttpServerHdlr
	else
	{
		slcb_NetAppHttpServerHdlr(pSlHttpServerEvent,pSlHttpServerResponse);
	}
#endif
}


void _SlNetAppRequestHdlr(SlNetAppRequest_t *pNetAppRequest, SlNetAppResponse_t *pNetAppResponse)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_NETAPP_REQUEST];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppRequestHdlr)(currentNode->event))(pNetAppRequest,pNetAppResponse))
		{
			return;
		}
		currentNode = currentNode->next;
	}
	if (NULL != g_UserEvents[SL_EVENT_HDL_NETAPP_REQUEST])
	{
		((_pSlNetAppRequestHdlr)g_UserEvents[SL_EVENT_HDL_NETAPP_REQUEST])(pNetAppRequest,pNetAppResponse);
	}
#ifdef slcb_NetAppRequestHdlr
	else
	{
		slcb_NetAppRequestHdlr(pNetAppRequest,pNetAppResponse);
	}
#endif
}


void _SlNetAppRequestMemFree (_u8 *buffer)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_MEM_FREE];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationNetAppRequestMemFree)(currentNode->event))(buffer))
		{
			return;
		}
		currentNode = currentNode->next;
	}
	if (NULL != g_UserEvents[SL_EVENT_HDL_MEM_FREE])
	{
		((_pSlNetAppRequestMemFree)g_UserEvents[SL_EVENT_HDL_MEM_FREE])(buffer);
	}
#ifdef slcb_NetAppRequestMemFree
	else
	{
		slcb_NetAppRequestMemFree(buffer);
	}
#endif
}


void _SlSocketTriggerEventHandler(SlSockTriggerEvent_t* pSlSockTriggerEvent)
{
	SlEventsListNode_t* currentNode = g_LibsEvents[SL_EVENT_HDL_SOCKET_TRIGGER];
	while(currentNode != NULL)
	{
		if(EVENT_PROPAGATION_BLOCK == ((_pSlPropogationSocketTriggerEventHandler)(currentNode->event))(pSlSockTriggerEvent))
		{
			return;
		}
		currentNode = currentNode->next;
	}
	if (NULL != g_UserEvents[SL_EVENT_HDL_SOCKET_TRIGGER])
	{
		((_pSlSocketTriggerEventHandler)g_UserEvents[SL_EVENT_HDL_SOCKET_TRIGGER])(pSlSockTriggerEvent);
	}
#ifdef slcb_SocketTriggerEventHandler
	else
	{
		slcb_SocketTriggerEventHandler(pSlSockTriggerEvent);
	}
#endif
}

#endif /* SL_RUNTIME_EVENT_REGISTERATION */