#include <stdint.h>
#include <stdbool.h>
#include "nrf.h"
#include "nrf_error.h"
#include "boards.h"
#include "nrf_delay.h"
#include "mesh_app_utils.h"
#include "nrfx_gpiote.h"
#include "nrf_drv_twi.h"
#include "ctrl_miboxer_p3.h"
#include "log.h"



/*** Defines */

#define TWI_FREQ_12KHZ                  0x003126E9

#define MIBOXER_7BIT_ADDR               0x53

#define MIBOXER_EVT_FLAG_HUE            1
#define MIBOXER_EVT_FLAG_LIGHTNESS      2
#define MIBOXER_EVT_FLAG_SATURATION     4



/*** Type definitions */

enum miboxer_state_e {
    MIBOXER_STATE_IDLE,
    MIBOXER_STATE_GPIO,
    MIBOXER_STATE_TWI
};


/*** Forward declarations */

static void gpio_disable(void);
static ret_code_t twi_enable(void);
static void twi_disable(void);



/*** Static variables */

static const nrfx_gpiote_in_config_t m_gpio_in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(0);
static const nrf_drv_twi_config_t m_twi_config = {
   .scl = TWI_SCL_PIN,
   .sda = TWI_SDA_PIN,
   .frequency = TWI_FREQ_12KHZ,
   .interrupt_priority = APP_IRQ_PRIORITY_LOWEST,
   .clear_bus_init = false
};
static uint8_t init_cmd[3] = { 0x31, 0xAF, 0x33 };
static uint8_t init_data[][3] = {
    { 0x80, 0x16, 0x00 },
    { 0x81, 0x16, 0x00 },
    { 0x82, 0x16, 0x00 },
    { 0x83, 0x16, 0x00 },
    { 0x84, 0x1f, 0x00 },
    { 0x85, 0x1f, 0x00 },
    { 0x86, 0x1f, 0x00 },
    { 0x87, 0x1f, 0x00 },
    { 0x88, 0x1f, 0x00 },
    { 0x89, 0x1f, 0x00 },
    { 0x8a, 0x90, 0x00 },
    { 0x8b, 0x90, 0x00 },
    { 0x8c, 0x98, 0x00 },
    { 0x8d, 0x98, 0x00 },
    { 0x8e, 0x90, 0x00 },
    { 0x8f, 0x90, 0x00 },
    { 0x90, 0x50, 0x00 },
    { 0x91, 0x50, 0x00 },
    { 0x92, 0x50, 0x00 },
    { 0x93, 0x50, 0x00 },
    { 0x94, 0x05, 0x00 },
    { 0x95, 0x05, 0x00 },
    { 0xff, 0xff, 0xff }
};
static uint8_t m_rx_buffer[3];
static enum miboxer_state_e m_state;
static uint8_t m_last_btn_flags;
static miboxer_handler_cb_t m_miboxer_handler_cb;



/**** Implementation */

static uint8_t miboxer_value_to_linear(uint8_t miboxer_value)
{
    uint16_t value =
        miboxer_value >= 0 && miboxer_value <= 175
            ? 255 - 80 - miboxer_value
            : 176 + 255 - miboxer_value;
    if (value < 31) return 0;
    if (value > 224) return 255;
    return ((value - 31) * 255) / 194;
}


static uint8_t miboxer_value_to_hue(uint8_t miboxer_value)
{
    return miboxer_value - 150;
}


static void _gpio_event_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
    ret_code_t err_code;

    gpio_disable();
    err_code = twi_enable();
    switch (err_code) {
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "Unexpected GPIO event\n");
        break;
    default:
        ERROR_CHECK(err_code);
    }

    err_code = nrf_drv_twi_rx(&m_twi, MIBOXER_7BIT_ADDR, m_rx_buffer, sizeof(m_rx_buffer));
    ERROR_CHECK(err_code);
}


static ret_code_t gpio_enable(void)
{
    ret_code_t err_code;

    if (m_state == MIBOXER_STATE_GPIO) {
        return NRF_ERROR_INVALID_STATE;
    }

    err_code = nrfx_gpiote_in_init(TWI_SDA_PIN, &m_gpio_in_config, _gpio_event_handler);
    if (err_code != NRF_SUCCESS) {
        return err_code;
    }
    nrfx_gpiote_in_event_enable(TWI_SDA_PIN, true);

    m_state = MIBOXER_STATE_GPIO;

    return NRF_SUCCESS;
}


static void gpio_disable(void)
{
    if (m_state != MIBOXER_STATE_GPIO) {
        return;
    }

    nrfx_gpiote_in_event_disable(TWI_SDA_PIN);
    nrfx_gpiote_in_uninit(TWI_SDA_PIN);

    m_state = MIBOXER_STATE_IDLE;
}


