#include <stdint.h>
#include <stm32f1xx_hal.h>

/*
 * LED1 = GPIO_PIN_8 OUTPUT PUSH-PULL
 * LED CNF: 10 (3:1 2:0)
 * LED MODE: 00 (1:0 0:0)
 *
 * BTN
 * Input, PullDown, 10Mhz
 * MODE: 00
 * CNF: 10
 *
 * PORT GPIOC
 * RCC = 0x4002 1000 - 0x4002 13FF
 * GPIOC = 0x4001 1000 - 0x4001 13FF
 * GPIO PORT C RCC_APB2ENR 4
 */

//inline constexpr uint32_t RCC_BASE = 0x40021000UL;
//inline constexpr uint32_t RCC_CR_OFFSET = 0x000;
//inline constexpr uint32_t RCC_CFGR_OFFSET = 0x004;
inline constexpr uint32_t RCC_APB2ENR_OFFSET = 0x018;
inline constexpr uint32_t RCC_APB1ENR_OFFSET = 0x01C;

inline constexpr uint32_t RCC_APB2ENR_ADDR = (RCC_BASE + RCC_APB2ENR_OFFSET);
inline constexpr uint32_t RCC_APB1ENR_ADDR = (RCC_BASE + RCC_APB1ENR_OFFSET);
inline constexpr uint32_t RCC_CR_ADDR = (RCC_BASE + RCC_CR_OFFSET);
inline constexpr uint32_t RCC_CFGR_ADDR = (RCC_BASE + RCC_CFGR_OFFSET);

//inline constexpr uint32_t GPIOA_BASE = 0x40010800;
//inline constexpr uint32_t GPIOC_BASE = 0x40011000;

inline constexpr uint32_t GPIOX_CRL_OFFSET = 0x00;
inline constexpr uint32_t GPIOX_CRH_OFFSET = 0x04;
inline constexpr uint32_t GPIOX_IDR_OFFSET = 0x08;
inline constexpr uint32_t GPIOX_ODR_OFFSET = 0x0C;

inline constexpr uint32_t GPIOA_CRL = (GPIOA_BASE + GPIOX_CRL_OFFSET);
inline constexpr uint32_t GPIOA_CRH = (GPIOA_BASE + GPIOX_CRH_OFFSET);
inline constexpr uint32_t GPIOA_ODR = (GPIOA_BASE + GPIOX_ODR_OFFSET);
inline constexpr uint32_t GPIOA_IDR = (GPIOA_BASE + GPIOX_IDR_OFFSET);

inline constexpr uint32_t GPIOC_CRH = (GPIOC_BASE + GPIOX_CRH_OFFSET);
inline constexpr uint32_t GPIOC_ODR = (GPIOC_BASE + GPIOX_ODR_OFFSET);

inline constexpr unsigned long PC8 = 8;
inline constexpr unsigned long PC9 = 9;
inline constexpr unsigned long PA0 = 0;

void SetBit(uint32_t value, uint32_t bit) {
    uint32_t* ptr_value = (uint32_t*)value;
    *ptr_value |= (1 << bit);
}

void UnsetBit(uint32_t value, uint32_t bit) {
    uint32_t* ptr_value = (uint32_t*)value;
    *ptr_value &= ~(1 << bit);
}

bool GetBit(uint32_t value, uint32_t bit) {
    uint32_t* ptr_value = (uint32_t*)value;
    return static_cast<bool>((*ptr_value >> bit) & 1);
}

void SetBit(uint32_t* value, uint32_t bit) {
    *value |= (1 << bit);
}

void UnsetBit(uint32_t* value, uint32_t bit) {
    *value &= ~(1 << bit);
}

bool GetBit(uint32_t* value, uint32_t bit) {
    return static_cast<bool>((*value >> bit) & 1);
}

// Clock
/*
 * We wanna set PLL to 16Mhz (minimum). Maximum would be 24Mhz
 * For that we use HSI Clock divided by two (4 Mhz) as input
 * 16Mhz = (8Mhz / 2) * 4
 *
 */


