/**
 * Copyright (c) 2015 - 2021, 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 "sdk_common.h"
#if NRF_MODULE_ENABLED(APP_GPIOTE)
#include "app_gpiote.h"
#include "nrf_bitmask.h"
#define MODULE_INITIALIZED (mp_users != NULL) /**< Macro designating whether the module has been initialized properly. */

#if (GPIO_COUNT == 1)
#define MAX_PIN_NUMBER 32
#elif (GPIO_COUNT == 2)
#define MAX_PIN_NUMBER (32 + P1_PIN_NUM)
#else
#error "Not supported."
#endif

/**@brief GPIOTE user type. */
typedef struct
{
    uint32_t                   pins_mask[GPIO_COUNT];             /**< Mask defining which pins user wants to monitor. */
    uint32_t                   pins_low_to_high_mask[GPIO_COUNT]; /**< Mask defining which pins will generate events to this user when toggling low->high. */
    uint32_t                   pins_high_to_low_mask[GPIO_COUNT]; /**< Mask defining which pins will generate events to this user when toggling high->low. */
    uint32_t                   sense_high_pins[GPIO_COUNT];       /**< Mask defining which pins are configured to generate GPIOTE interrupt on transition to high level. */
    app_gpiote_event_handler_t event_handler;                     /**< Pointer to function to be executed when an event occurs. */
    bool                       enabled;                           /**< Flag indicating whether user is enabled. */
} gpiote_user_t;

STATIC_ASSERT(sizeof(gpiote_user_t) <= GPIOTE_USER_NODE_SIZE);
STATIC_ASSERT(sizeof(gpiote_user_t) % 4 == 0);

static uint8_t         m_user_array_size;             /**< Size of user array. */
static uint8_t         m_user_count;                  /**< Number of registered users. */
static gpiote_user_t * mp_users = NULL;               /**< Array of GPIOTE users. */
static uint32_t        m_pins[GPIO_COUNT];            /**< Mask of initialized pins. */
static uint32_t        m_last_pins_state[GPIO_COUNT]; /**< Most recent state of pins. */

void gpiote_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
    int i;
    uint32_t pin_mask[GPIO_COUNT] = {0};
    uint32_t empty_pin_mask[GPIO_COUNT] = {0};
    nrf_bitmask_bit_set(pin, pin_mask);
    bool hitolo = nrf_bitmask_bit_is_set(pin, m_last_pins_state);
    nrf_gpio_ports_read(0, GPIO_COUNT, m_last_pins_state);

    for (i = 0; i < m_user_count; i++)
    {
        if (mp_users[i].enabled && nrf_bitmask_bit_is_set(pin, mp_users[i].pins_mask))
        {
            if (
          nrf_bitmask_bit_is_set(pin, mp_users[i].pins_high_to_low_mask)
          && hitolo)
            {
                mp_users[i].event_handler(empty_pin_mask,pin_mask);
            }
            else if (
          nrf_bitmask_bit_is_set(pin, mp_users[i].pins_low_to_high_mask)
          && !hitolo)
            {
                mp_users[i].event_handler(pin_mask,empty_pin_mask);
            }
        }
    }
}

uint32_t app_gpiote_init(uint8_t max_users, void * p_buffer)
{
    uint32_t ret_code = NRF_SUCCESS;

    if (p_buffer == NULL)
    {
        return NRF_ERROR_INVALID_PARAM;
    }

    // Check that buffer is correctly aligned.
    if (!is_word_aligned(p_buffer))
    {
        return NRF_ERROR_INVALID_PARAM;
    }

    // Initialize file globals.
    mp_users             = (gpiote_user_t *)p_buffer;
    m_user_array_size    = max_users;
    m_user_count         = 0;
    memset(m_pins,0, sizeof(m_pins));

    memset(mp_users, 0, m_user_array_size * sizeof(gpiote_user_t));

    if (nrf_drv_gpiote_is_init()==false)
    {
        ret_code = nrf_drv_gpiote_init();
    }

    return ret_code;
}

