/**
 * Copyright (c) 2014 - 2019, 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 <string.h>

#include "coap_observe_api.h"
#include "coap_observe.h"
#include "nrf_error.h"
#include "iot_common.h"
#include "sdk_common.h"
#include "sdk_config.h"
#include "coap.h"

#if IOT_COAP_CONFIG_LOG_ENABLED

#define NRF_LOG_MODULE_NAME coapobs

#define NRF_LOG_LEVEL       IOT_COAP_CONFIG_LOG_LEVEL
#define NRF_LOG_INFO_COLOR  IOT_COAP_CONFIG_INFO_COLOR
#define NRF_LOG_DEBUG_COLOR IOT_COAP_CONFIG_DEBUG_COLOR

#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();

#define COAP_TRC     NRF_LOG_DEBUG                                                              /**< Used for getting trace of execution in the module. */
#define COAP_ERR     NRF_LOG_ERROR                                                              /**< Used for logging errors in the module. */
#define COAP_DUMP    NRF_LOG_HEXDUMP_DEBUG                                                      /**< Used for dumping octet information to get details of bond information etc. */

#define COAP_ENTRY() COAP_TRC(">> %s", __func__)
#define COAP_EXIT()  COAP_TRC("<< %s", __func__)

#else // IOT_COAP_CONFIG_LOG_ENABLED

#define COAP_TRC(...)                                                                           /**< Disables traces. */
#define COAP_DUMP(...)                                                                          /**< Disables dumping of octet streams. */
#define COAP_ERR(...)                                                                           /**< Disables error logs. */

#define COAP_ENTRY(...)
#define COAP_EXIT(...)

#endif // IOT_COAP_CONFIG_LOG_ENABLED

#if (COAP_ENABLE_OBSERVE_SERVER == 1)
static coap_observer_t   m_observers[COAP_OBSERVE_MAX_NUM_OBSERVERS];

static void observe_server_init(void)
{
    COAP_ENTRY();

    // Loop through the observer array and clear the memory.
    for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVERS; i++)
    {
        memset(&m_observers[i], 0, sizeof(coap_observer_t));
    }

    COAP_EXIT();
}

uint32_t internal_coap_observe_server_register(uint32_t * p_handle, coap_observer_t * p_observer)
{
    COAP_ENTRY();

    NULL_PARAM_CHECK(p_handle);
    NULL_PARAM_CHECK(p_observer);

    NULL_PARAM_MEMBER_CHECK(p_observer->p_resource_of_interest);

    // Check if there is already a registered observer in the list to be reused.
    uint32_t handle;
    uint32_t err_code = coap_observe_server_search(&handle,
                                                   &p_observer->remote,
                                                   p_observer->p_resource_of_interest);
    if (err_code == NRF_SUCCESS)
    {
        memcpy(&m_observers[handle], p_observer, sizeof(coap_observer_t));
        *p_handle = handle;
        return NRF_SUCCESS;
    }

    // Check if there is an available spot in the observer list.
    for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVERS; i++)
    {
        if (m_observers[i].p_resource_of_interest == NULL)
        {
            memcpy(&m_observers[i], p_observer, sizeof(coap_observer_t));

            *p_handle = i;
            return NRF_SUCCESS;
        }
    }


    COAP_EXIT();

    return (NRF_ERROR_NO_MEM | IOT_COAP_ERR_BASE);
}


uint32_t internal_coap_observe_server_unregister(uint32_t handle)
{
    COAP_ENTRY();

    if (handle >= COAP_OBSERVE_MAX_NUM_OBSERVERS)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    if (m_observers[handle].p_resource_of_interest == NULL)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    m_observers[handle].p_resource_of_interest = NULL;

    COAP_EXIT();

    return NRF_SUCCESS;
}


uint32_t internal_coap_observe_server_search(uint32_t *        p_handle,
                                             coap_remote_t *   p_observer_addr,
                                             coap_resource_t * p_resource)
{
    NULL_PARAM_CHECK(p_handle);
    NULL_PARAM_CHECK(p_observer_addr);
    NULL_PARAM_CHECK(p_resource);

    for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVERS; i++)
    {
        if (m_observers[i].p_resource_of_interest == p_resource)
        {
            if (m_observers[i].remote.port_number == p_observer_addr->port_number)
            {
                if (memcmp(p_observer_addr->addr, m_observers[i].remote.addr, sizeof(p_observer_addr->addr)) == 0)
                {
                    *p_handle = i;
                    return NRF_SUCCESS;
                }
            }
        }
    }

    return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
}


