Momentum-Apps/flip_social/draw/flip_social_draw.c

#include "flip_social_draw.h"
Action action = ActionNone;
bool flip_social_board_is_active(Canvas* canvas) {
    if(fhttp.state == INACTIVE) {
        canvas_draw_str(canvas, 0, 7, "Wifi Dev Board disconnected.");
        canvas_draw_str(canvas, 0, 17, "Please connect to the board.");
        canvas_draw_str(canvas, 0, 32, "If your board is connected,");
        canvas_draw_str(canvas, 0, 42, "make sure you have flashed");
        canvas_draw_str(canvas, 0, 52, "your WiFi Devboard with the");
        canvas_draw_str(canvas, 0, 62, "latest FlipperHTTP flash.");
        return false;
    }
    return true;
}

void flip_social_handle_error(Canvas* canvas) {
    if(fhttp.last_response != NULL) {
        if(strstr(fhttp.last_response, "[ERROR] Not connected to Wifi. Failed to reconnect.") !=
           NULL) {
            canvas_clear(canvas);
            canvas_draw_str(canvas, 0, 10, "[ERROR] Not connected to Wifi.");
            canvas_draw_str(canvas, 0, 50, "Update your WiFi settings.");
            canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
        } else if(strstr(fhttp.last_response, "[ERROR] Failed to connect to Wifi.") != NULL) {
            canvas_clear(canvas);
            canvas_draw_str(canvas, 0, 10, "[ERROR] Not connected to Wifi.");
            canvas_draw_str(canvas, 0, 50, "Update your WiFi settings.");
            canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
        } else {
            canvas_draw_str(canvas, 0, 42, "Failed...");
            canvas_draw_str(canvas, 0, 52, "Update your credentials.");
            canvas_draw_str(canvas, 0, 62, "Press BACK to return.");
        }
    } else {
        canvas_draw_str(canvas, 0, 42, "Failed...");
        canvas_draw_str(canvas, 0, 52, "Update your credentials.");
        canvas_draw_str(canvas, 0, 62, "Press BACK to return.");
    }
}

void on_input(const void* event, void* ctx) {
    UNUSED(ctx);

    InputKey key = ((InputEvent*)event)->key;
    InputType type = ((InputEvent*)event)->type;

    if(type != InputTypeRelease) {
        return;
    }

    switch(key) {
    case InputKeyOk:
        action = ActionFlip;
        break;
    case InputKeyBack:
        action = ActionBack;
        break;
    case InputKeyRight:
        action = ActionNext;
        break;
    case InputKeyLeft:
        action = ActionPrev;
        break;
    case InputKeyUp:
        action = ActionPrev;
        break;
    case InputKeyDown:
        action = ActionNext;
        break;
    default:
        action = ActionNone;
        break;
    }
}

// Function to draw the message on the canvas with word wrapping
void draw_user_message(Canvas* canvas, const char* user_message, int x, int y) {
    if(user_message == NULL) {
        FURI_LOG_E(TAG, "User message is NULL.");
        return;
    }

    size_t msg_length = strlen(user_message);
    size_t start = 0;
    int line_num = 0;
    char line[MAX_LINE_LENGTH + 1]; // Buffer for the current line (+1 for null terminator)

    while(start < msg_length && line_num < 4) {
        size_t remaining = msg_length - start;
        size_t len = (remaining > MAX_LINE_LENGTH) ? MAX_LINE_LENGTH : remaining;

        if(remaining > MAX_LINE_LENGTH) {
            // Find the last space within the first 'len' characters
            size_t last_space = len;
            while(last_space > 0 && user_message[start + last_space - 1] != ' ') {
                last_space--;
            }

            if(last_space > 0) {
                len = last_space; // Adjust len to the position of the last space
            }
        }

        // Copy the substring to 'line' and null-terminate it
        memcpy(line, user_message + start, len);
        line[len] = '\0'; // Ensure the string is null-terminated

        // Draw the string on the canvas
        // Adjust the y-coordinate based on the line number
        canvas_draw_str_aligned(canvas, x, y + line_num * 10, AlignLeft, AlignTop, line);

        // Update the start position for the next line
        start += len;

        // Skip any spaces to avoid leading spaces on the next line
        while(start < msg_length && user_message[start] == ' ') {
            start++;
        }

        // Increment the line number
        line_num++;
    }
}

