/**
 * Copyright (c) 2014 - 2018, Nordic Semiconductor ASA
 *
 * 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, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, 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. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 <sys/socket.h>
#include <sys/select.h>
#include <netinet/in.h>
#ifdef UNIX
#include <fcntl.h>
#endif
#include <errno.h>
#include <stdint.h>
#include "mem_manager.h"
#include "sdk_errors.h"
#include "sdk_config.h"
#include "iot_common.h"
#include "nordic_common.h"
#include "coap_transport.h"
#include "coap.h"

/**@brief UDP port information. */
typedef struct
{
    int               socket_fd;                           /**< Socket information provided by UDP. */
    uint16_t          port_number;                         /**< Associated port number. */
} udp_port_t;

static udp_port_t m_port_table[COAP_PORT_COUNT];           /**< Table maintaining association between CoAP ports and corresponding UDP socket identifiers. */

static fd_set m_readfds;
static int    m_max_sd = 0;

/**@brief Creates port as requested in p_port.
 *
 * @details Creates port as requested in p_port.
 *
 * @param[in]   index    Index to the m_port_table where entry of the port created is to be made.
 * @param[in]   p_port   Port information to be created.
 *
 * @retval NRF_SUCCESS   Indicates if port was created successfully, else an an error code
 *                       indicating reason for failure.
 */
static uint32_t port_create(uint32_t index, coap_port_t  * p_port)
{
    // Request new socket creation.
    int socket_fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);

    if (socket_fd != -1)
    {
        // Bind the socket to the local port.
        struct sockaddr_in6 sin6;

        memset(&sin6, 0, sizeof(struct sockaddr_in6));
        sin6.sin6_family = AF_INET6;
        sin6.sin6_port = htons(p_port->port_number);
        sin6.sin6_addr = in6addr_any;

        int retval = bind(socket_fd, (struct sockaddr *)&sin6, sizeof(sin6));
        if (retval != -1)
        {
              m_port_table[index].port_number = p_port->port_number;
              m_port_table[index].socket_fd   = socket_fd;
        }
        else
        {
            // Not all procedures succeeded with allocated socket, hence free it.
            UNUSED_VARIABLE(close(socket_fd));
            return NRF_ERROR_INVALID_PARAM;
        }
    }

    // Configure socket to be non-blocking.
    int flags = fcntl(socket_fd, F_GETFL, 0);
    flags |= O_NONBLOCK;
    UNUSED_VARIABLE(fcntl(m_port_table[index].socket_fd, F_SETFL, flags));

    // Add socket to file descriptor set.
    FD_SET(m_port_table[index].socket_fd, &m_readfds);

    // If enumeration is having a gap, increase the max fd count.
    if (socket_fd >= m_max_sd)
    {
        m_max_sd = (socket_fd + 1);
    }

    return NRF_SUCCESS;
}


uint32_t coap_transport_init(const coap_transport_init_t   * p_param)
{
    uint32_t err_code = NRF_SUCCESS;
    uint32_t index;

    NULL_PARAM_CHECK(p_param);
    NULL_PARAM_CHECK(p_param->p_port_table);

    FD_ZERO(&m_readfds);

    err_code = nrf_mem_init();

    if (err_code == NRF_SUCCESS) {
        for (index = 0; index < COAP_PORT_COUNT; index++)
        {
            // Create end point for each of the COAP ports.
            err_code = port_create(index, &p_param->p_port_table[index]);
            if (err_code != NRF_SUCCESS)
            {
                break;
            }
        }
    }

    return err_code;
}


uint32_t coap_transport_write(const coap_port_t    * p_port,
                              const coap_remote_t  * p_remote,
                              const uint8_t        * p_data,
                              uint16_t               datalen)
{

    uint32_t err_code = NRF_ERROR_NOT_FOUND;
    uint32_t index;

    NULL_PARAM_CHECK(p_port);
    NULL_PARAM_CHECK(p_remote);
    NULL_PARAM_CHECK(p_data);

    // Search for the corresponding port.
    for (index = 0; index < COAP_PORT_COUNT; index++)
    {
        if (m_port_table[index].port_number == p_port->port_number)
        {
            COAP_MUTEX_UNLOCK();

            static struct sockaddr_in6 dest_address_in6;

            memset(&dest_address_in6, 0, sizeof(struct sockaddr_in6));
            dest_address_in6.sin6_family = AF_INET6;
            dest_address_in6.sin6_port = htons(p_remote->port_number);

            memcpy(&dest_address_in6.sin6_addr, p_remote->addr, sizeof(struct in6_addr));

            // Send on UDP port.
            int retval = sendto(m_port_table[index].socket_fd,
                                p_data,
                                datalen,
                                0,
                                (struct sockaddr *)&dest_address_in6,
                                sizeof(dest_address_in6));
            if (retval == -1)
            {
                // Error in sendto.
                err_code = NRF_ERROR_INTERNAL;
            }
            else
            {
                err_code = NRF_SUCCESS;
            }

            COAP_MUTEX_LOCK();
            break;
        }
    }

    return err_code;
}


void coap_transport_process(void)
{
    return;
}


uint32_t coap_security_setup(uint16_t                       local_port,
                             nrf_tls_role_t                 role,
                             coap_remote_t          * const p_remote,
                             nrf_tls_key_settings_t * const p_settings)
{
    return SDK_ERR_API_NOT_IMPLEMENTED;
}


uint32_t coap_security_destroy(uint16_t              local_port,
                               coap_remote_t * const p_remote)
{
    return SDK_ERR_API_NOT_IMPLEMENTED;
}


void coap_transport_input(void)
{
    int retval = select(m_max_sd, &m_readfds, NULL, NULL, NULL);

    if (retval == -1)
    {
        // Error in select().
        // Placeholder for debugging.
    }
    else if (retval >= 1) // Number of file descriptiors with activity.
    {
        uint32_t index = 0;
        int socket_fd = m_port_table[index].socket_fd;

        // The descriptor has data.
        if (FD_ISSET(socket_fd, &m_readfds)) // If socket_fd is set to read.
        {
            static uint8_t read_mem[COAP_MESSAGE_DATA_MAX_SIZE];
            static struct  sockaddr_in6 client_address_in6;
            socklen_t address_length = sizeof(struct  sockaddr_in6);

            int bytes_read = recvfrom(socket_fd,
                                      read_mem,
                                      sizeof(read_mem),
                                      0,
                                      (struct sockaddr *)&client_address_in6,
                                      (socklen_t *)&address_length); // Blocking call, waiting for incoming transaction.
            if (bytes_read >= 0)
            {
                coap_port_t port;
                port.port_number = m_port_table[index].port_number;

                coap_remote_t remote_endpoint;
                memcpy(remote_endpoint.addr, &client_address_in6.sin6_addr, sizeof(struct in6_addr));
                remote_endpoint.port_number = ntohs(client_address_in6.sin6_port);

                uint32_t result = NRF_SUCCESS;

                // Notify the CoAP module of received data.
                retval = coap_transport_read(&port,
                                             &remote_endpoint,
                                             NULL,
                                             result,
                                             read_mem,
                                             (uint16_t)bytes_read);

                // Nothing much to do if CoAP could not interpret the datagram.
                UNUSED_VARIABLE(retval);
            }
            else
            {
                // Error in readfrom().
                // Placeholder for debugging.
                // If select() indicated this socket file descriptor to have pending
                // data, this case should not occur.
            }
        }
    }
    else
    {
        // In case of socket() returning 0, timeout.
        // Not implemented.
    }
}