#include "string.h"
#include "freertos/FreeRTOS.h"
#include "freertos/timers.h"
#include "freertos/queue.h"
#include "esp_log.h"
#include "driver/gpio.h"
#include "driver/ledc.h"
#include "nvs_flash.h"

#include "main.h"
#include "pumps.h"

#define TAG     "PUMP!"

uint8_t running = 0;

typedef enum {
  PUMP_STATE_IDLE = 0,
  PUMP_STATE_RAMPING_UP,
  PUMP_STATE_RUNNING,
  PUMP_STATE_RAMPING_DOWN,
} pump_states_e;

TimerHandle_t pump_timers[PUMPS];
QueueHandle_t pump_step_queue;

static pump_states_e pump_states[PUMPS] = { PUMP_STATE_IDLE };
static uint8_t pumps_duration[PUMPS] = {0};
static uint8_t pumps_enabled[PUMPS] = {0};
static uint8_t pumps_running[PUMPS] = {0};
static uint8_t safety = 1;

#define RAMP_UP_TIME            (500)
#define RAMP_DOWN_TIME          (250)

#define LEDC_HS_TIMER           LEDC_TIMER_0
#define LEDC_HS_MODE            LEDC_HIGH_SPEED_MODE
#define LEDC_LS_TIMER           LEDC_TIMER_1
#define LEDC_LS_MODE            LEDC_LOW_SPEED_MODE

#define LEDC_CONFIG(CHANNEL_NO, GPIO) (ledc_channel_config_t){\
  .channel = CHANNEL_NO,\
  .duty = 0,\
  .gpio_num = GPIO,\
  .speed_mode = LEDC_LOW_SPEED_MODE,\
  .hpoint = 0,\
  .timer_sel = LEDC_TIMER_1,\
  .flags.output_invert = 0,\
}

ledc_channel_config_t ledc_motor_channels[4] = {};

void pumps_update_config() {
  ESP_LOGI(TAG, "writing config");

  size_t size = sizeof(uint8_t) * PUMPS;
  nvs_set_blob(config_handle, "pumps_duration", &pumps_duration, size);
  nvs_commit(config_handle);
}

uint8_t pumps_set_duration(uint8_t idx, uint8_t time) {
  if(idx > PUMPS) return PUMPS_ERR_OUT_IDX;

  ESP_LOGI(TAG, "duration update: %d = %d", idx, time);

  pumps_duration[idx] = time;

  pumps_update_config();

  return 0;
}

uint8_t pumps_get_duration(uint8_t idx) {
  return pumps_duration[idx];
}

uint8_t pumps_set_enabled(uint8_t idx, uint8_t value) {
  uint8_t io = pump_gpio_map[idx];

  value = (value ? 1 : 0);

  ESP_LOGI(TAG, "gpio: %d value: %d", io, value);
  // invert IO
  if(safety)
    gpio_set_level(io, value);

  return pumps_enabled[idx] = value;
}

uint8_t pumps_get_enabled(uint8_t idx) {
  return pumps_enabled[idx] ? 1 : 0;
}

uint8_t pumps_get_running(uint8_t idx) {
  return pumps_running[idx];
}

uint8_t pump_enable(int8_t i) {
  ESP_LOGI(TAG, "pump: %d enabled", i);

  return gpio_set_level(pump_gpio_map[i], 0);
}

uint8_t pump_disable(int8_t i) {
  ESP_LOGI(TAG, "pump: %d disabled", i);

  return gpio_set_level(pump_gpio_map[i], 0);
}

void pump_timer_done(TimerHandle_t timer) {
  uint8_t idx = (pcTimerGetName(timer) - 0x48);
  ESP_LOGD(TAG, "pump done: %d", idx);

  xQueueSend(pump_step_queue, &idx, portMAX_DELAY);
}

void pumps_stop() {
  for(uint8_t i = 0; i < PUMPS; i++) {
    if(pump_timers[i] != NULL) {
      pump_disable(i);
      xTimerStop(pump_timers[i], 0);
    }
  }
}

void pumps_run() {
  if(running > 0) return;

  ESP_LOGI(TAG, "Running pumps");

  for(uint8_t i = 0; i < PUMPS; i++) {
    //if(pumps_duration[i] == 0 || pumps_enabled[i] != 1) continue;

    if(pump_states[i] != PUMP_STATE_IDLE) {
      ESP_LOGW(TAG, "Attempting to start pump in non-IDLE state. idx: %d state: %d", i, pump_states[i]);
    }

    ledc_set_fade_with_time(ledc_motor_channels[i].speed_mode, ledc_motor_channels[i].channel, 8192, RAMP_UP_TIME);
    ledc_fade_start(ledc_motor_channels[i].speed_mode, ledc_motor_channels[i].channel, LEDC_FADE_NO_WAIT);

    pump_states[i] = PUMP_STATE_RAMPING_UP;

    running++;
    ESP_LOGI(TAG, "Pump %d started", i);
  }
}