void flip_social_callback_draw_compose(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }
    if(!app_instance) {
        FURI_LOG_E(TAG, "FlipSocialApp is NULL");
        return;
    }
    if(!selected_message) {
        FURI_LOG_E(TAG, "Selected message is NULL");
        return;
    }

    if(strlen(selected_message) > MAX_MESSAGE_LENGTH) {
        FURI_LOG_E(TAG, "Message is too long");
        return;
    }

    if(!flip_social_dialog_shown) {
        flip_social_dialog_shown = true;
        app_instance->input_event_queue = furi_record_open(RECORD_INPUT_EVENTS);
        app_instance->input_event =
            furi_pubsub_subscribe(app_instance->input_event_queue, on_input, NULL);
        auth_headers_alloc();
    }

    draw_user_message(canvas, selected_message, 0, 2);

    canvas_draw_icon(canvas, 0, 53, &I_ButtonLeft_4x7);
    canvas_draw_str_aligned(canvas, 7, 54, AlignLeft, AlignTop, "Delete");
    canvas_draw_icon(canvas, 52, 53, &I_ButtonBACK_10x8);
    canvas_draw_str_aligned(canvas, 64, 54, AlignLeft, AlignTop, "Back");
    canvas_draw_icon(canvas, 100, 53, &I_ButtonRight_4x7);
    canvas_draw_str_aligned(canvas, 107, 54, AlignLeft, AlignTop, "Post");

    // handle action
    switch(action) {
    case ActionNone:
        break;
    case ActionBack:
        flip_social_dialog_stop = true;
        break;
    case ActionNext:
        // send selected_message
        if(selected_message && app_instance->login_username_logged_in) {
            if(strlen(selected_message) > MAX_MESSAGE_LENGTH) {
                FURI_LOG_E(TAG, "Message is too long");
                return;
            }
            // Send the selected_message
            char command[256];
            snprintf(
                command,
                sizeof(command),
                "{\"username\":\"%s\",\"content\":\"%s\"}",
                app_instance->login_username_logged_in,
                selected_message);

            if(!flipper_http_post_request_with_headers(
                   "https://www.flipsocial.net/api/feed/post/", auth_headers, command)) {
                FURI_LOG_E(TAG, "Failed to send HTTP request for feed");
                fhttp.state = ISSUE;
                return;
            }

            fhttp.state = RECEIVING;
            furi_timer_start(fhttp.get_timeout_timer, TIMEOUT_DURATION_TICKS);
        } else {
            FURI_LOG_E(TAG, "Message or username is NULL");
            return;
        }
        while(fhttp.state == RECEIVING && furi_timer_is_running(fhttp.get_timeout_timer) > 0) {
            // Wait for the feed to be received
            furi_delay_ms(100);

            // Draw the resulting string on the canvas
            canvas_draw_str(canvas, 0, 30, "Receiving..");
        }
        flip_social_dialog_stop = true;
        furi_timer_stop(fhttp.get_timeout_timer);
        break;
    case ActionPrev:
        // delete message
        app_instance->pre_saved_messages.messages[app_instance->pre_saved_messages.index] = NULL;

        for(uint32_t i = app_instance->pre_saved_messages.index;
            i < app_instance->pre_saved_messages.count - 1;
            i++) {
            app_instance->pre_saved_messages.messages[i] =
                app_instance->pre_saved_messages.messages[i + 1];
        }
        app_instance->pre_saved_messages.count--;

        // add the item to the submenu
        submenu_reset(app_instance->submenu_compose);

        submenu_add_item(
            app_instance->submenu_compose,
            "Add Pre-Save",
            FlipSocialSubmenuComposeIndexAddPreSave,
            flip_social_callback_submenu_choices,
            app_instance);

        for(uint32_t i = 0; i < app_instance->pre_saved_messages.count; i++) {
            submenu_add_item(
                app_instance->submenu_compose,
                app_instance->pre_saved_messages.messages[i],
                FlipSocialSubemnuComposeIndexStartIndex + i,
                flip_social_callback_submenu_choices,
                app_instance);
        }

        // save playlist
        save_playlist(&app_instance->pre_saved_messages);

        flip_social_dialog_stop = true;
        break;
    default:
        action = ActionNone;
        break;
    }

    if(flip_social_dialog_stop) {
        furi_pubsub_unsubscribe(app_instance->input_event_queue, app_instance->input_event);
        flip_social_dialog_shown = false;
        flip_social_dialog_stop = false;
        if(action == ActionNext) {
            canvas_clear(canvas);
            canvas_draw_str(canvas, 0, 10, "Sent successfully!");
            canvas_draw_str(canvas, 0, 50, "Loading feed :D");
            canvas_draw_str(canvas, 0, 60, "Please wait...");
            action = ActionNone;
            if(flipper_http_process_response_async(
                   flip_social_get_feed, flip_social_parse_json_feed)) {
                view_dispatcher_switch_to_view(
                    app_instance->view_dispatcher, FlipSocialViewLoggedInFeed);
            } else {
                // Set failure FlipSocialFeed object
                if(!flip_social_temp_feed()) {
                    return;
                }
                view_dispatcher_switch_to_view(
                    app_instance->view_dispatcher, FlipSocialViewLoggedInFeed);
            }
        } else if(action == ActionBack) {
            action = ActionNone;
            view_dispatcher_switch_to_view(
                app_instance->view_dispatcher, FlipSocialViewLoggedInSubmenu);
        } else {
            action = ActionNone;
            view_dispatcher_switch_to_view(
                app_instance->view_dispatcher, FlipSocialViewLoggedInCompose);
        }
    }
}
// function to draw the dialog canvas
void flip_social_canvas_draw_message(
    Canvas* canvas,
    char* user_username,
    char* user_message,
    bool is_flipped,
    bool show_prev,
    bool show_next,
    int flip_count) {
    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str_aligned(canvas, 64, 5, AlignCenter, AlignCenter, user_username);
    canvas_set_font(canvas, FontSecondary);

    char flip_count_str[12];
    if(flip_count == 1) {
        snprintf(flip_count_str, sizeof(flip_count_str), "%d Flip", flip_count);
        canvas_draw_str_aligned(canvas, 106, 54, AlignLeft, AlignTop, flip_count_str);
    } else {
        snprintf(flip_count_str, sizeof(flip_count_str), "%d Flips", flip_count);

        if(flip_count < 10) {
            canvas_draw_str_aligned(canvas, 100, 54, AlignLeft, AlignTop, flip_count_str);
        } else if(flip_count < 100) {
            canvas_draw_str_aligned(canvas, 94, 54, AlignLeft, AlignTop, flip_count_str);
        } else {
            canvas_draw_str_aligned(canvas, 88, 54, AlignLeft, AlignTop, flip_count_str);
        }
    }

    draw_user_message(canvas, user_message, 0, 12);

    // combine and shift icons/labels around if not show_prev or show_next
    if(show_prev && show_next && !is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonLeft_4x7);
        canvas_draw_str_aligned(canvas, 6, 54, AlignLeft, AlignTop, "Prev");
        canvas_draw_icon(canvas, 30, 54, &I_ButtonRight_4x7);
        canvas_draw_str_aligned(canvas, 36, 54, AlignLeft, AlignTop, "Next");
        canvas_draw_icon(canvas, 58, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 67, 54, AlignLeft, AlignTop, "Flip");
    } else if(show_prev && !show_next && !is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonLeft_4x7);
        canvas_draw_str_aligned(canvas, 6, 54, AlignLeft, AlignTop, "Prev");
        canvas_draw_icon(canvas, 28, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 37, 54, AlignLeft, AlignTop, "Flip");
    } else if(!show_prev && show_next && !is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonRight_4x7);
        canvas_draw_str_aligned(canvas, 6, 54, AlignLeft, AlignTop, "Next");
        canvas_draw_icon(canvas, 28, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 37, 54, AlignLeft, AlignTop, "Flip");
    } else if(show_prev && show_next && is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonLeft_4x7);
        canvas_draw_str_aligned(canvas, 6, 54, AlignLeft, AlignTop, "Prev");
        canvas_draw_icon(canvas, 28, 54, &I_ButtonRight_4x7);
        canvas_draw_str_aligned(canvas, 34, 54, AlignLeft, AlignTop, "Next");
        canvas_draw_icon(canvas, 54, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 63, 54, AlignLeft, AlignTop, "UnFlip");
    } else if(show_prev && !show_next && is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonLeft_4x7);
        canvas_draw_str_aligned(canvas, 6, 54, AlignLeft, AlignTop, "Prev");
        canvas_draw_icon(canvas, 28, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 37, 54, AlignLeft, AlignTop, "UnFlip");
    } else if(!show_prev && show_next && is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonRight_4x7);
        canvas_draw_str_aligned(canvas, 6, 54, AlignLeft, AlignTop, "Next");
        canvas_draw_icon(canvas, 28, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 37, 54, AlignLeft, AlignTop, "UnFlip");
    } else if(!show_prev && !show_next && is_flipped) {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 9, 54, AlignLeft, AlignTop, "UnFlip");
    } else {
        canvas_draw_icon(canvas, 0, 54, &I_ButtonOK_7x7);
        canvas_draw_str_aligned(canvas, 9, 54, AlignLeft, AlignTop, "Flip");
    }
}
// Callback function to handle the feed dialog
void flip_social_callback_draw_feed(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }
    if(!app_instance) {
        FURI_LOG_E(TAG, "FlipSocialApp is NULL");
        return;
    }

    if(!flip_social_dialog_shown) {
        flip_social_dialog_shown = true;
        app_instance->input_event_queue = furi_record_open(RECORD_INPUT_EVENTS);
        app_instance->input_event =
            furi_pubsub_subscribe(app_instance->input_event_queue, on_input, NULL);
        auth_headers_alloc();
    }

    // handle action
    switch(action) {
    case ActionNone:
        flip_social_canvas_draw_message(
            canvas,
            flip_social_feed->usernames[flip_social_feed->index],
            flip_social_feed->messages[flip_social_feed->index],
            flip_social_feed->is_flipped[flip_social_feed->index],
            flip_social_feed->index > 0,
            flip_social_feed->index < flip_social_feed->count - 1,
            flip_social_feed->flips[flip_social_feed->index]);
        break;
    case ActionNext:
        canvas_clear(canvas);
        if(flip_social_feed->index < flip_social_feed->count - 1) {
            flip_social_feed->index++;
        }
        flip_social_canvas_draw_message(
            canvas,
            flip_social_feed->usernames[flip_social_feed->index],
            flip_social_feed->messages[flip_social_feed->index],
            flip_social_feed->is_flipped[flip_social_feed->index],
            flip_social_feed->index > 0,
            flip_social_feed->index < flip_social_feed->count - 1,
            flip_social_feed->flips[flip_social_feed->index]);
        action = ActionNone;
        break;
    case ActionPrev:
        canvas_clear(canvas);
        if(flip_social_feed->index > 0) {
            flip_social_feed->index--;
        }
        flip_social_canvas_draw_message(
            canvas,
            flip_social_feed->usernames[flip_social_feed->index],
            flip_social_feed->messages[flip_social_feed->index],
            flip_social_feed->is_flipped[flip_social_feed->index],
            flip_social_feed->index > 0,
            flip_social_feed->index < flip_social_feed->count - 1,
            flip_social_feed->flips[flip_social_feed->index]);
        action = ActionNone;
        break;
    case ActionFlip:
        canvas_clear(canvas);
        // Moved to above the is_flipped check
        if(!flip_social_feed->is_flipped[flip_social_feed->index]) {
            // increase the flip count
            flip_social_feed->flips[flip_social_feed->index]++;
        } else {
            // decrease the flip count
            flip_social_feed->flips[flip_social_feed->index]--;
        }
        // change the flip status
        flip_social_feed->is_flipped[flip_social_feed->index] =
            !flip_social_feed->is_flipped[flip_social_feed->index];
        // send post request to flip the message
        if(app_instance->login_username_logged_in == NULL) {
            FURI_LOG_E(TAG, "Username is NULL");
            return;
        }
        char payload[256];
        snprintf(
            payload,
            sizeof(payload),
            "{\"username\":\"%s\",\"post_id\":\"%u\"}",
            app_instance->login_username_logged_in,
            flip_social_feed->ids[flip_social_feed->index]);
        flipper_http_post_request_with_headers(
            "https://www.flipsocial.net/api/feed/flip/", auth_headers, payload);
        flip_social_canvas_draw_message(
            canvas,
            flip_social_feed->usernames[flip_social_feed->index],
            flip_social_feed->messages[flip_social_feed->index],
            flip_social_feed->is_flipped[flip_social_feed->index],
            flip_social_feed->index > 0,
            flip_social_feed->index < flip_social_feed->count - 1,
            flip_social_feed->flips[flip_social_feed->index]);
        action = ActionNone;
        break;
    case ActionBack:
        canvas_clear(canvas);
        flip_social_dialog_stop = true;
        flip_social_feed->index = 0;
        action = ActionNone;
        break;
    default:
        break;
    }

    if(flip_social_dialog_stop) {
        furi_pubsub_unsubscribe(app_instance->input_event_queue, app_instance->input_event);
        flip_social_dialog_shown = false;
        flip_social_dialog_stop = false;
        action = ActionNone;
    }
}
/**
 * @brief Navigation callback for asynchonously handling the login process.
 * @param canvas The canvas to draw on.
 * @param model The model - unused
 * @return void
 */