uint32_t internal_coap_observe_server_next_get(coap_observer_t ** pp_observer,
                                               coap_observer_t *  p_observer,
                                               coap_resource_t *  p_resource)
{
    NULL_PARAM_CHECK(p_resource);
    NULL_PARAM_CHECK(pp_observer);

    if (p_observer == NULL)
    {
        for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVERS; i++)
        {
            if (m_observers[i].p_resource_of_interest == p_resource)
            {
                (*pp_observer) = &m_observers[i];
                return NRF_SUCCESS;
            }
        }
    }
    else
    {
        uint32_t index_to_previous = (uint8_t)(((uint32_t)p_observer - (uint32_t)m_observers) / (uint32_t)sizeof(coap_observer_t));

        for (uint32_t i = index_to_previous + 1; i < COAP_OBSERVE_MAX_NUM_OBSERVERS; i++)
        {
            if (m_observers[i].p_resource_of_interest == p_resource)
            {
                (*pp_observer) = &m_observers[i];
                return NRF_SUCCESS;
            }
        }
    }
    (*pp_observer) = NULL;

    return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
}

uint32_t internal_coap_observe_server_get(uint32_t handle, coap_observer_t ** pp_observer)
{
    NULL_PARAM_CHECK(pp_observer);

    if (handle >= COAP_OBSERVE_MAX_NUM_OBSERVERS)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    if (m_observers[handle].p_resource_of_interest == NULL)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    *pp_observer = &m_observers[handle];
    return NRF_SUCCESS;
}
#else
#define observe_server_init(...)
#endif

#if (COAP_ENABLE_OBSERVE_CLIENT == 1)
static coap_observable_t m_observables[COAP_OBSERVE_MAX_NUM_OBSERVABLES];

static void observe_client_init(void)
{
    // Loop through the observable array and clear the memory.
    for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVABLES; i++)
    {
        memset(&m_observables[i], 0, sizeof(coap_observable_t));
    }
}


uint32_t internal_coap_observe_client_register(uint32_t *          p_handle,
                                               coap_observable_t * p_observable)
{
    COAP_ENTRY();

    NULL_PARAM_CHECK(p_handle);
    NULL_PARAM_CHECK(p_observable);

    NULL_PARAM_MEMBER_CHECK(p_observable->response_callback);

    // Check if there is an available spot in the observer list.
    for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVABLES; i++)
    {
        if (m_observables[i].response_callback == NULL)
        {
            memcpy(&m_observables[i], p_observable, sizeof(coap_observable_t));
            *p_handle = i;
            return NRF_SUCCESS;
        }
    }

    COAP_EXIT();

    return (NRF_ERROR_NO_MEM | IOT_COAP_ERR_BASE);
}


uint32_t internal_coap_observe_client_unregister(uint32_t handle)
{
    COAP_ENTRY();

    if (handle >= COAP_OBSERVE_MAX_NUM_OBSERVABLES)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    if (m_observables[handle].response_callback == NULL)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    m_observables[handle].response_callback = NULL;

    COAP_EXIT();

    return NRF_SUCCESS;
}


uint32_t internal_coap_observe_client_search(uint32_t * p_handle, uint8_t * p_token, uint16_t token_len)
{
    NULL_PARAM_CHECK(p_handle);
    NULL_PARAM_CHECK(p_token);

    for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVABLES; i++)
    {
        if ((m_observables[i].response_callback != NULL)                           &&
            (0 != m_observables[i].token_len)                                           &&
            (memcmp(m_observables[i].token, p_token, m_observables[i].token_len) == 0))
        {
            *p_handle = i;
            return NRF_SUCCESS;
        }
    }

    return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
}


uint32_t internal_coap_observe_client_get(uint32_t handle, coap_observable_t ** pp_observable)
{
    NULL_PARAM_CHECK(pp_observable);

    if (handle >= COAP_OBSERVE_MAX_NUM_OBSERVABLES)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    if (m_observables[handle].response_callback == NULL)
    {
        return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
    }

    *pp_observable = &m_observables[handle];

    return NRF_SUCCESS;
}

