#include <stdio.h>
#include <string.h>

#include "esp_log.h"
#include "i2c_mutex.h"
#include "sdkconfig.h"

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "u8g2_esp32_hal.h"

static const char *TAG = "u8g2_hal";
static const unsigned int I2C_TIMEOUT_MS = 100;

static spi_device_handle_t handle_spi;  // SPI handle.
static i2c_cmd_handle_t handle_i2c;     // I2C handle.

#undef ESP_ERROR_CHECK
#define ESP_ERROR_CHECK(x)                                            \
  do {                                                                \
    esp_err_t _rc = (x);                                              \
    if (_rc != ESP_OK) {                                              \
      const char *_error_name = esp_err_to_name(_rc);                 \
      ESP_LOGE(TAG, "%s:%d failed: %s (%#x)", __FUNCTION__, __LINE__, \
               _error_name, _rc);                                     \
      return 0;                                                       \
    }                                                                 \
  } while (0);

/*
 * HAL callback function as prescribed by the U8G2 library.  This callback is
 * invoked to handle SPI communications.
 */
uint8_t u8g2_esp32_spi_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
                               void *arg_ptr) {
  ESP_LOGV(TAG, "spi_byte_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p",
           msg, arg_int, arg_ptr);
  switch (msg) {
    case U8X8_MSG_BYTE_SET_DC:
      if (u8x8->pins[U8X8_PIN_DC] != U8X8_PIN_NONE) {
        gpio_set_level(u8x8->pins[U8X8_PIN_DC], arg_int);
      }
      break;

    case U8X8_MSG_BYTE_INIT: {
      if (u8x8->pins[U8X8_PIN_SPI_CLOCK] == U8X8_PIN_NONE ||
          u8x8->pins[U8X8_PIN_SPI_DATA] == U8X8_PIN_NONE ||
          u8x8->pins[U8X8_PIN_CS] == U8X8_PIN_NONE) {
        break;
      }

      spi_bus_config_t bus_config;
      memset(&bus_config, 0, sizeof(spi_bus_config_t));
      bus_config.sclk_io_num = u8x8->pins[U8X8_PIN_SPI_CLOCK];  // CLK
      bus_config.mosi_io_num = u8x8->pins[U8X8_PIN_SPI_DATA];   // MOSI
      bus_config.miso_io_num = -1;                              // MISO
      bus_config.quadwp_io_num = -1;                            // Not used
      bus_config.quadhd_io_num = -1;                            // Not used
      // ESP_LOGI(TAG, "... Initializing bus.");
      ESP_ERROR_CHECK(spi_bus_initialize(HSPI_HOST, &bus_config, 1));

      spi_device_interface_config_t dev_config;
      dev_config.address_bits = 0;
      dev_config.command_bits = 0;
      dev_config.dummy_bits = 0;
      dev_config.mode = 0;
      dev_config.duty_cycle_pos = 0;
      dev_config.cs_ena_posttrans = 0;
      dev_config.cs_ena_pretrans = 0;
      dev_config.clock_speed_hz = 10000;
      dev_config.spics_io_num = u8x8->pins[U8X8_PIN_CS];
      dev_config.flags = 0;
      dev_config.queue_size = 200;
      dev_config.pre_cb = NULL;
      dev_config.post_cb = NULL;
      // ESP_LOGI(TAG, "... Adding device bus.");
      ESP_ERROR_CHECK(spi_bus_add_device(HSPI_HOST, &dev_config, &handle_spi));

      break;
    }

    case U8X8_MSG_BYTE_SEND: {
      spi_transaction_t trans_desc;
      trans_desc.addr = 0;
      trans_desc.cmd = 0;
      trans_desc.flags = 0;
      trans_desc.length = 8 * arg_int;  // Number of bits NOT number of bytes.
      trans_desc.rxlength = 0;
      trans_desc.tx_buffer = arg_ptr;
      trans_desc.rx_buffer = NULL;

      // ESP_LOGI(TAG, "... Transmitting %d bytes.", arg_int);
      ESP_ERROR_CHECK(spi_device_transmit(handle_spi, &trans_desc));
      break;
    }
  }
  return 0;
}  // u8g2_esp32_spi_byte_cb

/*
 * HAL callback function as prescribed by the U8G2 library.  This callback is
 * invoked to handle I2C communications.
 */
