#include <cstdint>
#include <stdio.h>
#include <array>

#include "app_networking.hpp"
#include "app_serial.hpp"

#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "nvs_flash.h"
#include "driver/uart.h"

namespace
{

TaskHandle_t s_main_task = nullptr;

QueueSetHandle_t s_queue_set = nullptr;
QueueHandle_t s_esp_now_queue = nullptr;
QueueHandle_t s_uart_queue = nullptr;

void s_sendUartData()
{
  std::size_t uart_rx_size = 0;
  uart_get_buffered_data_len(UART_NUM_0, &uart_rx_size);
  if (uart_rx_size > 128 / 2)
  {
    std::array<std::uint8_t, 128> tx_buffer;
    uart_read_bytes(UART_NUM_0, tx_buffer.data(), uart_rx_size, 0);
    Networking::sendData(tx_buffer, uart_rx_size);
  }
}

[[noreturn]] void s_mainTask(void*)
{
  while (true)
  {
    QueueSetMemberHandle_t queue_select = xQueueSelectFromSet(s_queue_set, portMAX_DELAY);

    if (queue_select == s_esp_now_queue)
    {
      Networking::EspNowEvent event;
      xQueueReceive(queue_select, &event, 0);

      if (event.type == Networking::EspNowEvent::MSG_RECEIVED)
      {
        std::size_t uart_free = 0;
        uart_get_tx_buffer_free_size(UART_NUM_0, &uart_free);
        if (uart_free >= event.rx_length)
        {
          const auto& esp_rx_buffer = Networking::getRxBuffer();
          uart_write_bytes(UART_NUM_0, esp_rx_buffer.data(), event.rx_length);
        }
        else
        {
          // log data drop
        }
      }
      else if (event.type == Networking::EspNowEvent::MSG_SEND_COMPLETE && Networking::isTxInFlight())
      {
        // check if we have an UART_RX buffer, send if possible.
        s_sendUartData();
      }
    }
    else if (queue_select == s_uart_queue)
    {
      uart_event_t event;
      xQueueReceive(s_uart_queue, &event, 0);

      if (event.type == UART_DATA)
      {
        s_sendUartData();
      }
    }
  }
}

}// namespace

extern "C" void app_main(void)
{
  ESP_ERROR_CHECK(nvs_flash_init());

  Networking::setupWifi();
  s_esp_now_queue = Networking::setupEspNow();
  s_uart_queue = Serial::setupSerial();

  s_queue_set = xQueueCreateSet(4 + 4);
  xQueueAddToSet(s_esp_now_queue, s_queue_set);
  xQueueAddToSet(s_uart_queue, s_queue_set);

  xTaskCreate(s_mainTask, "main_task", 2048, nullptr, 4, &s_main_task);
}