void pump_step_task() {
  uint8_t idx;
  BaseType_t awoke = pdFALSE;

  ESP_LOGI(TAG, "Starting pump stepping task");

  while(xQueueReceive(pump_step_queue, &idx, &awoke)) {
    ESP_LOGI(TAG, "step %d complete for %d", pump_states[idx], idx);

    if(pump_states[idx] == PUMP_STATE_RAMPING_UP) {
      uint16_t pump_time = pumps_duration[idx] * 250 - (RAMP_UP_TIME + RAMP_DOWN_TIME) / 2;

      if(RAMP_UP_TIME + RAMP_DOWN_TIME / 2 > pumps_duration[idx] * 250) {
        ESP_LOGW(TAG, "Pump %d total ramp time great that duration, running for 1 Tick", idx);

        pump_time = 10;
      }

      ESP_LOGI(TAG, "Running pump %d for %dms", idx, pump_time);

      xTimerChangePeriod(pump_timers[idx], pump_time / portTICK_PERIOD_MS, portMAX_DELAY);
      xTimerStart(pump_timers[idx], portMAX_DELAY);

      pump_states[idx] = PUMP_STATE_RUNNING;

      continue;
    } else if(pump_states[idx] == PUMP_STATE_RUNNING) {
      ledc_set_fade_with_time(ledc_motor_channels[idx].speed_mode, ledc_motor_channels[idx].channel, 0, RAMP_UP_TIME);
      ledc_fade_start(ledc_motor_channels[idx].speed_mode, ledc_motor_channels[idx].channel, LEDC_FADE_NO_WAIT);

      pump_states[idx] = PUMP_STATE_RAMPING_DOWN;
      continue;
    } else if(pump_states[idx] == PUMP_STATE_RAMPING_DOWN) {
      ESP_LOGI(TAG, "Pump cycles complete: %d", idx);
      pump_states[idx] = PUMP_STATE_IDLE;

      running--;
    } else {
      ESP_LOGE(TAG, "Pump step fired with unknown state: %d", pump_states[idx]);
    }
  }
}

static IRAM_ATTR bool ledc_fade_end_event(const ledc_cb_param_t *param, void *parg) {
  BaseType_t awoke = pdFALSE;

  xQueueSendFromISR(pump_step_queue, parg, &awoke);

  return (awoke == pdTRUE);
}

uint8_t pumps_io_init() {
  gpio_config_t io_conf;

  for(uint8_t i = 0 ; i < PUMPS; i++) {
    gpio_set_level(pump_gpio_map[i], 0);
  }

  io_conf.intr_type = GPIO_INTR_DISABLE;
  io_conf.mode = GPIO_MODE_OUTPUT;
  io_conf.pin_bit_mask = GPIO_PUMP_PIN_SEL;
  io_conf.pull_down_en = 1;
  io_conf.pull_up_en = 0;

  return gpio_config(&io_conf);
}

uint8_t pumps_init() {
  // zero out pump enabled, duration
  memset(&pumps_enabled, 0, sizeof(uint8_t) * PUMPS);
  memset(&pumps_duration, 5, sizeof(uint8_t) * PUMPS);

  // this should neve go above 4, but just in case?
  pump_step_queue = xQueueCreate(PUMPS * 4, sizeof(uint8_t));

  size_t size = sizeof(uint8_t) * PUMPS;
  if(!nvs_get_blob(config_handle, "pumps_duration", &pumps_duration, &size)) {
    ESP_LOGI(TAG, "Initializing pumps config");

    nvs_set_blob(config_handle, "pumps_duration", &pumps_duration, size);
  };

  ledc_timer_config_t ledc_timer = {
    .duty_resolution = LEDC_TIMER_13_BIT, // resolution of PWM duty
    .freq_hz = 4000,                      // frequency of PWM signal
    .speed_mode = LEDC_LS_MODE,           // timer mode
    .timer_num = LEDC_LS_TIMER,            // timer index
    .clk_cfg = LEDC_AUTO_CLK,              // Auto select the source clock
  };

  ledc_timer_config(&ledc_timer);

  ledc_timer.speed_mode = LEDC_HS_MODE;
  ledc_timer.timer_num = LEDC_HS_TIMER;

  ledc_timer_config(&ledc_timer);

  for(uint8_t i = 0; i < PUMPS; i++) {
    gpio_set_level(pump_gpio_map[i], 0);

    pump_timers[i] = xTimerCreate((const char *)(0x48 + i), 1, pdFALSE, (void*)0, pump_timer_done);
  }

  for(uint8_t i = 0; i < PUMPS; i++) {
    ledc_motor_channels[i] = LEDC_CONFIG(i, pump_gpio_map[i]);
    ledc_channel_config(&ledc_motor_channels[i]);
  }

  ledc_cbs_t callbacks = {
    .fade_cb = ledc_fade_end_event
  };

  ledc_fade_func_install(0);

  uint8_t *idx;

  for(uint8_t i = 0; i < PUMPS; i++) {
    idx = malloc(1);
    memcpy(idx, &i, 1);
    ledc_cb_register(ledc_motor_channels[i].speed_mode, ledc_motor_channels[i].channel, &callbacks, idx);
  }

  ESP_LOGI(TAG, "pumps_enabled: %d %d %d %d", pumps_enabled[0], pumps_enabled[1], pumps_enabled[2], pumps_enabled[3]);
  ESP_LOGI(TAG, "pumps_duration: %d %d %d %d", pumps_duration[0], pumps_duration[1], pumps_duration[2], pumps_duration[3]);

  xTaskCreate(pump_step_task, "ramp", 4024, NULL, tskIDLE_PRIORITY + 4, NULL);

  return 0;
}