uint8_t u8g2_esp32_i2c_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
                               void *arg_ptr) {
#define TXBUF_SIZE 32
  static uint8_t txbuf[TXBUF_SIZE];
  static uint8_t *txbuf_ptr;
  // ESP_LOGV(TAG, "i2c_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg,
  //   arg_int, arg_ptr);
  switch (msg) {
    case U8X8_MSG_BYTE_SET_DC: {
      if (u8x8->pins[U8X8_PIN_DC] != U8X8_PIN_NONE) {
        gpio_set_level(u8x8->pins[U8X8_PIN_DC], arg_int);
      }
      break;
    }

    case U8X8_MSG_BYTE_INIT: {
      if (u8x8->pins[U8X8_PIN_I2C_DATA] == U8X8_PIN_NONE ||
          u8x8->pins[U8X8_PIN_I2C_CLOCK] == U8X8_PIN_NONE) {
        ESP_LOGE(TAG, "i2c_byte_cb: missing pins");
        break;
      }

      break;
      i2c_config_t conf;
      conf.mode = I2C_MODE_MASTER;
      conf.sda_io_num = u8x8->pins[U8X8_PIN_I2C_DATA];
      conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
      conf.scl_io_num = u8x8->pins[U8X8_PIN_I2C_CLOCK];
      conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
      ESP_LOGV(TAG, "clk_speed %d", I2C_MASTER_FREQ_HZ);
      conf.master.clk_speed = I2C_MASTER_FREQ_HZ;
      ESP_ERROR_CHECK(i2c_param_config(I2C_MASTER_NUM, &conf));
      ESP_ERROR_CHECK(i2c_driver_install(
          I2C_MASTER_NUM, conf.mode, I2C_MASTER_RX_BUF_DISABLE,
          I2C_MASTER_TX_BUF_DISABLE,
          ESP_INTR_FLAG_IRAM | ESP_INTR_FLAG_LEVEL1));
      ESP_LOGI(TAG, "i2c_byte_cb: BYTE_INIT sda_io_num: %d, scl_io_num: %d",
               conf.sda_io_num, conf.scl_io_num);
      break;
    }

    case U8X8_MSG_BYTE_SEND: {
      uint8_t *data_ptr = (uint8_t *)arg_ptr;
      size_t data_len = (size_t)arg_int;
      // ESP_LOGV(TAG, "U8x8_MSG_BYTE_SEND. txbuf len: %d", txbuf_ptr - txbuf);
      // ESP_LOG_BUFFER_HEXDUMP(TAG, data_ptr, data_len, ESP_LOG_VERBOSE);

      if (txbuf_ptr + data_len >= txbuf_ptr + TXBUF_SIZE) {
        ESP_LOGE(TAG, "txbuf overflow");
        return 0;
      }
      memcpy(txbuf_ptr, data_ptr, data_len);
      txbuf_ptr += data_len;
      break;
    }

    case U8X8_MSG_BYTE_START_TRANSFER: {
      uint8_t i2c_address = u8x8_GetI2CAddress(u8x8);
      handle_i2c = i2c_cmd_link_create();
      // ESP_LOGV(TAG, "Start I2C transfer to %02X.", i2c_address >> 1);
      ESP_ERROR_CHECK(i2c_master_start(handle_i2c));
      ESP_ERROR_CHECK(i2c_master_write_byte(
          handle_i2c, i2c_address | I2C_MASTER_WRITE, ACK_CHECK_EN));
      txbuf_ptr = txbuf;
      break;
    }

    case U8X8_MSG_BYTE_END_TRANSFER: {
      ESP_LOGV(TAG, "end I2C transfer. txbuf len: %d", txbuf_ptr - txbuf);
      // ESP_LOG_BUFFER_HEXDUMP(TAG, txbuf, txbuf_ptr - txbuf, ESP_LOG_VERBOSE);
      ESP_ERROR_CHECK(
          i2c_master_write(handle_i2c, txbuf, txbuf_ptr - txbuf, ACK_CHECK_EN));
      ESP_ERROR_CHECK(i2c_master_stop(handle_i2c));
      xSemaphoreTake(i2c_mutex, portMAX_DELAY);
      esp_err_t ret = i2c_master_cmd_begin(I2C_MASTER_NUM, handle_i2c,
                                           I2C_TIMEOUT_MS / portTICK_RATE_MS);
      xSemaphoreGive(i2c_mutex);
      ESP_ERROR_CHECK(ret);
      i2c_cmd_link_delete(handle_i2c);
      break;
    }
    default:
      ESP_LOGW(TAG,
               "i2c_byte_cb: Received an unimplemented msg: %d, arg_int: "
               "%d, arg_ptr: %p",
               msg, arg_int, arg_ptr);
      return 0;
  }
  return 1;
}  // u8g2_esp32_i2c_byte_cb