// INTERRUPTS
/*
 * Setps:
 * - Configure GPIO to Input mode
 * - Use SYSCFG register to connect GPIO to an EXTI lin
 * - Confiure EXTI for a specific trigger (rising, falling, ...)
 *
 * Common Mistakes to Avoid:
 * - Forgetting enable SYSFG CLK
 * - Mapping Multiple Pins to same EXTI Line (for example PA1 and PB1)
 * - Not unmasking the line in EXTI Register
 * - Forgetting to do enable in NVIC
 * - Not clearing the pending bit in ISR -> infinite loop
 *
 * BTN is on GPIOA0 (PA0)
 * PA0 -> EXTI0
 * EXTI_IMR Bit 0 auf 1 Setzen
 */

//inline constexpr uint32_t EXTI_BASE 	= 0x40010400;
inline constexpr uint32_t EXTI_IMR 		= (EXTI_BASE + 0x00);
inline constexpr uint32_t EXTI_EMR 		= (EXTI_BASE + 0x04);
inline constexpr uint32_t EXTI_RTSR 	= (EXTI_BASE + 0x08);
inline constexpr uint32_t EXTI_FTSR 	= (EXTI_BASE + 0x0C);
inline constexpr uint32_t EXTI_SWIER 	= (EXTI_BASE + 0x10);
inline constexpr uint32_t EXTI_PR 		= (EXTI_BASE + 0x14);

extern "C" {

    static int ActiveBlink = 0;
    /*
     * Handles EXTI line interrupt for a given GPIO pin.
     */
    void GPIO_IRQHandling(uint8_t PinNumber)
    {
        // clear the exti pr register corresponding to the pin number
        if (EXTI->PR & (1UL << PinNumber))
        {
            // clear
            EXTI->PR |= (1UL << PinNumber);

            uint32_t *pGpioCOdr = (uint32_t*) GPIOC_ODR;
            GPIOC->ODR ^= (1 << PC9);
            if (ActiveBlink == 0) {
                ActiveBlink = 1;
                TIM2->ARR = 100;
            } else {
                ActiveBlink = 0;
                TIM2->ARR = 1000;
            }
        }
    }

    void EXTI0_IRQHandler(void) {
        GPIO_IRQHandling(PA0);
    }

    void TIM2_IRQHandler(void) {
        // Handle a timer 'update' interrupt event
        if (TIM2->SR & TIM_SR_UIF) {
            TIM2->SR &= ~(TIM_SR_UIF);
            // Toggle the LED output pin.
            GPIOC->ODR ^= (1 << PC8);
        }
    }
}