void flip_social_callback_draw_login(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }

    canvas_set_font(canvas, FontSecondary);

    if(!flip_social_board_is_active(canvas)) {
        return;
    }

    canvas_draw_str(canvas, 0, 7, "Logging in...");

    // Perform login request
    if(!flip_social_sent_login_request) {
        if(!app_instance->login_username_logged_out || !app_instance->login_password_logged_out ||
           strlen(app_instance->login_username_logged_out) == 0 ||
           strlen(app_instance->login_password_logged_out) == 0) {
            canvas_clear(canvas);
            canvas_draw_str(canvas, 0, 10, "Please enter your credentials.");
            canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
            return;
        }

        flip_social_sent_login_request = true;

        char buffer[256];
        snprintf(
            buffer,
            sizeof(buffer),
            "{\"username\":\"%s\",\"password\":\"%s\"}",
            app_instance->login_username_logged_out,
            app_instance->login_password_logged_out);
        auth_headers_alloc();
        flip_social_login_success = flipper_http_post_request_with_headers(
            "https://www.flipsocial.net/api/user/login/", auth_headers, buffer);
        if(flip_social_login_success) {
            fhttp.state = RECEIVING;
            return;
        } else {
            fhttp.state = ISSUE;
            return;
        }
    }
    // handle response
    if(flip_social_sent_login_request && flip_social_login_success) {
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str(canvas, 0, 17, "Request Sent!");
        canvas_draw_str(canvas, 0, 32, "Awaiting reponse...");

        if(fhttp.state == IDLE && fhttp.last_response != NULL) {
            // read response
            if(strstr(fhttp.last_response, "[SUCCESS]") != NULL ||
               strstr(fhttp.last_response, "User found") != NULL) {
                canvas_draw_str(canvas, 0, 42, "Login successful!");
                canvas_draw_str(canvas, 0, 62, "Welcome back!");

                app_instance->is_logged_in = "true";

                // set the logged_in_username and change_password_logged_in
                if(app_instance->login_username_logged_out) {
                    strcpy(
                        app_instance->login_username_logged_in,
                        app_instance->login_username_logged_out);
                }
                if(app_instance->login_password_logged_out) {
                    app_instance->change_password_logged_in =
                        app_instance->login_password_logged_out;
                }

                save_settings(
                    app_instance->wifi_ssid_logged_out,
                    app_instance->wifi_password_logged_out,
                    app_instance->login_username_logged_out,
                    app_instance->login_username_logged_in,
                    app_instance->login_password_logged_out,
                    app_instance->change_password_logged_in,
                    app_instance->is_logged_in);

                // send user to the logged in submenu
                view_dispatcher_switch_to_view(
                    app_instance->view_dispatcher, FlipSocialViewLoggedInSubmenu);
            } else if(strstr(fhttp.last_response, "User not found") != NULL) {
                canvas_clear(canvas);
                canvas_draw_str(canvas, 0, 10, "Account not found...");
                canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
            } else {
                flip_social_handle_error(canvas);
            }
        } else if((fhttp.state == ISSUE || fhttp.state == INACTIVE) && fhttp.last_response != NULL) {
            flip_social_handle_error(canvas);
        } else if(fhttp.state == IDLE && fhttp.last_response == NULL) {
            flip_social_handle_error(canvas);
        }
    } else if(flip_social_sent_login_request && !flip_social_login_success) {
        canvas_clear(canvas);
        canvas_draw_str(canvas, 0, 10, "Failed sending request.");
        canvas_draw_str(canvas, 0, 50, "Update your WiFi settings.");
        canvas_draw_str(canvas, 0, 62, "Press BACK to return.");
    }
}

