#ifndef I2C_HELPERS_H
#define I2C_HELPERS_H

#include "hal.h"
#include "bswap.h"


typedef struct {
    /**
     * @brief Pointer to the I2C driver.
     */
    I2CDriver *driver;
    /**
     * @brief I2C address.
     */
    i2caddr_t addr;
} I2CHelper;



#if !defined(I2C_HELPERS_AUTOMATIC_DRV) || (I2C_HELPERS_AUTOMATIC_DRV == FALSE)

#define i2c_send(i2c, txbuf, txbytes)					\
    _i2c_send(i2c, txbuf, txbytes)
#define i2c_transmit(i2c, txbuf, txbytes, rxbuf, rxbytes)		\
    _i2c_transmit(i2c, txbuf, txbytes, rxbuf, rxbytes)
#define i2c_receive(i2, rxbuf, rxbytes)					\
    _i2c_receive(i2c, rxbuf, rxbytes)

#define i2c_send_timeout(i2c, txbuf, txbytes)				\
    _i2c_send(i2c, txbuf, txbytes)
#define i2c_transmit_timeout(i2c, txbuf, txbytes, rxbuf, rxbytes)	\
    _i2c_transmit(i2c, txbuf, txbytes, rxbuf, rxbytes)
#define i2c_receive_timeout(i2, rxbuf, rxbytes)				\
    _i2c_receive(i2c, rxbuf, rxbytes)

#define i2c_reg(i2c, reg)						\
    _i2c_reg(i2c, reg) 

#define i2c_reg_recv8(i2c, reg, val)					\
    _i2c_reg_recv8(i2c, reg, val)		
#define i2c_reg_recv16(i2c, reg, val)					\
    _i2c_reg_recv16(i2c, reg, val)		
#define i2c_reg_recv16_le(i2c, reg, val)				\
    _i2c_reg_recv16_le(i2c, reg, val)
#define i2c_reg_recv16_be(i2c, reg, val)				\
    _i2c_reg_recv16_be(i2c, reg, val) 
#define i2c_reg_recv32(i2c, reg, val)					\
    _i2c_reg_recv32(i2c, reg, val)
#define i2c_reg_recv32_le(i2c, reg, val)				\
    _i2c_reg_recv32_le(i2c, reg, val)
#define i2c_reg_recv32_be(i2c, reg, val)				\
    _i2c_reg_recv32_be(i2c, reg, val)

#define i2c_recv8(i2c, val)						\
    _i2c_recv8(i2c, val)		
#define i2c_recv16(i2c, val)						\
    _i2c_recv16(i2c, val)		
#define i2c_recv16_le(i2c, val)						\
    _i2c_recv16_le(i2c, val)
#define i2c_recv16_be(i2c, val)						\
    _i2c_recv16_be(i2c, val) 
#define i2c_recv32(i2c, val)						\
    _i2c_recv32(i2c, val)
#define i2c_recv32_le(i2c, val)						\
    _i2c_recv32_le(i2c, val)
#define i2c_recv32_be(i2c, val)						\
    _i2c_recv32_be(i2c, val)

#else

#define i2c_send(txbuf, txbytes)					\
    _i2c_send(&drv->config->i2c, txbuf, txbytes)
#define i2c_transmit(txbuf, txbytes, rxbuf, rxbytes)			\
    _i2c_transmit(&drv->config->i2c, txbuf, txbytes, rxbuf, rxbytes)
#define i2c_receive(rxbuf, rxbytes)					\
    _i2c_receive(&drv->config->i2c, rxbuf, rxbytes)

#define i2c_send_timeout(txbuf, txbytes)				\
    _i2c_send(&drv->config->i2c, txbuf, txbytes)
#define i2c_transmit_timeout(txbuf, txbytes, rxbuf, rxbytes)	\
    _i2c_transmit(&drv->config->i2c, txbuf, txbytes, rxbuf, rxbytes)
#define i2c_receive_timeout(rxbuf, rxbytes)				\
    _i2c_receive(&drv->config->i2c, rxbuf, rxbytes)


#define i2c_reg(reg)							\
    _i2c_reg(&drv->config->i2c, reg) 

#define i2c_reg_recv8(reg, val)						\
    _i2c_reg_recv8(&drv->config->i2c, reg, val)		
#define i2c_reg_recv16(reg, val)					\
    _i2c_reg_recv16(&drv->config->i2c, reg, val)		
#define i2c_reg_recv16_le(reg, val)					\
    _i2c_reg_recv16_le(&drv->config->i2c, reg, val)
#define i2c_reg_recv16_be(reg, val)					\
    _i2c_reg_recv16_be(&drv->config->i2c, reg, val) 
#define i2c_reg_recv32(reg, val)					\
    _i2c_reg_recv32(&drv->config->i2c, reg, val)
#define i2c_reg_recv32_le(reg, val)					\
    _i2c_reg_recv32_le(&drv->config->i2c, reg, val)
#define i2c_reg_recv32_be(reg, val)					\
    _i2c_reg_recv32_be(&drv->config->i2c, reg, val)

#define i2c_recv8(val)							\
    _i2c_recv8(&drv->config->i2c, val)		
#define i2c_recv16(val)							\
    _i2c_recv16(&drv->config->i2c, val)		
#define i2c_recv16_le(val)						\
    _i2c_recv16_le(&drv->config->i2c, val)
