/*
 * Sockets_Wrapper.c
 *
 *  Created on: 10-Aug-2022
 *      Author: sruthi
 */

/*
 * sockets_wrapper.c
 *
 *  Created on: 01-Jun-2022
 *      Author: sruthi
 */

/* Standard includes. */
#include <string.h>

/* FreeRTOS includes. */
#include "FreeRTOS.h"

#include "Sockets_Wrapper.h"

#include "logging_levels.h"


#ifndef LIBRARY_LOG_NAME
    #define LIBRARY_LOG_NAME    "socket_wrapper"
#endif

#ifndef LIBRARY_LOG_LEVEL
    #define LIBRARY_LOG_LEVEL    LOG_ERROR
#endif


#ifndef SdkLog
    #define SdkLog( X ) printf X
#endif

#include "logging_stack.h"
/*-----------------------------------------------------------*/

/* Maximum number of times to call FreeRTOS_recv when initiating a graceful shutdown. */
#ifndef FREERTOS_SOCKETS_WRAPPER_SHUTDOWN_LOOPS
    #define FREERTOS_SOCKETS_WRAPPER_SHUTDOWN_LOOPS    ( 3 )
#endif

/* A negative error code indicating a network failure. */
#define FREERTOS_SOCKETS_WRAPPER_NETWORK_ERROR    ( -1 )

/*-----------------------------------------------------------*/

BaseType_t Sockets_Connect( Socket_t * pTcpSocket,
                            const char * pHostName,
                            uint16_t port,
                            uint32_t receiveTimeoutMs,
                            uint32_t sendTimeoutMs )
{
    Socket_t tcpSocket = FREERTOS_INVALID_SOCKET;
    BaseType_t socketStatus = 0;
    BaseType_t socketStatus_check = 0;
    struct freertos_sockaddr serverAddress = { 0 };
    TickType_t transportTimeout = 0;

    /* Create a new TCP socket. */

    do
	{
		tcpSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );

		if( tcpSocket == FREERTOS_INVALID_SOCKET )
		{
		   // LogError( ( "Failed to create new socket." ) );
			socketStatus = FREERTOS_SOCKETS_WRAPPER_NETWORK_ERROR;
		}
		else
		{
		   //LogDebug( ( "Created new TCP socket." ) );

			/* Connection parameters. */
			serverAddress.sin_family = FREERTOS_AF_INET;
			serverAddress.sin_port = FreeRTOS_htons( port );
			serverAddress.sin_addr = ( uint32_t ) FreeRTOS_gethostbyname( pHostName );
			serverAddress.sin_len = ( uint8_t ) sizeof( serverAddress );
			socketStatus = 0;
			/* Check for errors from DNS lookup. */
			if( serverAddress.sin_addr == 0U )
			{
			   LogError(("Failed to connect to server: DNS resolution failed: Hostname=%s.",
					pHostName));
				socketStatus = FREERTOS_SOCKETS_WRAPPER_NETWORK_ERROR;
			}
		}

		if( socketStatus == 0 )
		{
			/* Establish connection. */
		   //LogDebug( ( "Creating TCP Connection to %s.", pHostName ) );
			socketStatus = FreeRTOS_connect( tcpSocket, &serverAddress, sizeof( serverAddress ) );


			if( socketStatus != 0 )
			{
			   LogError( ( "Failed to connect to server: FreeRTOS_Connect failed: ReturnCode=%d,"
							" Hostname=%s, Port=%u.",socketStatus,pHostName,port ) );
               FreeRTOS_closesocket(tcpSocket);
			}
			else
				break;

		}
		//else
		{
			 //LogError( ( "close socket\n") );
		}

    }while(socketStatus != 0);

    if( socketStatus == 0 )
    {
        /* Set socket receive timeout. */
        transportTimeout = pdMS_TO_TICKS( receiveTimeoutMs );
        /* Setting the receive block time cannot fail. */
        ( void ) FreeRTOS_setsockopt( tcpSocket,
                                      0,
                                      FREERTOS_SO_RCVTIMEO,
                                      &transportTimeout,
                                      sizeof( TickType_t ) );

        /* Set socket send timeout. */
        transportTimeout = pdMS_TO_TICKS( sendTimeoutMs );
        /* Setting the send block time cannot fail. */
        ( void ) FreeRTOS_setsockopt( tcpSocket,
                                      0,
                                      FREERTOS_SO_SNDTIMEO,
                                      &transportTimeout,
                                      sizeof( TickType_t ) );
    }

    /* Clean up on failure. */
    if( socketStatus != 0 )
    {
        if( tcpSocket != FREERTOS_INVALID_SOCKET )
        {
            ( void ) FreeRTOS_closesocket( tcpSocket );
        }
    }
    else
    {
        /* Set the socket. */
        *pTcpSocket = tcpSocket;
         LogInfo( ( "Established TCP connection with %s.", pHostName ) );
    }

    return socketStatus;
}

/*-----------------------------------------------------------*/

void Sockets_Disconnect( Socket_t tcpSocket )
{
    BaseType_t waitForShutdownLoopCount = 0;
    uint8_t pDummyBuffer[ 2 ];

    if( tcpSocket != FREERTOS_INVALID_SOCKET )
    {
        /* Initiate graceful shutdown. */
        ( void ) FreeRTOS_shutdown( tcpSocket, FREERTOS_SHUT_RDWR );

        /* Wait for the socket to disconnect gracefully (indicated by FreeRTOS_recv()
         * returning a FREERTOS_EINVAL error) before closing the socket. */
        while( FreeRTOS_recv( tcpSocket, pDummyBuffer, sizeof( pDummyBuffer ), 0 ) >= 0 )
        {
            /* We don't need to delay since FreeRTOS_recv should already have a timeout. */

            if( ++waitForShutdownLoopCount >= FREERTOS_SOCKETS_WRAPPER_SHUTDOWN_LOOPS )
            {
                break;
            }
        }

        ( void ) FreeRTOS_closesocket( tcpSocket );
    }
}