/**
 * @brief Navigation callback for asynchonously handling the register process.
 * @param canvas The canvas to draw on.
 * @param model The model - unused
 * @return void
 */
void flip_social_callback_draw_register(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }

    canvas_set_font(canvas, FontSecondary);

    if(!flip_social_board_is_active(canvas)) {
        return;
    }

    canvas_draw_str(canvas, 0, 7, "Registering...");

    // Perform login request
    if(!flip_social_sent_register_request) {
        // check if the username and password are valid
        if(!app_instance->register_username_logged_out ||
           !app_instance->register_password_logged_out ||
           strlen(app_instance->register_username_logged_out) == 0 ||
           strlen(app_instance->register_password_logged_out) == 0) {
            canvas_clear(canvas);
            canvas_draw_str(canvas, 0, 10, "Please enter your credentials.");
            canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
            return;
        }

        // check if both passwords match
        if(strcmp(
               app_instance->register_password_logged_out,
               app_instance->register_password_2_logged_out) != 0) {
            canvas_clear(canvas);
            canvas_draw_str(canvas, 0, 10, "Passwords do not match.");
            canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
            return;
        }

        char buffer[128];
        snprintf(
            buffer,
            sizeof(buffer),
            "{\"username\":\"%s\",\"password\":\"%s\"}",
            app_instance->register_username_logged_out,
            app_instance->register_password_logged_out);
        flip_social_register_success = flipper_http_post_request_with_headers(
            "https://www.flipsocial.net/api/user/register/",
            "{\"Content-Type\":\"application/json\"}",
            buffer);

        flip_social_sent_register_request = true;
        if(flip_social_register_success) {
            // Set the state to RECEIVING to ensure we continue to see the receiving message
            fhttp.state = RECEIVING;
        } else {
            fhttp.state = ISSUE;
        }
    }
    // handle response
    if(flip_social_sent_register_request && flip_social_register_success) {
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str(canvas, 0, 17, "Request Sent!");
        canvas_draw_str(canvas, 0, 32, "Awaiting reponse...");

        if(fhttp.state == IDLE) {
            // read response
            if(fhttp.last_response != NULL &&
               (strstr(fhttp.last_response, "[SUCCESS]") != NULL ||
                strstr(fhttp.last_response, "User created") != NULL)) {
                canvas_draw_str(canvas, 0, 42, "Registeration successful!");
                canvas_draw_str(canvas, 0, 62, "Welcome to FlipSocial!");

                // set the login credentials
                if(app_instance->login_username_logged_out) {
                    app_instance->login_username_logged_out =
                        app_instance->register_username_logged_out;
                }
                if(app_instance->login_password_logged_out) {
                    app_instance->login_password_logged_out =
                        app_instance->register_password_logged_out;
                    app_instance->change_password_logged_in =
                        app_instance->register_password_logged_out;
                }
                if(app_instance->login_username_logged_in) {
                    app_instance->login_username_logged_in =
                        app_instance->register_username_logged_out;
                }

                app_instance->is_logged_in = "true";

                // update header credentials
                auth_headers_alloc();

                // save the credentials
                save_settings(
                    app_instance->wifi_ssid_logged_out,
                    app_instance->wifi_password_logged_out,
                    app_instance->login_username_logged_out,
                    app_instance->login_username_logged_in,
                    app_instance->login_password_logged_out,
                    app_instance->change_password_logged_in,
                    app_instance->is_logged_in);

                // send user to the logged in submenu
                view_dispatcher_switch_to_view(
                    app_instance->view_dispatcher, FlipSocialViewLoggedInSubmenu);
            } else if(strstr(fhttp.last_response, "Username or password not provided") != NULL) {
                canvas_clear(canvas);
                canvas_draw_str(canvas, 0, 10, "Please enter your credentials.");
                canvas_draw_str(canvas, 0, 60, "Press BACK to return.");
            } else if(
                strstr(fhttp.last_response, "User already exists") != NULL ||
                strstr(fhttp.last_response, "Multiple users found") != NULL) {
                canvas_draw_str(canvas, 0, 42, "Registration failed...");
                canvas_draw_str(canvas, 0, 52, "Username already exists.");
                canvas_draw_str(canvas, 0, 62, "Press BACK to return.");
            } else {
                canvas_draw_str(canvas, 0, 42, "Registration failed...");
                canvas_draw_str(canvas, 0, 52, "Update your credentials.");
                canvas_draw_str(canvas, 0, 62, "Press BACK to return.");
            }
        } else if(fhttp.state == ISSUE || fhttp.state == INACTIVE) {
            flip_social_handle_error(canvas);
        }
    } else if(flip_social_sent_register_request && !flip_social_register_success) {
        canvas_clear(canvas);
        canvas_draw_str(canvas, 0, 10, "Failed sending request.");
        canvas_draw_str(canvas, 0, 50, "Update your WiFi settings.");
        canvas_draw_str(canvas, 0, 62, "Press BACK to return.");
    }
}