uint32_t app_gpiote_user_register(app_gpiote_user_id_t     * p_user_id,
                                  uint32_t const *           p_pins_low_to_high_mask,
                                  uint32_t const *           p_pins_high_to_low_mask,
                                  app_gpiote_event_handler_t event_handler)
{
    uint32_t user_pin_mask[GPIO_COUNT];
    ASSERT(event_handler != NULL);

    // Check state and parameters.
    VERIFY_MODULE_INITIALIZED();

    if (m_user_count >= m_user_array_size)
    {
        return NRF_ERROR_NO_MEM;
    }

    nrf_bitmask_masks_or(p_pins_low_to_high_mask, p_pins_high_to_low_mask,
                user_pin_mask, sizeof(user_pin_mask));
    // Allocate new user.
    mp_users[m_user_count].enabled       = false;
    mp_users[m_user_count].event_handler = event_handler;

    memcpy(mp_users[m_user_count].pins_mask,
          user_pin_mask,
          sizeof(mp_users[m_user_count].pins_mask));
    memcpy(mp_users[m_user_count].pins_low_to_high_mask,
           p_pins_low_to_high_mask,
           sizeof(mp_users[m_user_count].pins_low_to_high_mask));
    memcpy(mp_users[m_user_count].pins_high_to_low_mask,
           p_pins_high_to_low_mask,
           sizeof(mp_users[m_user_count].pins_high_to_low_mask));

    uint32_t i;
    const nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false);

    uint32_t num_of_pins = MAX_PIN_NUMBER;
    for (i = 0; i < num_of_pins; i++)
    {
        if (nrf_bitmask_bit_is_set(i, user_pin_mask) &&
           !nrf_bitmask_bit_is_set(i, m_pins))
        {
            uint32_t ret_val = nrf_drv_gpiote_in_init(i, &config, gpiote_handler);
            VERIFY_SUCCESS(ret_val);
            nrf_bitmask_bit_set(i, m_pins);
        }
    }

    /* Success - return user id and increment counter */
    *p_user_id = m_user_count++;
    return NRF_SUCCESS;
}

uint32_t app_gpiote_user_register_ex(app_gpiote_user_id_t * p_user_id,
                                     app_gpiote_user_pin_config_t const * p_pins_config,
                                     size_t pin_count,
                                     app_gpiote_event_handler_t event_handler)
{
    ASSERT(event_handler != NULL);

    // Check state and parameters.
    VERIFY_MODULE_INITIALIZED();
    if (m_user_count >= m_user_array_size)
    {
        return NRF_ERROR_NO_MEM;
    }
    /* Prepare user structure */
    gpiote_user_t * p_user = &mp_users[m_user_count];

    p_user->enabled = false;
    memset(p_user, 0, sizeof(gpiote_user_t));
    mp_users[m_user_count].event_handler = event_handler;

    for (; pin_count != 0; --pin_count, ++p_pins_config)
    {
        nrfx_gpiote_pin_t pin = (nrfx_gpiote_pin_t)p_pins_config->pin_number;
        const nrf_drv_gpiote_in_config_t config = GPIOTE_RAW_CONFIG_IN_SENSE_TOGGLE(false);
        if (!nrf_bitmask_bit_is_set(pin, m_pins))
        {
            uint32_t ret_val = nrf_drv_gpiote_in_init(pin, &config, gpiote_handler);
            VERIFY_SUCCESS(ret_val);
            nrf_bitmask_bit_set(pin, m_pins);
        }

        //lint -save -e650  Lint seems not properly support bitfields that uses enum as a base type
        if ((p_pins_config->sense == NRF_GPIOTE_POLARITY_LOTOHI) ||
            (p_pins_config->sense == NRF_GPIOTE_POLARITY_TOGGLE))
        {
            nrf_bitmask_bit_set(pin, p_user->pins_low_to_high_mask);
        }
        if ((p_pins_config->sense == NRF_GPIOTE_POLARITY_HITOLO) ||
            (p_pins_config->sense == NRF_GPIOTE_POLARITY_TOGGLE))
        {
            nrf_bitmask_bit_set(pin, p_user->pins_high_to_low_mask);
        }
        //lint -restore
    }
    /* Mark all pins used by the selected user */
    nrf_bitmask_masks_or(
        p_user->pins_low_to_high_mask,
        p_user->pins_high_to_low_mask,
        p_user->pins_mask,
        sizeof(p_user->pins_mask));
    /* Success - return user id and increment counter */
    *p_user_id = m_user_count++;

    return NRF_SUCCESS;
}