int main(void)
{
    // Init system Clock
    uint32_t *pRccCfgr = (uint32_t*) RCC_CFGR_ADDR;
    //set PLLMUL to x4
    UnsetBit(pRccCfgr, 18);
    SetBit(pRccCfgr, 19);
    UnsetBit(pRccCfgr, 20);
    UnsetBit(pRccCfgr, 21);

    //set PLLSRC to HSI oscillator / 2
    UnsetBit(pRccCfgr, 16);

    uint32_t *pRccCr = (uint32_t*) RCC_CR_ADDR;
    //enable PLL clock
    SetBit(pRccCr, 24);

    //wait till PLL clock is ready
    while (!GetBit(pRccCr, 25)) {};

    //Set PLL clock as system clock
    UnsetBit(pRccCfgr, 0);
    SetBit(pRccCfgr, 1);

    //wait till PLL clock is set as system clock
    while (!(GetBit(pRccCfgr, 3) && !GetBit(pRccCfgr, 2))) {}

    const auto coreClockHz = 16000000;

    // BUTTON INTERRUPT CFG

    //enable interrupt requests for interrupt line 0
    uint32_t *pExtiIMR = (uint32_t*) EXTI_IMR;
    SetBit(pExtiIMR, 0);

    //enable rising trigger on interrupt line
    uint32_t *pExtiRTSR = (uint32_t*) EXTI_RTSR;
    SetBit(pExtiRTSR, 0);

    uint32_t *pExtiFTSR = (uint32_t*) EXTI_FTSR;
    UnsetBit(pExtiFTSR, 0);


    NVIC_SetPriority(EXTI0_IRQn, 0);
    NVIC_EnableIRQ(EXTI0_IRQn);

    // TIMER INTERRUPT CFG
    uint32_t *pRccApb1Enr = (uint32_t*) RCC_APB1ENR_ADDR;

    //Enable TIM2
    SetBit(pRccApb1Enr, 0);

    //Disable TIM2 Counter
    TIM2->CR1 &= ~(TIM_CR1_CEN);

    //Reset TIM2
    //SetBit(RCC->APB1RSTR, 0);
    //UnsetBit(RCC->APB1RSTR, 0);
    RCC->APB1RSTR |=  (RCC_APB1RSTR_TIM2RST);
    RCC->APB1RSTR &= ~(RCC_APB1RSTR_TIM2RST);

    //Set TIM2 to count every millisecond
    TIM2->PSC = coreClockHz / 1000;

    // Reset timmer counter every 1000 counts (1 second)
    TIM2->ARR = 1000;

    // enable ARR register buffering, needed to change ARR counter on the fly
    TIM2->CR1 |= TIM_CR1_ARPE;

    // Send an update event to reset the timer and apply settings
    TIM2->EGR  |= TIM_EGR_UG;

    // Enable interrupts on timer updates
    TIM2->DIER |= TIM_DIER_UIE;
    //SetBit(TIM2->DIER, TIM_DIER_UIE);

    //Enable TIM2 Counter
    TIM2->CR1  |= TIM_CR1_CEN;
    //SetBit(TIM2->CR1, TIM_CR1_CEN);

    //Activate Interrupts for TIM2
    NVIC_SetPriority(TIM2_IRQn, 3);
    NVIC_EnableIRQ(TIM2_IRQn);

    uint32_t *pRccApb2Enr = (uint32_t*) RCC_APB2ENR_ADDR;

    // enalbe clock for GPIO Port A on APB2
    *pRccApb2Enr |= (1 << 2);

    // enalbe clock for GPIO Port C on APB2
    *pRccApb2Enr |= (1 << 4);

    //Configure LED 8 Pin as Output with Push-Pull Resistor
    uint32_t *pGpioCCrh = (uint32_t*) GPIOC_CRH;
    //Set LED MODE
    SetBit(pGpioCCrh, 0);
    UnsetBit(pGpioCCrh, 1);
    ////Set LED CNF
    UnsetBit(pGpioCCrh, 2);
    UnsetBit(pGpioCCrh, 3);

    //Configure LED 9 Pin as Output with Push-Pull Resistor
    //Set LED MODE
    SetBit(pGpioCCrh, 4);
    UnsetBit(pGpioCCrh, 5);
    ////Set LED CNF
    UnsetBit(pGpioCCrh, 6);
    UnsetBit(pGpioCCrh, 7);

    //Configure BTN Pin as Input with PullDown Resistor
    uint32_t *pGpioACrl = (uint32_t*) GPIOA_CRL;
    //Set BTN MODE
    UnsetBit(pGpioACrl, 0);
    UnsetBit(pGpioACrl, 1);
    //Set BTN CNF
    UnsetBit(pGpioACrl, 2);
    SetBit(pGpioACrl, 3);

    uint32_t *pGpioAIdr = (uint32_t*) GPIOA_IDR;
    uint32_t *pGpioCOdr = (uint32_t*) GPIOC_ODR;
    while(1)
    {
        //const auto buttonIsSet = GetBit(pGpioAIdr, 0);
        //auto DoBlink = static_cast<bool>(ActiveBlink);

        //SetBit(pGpioCOdr, PC8);
        //if (DoBlink) {
        //    SetBit(pGpioCOdr, PC9);
        //}
        for (uint32_t i = 0; i < 500000; i++);

        //DoBlink = static_cast<bool>(ActiveBlink);

        //UnsetBit(pGpioCOdr, PC8);
        //if (DoBlink) {
        //    UnsetBit(pGpioCOdr, PC9);
        //}
        for (uint32_t i = 0; i < 500000; i++);
    }
    return 0;
}