// function to draw the dialog canvas
void flip_social_canvas_draw_explore(Canvas* canvas, char* user_username, char* content) {
    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str_aligned(canvas, 64, 5, AlignCenter, AlignCenter, user_username);
    canvas_set_font(canvas, FontSecondary);

    draw_user_message(canvas, content, 0, 12);

    canvas_set_font(canvas, FontSecondary);
    canvas_draw_icon(canvas, 0, 53, &I_ButtonLeft_4x7);
    canvas_draw_str_aligned(canvas, 9, 54, AlignLeft, AlignTop, "Remove");
    canvas_draw_icon(canvas, 98, 53, &I_ButtonRight_4x7);
    canvas_draw_str_aligned(canvas, 107, 54, AlignLeft, AlignTop, "Add");

    if(strlen(content) > 0) {
        last_explore_response = content;
    }
}

// Callback function to handle the explore dialog
void flip_social_callback_draw_explore(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }
    if(!app_instance) {
        FURI_LOG_E(TAG, "FlipSocialApp is NULL");
        return;
    }

    if(!flip_social_dialog_shown) {
        flip_social_dialog_shown = true;
        app_instance->input_event_queue = furi_record_open(RECORD_INPUT_EVENTS);
        app_instance->input_event =
            furi_pubsub_subscribe(app_instance->input_event_queue, on_input, NULL);
        auth_headers_alloc();
    }
    flip_social_canvas_draw_explore(
        canvas, flip_social_explore->usernames[flip_social_explore->index], last_explore_response);

    // handle action
    switch(action) {
    case ActionNext:
        // add friend
        char add_payload[128];
        snprintf(
            add_payload,
            sizeof(add_payload),
            "{\"username\":\"%s\",\"friend\":\"%s\"}",
            app_instance->login_username_logged_in,
            flip_social_explore->usernames[flip_social_explore->index]);
        flipper_http_post_request_with_headers(
            "https://www.flipsocial.net/api/user/add-friend/", auth_headers, add_payload);
        canvas_clear(canvas);
        flip_social_canvas_draw_explore(
            canvas, flip_social_explore->usernames[flip_social_explore->index], "Added!");
        action = ActionNone;
        break;
    case ActionPrev:
        // remove friend
        char remove_payload[128];
        snprintf(
            remove_payload,
            sizeof(remove_payload),
            "{\"username\":\"%s\",\"friend\":\"%s\"}",
            app_instance->login_username_logged_in,
            flip_social_explore->usernames[flip_social_explore->index]);
        flipper_http_post_request_with_headers(
            "https://www.flipsocial.net/api/user/remove-friend/", auth_headers, remove_payload);
        canvas_clear(canvas);
        flip_social_canvas_draw_explore(
            canvas, flip_social_explore->usernames[flip_social_explore->index], "Removed!");
        action = ActionNone;
        break;
    case ActionBack:
        canvas_clear(canvas);
        flip_social_dialog_stop = true;
        last_explore_response = "";
        flip_social_dialog_shown = false;
        flip_social_explore->index = 0;
        action = ActionNone;
        break;
    default:
        break;
    }

    if(flip_social_dialog_stop) {
        furi_pubsub_unsubscribe(app_instance->input_event_queue, app_instance->input_event);
        flip_social_dialog_shown = false;
        flip_social_dialog_stop = false;
        action = ActionNone;
    }
}