uint32_t internal_coap_observe_client_next_get(coap_observable_t ** pp_observable,
                                               uint32_t *           p_handle,
                                               coap_observable_t *  p_observable)
{
    NULL_PARAM_CHECK(pp_observable);

    if (p_observable == NULL)
    {
        for (uint32_t i = 0; i < COAP_OBSERVE_MAX_NUM_OBSERVABLES; i++)
        {
            if (m_observables[i].response_callback != NULL)
            {
                (*pp_observable) = &m_observables[i];
                (*p_handle)      = i;
                return NRF_SUCCESS;
            }
        }
    }
    else
    {
        uint32_t index_to_previous = (uint8_t)(((uint32_t)p_observable - (uint32_t)m_observables) / (uint32_t)sizeof(coap_observable_t));

        for (uint32_t i = index_to_previous + 1; i < COAP_OBSERVE_MAX_NUM_OBSERVABLES; i++)
        {
            if (m_observables[i].response_callback != NULL)
            {
                (*pp_observable) = &m_observables[i];
                (*p_handle)      = i;
                return NRF_SUCCESS;
            }
        }
    }
    (*pp_observable) = NULL;

    COAP_MUTEX_UNLOCK();

    return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE);
}

static uint32_t observe_opt_present(coap_message_t * p_message)
{
    uint8_t index;
    for (index = 0; index < p_message->options_count; index++)
    {
        if (p_message->options[index].number == COAP_OPT_OBSERVE)
        {
            return NRF_SUCCESS;
        }
    }
    return NRF_ERROR_NOT_FOUND;
}

static void set_max_age(coap_observable_t * observable, coap_message_t * p_response)
{
    uint8_t index;
    for (index = 0; index < p_response->options_count; index++)
    {
        if (p_response->options[index].number == COAP_OPT_MAX_AGE)
        {
            uint32_t max_age;
            observable->max_age = coap_opt_uint_decode(&max_age,
                                                       p_response->options[index].length,
                                                       p_response->options[index].p_data);
            observable->max_age = max_age;
            return;
        }
    }

    // Max-Age option is not present, set default value to 60.
    observable->max_age = 60;
}

void coap_observe_client_send_handle(coap_message_t * p_request)
{
    COAP_ENTRY();

    if (p_request->header.code == COAP_CODE_GET)
    {
        uint32_t observe_option = 0;
        if (observe_opt_present(p_request) == NRF_SUCCESS)
        {
            // Locate option and check value.
            uint8_t index;
            for (index = 0; index < p_request->options_count; index++)
            {
                if (p_request->options[index].number == COAP_OPT_OBSERVE)
                {
                    uint32_t err_code = coap_opt_uint_decode(&observe_option,
                                                             p_request->options[index].length,
                                                             p_request->options[index].p_data);
                    if (err_code != NRF_SUCCESS)
                    {
                       return;
                    }
                    break;
                }
            }
        }

        if (observe_option == 1)
        {
            // Un-register observable instance.
            uint32_t handle;
            uint32_t err_code = internal_coap_observe_client_search(&handle,
                                                           p_request->token,
                                                           p_request->header.token_len);
            if (err_code == NRF_SUCCESS)
            {
                (void)internal_coap_observe_client_unregister(handle);
                COAP_TRC("OBSERVE=1 in request, client_unregister handle: %i", handle);

            }
        }
    }

    COAP_EXIT();
}

