Momentum-Apps/flipper_http/flipper_http.c

// Description: Flipper HTTP API (For use with Flipper Zero and the FlipperHTTP flash: https://github.com/jblanked/FlipperHTTP)
// License: MIT
// Author: JBlanked
// File: flipper_http.c
#include <flipper_http/flipper_http.h>

/**
 * @brief      Worker thread to handle UART data asynchronously.
 * @return     0
 * @param      context   The FlipperHTTP context.
 * @note       This function will handle received data asynchronously via the callback.
 */
static int32_t flipper_http_worker(void *context)
{
    if (!context)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return -1;
    }
    FlipperHTTP *fhttp = (FlipperHTTP *)context;
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return -1;
    }
    size_t rx_line_pos = 0;

    while (1)
    {
        uint32_t events = furi_thread_flags_wait(
            WorkerEvtStop | WorkerEvtRxDone, FuriFlagWaitAny, FuriWaitForever);
        if (events & WorkerEvtStop)
        {
            break;
        }
        if (events & WorkerEvtRxDone)
        {
            // Continuously read from the stream buffer until it's empty
            while (!furi_stream_buffer_is_empty(fhttp->flipper_http_stream))
            {
                // Read one byte at a time
                char c = 0;
                size_t received = furi_stream_buffer_receive(fhttp->flipper_http_stream, &c, 1, 0);

                if (received == 0)
                {
                    // No more data to read
                    break;
                }

                fhttp->bytes_received += received;

                // print amount of bytes received
                // FURI_LOG_I(HTTP_TAG, "Bytes received: %d", fhttp->bytes_received);

                // Append the received byte to the file if saving is enabled
                if (fhttp->save_bytes)
                {
                    // Add byte to the buffer
                    fhttp->file_buffer[fhttp->file_buffer_len++] = c;
                    // Write to file if buffer is full
                    if (fhttp->file_buffer_len >= FILE_BUFFER_SIZE)
                    {
                        if (!flipper_http_append_to_file(
                                fhttp->file_buffer,
                                fhttp->file_buffer_len,
                                fhttp->just_started_bytes,
                                fhttp->file_path))
                        {
                            FURI_LOG_E(HTTP_TAG, "Failed to append data to file");
                        }
                        fhttp->file_buffer_len = 0;
                        fhttp->just_started_bytes = false;
                    }
                }

                // Handle line buffering only if callback is set (text data)
                if (fhttp->handle_rx_line_cb)
                {
                    // Handle line buffering
                    if (c == '\n' || rx_line_pos >= RX_LINE_BUFFER_SIZE - 1)
                    {
                        fhttp->rx_line_buffer[rx_line_pos] = '\0'; // Null-terminate the line

                        // Invoke the callback with the complete line
                        fhttp->handle_rx_line_cb(fhttp->rx_line_buffer, fhttp->callback_context);

                        // Reset the line buffer position
                        rx_line_pos = 0;
                    }
                    else
                    {
                        fhttp->rx_line_buffer[rx_line_pos++] = c; // Add character to the line buffer
                    }
                }
            }
        }
    }

    return 0;
}

// UART RX Handler Callback (Interrupt Context)
/**
 * @brief      A private callback function to handle received data asynchronously.
 * @return     void
 * @param      handle    The UART handle.
 * @param      event     The event type.
 * @param      context   The FlipperHTTP context.
 * @note       This function will handle received data asynchronously via the callback.
 */
static void _flipper_http_rx_callback(
    FuriHalSerialHandle *handle,
    FuriHalSerialRxEvent event,
    void *context)
{
    FlipperHTTP *fhttp = (FlipperHTTP *)context;
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return;
    }
    if (event == FuriHalSerialRxEventData)
    {
        uint8_t data = furi_hal_serial_async_rx(handle);
        furi_stream_buffer_send(fhttp->flipper_http_stream, &data, 1, 0);
        furi_thread_flags_set(fhttp->rx_thread_id, WorkerEvtRxDone);
    }
}

// Timer callback function
/**
 * @brief      Callback function for the GET timeout timer.
 * @return     0
 * @param      context   The FlipperHTTP context.
 * @note       This function will be called when the GET request times out.
 */
static void get_timeout_timer_callback(void *context)
{
    FlipperHTTP *fhttp = (FlipperHTTP *)context;
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return;
    }
    FURI_LOG_E(HTTP_TAG, "Timeout reached without receiving the end.");

    // Reset the state
    fhttp->started_receiving = false;

    // Update UART state
    fhttp->state = ISSUE;
}

static void flipper_http_rx_callback(const char *line, void *context); // forward declaration
// Instead of two globals, we use a single static pointer to the active instance.
static FlipperHTTP *active_fhttp = NULL;

