#include <stdio.h>
#include <stdint.h>

#include "driver/gpio.h"
#include "driver/gptimer.h"
#include "esp_err.h"
#include "esp_random.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "driver/ledc.h"
#include "hal/ledc_types.h"
#include "hal/timer_types.h"
#include "soc/clk_tree_defs.h"

#define SEQ_MAX_LEN 8

/* Inputs */
// Clock In
// Reset In

/* Outputs */
#define GPIO_CLK_OUT (7) // Clock Out
#define GPIO_GATE_OUT (8) // Gate CV Out

/* LED GPIO Pins */
#define LEDC_CLK_OUT (5)
#define LEDC_GATE_OUT (6)

gptimer_handle_t clk_blink_timer = NULL;
gptimer_handle_t gate_blink_timer = NULL;

static void gpio_init(void) {
  // Setup Clock CV Output
  gpio_reset_pin(GPIO_CLK_OUT);
  gpio_set_direction(GPIO_CLK_OUT, GPIO_MODE_OUTPUT);
  // Setup Gate CV Output
  gpio_reset_pin(GPIO_GATE_OUT);
  gpio_set_direction(GPIO_GATE_OUT, GPIO_MODE_OUTPUT);
}

static void gate_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) {
  gptimer_stop(gate_blink_timer);
  ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, 0));
  ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1));
}

static void clk_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) {
  gptimer_stop(clk_blink_timer);
  ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0));
  ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0));
}

static void ledc_init(void) {
  // Setup LEDC PWM timer configuration
  ledc_timer_config_t ledc_timer = {
    .speed_mode = LEDC_LOW_SPEED_MODE,
    .timer_num = LEDC_TIMER_0,
    .duty_resolution = LEDC_TIMER_13_BIT,
    .freq_hz = 5000,
    .clk_cfg = LEDC_AUTO_CLK
  };
  ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));

  // Setup Clock LED
  ledc_channel_config_t ledc_clk_channel = {
    .channel = LEDC_CHANNEL_0,
    .gpio_num = LEDC_CLK_OUT,
    .speed_mode = LEDC_LOW_SPEED_MODE,
    .timer_sel = LEDC_TIMER_0,
    .intr_type = LEDC_INTR_DISABLE,
    .duty = 0,
    .hpoint = 0
  };
  ESP_ERROR_CHECK(ledc_channel_config(&ledc_clk_channel));

  // Setup Gate LED
  ledc_channel_config_t ledc_gate_channel = {
    .channel = LEDC_CHANNEL_1,
    .gpio_num = LEDC_GATE_OUT,
    .speed_mode = LEDC_LOW_SPEED_MODE,
    .timer_sel = LEDC_TIMER_0,
    .intr_type = LEDC_INTR_DISABLE,
    .duty = 0,
    .hpoint = 0
  };
  ESP_ERROR_CHECK(ledc_channel_config(&ledc_gate_channel));

  // Setup LED blink timer
  gptimer_config_t led_blink_timer_config = {
    .clk_src = GPTIMER_CLK_SRC_DEFAULT,
    .direction = GPTIMER_COUNT_UP,
    .resolution_hz = 1 * 1000 * 1000 // 1MHz; 1 tick = 1 µs
  };
  ESP_ERROR_CHECK(gptimer_new_timer(&led_blink_timer_config, &clk_blink_timer));
  ESP_ERROR_CHECK(gptimer_new_timer(&led_blink_timer_config, &gate_blink_timer));

  // Configure timer alarm
  gptimer_alarm_config_t led_off_alarm_config = {
    .alarm_count = 100 * 1000, // 50ms @ 1MHz
    .reload_count = 0,
    .flags.auto_reload_on_alarm = true
  };
  ESP_ERROR_CHECK(gptimer_set_alarm_action(clk_blink_timer, &led_off_alarm_config));
  ESP_ERROR_CHECK(gptimer_set_alarm_action(gate_blink_timer, &led_off_alarm_config));

  //register clk callback
  gptimer_event_callbacks_t clk_cbs = {.on_alarm = clk_off_alarm_cb};
  ESP_ERROR_CHECK(
      gptimer_register_event_callbacks(clk_blink_timer, &clk_cbs, NULL));
  ESP_ERROR_CHECK(gptimer_enable(clk_blink_timer));

  // register gate callback
  gptimer_event_callbacks_t gate_cbs = {.on_alarm = gate_off_alarm_cb};
  ESP_ERROR_CHECK(
      gptimer_register_event_callbacks(gate_blink_timer, &gate_cbs, NULL));
  ESP_ERROR_CHECK(gptimer_enable(gate_blink_timer));
}

static void blink_led(ledc_channel_t channel) {
  ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, channel, 9000));
  ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, channel));

  if (channel == LEDC_CHANNEL_0) {
    ESP_ERROR_CHECK(gptimer_start(clk_blink_timer));
  } else if (channel == LEDC_CHANNEL_1) {
    ESP_ERROR_CHECK(gptimer_start(gate_blink_timer));
  }
}

static void pulse_cv(uint8_t gpio_num) {
  gpio_set_level(gpio_num, 1);
  vTaskDelay(20 / portTICK_PERIOD_MS);
  gpio_set_level(gpio_num, 0);
}

static void gen_rand_seq(uint8_t *sequence) {
  for (uint8_t i = 0; i < SEQ_MAX_LEN; i++) {
    sequence[i] = esp_random() % 2;
  }
}

void app_main(void) {
  /* Initialize Peripherals */
  /* Initialize GPIO */
  gpio_init();
  /* Initialize Monitor LEDs */
  ledc_init();
  /* Initialize sequence */
  uint8_t sequence[SEQ_MAX_LEN] = {0};
  uint8_t seq_len = SEQ_MAX_LEN;

  /* Main Loop */
  while (1) {
    for (uint8_t step = 0; step < seq_len; step++) {

      blink_led(LEDC_CHANNEL_0); // blink clock led
      pulse_cv(GPIO_CLK_OUT);

      // if step has been set for sequence
      if (sequence[step] == 1) {
        pulse_cv(GPIO_GATE_OUT);
        blink_led(LEDC_CHANNEL_1); // blink gate triggered led
      }
      printf("%i", sequence[step]);
      vTaskDelay(500 / portTICK_PERIOD_MS);
    }
    gen_rand_seq(sequence);
    printf("\n");

  }
}