void coap_observe_client_response_handle(coap_message_t * p_response, coap_queue_item_t * p_item)
{
    COAP_ENTRY();

    if (observe_opt_present(p_response) == NRF_SUCCESS)
    {
        if (p_item == NULL)
        {
            // Search for the token in the observable list.
            uint32_t handle;
            uint32_t err_code = internal_coap_observe_client_search(&handle, p_response->token, p_response->header.token_len);
            if (err_code == NRF_SUCCESS)
            {
                // Fetch the observable.
                coap_observable_t * p_observable;
                err_code = internal_coap_observe_client_get(handle, &p_observable);
                if (err_code == NRF_SUCCESS)
                {
                    // Update max-age to the newly recieved message.
                    set_max_age(p_observable, p_response);

                    COAP_MUTEX_UNLOCK();

                    // Callback to the application.
                    p_observable->response_callback(NRF_SUCCESS, NULL, p_response);

                    COAP_MUTEX_LOCK();

                    COAP_TRC("Notification received on handle: %i", handle);

        #ifdef COAP_AUTOMODE
                    if (p_response->header.type == COAP_TYPE_CON)
                    {
                        // Reply an ACK upon CON message.
                    }
                    else if (p_response->header.type == COAP_TYPE_RST)
                    {
                        // Remove observable from list.
                    }
        #endif
                }
                else
                {
        #ifdef COAP_AUTOMODE
                    if (p_response->header.type == COAP_TYPE_CON)
                    {
                        // Reply reset upon CON message when observer is not located.
                    }
        #endif
                }
            }
            else
            {
                // Send RST message back to server to indicate there is no one listening.
            }
        }
        else // p_item set.
        {
            // If there is no observable instance created yet for thit token, add it.
            uint32_t handle;
            uint32_t err_code = internal_coap_observe_client_search(&handle, p_response->token, p_response->header.token_len);
            if (err_code == (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE))
            {
                // If the response is a valid response, add the observable resource.
                if (p_response->header.code == COAP_CODE_205_CONTENT)
                {
                    coap_observable_t observable;
                    // Token Length.
                    observable.token_len = p_response->header.token_len;
                    // Remote.
                    memcpy(&observable.remote, &p_response->remote, sizeof(coap_remote_t));
                    // Token.
                    memcpy(observable.token, p_response->token, observable.token_len);
                    // Callback to be called upon notification.
                    observable.response_callback = p_item->callback;

                    // Update max-age to the newly recieved message.
                    set_max_age(&observable, p_response);

                    // Register the observable.
                    uint32_t observable_resource_handle;
                    (void)internal_coap_observe_client_register(&observable_resource_handle, &observable);
                    // TODO: error check

                    COAP_TRC("Subscription response received, client_register handle: %i", observable_resource_handle);
                }
            }
        }
    }
    else // COAP_OPT_OBSERVE not present
    {
        uint32_t handle;
        uint32_t err_code = internal_coap_observe_client_search(&handle, p_response->token, p_response->header.token_len);
        if (err_code == NRF_SUCCESS)
        {
            (void)internal_coap_observe_client_unregister(handle);
            COAP_TRC("OBSERVE not present in notification, client_unregister handle: %i", handle);
        }
    }

    COAP_EXIT();
}
#else
#define observe_client_init(...)
#endif

void internal_coap_observe_init(void)
{
    observe_server_init();
    observe_client_init();
}

#if (COAP_ENABLE_OBSERVE_SERVER == 1)

uint32_t coap_observe_server_register(uint32_t * p_handle, coap_observer_t * p_observer)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_server_register(p_handle, p_observer);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_server_unregister(uint32_t handle)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_server_unregister(handle);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_server_search(uint32_t * p_handle, coap_remote_t * p_observer_addr, coap_resource_t * p_resource)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_server_search(p_handle, p_observer_addr, p_resource);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_server_next_get(coap_observer_t ** pp_observer, coap_observer_t * p_observer, coap_resource_t * p_resource)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_server_next_get(pp_observer, p_observer, p_resource);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_server_get(uint32_t handle, coap_observer_t ** pp_observer)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_server_get(handle, pp_observer);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

#endif // COAP_ENABLE_OBSERVE_SERVER = 1

#if (COAP_ENABLE_OBSERVE_CLIENT == 1)

uint32_t coap_observe_client_register(uint32_t * p_handle, coap_observable_t * p_observable)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_client_register(p_handle, p_observable);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_client_unregister(uint32_t handle)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_client_unregister(handle);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_client_search(uint32_t * p_handle, uint8_t * p_token, uint16_t token_len)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_client_search(p_handle, p_token, token_len);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_client_get(uint32_t handle, coap_observable_t ** pp_observable)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_client_get(handle, pp_observable);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

uint32_t coap_observe_client_next_get(coap_observable_t ** pp_observable, uint32_t * p_handle, coap_observable_t * p_observable)
{
    COAP_MUTEX_UNLOCK();

    uint32_t err_code = internal_coap_observe_client_next_get(pp_observable, p_handle, p_observable);

    COAP_MUTEX_UNLOCK();

    return err_code;
}

#endif // COAP_ENABLE_OBSERVE_CLIENT == 1