FlipperHTTP *flipper_http_alloc()
{
    // If an active instance already exists, free it first.
    if (active_fhttp != NULL)
    {
        FURI_LOG_E(HTTP_TAG, "Existing UART instance detected, freeing previous instance.");
        flipper_http_free(active_fhttp);
        active_fhttp = NULL;
    }

    FlipperHTTP *fhttp = malloc(sizeof(FlipperHTTP));
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate FlipperHTTP.");
        return NULL;
    }
    memset(fhttp, 0, sizeof(FlipperHTTP));

    fhttp->flipper_http_stream = furi_stream_buffer_alloc(RX_BUF_SIZE, 1);
    if (!fhttp->flipper_http_stream)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate UART stream buffer.");
        free(fhttp);
        return NULL;
    }

    fhttp->rx_thread = furi_thread_alloc();
    if (!fhttp->rx_thread)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate UART thread.");
        furi_stream_buffer_free(fhttp->flipper_http_stream);
        free(fhttp);
        return NULL;
    }

    furi_thread_set_name(fhttp->rx_thread, "FlipperHTTP_RxThread");
    furi_thread_set_stack_size(fhttp->rx_thread, 1024);
    furi_thread_set_context(fhttp->rx_thread, fhttp);
    furi_thread_set_callback(fhttp->rx_thread, flipper_http_worker);

    fhttp->handle_rx_line_cb = flipper_http_rx_callback;
    fhttp->callback_context = fhttp;

    furi_thread_start(fhttp->rx_thread);
    fhttp->rx_thread_id = furi_thread_get_id(fhttp->rx_thread);

    // Acquire UART control
    fhttp->serial_handle = furi_hal_serial_control_acquire(UART_CH);
    if (!fhttp->serial_handle)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to acquire UART control - handle is NULL");
        furi_thread_flags_set(fhttp->rx_thread_id, WorkerEvtStop);
        furi_thread_join(fhttp->rx_thread);
        furi_thread_free(fhttp->rx_thread);
        furi_stream_buffer_free(fhttp->flipper_http_stream);
        free(fhttp);
        return NULL;
    }

    // Initialize and enable UART
    furi_hal_serial_init(fhttp->serial_handle, BAUDRATE);
    furi_hal_serial_enable_direction(fhttp->serial_handle, FuriHalSerialDirectionRx);
    furi_hal_serial_async_rx_start(fhttp->serial_handle, _flipper_http_rx_callback, fhttp, false);
    furi_hal_serial_tx_wait_complete(fhttp->serial_handle);

    // Allocate the timeout timer
    fhttp->get_timeout_timer = furi_timer_alloc(get_timeout_timer_callback, FuriTimerTypeOnce, fhttp);
    if (!fhttp->get_timeout_timer)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate HTTP request timeout timer.");
        furi_hal_serial_async_rx_stop(fhttp->serial_handle);
        furi_hal_serial_disable_direction(fhttp->serial_handle, FuriHalSerialDirectionRx);
        furi_hal_serial_control_release(fhttp->serial_handle);
        furi_hal_serial_deinit(fhttp->serial_handle);
        furi_thread_flags_set(fhttp->rx_thread_id, WorkerEvtStop);
        furi_thread_join(fhttp->rx_thread);
        furi_thread_free(fhttp->rx_thread);
        furi_stream_buffer_free(fhttp->flipper_http_stream);
        free(fhttp);
        return NULL;
    }
    furi_timer_set_thread_priority(FuriTimerThreadPriorityElevated);

    fhttp->last_response = malloc(RX_BUF_SIZE);
    if (!fhttp->last_response)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate memory for last_response.");
        furi_timer_free(fhttp->get_timeout_timer);
        furi_hal_serial_async_rx_stop(fhttp->serial_handle);
        furi_hal_serial_disable_direction(fhttp->serial_handle, FuriHalSerialDirectionRx);
        furi_hal_serial_control_release(fhttp->serial_handle);
        furi_hal_serial_deinit(fhttp->serial_handle);
        furi_thread_flags_set(fhttp->rx_thread_id, WorkerEvtStop);
        furi_thread_join(fhttp->rx_thread);
        furi_thread_free(fhttp->rx_thread);
        furi_stream_buffer_free(fhttp->flipper_http_stream);
        free(fhttp);
        return NULL;
    }
    memset(fhttp->last_response, 0, RX_BUF_SIZE);
    fhttp->state = IDLE;

    // Track the active instance globally.
    active_fhttp = fhttp;

    return fhttp;
}

void flipper_http_free(FlipperHTTP *fhttp)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return;
    }
    if (fhttp->serial_handle == NULL)
    {
        FURI_LOG_E(HTTP_TAG, "UART handle is NULL. Already deinitialized?");
        return;
    }
    // Stop asynchronous RX and clean up UART
    furi_hal_serial_async_rx_stop(fhttp->serial_handle);
    furi_hal_serial_disable_direction(fhttp->serial_handle, FuriHalSerialDirectionRx);
    furi_hal_serial_deinit(fhttp->serial_handle);
    furi_hal_serial_control_release(fhttp->serial_handle);

    // Signal and free the worker thread
    furi_thread_flags_set(fhttp->rx_thread_id, WorkerEvtStop);
    furi_thread_join(fhttp->rx_thread);
    furi_thread_free(fhttp->rx_thread);

    // Free the stream buffer
    furi_stream_buffer_free(fhttp->flipper_http_stream);

    // Free the timer, if allocated
    if (fhttp->get_timeout_timer)
    {
        furi_timer_free(fhttp->get_timeout_timer);
        fhttp->get_timeout_timer = NULL;
    }

    // Free the last_response buffer
    if (fhttp->last_response)
    {
        free(fhttp->last_response);
        fhttp->last_response = NULL;
    }

    // If this instance is the active instance, clear the static pointer.
    if (active_fhttp == fhttp)
    {
        free(active_fhttp);
        active_fhttp = NULL;
    }

    free(fhttp);
}

/**
 * @brief      Append received data to a file.
 * @return     true if the data was appended successfully, false otherwise.
 * @param      data        The data to append to the file.
 * @param      data_size   The size of the data to append.
 * @param      start_new_file  Flag to indicate if a new file should be created.
 * @param      file_path   The path to the file.
 * @note       Make sure to initialize the file path before calling this function.
 */
