#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include <driver/gpio.h>
#include <esp_system.h>
#include <stdio.h>

#define GPIO_RED_ALARM GPIO_NUM_32
#define GPIO_BLUE_ALARM GPIO_NUM_33
#define GPIO_RED_ACK GPIO_NUM_19
#define GPIO_BLUE_ACK GPIO_NUM_18
#define GPIO_RED_LED GPIO_NUM_17
#define GPIO_BLUE_LED GPIO_NUM_16

void setup() {
  printf("Initializing GPIO...\n");
  gpio_set_direction(GPIO_RED_ALARM, GPIO_MODE_INPUT);
  gpio_set_direction(GPIO_BLUE_ALARM, GPIO_MODE_INPUT);
  gpio_set_direction(GPIO_RED_ACK, GPIO_MODE_INPUT);
  gpio_set_direction(GPIO_BLUE_ACK, GPIO_MODE_INPUT);
  gpio_set_direction(GPIO_RED_LED, GPIO_MODE_OUTPUT);
  gpio_set_direction(GPIO_BLUE_LED, GPIO_MODE_OUTPUT);
  printf("Initialization done...\n");
}

// Handles to enable easy cancellation fo the tasks
TaskHandle_t redLedTaskHandle;
TaskHandle_t blueLedTaskHandle;

/*
Check red alarm button state and raise the alarm condition accordingly.
*/
void controlTaskRed(void *pvParams) {
  int red_alarm_last_state = 1;
  int red_alarm_state = 1;

  // Normal debounced button state check loop using task delays
  for (;;) {
    red_alarm_state = gpio_get_level(GPIO_RED_ALARM);

    if (red_alarm_state != red_alarm_last_state && red_alarm_state == 0) {
      printf("Detected falling edge in red alarm button.\n");
      printf("Starting the red alarm blink task.\n");
      xTaskCreate(&blinkTaskRed, "blink_task_red", 2048, NULL,
                  3, // red LED with higher priority than blue
                  &redLedTaskHandle);
    }
    vTaskDelay(pdMS_TO_TICKS(10)); // 10 ms delay is fine for normal usage.

    red_alarm_last_state = red_alarm_state;
  }
}

/*
Check blue alarm button state and rais ethe alarm condition accordingly.
*/
void controlTaskBlue(void *pvParams) {
  int blue_alarm_last_state = 1;
  int blue_alarm_state = 1;

  // Normal debounced button state check loop using task delays
  for (;;) {
    blue_alarm_state = gpio_get_level(GPIO_BLUE_ALARM);

    if (blue_alarm_state != blue_alarm_last_state && blue_alarm_state == 0) {
      printf("Detected falling edge in blue alarm button.\n");
      printf("Starting the blue alarm blink task.\n");

      xTaskCreate(&blinkTaskBlue, "blink_task_blue", 2048, NULL,
                  2, // lowest priority for the blue LED
                  &blueLedTaskHandle);
    }
    vTaskDelay(pdMS_TO_TICKS(10)); // 10 ms delay is fine for normal usage.

    blue_alarm_last_state = blue_alarm_state;
  }
}

/*
Blink the red alarm led according to the alarm condition.
*/
void blinkTaskRed(void *pvParams) {
  for (;;) {
    gpio_set_level(GPIO_RED_LED, 1);
    vTaskDelay(pdMS_TO_TICKS(250));
    gpio_set_level(GPIO_RED_LED, 0);
    vTaskDelay(pdMS_TO_TICKS(250));
  }
}

/*
Blink the blue alarm led according to the alarm condition.
*/
void blinkTaskBlue(void *pvParams) {
  for (;;) {
    gpio_set_level(GPIO_BLUE_LED, 1);
    vTaskDelay(pdMS_TO_TICKS(1000));
    gpio_set_level(GPIO_BLUE_LED, 0);
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

/*
Check the ack button states and lower the alarm(s) accordingly.
*/
void ackTask(void *pvParams) {
  int red_ack_last_state = 1;
  int blue_ack_last_state = 1;
  int red_ack_state = 1;
  int blue_ack_state = 1;

  for (;;) {
    red_ack_state = gpio_get_level(GPIO_RED_ACK);
    blue_ack_state = gpio_get_level(GPIO_BLUE_ACK);
    if (red_ack_state != red_ack_last_state && red_ack_state == 0) {
      printf("Detected falling edge in red ack button.\n");
      printf("Deleting the red led task.\n");
      vTaskDelete(redLedTaskHandle);
      printf("Ensure that the red led is left off.\n");
      gpio_set_level(GPIO_RED_LED, 0);
    }
    if (blue_ack_state != blue_ack_last_state && blue_ack_state == 0) {
      printf("Detected falling edge in blue ack button.\n");
      printf("Deleting the blue led task.\n");
      vTaskDelete(blueLedTaskHandle);
      printf("Ensure that the blue led is left off.\n");
      gpio_set_level(GPIO_BLUE_LED, 0);
    }

    vTaskDelay(pdMS_TO_TICKS(10));

    red_ack_last_state = red_ack_state;
    blue_ack_last_state = blue_ack_state;
  }
}

void loop() {
  printf("Reached main loop, starting...\n");

  xTaskCreate(&controlTaskRed, "red_control_task", 2048, NULL,
              6, // highest priority for the red control task
              NULL);
  xTaskCreate(&controlTaskBlue, "blue_control_task", 2048, NULL,
              5, // second highest priority for the blue control task
              NULL);

  xTaskCreate(&ackTask, "acknowledgement_task", 2048, NULL,
              4, // acknowledgements should come before LED blinks
              NULL);

  for (;;)
    ;
}