//#include <stm32f1xx_hal.h>
//#include <stm32f1xx_it.h>
//#include <stm32f1xx_hal_uart.h>
//#include <stm32f1xx_hal_gpio_ex.h>
//
//#include <tuple>
//
///*
// * reserve PB11-PB15 for SPI2
// */
//
//// STM32VL-Discovery green led - PC9
//#define BTN_PORT GPIOA
//#define LED_PORT GPIOC
//#define LED1_PIN GPIO_PIN_8
//#define LED2_PIN GPIO_PIN_9
//#define BTN_PIN GPIO_PIN_0
//#define LED_PORT_CLK_ENABLE __HAL_RCC_GPIOC_CLK_ENABLE
//
//#define LoRa_RESET_Pin GPIO_PIN_4
//#define LoRa_RESET_GPIO_Port GPIOC
//#define LoRa_CS_Pin GPIO_PIN_5
//#define LoRa_CS_GPIO_Port GPIOC
//
//#include "commons.hpp"
//#include "logging.hpp"
//#include "rfm95.hpp"
//#include "spi.hpp"
//
//extern uint8_t LoRa_buff[RH_RF95_FIFO_SIZE];
//extern SPI_HandleTypeDef hspi1;
//
//void print_version(void) { log::info("running PentaTrack v0.2.0"); }
//void print_help(void);
//
//void loglevel_error(void) { log::set_loglevel(LogLevel::ERROR); }
//void loglevel_info(void) { log::set_loglevel(LogLevel::INFO); }
//void loglevel_debug(void) { log::set_loglevel(LogLevel::DEBUG); }
//
//template <size_t Size>
//class cmd_holder {
// public:
//  typedef void (*functionPointerType)(void);
//
//  using command_t =
//      std::tuple<std::string_view, std::string_view, functionPointerType>;
//  template <size_t S>
//  using command_array_t = std::array<command_t, Size>;
//
//  template <typename... Args>
//  constexpr cmd_holder(Args... command_list)
//      : commands{std::forward<Args>(command_list)...} {}
//
//  constexpr functionPointerType get_func(std::string_view message) const {
//    for (const auto &[cmd_name, cmd_help, func] : commands) {
//      if (message == cmd_name) {
//        return func;
//      }
//    }
//
//    return nullptr;
//  }
//
//  void print_help() const {
//    log::info("Listing available commands:");
//    for (const auto &[cmd_name, cmd_help, func] : commands) {
//      log::info("\t", cmd_name, " - ", cmd_help);
//    }
//  }
//
// private:
//  std::array<command_t, Size> commands;
//};
//
//static bool updated_main_buf = false;
//static bool print_main_buf = false;
//static buffer<uint8_t, 512> main_buffer{};
//static gps_data gps;
//
//void print_buf(void) { main_buffer.print(); }
//void print_gps(void) { gps.print(); }
//void print_buf_toggle(void) { print_main_buf = !print_main_buf; }
//
//class cmd_handler {
// public:
//  static constexpr auto MaxCmdLength = 24;
//  using array_t = std::array<uint8_t, MaxCmdLength>;
//  using iterator_t = array_t::iterator;
//  using const_iterator_t = array_t::const_iterator;
//
//  constexpr cmd_handler() : symbols{}, iterator{symbols.begin()} {}
//
//  static cmd_handler &get() {
//    static auto c = cmd_handler{};
//    return c;
//  };
//
//  void add_symbol(uint8_t symbol) {
//    *iterator = symbol;
//    iterator++;
//    if (iterator == symbols.end()) {
//      iterator = symbols.begin();
//    }
//  }
//
//  std::string_view get_current_cmd() const {
//    return {reinterpret_cast<const char *>(symbols.data()),
//            static_cast<size_t>(
//                std::distance(symbols.begin(), const_iterator_t{iterator}))};
//  }
//
//  bool exists() const {
//    return commands.get_func(get_current_cmd()) != nullptr;
//  }
//
//  void execute() {
//    const auto current_cmd = get_current_cmd();
//    log::debug("Try executing command: ", current_cmd);
//    const auto func = commands.get_func(current_cmd);
//    iterator = symbols.begin();
//
//    if (func == nullptr) {
//      log::info("Unknown Command: ", current_cmd);
//      log::info("Type 'help' to show available commands.");
//      return;
//    }
//
//    func();
//  }
//
//  void queue_execution() { ShouldExecute = true; }
//
//  void run() {
//    if (ShouldExecute) {
//      execute();
//      ShouldExecute = false;
//    }
//  }
//
//  void print_help_() const { commands.print_help(); }
//
// private:
//  static constexpr cmd_holder<8> commands{
//      std::make_tuple("ver", "Prints current version.", &print_version),
//      std::make_tuple("error", "Set LogLevel to Error.", &loglevel_error),
//      std::make_tuple("info", "Set LogLevel to Info.", &loglevel_info),
//      std::make_tuple("debug", "Set LogLevel to Debug.", &loglevel_debug),
//      std::make_tuple("gps", "Prints captured gps data", &print_gps),
//      std::make_tuple("buf", "Prints uart2 buffer", &print_buf),
//      std::make_tuple("buft", "toggles continous printing of uart2 buffer",
//                      &print_buf_toggle),
//      std::make_tuple("help", "Prints available commands", &print_help)};
//
//  array_t symbols;
//  iterator_t iterator;
//  bool ShouldExecute = false;
//};
//
//void print_help(void) { cmd_handler::get().print_help_(); }
//
//// This prevent name mangling for functions used in C/assembly files.
//extern "C" {
//void SysTick_Handler(void) {
//  HAL_IncTick();
//  HAL_SYSTICK_IRQHandler();
//}
//
//void EXTI0_IRQHandler(void)
//{
//  /* USER CODE BEGIN EXTI0_IRQn 0 */
//
//  /* USER CODE END EXTI0_IRQn 0 */
//  HAL_GPIO_EXTI_IRQHandler(BTN_PIN);
//  /* USER CODE BEGIN EXTI0_IRQn 1 */
//
//  /* USER CODE END EXTI0_IRQn 1 */
//}
//
//void USART2_IRQHandler(void) {
//  HAL_UART_IRQHandler(&gps_interface::s_UARTHandle);
//  HAL_UART_Receive_IT(&gps_interface::s_UARTHandle, uart_interface::get_buf(),
//                      1);
//}
//
//void USART1_IRQHandler(void) {
//  HAL_UART_IRQHandler(&uart_interface::s_UARTHandle);
//  HAL_UART_Receive_IT(&uart_interface::s_UARTHandle, uart_interface::get_buf(),
//                      1);
//}
//
//void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
//  if (huart == &gps_interface::s_UARTHandle) {
//    return;
//  }
//
//  const uint8_t value = *uart_interface::get_buf();
//
//  if (value == '\r') {
//    cmd_handler::get().queue_execution();
//    return;
//  }
//
//  cmd_handler::get().add_symbol(value);
//}
//
//void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
//  // const uint8_t value = *gps_interface::get_buf();
//  // gps_interface::write({reinterpret_cast<const char *>(&value), 1});
//}
//
//void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {
//  // log::debug("DMA Callback");
//
//  HAL_GPIO_WritePin(LED_PORT, LED1_PIN, GPIO_PIN_SET);
//  if (main_buffer.copy_from(gps_interface::new_rx_buf, Size)) {
//    updated_main_buf = true;
//  }
//  HAL_GPIO_WritePin(LED_PORT, LED1_PIN, GPIO_PIN_RESET);
//
//  HAL_UARTEx_ReceiveToIdle_DMA(&gps_interface::s_UARTHandle,
//                               gps_interface::new_rx_buf.data(),
//                               gps_interface::new_rx_buf.size());
//  __HAL_DMA_DISABLE_IT(&gps_interface::s_DMAHandle, DMA_IT_HT);
//}
//
///**
// * @brief This function handles DMA1 channel6 global interrupt.
// */
//void DMA1_Channel6_IRQHandler(void) {
//  /* USER CODE BEGIN DMA1_Channel6_IRQn 0 */
//
//  /* USER CODE END DMA1_Channel6_IRQn 0 */
//  HAL_DMA_IRQHandler(&gps_interface::s_DMAHandle);
//
//  /* USER CODE BEGIN DMA1_Channel6_IRQn 1 */
//
//  /* USER CODE END DMA1_Channel6_IRQn 1 */
//}
//}
//
//void initGPIO() {
//  __HAL_RCC_GPIOC_CLK_ENABLE();
//  __HAL_RCC_GPIOA_CLK_ENABLE();
//
//  //GPIO_InitTypeDef GPIO_Config2;
//  //GPIO_Config2.Mode = GPIO_MODE_INPUT;
//  //GPIO_Config2.Pull = GPIO_PULLDOWN;
//  //GPIO_Config2.Speed = GPIO_SPEED_FREQ_HIGH;
//  //GPIO_Config2.Pin = BTN_PIN;
//
//  GPIO_InitTypeDef GPIO_Config2;
//  GPIO_Config2.Mode = GPIO_MODE_IT_FALLING;
//  GPIO_Config2.Pull = GPIO_PULLUP;
//  GPIO_Config2.Pin = BTN_PIN;
//
//  GPIO_InitTypeDef GPIO_Config;
//  GPIO_Config.Mode = GPIO_MODE_OUTPUT_PP;
//  GPIO_Config.Pull = GPIO_NOPULL;
//  GPIO_Config.Speed = GPIO_SPEED_FREQ_HIGH;
//  GPIO_Config.Pin = LED1_PIN | LED2_PIN;
//
//  GPIO_InitTypeDef GPIO_ConfigSPI;
//  GPIO_ConfigSPI.Mode = GPIO_MODE_OUTPUT_PP;
//  // GPIO_ConfigSPI.Pull = GPIO_NOPULL;
//  GPIO_ConfigSPI.Speed = GPIO_SPEED_FREQ_HIGH;
//  GPIO_ConfigSPI.Pin = LoRa_CS_Pin | LoRa_RESET_Pin;
//
//  // bare metal init of led1:
//  // volatile uint32_t* CRH = reinterpret_cast<uint32_t*>(0x40011000 +
//  // 0x04);
//  //*CRH |= 0x3;
//  //*CRH &= (~0xC);
//
//  HAL_GPIO_Init(LED_PORT, &GPIO_Config);
//  HAL_GPIO_Init(BTN_PORT, &GPIO_Config2);
//  HAL_GPIO_Init(LoRa_CS_GPIO_Port, &GPIO_ConfigSPI);
//  //  HAL_GPIO_WritePin(LoRa_CS_GPIO_Port, LoRa_CS_Pin, GPIO_PIN_SET);
//  //  HAL_GPIO_WritePin(LoRa_RESET_GPIO_Port, LoRa_RESET_Pin,
//  //  GPIO_PIN_SET);
//}
//
//extern "C" {
//#include <stdio.h>
//
//void start_interrupt() {
//  HAL_UARTEx_ReceiveToIdle_DMA(&gps_interface::s_UARTHandle,
//                               gps_interface::new_rx_buf.data(),
//                               gps_interface::new_rx_buf.size());
//  __HAL_DMA_DISABLE_IT(&gps_interface::s_DMAHandle, DMA_IT_HT);
//  HAL_GPIOEx_EnableEventout();
//}
//
//void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
//    if (GPIO_Pin == BTN_PIN) {
//        // Your interrupt handling code goes here
//        // For example, toggle an LED
//        HAL_GPIO_TogglePin(LED_PORT, LED1_PIN);
//    }
//}
//
//}
//
//int main(void) {
//  HAL_Init();
//  HAL_SYSTICK_Config(1);
//  initGPIO();
//
//  if (!log::init<uart_logger>()) {
//    // toggle status led or something
//  }
//  log::set_loglevel(LogLevel::DEBUG);
//  log::info("logging Initialized");
//
//  //if (!MX_SPI1_Init()) {
//  //  // toggle status led or something
//  //}
//  //HAL_GPIO_WritePin(LoRa_CS_GPIO_Port, LoRa_CS_Pin, GPIO_PIN_SET);
//  //HAL_GPIO_WritePin(LoRa_RESET_GPIO_Port, LoRa_RESET_Pin, GPIO_PIN_SET);
//
//  HAL_NVIC_SetPriority(EXTI0_IRQn, 0 ,0);
//  HAL_NVIC_EnableIRQ(EXTI0_IRQn);
//
//  while(1) {
//    HAL_GPIO_WritePin(LED_PORT, LED2_PIN, GPIO_PIN_SET);
//    HAL_Delay(100);
//    HAL_GPIO_WritePin(LED_PORT, LED2_PIN, GPIO_PIN_RESET);
//    HAL_Delay(100);
//  }
// // HAL_Delay(10);
//
// // log::debug("SPI1 Initialized.");
// // log::debug("SPI1 Initialized.");
//
// // if (!gps_interface::init()) {
// //   log::error("UART2 Initialization failed, needed for GPS");
// // } else {
// //   log::debug("Uart2 Initialized");
// // }
//
// // log::debug("Initialization done.");
//
// // char OP_Mode = 0x01;
// // char buff = 0x7F & OP_Mode;
// // char res = 0;
//
// // HAL_GPIO_WritePin(LoRa_CS_GPIO_Port, LoRa_CS_Pin, GPIO_PIN_RESET);
// // [[maybe_unused]] auto result =
// //     HAL_SPI_Transmit(&hspi1, (uint8_t *)&buff, 1, 100);
// // HAL_SPI_Receive(&hspi1, (uint8_t *)&res, 1, 100);
// // HAL_GPIO_WritePin(LoRa_CS_GPIO_Port, LoRa_CS_Pin, GPIO_PIN_SET);
//
// // // RF95_Init();
//
// // HAL_GPIO_WritePin(LED_PORT, LED2_PIN, GPIO_PIN_RESET);
//
// // while (1) {
// //   cmd_handler::get().run();
//
// //   // gps_interface::write("TEST");
// //   //  RF95_setModeRx_Continuous();
// //   // HAL_GPIO_WritePin(LED_PORT, LED1_PIN, GPIO_PIN_RESET);
// //   // RF95_receive(LoRa_buff);
// //   // HAL_Delay(100);
// //   // HAL_GPIO_WritePin(LED_PORT, LED1_PIN, GPIO_PIN_SET);
// //   // HAL_Delay(100);
//
// //   if (gps.is_valid()) {
// //     HAL_GPIO_WritePin(LED_PORT, LED2_PIN, GPIO_PIN_SET);
// //   }
//
// //   if (updated_main_buf) {
// //     updated_main_buf = false;
// //     gps.extract_gps_data(main_buffer);
//
// //     if (print_main_buf) {
// //       updated_main_buf = !main_buffer.print();
// //     }
// //   }
//
// //   // std::string_view msg{reinterpret_cast<char *>(LoRa_buff)};
// //   // log::info("Received Message");
// //   // log::debug("Received Message");
// //   // log::debug(msg);
//
// //   // std::string_view foo{"Das ist ein test"};
// //   // strcpy((char *)LoRa_buff, foo.data());
//
// //   // RF95_send(LoRa_buff);
// // }
//
//  return 0;
//}
//