bool flipper_http_append_to_file(
    const void *data,
    size_t data_size,
    bool start_new_file,
    char *file_path)
{
    Storage *storage = furi_record_open(RECORD_STORAGE);
    File *file = storage_file_alloc(storage);

    if (start_new_file)
    {
        // Delete the file if it already exists
        if (storage_file_exists(storage, file_path))
        {
            if (!storage_simply_remove_recursive(storage, file_path))
            {
                FURI_LOG_E(HTTP_TAG, "Failed to delete file: %s", file_path);
                storage_file_free(file);
                furi_record_close(RECORD_STORAGE);
                return false;
            }
        }
        // Open the file in write mode
        if (!storage_file_open(file, file_path, FSAM_WRITE, FSOM_CREATE_ALWAYS))
        {
            FURI_LOG_E(HTTP_TAG, "Failed to open file for writing: %s", file_path);
            storage_file_free(file);
            furi_record_close(RECORD_STORAGE);
            return false;
        }
    }
    else
    {
        // Open the file in append mode
        if (!storage_file_open(file, file_path, FSAM_WRITE, FSOM_OPEN_APPEND))
        {
            FURI_LOG_E(HTTP_TAG, "Failed to open file for appending: %s", file_path);
            storage_file_free(file);
            furi_record_close(RECORD_STORAGE);
            return false;
        }
    }

    // Write the data to the file
    if (storage_file_write(file, data, data_size) != data_size)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to append data to file");
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return false;
    }

    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);
    return true;
}

/**
 * @brief      Load data from a file.
 * @return     The loaded data as a FuriString.
 * @param      file_path The path to the file to load.
 */
FuriString *flipper_http_load_from_file(char *file_path)
{
    // Open the storage record
    Storage *storage = furi_record_open(RECORD_STORAGE);
    if (!storage)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to open storage record");
        return NULL;
    }

    // Allocate a file handle
    File *file = storage_file_alloc(storage);
    if (!file)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate storage file");
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Open the file for reading
    if (!storage_file_open(file, file_path, FSAM_READ, FSOM_OPEN_EXISTING))
    {
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        FURI_LOG_E(HTTP_TAG, "Failed to open file for reading: %s", file_path);
        return NULL;
    }

    // Allocate a FuriString to hold the received data
    FuriString *str_result = furi_string_alloc();
    if (!str_result)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate FuriString");
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Reset the FuriString to ensure it's empty before reading
    furi_string_reset(str_result);

    // Define a buffer to hold the read data
    uint8_t *buffer = (uint8_t *)malloc(MAX_FILE_SHOW);
    if (!buffer)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate buffer");
        furi_string_free(str_result);
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Read data into the buffer
    size_t read_count = storage_file_read(file, buffer, MAX_FILE_SHOW);
    if (storage_file_get_error(file) != FSE_OK)
    {
        FURI_LOG_E(HTTP_TAG, "Error reading from file.");
        furi_string_free(str_result);
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Append each byte to the FuriString
    for (size_t i = 0; i < read_count; i++)
    {
        furi_string_push_back(str_result, buffer[i]);
    }

    // Clean up
    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);
    free(buffer);
    return str_result;
}

/**
 * @brief      Load data from a file with a size limit.
 * @return     The loaded data as a FuriString.
 * @param      file_path The path to the file to load.
 * @param      limit     The size limit for loading data.
 */
FuriString *flipper_http_load_from_file_with_limit(char *file_path, size_t limit)
{
    // Open the storage record
    Storage *storage = furi_record_open(RECORD_STORAGE);
    if (!storage)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to open storage record");
        return NULL;
    }

    // Allocate a file handle
    File *file = storage_file_alloc(storage);
    if (!file)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate storage file");
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Open the file for reading
    if (!storage_file_open(file, file_path, FSAM_READ, FSOM_OPEN_EXISTING))
    {
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        FURI_LOG_E(HTTP_TAG, "Failed to open file for reading: %s", file_path);
        return NULL;
    }

    if (memmgr_get_free_heap() < limit)
    {
        FURI_LOG_E(HTTP_TAG, "Not enough heap to read file.");
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Allocate a buffer to hold the read data
    uint8_t *buffer = (uint8_t *)malloc(limit);
    if (!buffer)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate buffer");
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Allocate a FuriString with preallocated capacity
    FuriString *str_result = furi_string_alloc();
    if (!str_result)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate FuriString");
        free(buffer);
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }
    furi_string_reserve(str_result, limit);

    // Read data into the buffer
    size_t read_count = storage_file_read(file, buffer, limit);
    if (storage_file_get_error(file) != FSE_OK)
    {
        FURI_LOG_E(HTTP_TAG, "Error reading from file.");
        furi_string_free(str_result);
        free(buffer);
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }
    if (read_count == 0)
    {
        FURI_LOG_E(HTTP_TAG, "No data read from file.");
        furi_string_free(str_result);
        free(buffer);
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return NULL;
    }

    // Append the entire buffer to FuriString in one operation
    furi_string_cat_str(str_result, (char *)buffer);

    // Clean up
    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);
    free(buffer);
    return str_result;
}

/**
 * @brief Perform a task while displaying a loading screen
 * @param fhttp The FlipperHTTP context
 * @param http_request The function to send the request
 * @param parse_response The function to parse the response
 * @param success_view_id The view ID to switch to on success
 * @param failure_view_id The view ID to switch to on failure
 * @param view_dispatcher The view dispatcher to use
 * @return
 */