/*
 * HAL callback function as prescribed by the U8G2 library.  This callback is
 * invoked to handle callbacks for GPIO and delay functions.
 */
uint8_t u8g2_esp32_gpio_and_delay_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
                                     void *arg_ptr) {
  ESP_LOGV(TAG,
           "gpio_and_delay_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p",
           msg, arg_int, arg_ptr);

  switch (msg) {
      // Initialize the GPIO and DELAY HAL functions.  If the pins for DC and
      // RESET have been specified then we define those pins as GPIO outputs.
    case U8X8_MSG_GPIO_AND_DELAY_INIT: {
      uint64_t bitmask = 0;
      uint8_t dc = u8x8->pins[U8X8_PIN_DC];
      uint8_t reset = u8x8->pins[U8X8_PIN_RESET];
      uint8_t cs = u8x8->pins[U8X8_PIN_CS];
      if (dc != U8X8_PIN_NONE) {
        bitmask = bitmask | (1ull << dc);
      }
      if (reset != U8X8_PIN_NONE) {
        bitmask = bitmask | (1ull << reset);
      }
      if (cs != U8X8_PIN_NONE) {
        bitmask = bitmask | (1ull << cs);
      }
      ESP_LOGV(TAG, "GPIO_AND_DELAY_INIT: dc=%d, reset=%d, cs=%d", dc, reset,
               cs);

      if (bitmask == 0) {
        break;
      }
      gpio_config_t gpioConfig;
      gpioConfig.pin_bit_mask = bitmask;
      gpioConfig.mode = GPIO_MODE_OUTPUT;
      gpioConfig.pull_up_en = GPIO_PULLUP_DISABLE;
      gpioConfig.pull_down_en = GPIO_PULLDOWN_ENABLE;
      gpioConfig.intr_type = GPIO_INTR_DISABLE;
      gpio_config(&gpioConfig);
      break;
    }

      // Set the GPIO reset pin to the value passed in through arg_int.
    case U8X8_MSG_GPIO_RESET:
      if (u8x8->pins[U8X8_PIN_RESET] != U8X8_PIN_NONE) {
        gpio_set_level(u8x8->pins[U8X8_PIN_RESET], arg_int);
      }
      break;
      // Set the GPIO client select pin to the value passed in through arg_int.
    case U8X8_MSG_GPIO_CS:
      if (u8x8->pins[U8X8_PIN_CS] != U8X8_PIN_NONE) {
        gpio_set_level(u8x8->pins[U8X8_PIN_CS], arg_int);
      }
      break;
      // Set the Software I²C pin to the value passed in through arg_int.
    case U8X8_MSG_GPIO_I2C_CLOCK:
      if (u8x8->pins[U8X8_PIN_I2C_CLOCK] != U8X8_PIN_NONE) {
        gpio_set_level(u8x8->pins[U8X8_PIN_I2C_CLOCK], arg_int);
        //				printf("%c",(arg_int==1?'C':'c'));
      }
      break;
      // Set the Software I²C pin to the value passed in through arg_int.
    case U8X8_MSG_GPIO_I2C_DATA:
      if (u8x8->pins[U8X8_PIN_I2C_DATA] != U8X8_PIN_NONE) {
        gpio_set_level(u8x8->pins[U8X8_PIN_I2C_DATA], arg_int);
        //				printf("%c",(arg_int==1?'D':'d'));
      }
      break;

      // Delay for the number of milliseconds passed in through arg_int.
    case U8X8_MSG_DELAY_MILLI: vTaskDelay(arg_int / portTICK_PERIOD_MS); break;
    default:
      ESP_LOGW(TAG,
               "gpio_and_delay_cb: Received an unimplemented msg: %d, arg_int: "
               "%d, arg_ptr: %p",
               msg, arg_int, arg_ptr);
      return 0;
  }
  return 1;
}  // u8g2_esp32_gpio_and_delay_cb