__STATIC_INLINE uint32_t error_check(app_gpiote_user_id_t user_id)
{
    // Check state and parameters.
    VERIFY_MODULE_INITIALIZED();

    if (user_id >= m_user_count)
    {
        return NRF_ERROR_INVALID_PARAM;
    }
    return NRF_SUCCESS;
}
/**
 * @brief Function for enabling event on pin (if not yet enabled) or disabling the event if no other
 *        user requires it.
 *
 * @param pin    Pin to enable
 * @param enable If true function will attempt to enable the pin else it will attempt to disable it.
 */
static void pin_event_enable(uint32_t pin, bool enable)
{
    uint32_t i;
    bool enabled = false;
    //search if any user already enabled given pin
    for (i = 0; i < m_user_count; i++)
    {
        if (mp_users[i].enabled &&
                nrf_bitmask_bit_is_set(pin, mp_users[i].pins_mask))
        {
            enabled = true;
            break;
        }
    }
    if (!enabled)
    {
        if (enable)
        {
            nrf_gpio_ports_read(0, GPIO_COUNT, m_last_pins_state);
            nrf_drv_gpiote_in_event_enable(pin, true);
        }
        else
        {
            nrf_drv_gpiote_in_event_disable(pin);
        }
    }
}

/**
 * @brief Function for enabling or disabling events for pins used by the user.
 *
 * Function will enable pin events only if they are not yet enabled. Function will disable pin
 * events only if there is no other enabled user that is using them.
 *
 * @param user_id  User id.
 * @param enable   If true function will attempt to enable the pin else it will attempt to disable it.
 */
static uint32_t user_enable(app_gpiote_user_id_t user_id, bool enable)
{
    uint32_t ret_code = error_check(user_id);

    if (ret_code == NRF_SUCCESS)
    {
        uint32_t i;
        for (i = 0; i < MAX_PIN_NUMBER; i++)
        {
            if (nrf_bitmask_bit_is_set(i, mp_users[user_id].pins_mask))
            {
                pin_event_enable(i, enable);
            }
        }
    }
    return ret_code;
}

uint32_t app_gpiote_user_enable(app_gpiote_user_id_t user_id)
{
    uint32_t ret_code = NRF_SUCCESS;

    if (mp_users[user_id].enabled == false)
    {
        ret_code = user_enable(user_id, true);
        VERIFY_SUCCESS(ret_code);

        mp_users[user_id].enabled = true;
        return ret_code;
    }
    else
    {
        return ret_code;
    }
}

uint32_t app_gpiote_user_disable(app_gpiote_user_id_t user_id)
{
    uint32_t ret_code = NRF_SUCCESS;

    if (mp_users[user_id].enabled)
    {
        mp_users[user_id].enabled = false;
        ret_code = user_enable(user_id, false);
    }

    return ret_code;
}

uint32_t app_gpiote_pins_state_get(app_gpiote_user_id_t user_id, uint32_t * p_pins)
{
    gpiote_user_t * p_user;
    uint32_t ret_code = error_check(user_id);

    if (ret_code == NRF_SUCCESS)
    {
        p_user  = &mp_users[user_id];

        nrf_gpio_ports_read(0, GPIO_COUNT, p_pins);
        nrf_bitmask_masks_and(p_pins, p_user->pins_mask, p_pins, sizeof(p_user->pins_mask));
    }
    return ret_code;
}
#endif //NRF_MODULE_ENABLED(APP_GPIOTE)