void flipper_http_loading_task(FlipperHTTP *fhttp,
                               bool (*http_request)(void),
                               bool (*parse_response)(void),
                               uint32_t success_view_id,
                               uint32_t failure_view_id,
                               ViewDispatcher **view_dispatcher)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return;
    }
    if (fhttp->state == INACTIVE)
    {
        view_dispatcher_switch_to_view(*view_dispatcher, failure_view_id);
        return;
    }
    Loading *loading;
    int32_t loading_view_id = 987654321; // Random ID

    loading = loading_alloc();
    if (!loading)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate loading");
        view_dispatcher_switch_to_view(*view_dispatcher, failure_view_id);

        return;
    }

    view_dispatcher_add_view(*view_dispatcher, loading_view_id, loading_get_view(loading));

    // Switch to the loading view
    view_dispatcher_switch_to_view(*view_dispatcher, loading_view_id);

    // Make the request
    if (!flipper_http_process_response_async(fhttp, http_request, parse_response))
    {
        FURI_LOG_E(HTTP_TAG, "Failed to make request");
        view_dispatcher_switch_to_view(*view_dispatcher, failure_view_id);
        view_dispatcher_remove_view(*view_dispatcher, loading_view_id);
        loading_free(loading);

        return;
    }

    // Switch to the success view
    view_dispatcher_switch_to_view(*view_dispatcher, success_view_id);
    view_dispatcher_remove_view(*view_dispatcher, loading_view_id);
    loading_free(loading); // comment this out if you experience a freeze
}

/**
 * @brief      Parse JSON data.
 * @return     true if the JSON data was parsed successfully, false otherwise.
 * @param      fhttp The FlipperHTTP context
 * @param      key       The key to parse from the JSON data.
 * @param      json_data The JSON data to parse.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_parse_json(FlipperHTTP *fhttp, const char *key, const char *json_data)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    if (!key || !json_data)
    {
        FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_parse_json.");
        return false;
    }

    char buffer[512];
    int ret =
        snprintf(buffer, sizeof(buffer), "[PARSE]{\"key\":\"%s\",\"json\":%s}", key, json_data);

    if (ret < 0 || ret >= (int)sizeof(buffer))
    {
        FURI_LOG_E("FlipperHTTP", "Failed to format JSON parse command.");
        return false;
    }

    return flipper_http_send_data(fhttp, buffer);
}

/**
 * @brief      Parse JSON array data.
 * @return     true if the JSON array data was parsed successfully, false otherwise.
 * @param      fhttp The FlipperHTTP context
 * @param      key       The key to parse from the JSON array data.
 * @param      index     The index to parse from the JSON array data.
 * @param      json_data The JSON array data to parse.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_parse_json_array(FlipperHTTP *fhttp, const char *key, int index, const char *json_data)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    if (!key || !json_data)
    {
        FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_parse_json_array.");
        return false;
    }

    char buffer[512];
    int ret = snprintf(
        buffer,
        sizeof(buffer),
        "[PARSE/ARRAY]{\"key\":\"%s\",\"index\":%d,\"json\":%s}",
        key,
        index,
        json_data);

    if (ret < 0 || ret >= (int)sizeof(buffer))
    {
        FURI_LOG_E("FlipperHTTP", "Failed to format JSON parse array command.");
        return false;
    }

    return flipper_http_send_data(fhttp, buffer);
}

/**
 * @brief Process requests and parse JSON data asynchronously
 * @param fhttp The FlipperHTTP context
 * @param http_request The function to send the request
 * @param parse_json The function to parse the JSON
 * @return true if successful, false otherwise
 */
bool flipper_http_process_response_async(FlipperHTTP *fhttp, bool (*http_request)(void), bool (*parse_json)(void))
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    if (http_request()) // start the async request
    {
        furi_timer_start(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);
        fhttp->state = RECEIVING;
    }
    else
    {
        FURI_LOG_E(HTTP_TAG, "Failed to send request");
        return false;
    }
    while (fhttp->state == RECEIVING && furi_timer_is_running(fhttp->get_timeout_timer) > 0)
    {
        // Wait for the request to be received
        furi_delay_ms(100);
    }
    furi_timer_stop(fhttp->get_timeout_timer);
    if (!parse_json()) // parse the JSON before switching to the view (synchonous)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to parse the JSON...");
        return false;
    }
    return true;
}