// Callback function to handle the friends dialog
void flip_social_callback_draw_friends(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }
    if(!app_instance) {
        FURI_LOG_E(TAG, "FlipSocialApp is NULL");
        return;
    }

    if(!flip_social_dialog_shown) {
        flip_social_dialog_shown = true;
        app_instance->input_event_queue = furi_record_open(RECORD_INPUT_EVENTS);
        app_instance->input_event =
            furi_pubsub_subscribe(app_instance->input_event_queue, on_input, NULL);
        auth_headers_alloc();
    }
    flip_social_canvas_draw_explore(
        canvas, flip_social_friends->usernames[flip_social_friends->index], last_explore_response);

    // handle action
    switch(action) {
    case ActionNext:
        // add friend
        char add_payload[128];
        snprintf(
            add_payload,
            sizeof(add_payload),
            "{\"username\":\"%s\",\"friend\":\"%s\"}",
            app_instance->login_username_logged_in,
            flip_social_friends->usernames[flip_social_friends->index]);
        if(flipper_http_post_request_with_headers(
               "https://www.flipsocial.net/api/user/add-friend/", auth_headers, add_payload)) {
            canvas_clear(canvas);
            flip_social_canvas_draw_explore(
                canvas, flip_social_friends->usernames[flip_social_friends->index], "Added!");

            // add the friend to the friends list
            flip_social_friends->usernames[flip_social_friends->count] =
                flip_social_friends->usernames[flip_social_friends->index];
            flip_social_friends->count++;
            if(!flip_social_update_friends()) {
                FURI_LOG_E(TAG, "Failed to update friends");
            }
        }
        action = ActionNone;
        break;
    case ActionPrev:
        // remove friend
        char remove_payload[128];
        snprintf(
            remove_payload,
            sizeof(remove_payload),
            "{\"username\":\"%s\",\"friend\":\"%s\"}",
            app_instance->login_username_logged_in,
            flip_social_friends->usernames[flip_social_friends->index]);
        if(flipper_http_post_request_with_headers(
               "https://www.flipsocial.net/api/user/remove-friend/",
               auth_headers,
               remove_payload)) {
            canvas_clear(canvas);
            flip_social_canvas_draw_explore(
                canvas, flip_social_friends->usernames[flip_social_friends->index], "Removed!");

            // remove the friend from the friends list
            for(int i = flip_social_friends->index; i < flip_social_friends->count - 1; i++) {
                flip_social_friends->usernames[i] = flip_social_friends->usernames[i + 1];
            }
            flip_social_friends->count--;
            if(!flip_social_update_friends()) {
                FURI_LOG_E(TAG, "Failed to update friends");
            }
        }
        action = ActionNone;
        break;
    case ActionBack:
        canvas_clear(canvas);
        flip_social_dialog_stop = true;
        last_explore_response = "";
        flip_social_dialog_shown = false;
        flip_social_friends->index = 0;
        action = ActionNone;
        break;
    default:
        break;
    }

    if(flip_social_dialog_stop) {
        furi_pubsub_unsubscribe(app_instance->input_event_queue, app_instance->input_event);
        flip_social_dialog_shown = false;
        flip_social_dialog_stop = false;
        action = ActionNone;
    }
}

