#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/semphr.h>
#include <freertos/queue.h>
#include <driver/gpio.h>

#include "furi.h"
#include "thread.h"

static const char* TAG = "application";

/*
typedef enum {
    BUTTON_1_PRESSED,
    BUTTON_2_PRESSED
} button_event_t;

#define BTN_1 5
#define BTN_2 6
#define MY_TASK_STACK_SIZE 2048

QueueHandle_t buttonQueue;
SemaphoreHandle_t mutex;
UBaseType_t priority = 16;

void MyTask(void * parameter)
{ 
    printf("MyTask (Input)!\n");
    int btn1_last_state = gpio_get_level(BTN_1);
    int btn2_last_state = gpio_get_level(BTN_2);

    while(true)
    {
        // TODO Your code goes here
        // Check button states
        int btn1_state = gpio_get_level(BTN_1);
        int btn2_state = gpio_get_level(BTN_2);

        if (btn1_state == 0 && btn1_last_state != 0) {
            button_event_t event = BUTTON_1_PRESSED;
            xQueueSend(buttonQueue, &event, portMAX_DELAY);
        }
        if (btn2_state == 0 && btn2_last_state != 0) {
            button_event_t event = BUTTON_2_PRESSED;
            xQueueSend(buttonQueue, &event, portMAX_DELAY);
        }

        btn1_last_state = btn1_state;
        btn2_last_state = btn2_state;

        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}
void MyTask2(void * parameter)
{
    printf("MyTask (GUI)!\n");
    button_event_t event;
    SemaphoreHandle_t hMutex;

    while(true)
    {
        if (xQueueReceive(buttonQueue, &event, portMAX_DELAY)) {
            switch(event) {
                case BUTTON_1_PRESSED:
                    hMutex = (SemaphoreHandle_t)((uint32_t)mutex & ~1U);
                    xSemaphoreTake(hMutex, 0xFFFFFFFFU);


                    printf("[GUI] Button 1 pressed!\n");

                    hMutex = (SemaphoreHandle_t)((uint32_t)mutex & ~1U);
                    xSemaphoreGive(hMutex);
                    break;
                case BUTTON_2_PRESSED:
                    printf("[GUI] Button 2 pressed!\n");
                    break;
            }
        }
    }
}


static StaticTask_t myTaskBuffer;
static StackType_t myTaskStack[ MY_TASK_STACK_SIZE ];
static StaticTask_t task2Buffer;
static StackType_t task2Stack[ MY_TASK_STACK_SIZE ];
*/

int32_t main_task(void* param) {
  FURI_LOG_I(TAG, "main_task");
  return 0;
}
void furi_start_service(const char* name, ThreadCallback callback) {
    Thread* thread = furi_thread_alloc_ex(name, 2048, callback, NULL);
    furi_thread_mark_as_static(thread);
    furi_thread_set_appid(thread, name);
    furi_thread_start(thread);
}
void app_main() {

  esp_log_level_set("*", ESP_LOG_INFO); 

  printf("START!\n");
  FURI_LOG_I(TAG, "init complete");

  furi_start_service("main", &main_task);


  FURI_LOG_I(TAG, "all service running.");
  //furi_init();

    /*
  mutex = xSemaphoreCreateMutex();

  // Configure the GPIO pins as input
  gpio_config_t io_conf;
  io_conf.intr_type = GPIO_INTR_DISABLE;
  io_conf.mode = GPIO_MODE_INPUT;
  io_conf.pin_bit_mask = (1ULL << BTN_1) | (1ULL << BTN_2);
  io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
  io_conf.pull_up_en = GPIO_PULLUP_ENABLE;
  gpio_config(&io_conf);



  if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
    printf("Scheduler already started!\n");
  }

  buttonQueue = xQueueCreate(10, sizeof(button_event_t));
  if (buttonQueue == NULL) {
      printf("Failed to create queue!\n");
      return;
  }

  // Create MyTask
  TaskHandle_t myTaskHandle = xTaskCreateStatic(
            MyTask,
            "MyTask",
            MY_TASK_STACK_SIZE,
            NULL, // params
            priority, // Increased priority
            myTaskStack,
            &myTaskBuffer);

  if (myTaskHandle == NULL) {
    printf("Failed to create MyTask!\n");
  } else {
    printf("MyTask created successfully!\n");
  }

  // Create Task2
  TaskHandle_t task2Handle = xTaskCreateStatic(
            MyTask2,
            "Task2",
            MY_TASK_STACK_SIZE,
            NULL, // params
            priority, // Increased priority
            task2Stack,
            &task2Buffer);

  if (task2Handle == NULL) {
    printf("Failed to create Task2!\n");
  } else {
    printf("Task2 created successfully!\n");
  }

            
  printf("Hello, Wokwi!\n");
  while (true) {
    vTaskDelay(1000 / portTICK_PERIOD_MS);
  }*/
}