/**
 * @brief      Send a request to the specified URL.
 * @return     true if the request was successful, false otherwise.
 * @param      fhttp The FlipperHTTP context
 * @param      method The HTTP method to use.
 * @param      url  The URL to send the request to.
 * @param      headers  The headers to send with the request.
 * @param      payload  The data to send with the request.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_request(FlipperHTTP *fhttp, HTTPMethod method, const char *url, const char *headers, const char *payload)
{
    if (!fhttp)
    {
        FURI_LOG_E("FlipperHTTP", "Failed to get context.");
        return false;
    }
    if (!url)
    {
        FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_request.");
        return false;
    }

    // Prepare request command
    char command[512];
    int ret = 0;

    switch (method)
    {
    case GET:
        if (headers && strlen(headers) > 0)
            ret = snprintf(command, sizeof(command), "[GET/HTTP]{\"url\":\"%s\",\"headers\":%s}", url, headers);
        else
            ret = snprintf(command, sizeof(command), "[GET]%s", url);
        break;
    case POST:
        if (!headers || !payload)
        {
            FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_request.");
            return false;
        }
        ret = snprintf(command, sizeof(command), "[POST/HTTP]{\"url\":\"%s\",\"headers\":%s,\"payload\":%s}", url, headers, payload);
        break;
    case PUT:
        if (!headers || !payload)
        {
            FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_request.");
            return false;
        }
        ret = snprintf(command, sizeof(command), "[PUT/HTTP]{\"url\":\"%s\",\"headers\":%s,\"payload\":%s}", url, headers, payload);
        break;
    case DELETE:
        if (!headers || !payload)
        {
            FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_request.");
            return false;
        }
        ret = snprintf(command, sizeof(command), "[DELETE/HTTP]{\"url\":\"%s\",\"headers\":%s,\"payload\":%s}", url, headers, payload);
        break;
    case BYTES:
        if (!headers)
        {
            FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_request.");
            return false;
        }
        if (strlen(fhttp->file_path) == 0)
        {
            FURI_LOG_E("FlipperHTTP", "File path is not set.");
            return false;
        }
        fhttp->save_received_data = false;
        fhttp->is_bytes_request = true;
        ret = snprintf(command, sizeof(command), "[GET/BYTES]{\"url\":\"%s\",\"headers\":%s}", url, headers);
        break;
    case BYTES_POST:
        if (!headers || !payload)
        {
            FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_request.");
            return false;
        }
        if (strlen(fhttp->file_path) == 0)
        {
            FURI_LOG_E("FlipperHTTP", "File path is not set.");
            return false;
        }
        fhttp->save_received_data = false;
        fhttp->is_bytes_request = true;
        ret = snprintf(command, sizeof(command), "[POST/BYTES]{\"url\":\"%s\",\"headers\":%s,\"payload\":%s}", url, headers, payload);
        break;
    }

    // check if ret is valid
    if (ret < 0 || ret >= (int)sizeof(command))
    {
        FURI_LOG_E("FlipperHTTP", "Failed to format request command.");
        return false;
    }

    // set method
    fhttp->method = method;

    // Send request via UART
    return flipper_http_send_data(fhttp, command);
}

/**
 * @brief      Send a command to save WiFi settings.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_save_wifi(FlipperHTTP *fhttp, const char *ssid, const char *password)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    if (!ssid || !password)
    {
        FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_save_wifi.");
        return false;
    }

    char buffer[256];

    int ret = snprintf(
        buffer, sizeof(buffer), "[WIFI/SAVE]{\"ssid\":\"%s\",\"password\":\"%s\"}", ssid, password);

    if (ret < 0 || ret >= (int)sizeof(buffer))
    {
        FURI_LOG_E("FlipperHTTP", "Failed to format WiFi save command.");
        return false;
    }

    return flipper_http_send_data(fhttp, buffer);
}

/**
 * @brief      Send a command.
 * @return     true if the request was successful, false otherwise.
 * @param      fhttp The FlipperHTTP context
 * @param      command The command to send.
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_send_command(FlipperHTTP *fhttp, HTTPCommand command)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    switch (command)
    {
    case HTTP_CMD_WIFI_CONNECT:
        return flipper_http_send_data(fhttp, "[WIFI/CONNECT]");
    case HTTP_CMD_WIFI_DISCONNECT:
        return flipper_http_send_data(fhttp, "[WIFI/DISCONNECT]");
    case HTTP_CMD_IP_ADDRESS:
        return flipper_http_send_data(fhttp, "[IP/ADDRESS]");
    case HTTP_CMD_IP_WIFI:
        return flipper_http_send_data(fhttp, "[WIFI/IP]");
    case HTTP_CMD_SCAN:
        return flipper_http_send_data(fhttp, "[WIFI/SCAN]");
    case HTTP_CMD_LIST_COMMANDS:
        return flipper_http_send_data(fhttp, "[LIST]");
    case HTTP_CMD_LED_ON:
        return flipper_http_send_data(fhttp, "[LED/ON]");
    case HTTP_CMD_LED_OFF:
        return flipper_http_send_data(fhttp, "[LED/OFF]");
    case HTTP_CMD_PING:
        fhttp->state = INACTIVE; // set state as INACTIVE to be made IDLE if PONG is received
        return flipper_http_send_data(fhttp, "[PING]");
    case HTTP_CMD_REBOOT:
        return flipper_http_send_data(fhttp, "[REBOOT]");
    default:
        FURI_LOG_E(HTTP_TAG, "Invalid command.");
        return false;
    }
}

/**
 * @brief      Send data over UART with newline termination.
 * @return     true if the data was sent successfully, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @param      data  The data to send over UART.
 * @note       The data will be sent over UART with a newline character appended.
 */
bool flipper_http_send_data(FlipperHTTP *fhttp, const char *data)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }

    size_t data_length = strlen(data);
    if (data_length == 0)
    {
        FURI_LOG_E("FlipperHTTP", "Attempted to send empty data.");
        return false;
    }

    // Create a buffer with data + '\n'
    size_t send_length = data_length + 1; // +1 for '\n'
    if (send_length > 512)
    { // Ensure buffer size is sufficient
        FURI_LOG_E("FlipperHTTP", "Data too long to send over FHTTP->");
        return false;
    }

    char send_buffer[513]; // 512 + 1 for safety
    strncpy(send_buffer, data, 512);
    send_buffer[data_length] = '\n';     // Append newline
    send_buffer[data_length + 1] = '\0'; // Null-terminate

    if (fhttp->state == INACTIVE && ((strstr(send_buffer, "[PING]") == NULL) &&
                                     (strstr(send_buffer, "[WIFI/CONNECT]") == NULL)))
    {
        FURI_LOG_E("FlipperHTTP", "Cannot send data while INACTIVE.");
        fhttp->last_response = "Cannot send data while INACTIVE.";
        return false;
    }

    fhttp->state = SENDING;
    furi_hal_serial_tx(fhttp->serial_handle, (const uint8_t *)send_buffer, send_length);

    // FURI_LOG_I("FlipperHTTP", "Sent data over UART: %s", send_buffer);
    fhttp->state = IDLE;
    return true;
}