void flip_social_canvas_draw_user_message(
    Canvas* canvas,
    char* user_username,
    char* user_message,
    bool show_prev,
    bool show_next) {
    canvas_set_color(canvas, ColorBlack);
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str_aligned(canvas, 64, 5, AlignCenter, AlignCenter, user_username);
    canvas_set_font(canvas, FontSecondary);

    draw_user_message(canvas, user_message, 0, 12);

    canvas_set_font(canvas, FontSecondary);
    if(show_prev) {
        canvas_draw_icon(canvas, 0, 53, &I_ButtonLeft_4x7);
        canvas_draw_str_aligned(canvas, 9, 54, AlignLeft, AlignTop, "Prev");
    }

    canvas_draw_icon(canvas, 47, 53, &I_ButtonOK_7x7);
    canvas_draw_str_aligned(canvas, 56, 54, AlignLeft, AlignTop, "Create");

    if(show_next) {
        canvas_draw_icon(canvas, 98, 53, &I_ButtonRight_4x7);
        canvas_draw_str_aligned(canvas, 107, 54, AlignLeft, AlignTop, "Next");
    }
}

// Callback function to handle the messages dialog
void flip_social_callback_draw_messages(Canvas* canvas, void* model) {
    UNUSED(model);
    if(!canvas) {
        FURI_LOG_E(TAG, "Canvas is NULL");
        return;
    }
    if(!app_instance) {
        FURI_LOG_E(TAG, "FlipSocialApp is NULL");
        return;
    }

    if(!flip_social_dialog_shown) {
        flip_social_dialog_shown = true;
        app_instance->input_event_queue = furi_record_open(RECORD_INPUT_EVENTS);
        app_instance->input_event =
            furi_pubsub_subscribe(app_instance->input_event_queue, on_input, NULL);
    }

    // handle action
    switch(action) {
    case ActionNone:
        flip_social_canvas_draw_user_message(
            canvas,
            flip_social_messages->usernames[flip_social_messages->index],
            flip_social_messages->messages[flip_social_messages->index],
            flip_social_messages->index > 0,
            flip_social_messages->index < flip_social_messages->count - 1);
        action = ActionNone;
        break;
    case ActionNext:
        // view next message (if any)
        canvas_clear(canvas);
        if(flip_social_messages->index < flip_social_messages->count - 1) {
            flip_social_messages->index++;
        }
        flip_social_canvas_draw_user_message(
            canvas,
            flip_social_messages->usernames[flip_social_messages->index],
            flip_social_messages->messages[flip_social_messages->index],
            flip_social_messages->index > 0,
            flip_social_messages->index < flip_social_messages->count - 1);
        action = ActionNone;
        break;
    case ActionPrev:
        // view previous message (if any)
        canvas_clear(canvas);
        if(flip_social_messages->index > 0) {
            flip_social_messages->index--;
        }
        flip_social_canvas_draw_user_message(
            canvas,
            flip_social_messages->usernames[flip_social_messages->index],
            flip_social_messages->messages[flip_social_messages->index],
            flip_social_messages->index > 0,
            flip_social_messages->index < flip_social_messages->count - 1);
        action = ActionNone;
        break;
    case ActionBack:
        //  go back to the previous view
        flip_social_dialog_stop = true;
        action = ActionNone;
        break;
    case ActionFlip:
        // go to the input view
        flip_social_dialog_stop = true;
        flip_social_send_message = true;
        action = ActionNone;
        break;
    default:
        action = ActionNone;
        break;
    }

    if(flip_social_dialog_stop && flip_social_dialog_shown) {
        furi_pubsub_unsubscribe(app_instance->input_event_queue, app_instance->input_event);
        flip_social_dialog_shown = false;
        flip_social_dialog_stop = false;
        if(flip_social_send_message) {
            FURI_LOG_I(TAG, "Switching to new message input view");
            action = ActionNone;
            flip_social_send_message = false;
            view_dispatcher_switch_to_view(
                app_instance->view_dispatcher, FlipSocialViewLoggedInMessagesNewMessageInput);
        } else {
            action = ActionNone;
            view_dispatcher_switch_to_view(
                app_instance->view_dispatcher, FlipSocialViewLoggedInMessagesSubmenu);
        }
    }
}