static void twi_event_handler(nrf_drv_twi_evt_t const *p_event, void *p_context)
{
    ret_code_t err_code;
    miboxer_evt_t miboxer_evt;

    switch (p_event->type) {
    case NRF_DRV_TWI_EVT_DONE:
        if (p_event->xfer_desc.type == NRF_DRV_TWI_XFER_RX) {
            uint8_t evt_flags = m_rx_buffer[0];
            if (evt_flags & 0x80) {
                if (m_last_btn_flags != m_rx_buffer[2]) {
                    miboxer_evt.type = MIBOXER_EVT_BUTTON;
                    miboxer_evt.btn_flags = m_rx_buffer[2];
                    m_miboxer_handler_cb(&miboxer_evt);
                    m_last_btn_flags = m_rx_buffer[2];
                }

                if (evt_flags & MIBOXER_EVT_FLAG_LIGHTNESS) {
                    uint8_t lightness_value = miboxer_value_to_linear(m_rx_buffer[1]);
                    miboxer_evt.type = MIBOXER_EVT_LIGHTNESS;
                    miboxer_evt.lightness = miboxer_value_to_linear(m_rx_buffer[1]);
                    m_miboxer_handler_cb(&miboxer_evt);
                } else if (evt_flags & MIBOXER_EVT_FLAG_SATURATION) {
                    miboxer_evt.type = MIBOXER_EVT_SATURATION;
                    miboxer_evt.saturation = miboxer_value_to_linear(m_rx_buffer[1]);
                    m_miboxer_handler_cb(&miboxer_evt);
                } else if (evt_flags & MIBOXER_EVT_FLAG_HUE) {
                    miboxer_evt.type = MIBOXER_EVT_HUE;
                    miboxer_evt.hue = miboxer_value_to_hue(m_rx_buffer[1]);;
                    m_miboxer_handler_cb(&miboxer_evt);
                }
            }
        }
        break;

    default:
        break;
    }

    twi_disable();
    err_code = gpio_enable();
    switch (err_code) {
    case NRF_ERROR_INVALID_STATE:
        __LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "Unexpected TWI event\n");
        break;
    default:
        ERROR_CHECK(err_code);
    }
}


static ret_code_t twi_enable(void)
{
    ret_code_t err_code;

    if (m_state == MIBOXER_STATE_TWI) {
        return NRF_ERROR_INVALID_STATE;
    }

    err_code = nrf_drv_twi_init(&m_twi, &m_twi_config, twi_event_handler, NULL);
    if (err_code != NRF_SUCCESS) {
        return err_code;
    }
    nrf_drv_twi_enable(&m_twi);

    m_state = MIBOXER_STATE_TWI;

    return NRF_SUCCESS;
}


static void twi_disable(void)
{
    if (m_state != MIBOXER_STATE_TWI) {
        return;
    }

    nrf_drv_twi_disable(&m_twi);
    nrf_drv_twi_uninit(&m_twi);

    m_state = MIBOXER_STATE_IDLE;
}



/*** Interface functions */

ret_code_t miboxer_init(miboxer_handler_cb_t cb)
{
    ret_code_t err_code;

    if (cb == NULL) {
        return NRF_ERROR_INVALID_PARAM;
    }
    m_miboxer_handler_cb = cb;

    if (!nrfx_gpiote_is_init()) {
        err_code = nrfx_gpiote_init();
        if (err_code != NRF_SUCCESS) {
            return err_code;
        }
    }

    err_code = nrf_drv_twi_init(&m_twi, &m_twi_config, NULL, NULL);
    if (err_code != NRF_SUCCESS) {
        return err_code;
    }
    nrf_drv_twi_enable(&m_twi);

    for (int i = 0; i < 10; i++) {
        err_code = nrf_drv_twi_tx(&m_twi, MIBOXER_7BIT_ADDR, init_cmd, sizeof(init_cmd), false);
        nrf_delay_ms(10);
        if (err_code == NRF_SUCCESS) {
            break;
        }
    }
    if (err_code != NRF_SUCCESS) {
        return err_code;
    }

    for (int i = 0; i < ARRAY_SIZE(init_data); i++) {
        err_code = nrf_drv_twi_tx(&m_twi, MIBOXER_7BIT_ADDR, init_data[i], sizeof(init_data[i]), false);
        if (err_code != NRF_SUCCESS) {
            return err_code;
        }
        nrf_delay_ms(10);
    }

    nrf_drv_twi_disable(&m_twi);
    nrf_drv_twi_uninit(&m_twi);

    m_state = MIBOXER_STATE_IDLE;

    return NRF_SUCCESS;
}


ret_code_t miboxer_start(void)
{
    m_last_btn_flags = 0;
    return gpio_enable();
}