// Function to set content length and status code
static void set_header(FlipperHTTP *fhttp)
{
    // example response: [GET/SUCCESS]{"Status-Code":200,"Content-Length":12528}
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Invalid arguments provided to set_header.");
        return;
    }

    size_t error_size = -1;

    // reset values
    fhttp->content_length = 0;
    fhttp->status_code = 0;
    fhttp->bytes_received = 0;

    FuriString *furi_string = furi_string_alloc_set_str(fhttp->last_response);
    if (!furi_string)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to allocate memory for furi_string.");
        return;
    }

    size_t status_code_start = furi_string_search_str(furi_string, "\"Status-Code\":", 0);
    if (status_code_start != error_size)
    {
        // trim everything, including the status code and colon
        furi_string_right(furi_string, status_code_start + strlen("\"Status-Code\":"));

        // find comma (we have this currently: 200,"Content-Length":12528})
        size_t comma = furi_string_search_str(furi_string, ",\"Content-Length\":", 0);
        if (comma == error_size)
        {
            FURI_LOG_E(HTTP_TAG, "Failed to find comma in furi_string.");
            furi_string_free(furi_string);
            return;
        }

        // set status code
        FuriString *status_code_str = furi_string_alloc();

        // dest, src, start, length
        furi_string_set_n(status_code_str, furi_string, 0, comma);
        fhttp->status_code = atoi(furi_string_get_cstr(status_code_str));
        furi_string_free(status_code_str);

        // trim left to remove everything before the content length
        furi_string_right(furi_string, comma + strlen(",\"Content-Length\":"));

        // find closing brace (we have this currently: 12528})
        size_t closing_brace = furi_string_search_str(furi_string, "}", 0);
        if (closing_brace == error_size)
        {
            FURI_LOG_E(HTTP_TAG, "Failed to find closing brace in furi_string.");
            furi_string_free(furi_string);
            return;
        }

        // set content length
        FuriString *content_length_str = furi_string_alloc();

        // dest, src, start, length
        furi_string_set_n(content_length_str, furi_string, 0, closing_brace);
        fhttp->content_length = atoi(furi_string_get_cstr(content_length_str));
        furi_string_free(content_length_str);
    }

    // print results
    // FURI_LOG_I(HTTP_TAG, "Status Code: %d", fhttp->status_code);
    // FURI_LOG_I(HTTP_TAG, "Content Length: %d", fhttp->content_length);

    // free the furi_string
    furi_string_free(furi_string);
}

// Function to trim leading and trailing spaces and newlines from a constant string
static char *trim(const char *str)
{
    const char *end;
    char *trimmed_str;
    size_t len;

    // Trim leading space
    while (isspace((unsigned char)*str))
        str++;

    // All spaces?
    if (*str == 0)
        return strdup(""); // Return an empty string if all spaces

    // Trim trailing space
    end = str + strlen(str) - 1;
    while (end > str && isspace((unsigned char)*end))
        end--;

    // Set length for the trimmed string
    len = end - str + 1;

    // Allocate space for the trimmed string and null terminator
    trimmed_str = (char *)malloc(len + 1);
    if (trimmed_str == NULL)
    {
        return NULL; // Handle memory allocation failure
    }

    // Copy the trimmed part of the string into trimmed_str
    strncpy(trimmed_str, str, len);
    trimmed_str[len] = '\0'; // Null terminate the string

    return trimmed_str;
}

/**
 * @brief      Callback function to handle received data asynchronously.
 * @return     void
 * @param      line     The received line.
 * @param      context  The FlipperHTTP context.
 * @note       The received data will be handled asynchronously via the callback and handles the state of the UART.
 */