#define i2c_recv16_be(val)						\
    _i2c_recv16_be(&drv->config->i2c, val) 
#define i2c_recv32(val)							\
    _i2c_recv32(&drv->config->i2c, val)
#define i2c_recv32_le(val)						\
    _i2c_recv32_le(&drv->config->i2c, val)
#define i2c_recv32_be(val)						\
    _i2c_recv32_be(&drv->config->i2c, val)

#endif





static inline msg_t
_i2c_send(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes) {
    return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
			    txbuf, txbytes, NULL, 0, TIME_INFINITE);
};

static inline msg_t
_i2c_transmit(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes,
	     uint8_t *rxbuf, size_t rxbytes) {
    return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
			    txbuf, txbytes, rxbuf, rxbytes, TIME_INFINITE);
}

static inline msg_t
_i2c_receive(I2CHelper *i2c, uint8_t *rxbuf, size_t rxbytes) {
    return i2cMasterReceiveTimeout(i2c->driver, i2c->addr,
			    rxbuf, rxbytes, TIME_INFINITE);
};



static inline msg_t
_i2c_send_timeout(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes,
		 systime_t timeout) {
    return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
				    txbuf, txbytes, NULL, 0, timeout);
};

static inline msg_t
_i2c_transmit_timeout(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes,
		     uint8_t *rxbuf, size_t rxbytes, systime_t timeout) {
    return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
				    txbuf, txbytes, rxbuf, rxbytes, timeout);
}

static inline msg_t
_i2c_receive_timeout(I2CHelper *i2c, uint8_t *rxbuf, size_t rxbytes, systime_t timeout) {
    return i2cMasterReceiveTimeout(i2c->driver, i2c->addr,
			    rxbuf, rxbytes, timeout);
};


/*======================================================================*/


static inline msg_t
_i2c_reg(I2CHelper *i2c, uint8_t reg) {
    return _i2c_transmit(i2c, &reg, sizeof(reg), NULL, 0);
};

/*======================================================================*/

static inline msg_t
_i2c_reg_recv8(I2CHelper *i2c, uint8_t reg, uint8_t *val) {
    return _i2c_transmit(i2c, &reg, sizeof(reg), (uint8_t*)val, sizeof(val));
};

static inline msg_t
_i2c_reg_recv16(I2CHelper *i2c, uint8_t reg, uint16_t *val) {
    return _i2c_transmit(i2c, &reg, sizeof(reg), (uint8_t*)val, sizeof(val));
};

static inline msg_t
_i2c_reg_recv16_le(I2CHelper *i2c, uint8_t reg, uint16_t *val) {
    int msg = _i2c_reg_recv16(i2c, reg, val);
    if (msg >= 0) *val = le16_to_cpu(*val);
    return msg;
};

static inline msg_t
_i2c_reg_recv16_be(I2CHelper *i2c, uint8_t reg, uint16_t *val) {
    int msg = _i2c_reg_recv16(i2c, reg, val);
    if (msg >= 0) *val = be16_to_cpu(*val);
    return msg;
};    

static inline msg_t
_i2c_reg_recv32(I2CHelper *i2c, uint8_t reg, uint32_t *val) {
    return _i2c_transmit(i2c, &reg, sizeof(reg), (uint8_t*)val, sizeof(val));
};

static inline msg_t
_i2c_reg_recv32_le(I2CHelper *i2c, uint8_t reg, uint32_t *val) {
    int msg = _i2c_reg_recv32(i2c, reg, val);
    if (msg >= 0) *val = le32_to_cpu(*val);
    return msg;
};

static inline msg_t
_i2c_reg_recv32_be(I2CHelper *i2c, uint8_t reg, uint32_t *val) {
    int msg = _i2c_reg_recv32(i2c, reg, val);
    if (msg >= 0) *val = be32_to_cpu(*val);
    return msg;
};


/*======================================================================*/

static inline msg_t
_i2c_recv8(I2CHelper *i2c, uint8_t *val) {
    return _i2c_receive(i2c, (uint8_t*)val, sizeof(val));
};

static inline msg_t
_i2c_recv16(I2CHelper *i2c, uint16_t *val) {
    return _i2c_receive(i2c, (uint8_t*)val, sizeof(val));
};

static inline msg_t
_i2c_recv16_le(I2CHelper *i2c, uint16_t *val) {
    int msg = _i2c_recv16(i2c, val);
    if (msg >= 0) *val = le16_to_cpu(*val);
    return msg;
};

static inline msg_t
_i2c_recv16_be(I2CHelper *i2c, uint16_t *val) {
    int msg = _i2c_recv16(i2c, val);
    if (msg >= 0) *val = be16_to_cpu(*val);
    return msg;
};

static inline msg_t
_i2c_recv32(I2CHelper *i2c, uint32_t *val) {
    return _i2c_receive(i2c, (uint8_t*)val, sizeof(val));
};

static inline msg_t
_i2c_recv32_le(I2CHelper *i2c, uint32_t *val) {
    int msg = _i2c_recv32(i2c, val);
    if (msg >= 0) *val = le32_to_cpu(*val);
    return msg;
};

static inline msg_t
_i2c_recv32_be(I2CHelper *i2c, uint32_t *val) {
    int msg = _i2c_recv32(i2c, val);
    if (msg >= 0) *val = be32_to_cpu(*val);
    return msg;
};

#endif