static void flipper_http_rx_callback(const char *line, void *context)
{
    FlipperHTTP *fhttp = (FlipperHTTP *)context;
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return;
    }
    if (!line)
    {
        FURI_LOG_E(HTTP_TAG, "Invalid arguments provided to flipper_http_rx_callback.");
        return;
    }

    // Trim the received line to check if it's empty
    char *trimmed_line = trim(line);
    if (trimmed_line != NULL && trimmed_line[0] != '\0')
    {
        // if the line is not [GET/END] or [POST/END] or [PUT/END] or [DELETE/END]
        if (strstr(trimmed_line, "[GET/END]") == NULL &&
            strstr(trimmed_line, "[POST/END]") == NULL &&
            strstr(trimmed_line, "[PUT/END]") == NULL &&
            strstr(trimmed_line, "[DELETE/END]") == NULL)
        {
            strncpy(fhttp->last_response, trimmed_line, RX_BUF_SIZE);
        }
    }
    free(trimmed_line); // Free the allocated memory for trimmed_line

    if (fhttp->state != INACTIVE && fhttp->state != ISSUE)
    {
        fhttp->state = RECEIVING;
    }

    // Uncomment below line to log the data received over UART
    // FURI_LOG_I(HTTP_TAG, "Received UART line: %s", line);

    // Check if we've started receiving data from a GET request
    if (fhttp->started_receiving && (fhttp->method == GET || fhttp->method == BYTES))
    {
        // Restart the timeout timer each time new data is received
        furi_timer_restart(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        if (strstr(line, "[GET/END]") != NULL)
        {
            FURI_LOG_I(HTTP_TAG, "GET request completed.");
            // Stop the timer since we've completed the GET request
            furi_timer_stop(fhttp->get_timeout_timer);
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            fhttp->save_bytes = false;
            fhttp->save_received_data = false;

            if (fhttp->is_bytes_request)
            {
                // Search for the binary marker `[GET/END]` in the file buffer
                const char marker[] = "[GET/END]";
                const size_t marker_len = sizeof(marker) - 1; // Exclude null terminator

                for (size_t i = 0; i <= fhttp->file_buffer_len - marker_len; i++)
                {
                    // Check if the marker is found
                    if (memcmp(&fhttp->file_buffer[i], marker, marker_len) == 0)
                    {
                        // Remove the marker by shifting the remaining data left
                        size_t remaining_len = fhttp->file_buffer_len - (i + marker_len);
                        memmove(&fhttp->file_buffer[i], &fhttp->file_buffer[i + marker_len], remaining_len);
                        fhttp->file_buffer_len -= marker_len;
                        break;
                    }
                }

                // If there is data left in the buffer, append it to the file
                if (fhttp->file_buffer_len > 0)
                {
                    if (!flipper_http_append_to_file(fhttp->file_buffer, fhttp->file_buffer_len, false, fhttp->file_path))
                    {
                        FURI_LOG_E(HTTP_TAG, "Failed to append data to file.");
                    }
                    fhttp->file_buffer_len = 0;
                }
            }

            fhttp->is_bytes_request = false;
            return;
        }

        // Append the new line to the existing data
        if (fhttp->save_received_data &&
            !flipper_http_append_to_file(
                line, strlen(line), !fhttp->just_started, fhttp->file_path))
        {
            FURI_LOG_E(HTTP_TAG, "Failed to append data to file.");
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            return;
        }

        if (!fhttp->just_started)
        {
            fhttp->just_started = true;
        }
        return;
    }

    // Check if we've started receiving data from a POST request
    else if (fhttp->started_receiving && (fhttp->method == POST || fhttp->method == BYTES_POST))
    {
        // Restart the timeout timer each time new data is received
        furi_timer_restart(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        if (strstr(line, "[POST/END]") != NULL)
        {
            FURI_LOG_I(HTTP_TAG, "POST request completed.");
            // Stop the timer since we've completed the POST request
            furi_timer_stop(fhttp->get_timeout_timer);
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            fhttp->save_bytes = false;
            fhttp->save_received_data = false;

            if (fhttp->is_bytes_request)
            {
                // Search for the binary marker `[POST/END]` in the file buffer
                const char marker[] = "[POST/END]";
                const size_t marker_len = sizeof(marker) - 1; // Exclude null terminator

                for (size_t i = 0; i <= fhttp->file_buffer_len - marker_len; i++)
                {
                    // Check if the marker is found
                    if (memcmp(&fhttp->file_buffer[i], marker, marker_len) == 0)
                    {
                        // Remove the marker by shifting the remaining data left
                        size_t remaining_len = fhttp->file_buffer_len - (i + marker_len);
                        memmove(&fhttp->file_buffer[i], &fhttp->file_buffer[i + marker_len], remaining_len);
                        fhttp->file_buffer_len -= marker_len;
                        break;
                    }
                }

                // If there is data left in the buffer, append it to the file
                if (fhttp->file_buffer_len > 0)
                {
                    if (!flipper_http_append_to_file(fhttp->file_buffer, fhttp->file_buffer_len, false, fhttp->file_path))
                    {
                        FURI_LOG_E(HTTP_TAG, "Failed to append data to file.");
                    }
                    fhttp->file_buffer_len = 0;
                }
            }

            fhttp->is_bytes_request = false;
            return;
        }

        // Append the new line to the existing data
        if (fhttp->save_received_data &&
            !flipper_http_append_to_file(
                line, strlen(line), !fhttp->just_started, fhttp->file_path))
        {
            FURI_LOG_E(HTTP_TAG, "Failed to append data to file.");
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            return;
        }

        if (!fhttp->just_started)
        {
            fhttp->just_started = true;
        }
        return;
    }

    // Check if we've started receiving data from a PUT request
    else if (fhttp->started_receiving && fhttp->method == PUT)
    {
        // Restart the timeout timer each time new data is received
        furi_timer_restart(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        if (strstr(line, "[PUT/END]") != NULL)
        {
            FURI_LOG_I(HTTP_TAG, "PUT request completed.");
            // Stop the timer since we've completed the PUT request
            furi_timer_stop(fhttp->get_timeout_timer);
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            fhttp->save_bytes = false;
            fhttp->is_bytes_request = false;
            fhttp->save_received_data = false;
            return;
        }

        // Append the new line to the existing data
        if (fhttp->save_received_data &&
            !flipper_http_append_to_file(
                line, strlen(line), !fhttp->just_started, fhttp->file_path))
        {
            FURI_LOG_E(HTTP_TAG, "Failed to append data to file.");
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            return;
        }

        if (!fhttp->just_started)
        {
            fhttp->just_started = true;
        }
        return;
    }

    // Check if we've started receiving data from a DELETE request
    else if (fhttp->started_receiving && fhttp->method == DELETE)
    {
        // Restart the timeout timer each time new data is received
        furi_timer_restart(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        if (strstr(line, "[DELETE/END]") != NULL)
        {
            FURI_LOG_I(HTTP_TAG, "DELETE request completed.");
            // Stop the timer since we've completed the DELETE request
            furi_timer_stop(fhttp->get_timeout_timer);
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            fhttp->save_bytes = false;
            fhttp->is_bytes_request = false;
            fhttp->save_received_data = false;
            return;
        }

        // Append the new line to the existing data
        if (fhttp->save_received_data &&
            !flipper_http_append_to_file(
                line, strlen(line), !fhttp->just_started, fhttp->file_path))
        {
            FURI_LOG_E(HTTP_TAG, "Failed to append data to file.");
            fhttp->started_receiving = false;
            fhttp->just_started = false;
            fhttp->state = IDLE;
            return;
        }

        if (!fhttp->just_started)
        {
            fhttp->just_started = true;
        }
        return;
    }

    // Handle different types of responses
    if (strstr(line, "[SUCCESS]") != NULL || strstr(line, "[CONNECTED]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "Operation succeeded.");
    }
    else if (strstr(line, "[INFO]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "Received info: %s", line);

        if (fhttp->state == INACTIVE && strstr(line, "[INFO] Already connected to Wifi.") != NULL)
        {
            fhttp->state = IDLE;
        }
    }
    else if (strstr(line, "[GET/SUCCESS]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "GET request succeeded.");
        furi_timer_start(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        fhttp->started_receiving = true;
        fhttp->state = RECEIVING;

        // for GET request, save data only if it's a bytes request
        fhttp->save_bytes = fhttp->is_bytes_request;
        fhttp->just_started_bytes = true;
        fhttp->file_buffer_len = 0;

        // set header
        set_header(fhttp);
        return;
    }
    else if (strstr(line, "[POST/SUCCESS]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "POST request succeeded.");
        furi_timer_start(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        fhttp->started_receiving = true;
        fhttp->state = RECEIVING;

        // for POST request, save data only if it's a bytes request
        fhttp->save_bytes = fhttp->is_bytes_request;
        fhttp->just_started_bytes = true;
        fhttp->file_buffer_len = 0;

        // set header
        set_header(fhttp);
        return;
    }
    else if (strstr(line, "[PUT/SUCCESS]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "PUT request succeeded.");
        furi_timer_start(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        fhttp->started_receiving = true;
        fhttp->state = RECEIVING;

        // set header
        set_header(fhttp);
        return;
    }
    else if (strstr(line, "[DELETE/SUCCESS]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "DELETE request succeeded.");
        furi_timer_start(fhttp->get_timeout_timer, TIMEOUT_DURATION_TICKS);

        fhttp->started_receiving = true;
        fhttp->state = RECEIVING;

        // set header
        set_header(fhttp);
        return;
    }
    else if (strstr(line, "[DISCONNECTED]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "WiFi disconnected successfully.");
    }
    else if (strstr(line, "[ERROR]") != NULL)
    {
        FURI_LOG_E(HTTP_TAG, "Received error: %s", line);
        fhttp->state = ISSUE;
        return;
    }
    else if (strstr(line, "[PONG]") != NULL)
    {
        FURI_LOG_I(HTTP_TAG, "Received PONG response: Wifi Dev Board is still alive.");

        // send command to connect to WiFi
        if (fhttp->state == INACTIVE)
        {
            fhttp->state = IDLE;
            return;
        }
    }

    if (fhttp->state == INACTIVE && strstr(line, "[PONG]") != NULL)
    {
        fhttp->state = IDLE;
    }
    else if (fhttp->state == INACTIVE && strstr(line, "[PONG]") == NULL)
    {
        fhttp->state = INACTIVE;
    }
    else
    {
        fhttp->state = IDLE;
    }
}

/**
 * @brief      Send a request to the specified URL to start a WebSocket connection.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @param      url  The URL to send the WebSocket request to.
 * @param port The port to connect to
 * @param headers The headers to send with the WebSocket request
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_websocket_start(FlipperHTTP *fhttp, const char *url, uint16_t port, const char *headers)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    if (!url || !headers)
    {
        FURI_LOG_E("FlipperHTTP", "Invalid arguments provided to flipper_http_websocket_start.");
        return false;
    }

    // Prepare WebSocket request command with headers
    char command[512];
    int ret = snprintf(
        command,
        sizeof(command),
        "[SOCKET/START]{\"url\":\"%s\",\"port\":%d,\"headers\":%s}",
        url,
        port,
        headers);

    if (ret < 0 || ret >= (int)sizeof(command))
    {
        FURI_LOG_E("FlipperHTTP", "Failed to format WebSocket start command with headers.");
        return false;
    }

    // Send WebSocket request via UART
    return flipper_http_send_data(fhttp, command);
}

/**
 * @brief      Send a request to stop the WebSocket connection.
 * @return     true if the request was successful, false otherwise.
 * @param fhttp The FlipperHTTP context
 * @note       The received data will be handled asynchronously via the callback.
 */
bool flipper_http_websocket_stop(FlipperHTTP *fhttp)
{
    if (!fhttp)
    {
        FURI_LOG_E(HTTP_TAG, "Failed to get context.");
        return false;
    }
    return flipper_http_send_data(fhttp, "[SOCKET/STOP]");
}