Momentum-Apps/flip_storage/flip_social_storage.c

#include "flip_social_storage.h"

// Function to save the playlist
void save_playlist(const PreSavedPlaylist *playlist)
{
    if (!playlist)
    {
        FURI_LOG_E(TAG, "Playlist is NULL");
        return;
    }
    // Create the directory for saving settings
    char directory_path[128];
    snprintf(directory_path, sizeof(directory_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_social");

    // Create the directory
    Storage *storage = furi_record_open(RECORD_STORAGE);
    storage_common_mkdir(storage, directory_path);

    // Open the settings file
    File *file = storage_file_alloc(storage);
    if (!storage_file_open(file, PRE_SAVED_MESSAGES_PATH, FSAM_WRITE, FSOM_CREATE_ALWAYS))
    {
        FURI_LOG_E(TAG, "Failed to open settings file for writing: %s", PRE_SAVED_MESSAGES_PATH);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return;
    }

    // Write each playlist message on a separate line
    for (size_t i = 0; i < playlist->count; ++i)
    {
        // Add a newline character after each message
        if (storage_file_write(file, playlist->messages[i], strlen(playlist->messages[i])) != strlen(playlist->messages[i]))
        {
            FURI_LOG_E(TAG, "Failed to write playlist message %zu", i);
        }

        // Write a newline after each message
        if (storage_file_write(file, "\n", 1) != 1)
        {
            FURI_LOG_E(TAG, "Failed to write newline after message %zu", i);
        }
    }

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

// Function to load the playlist
bool load_playlist(PreSavedPlaylist *playlist)
{
    // Ensure playlist is not NULL
    if (!playlist)
    {
        FURI_LOG_E(TAG, "Playlist is NULL");
        return false;
    }

    // Ensure playlist->messages is not NULL and allocate memory for each message
    for (size_t i = 0; i < MAX_PRE_SAVED_MESSAGES; ++i)
    {
        if (!playlist->messages[i]) // Check if memory is already allocated
        {
            playlist->messages[i] = (char *)malloc(MAX_MESSAGE_LENGTH * sizeof(char));
            if (!playlist->messages[i])
            {
                FURI_LOG_E(TAG, "Failed to allocate memory for message %zu", i);
                return false; // Return false on memory allocation failure
            }
        }
    }

    // Open the storage
    Storage *storage = furi_record_open(RECORD_STORAGE);
    File *file = storage_file_alloc(storage);

    if (!storage_file_open(file, PRE_SAVED_MESSAGES_PATH, FSAM_READ, FSOM_OPEN_EXISTING))
    {
        FURI_LOG_E(TAG, "Failed to open pre-saved messages file for reading: %s", PRE_SAVED_MESSAGES_PATH);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return false; // Return false if the file does not exist
    }

    // Initialize the playlist count
    playlist->count = 0;

    // Read the file byte by byte to simulate reading lines
    char ch;
    size_t message_pos = 0;
    bool message_started = false;

    while (storage_file_read(file, &ch, 1) == 1) // Read one character at a time
    {
        message_started = true;

        if (ch == '\n' || message_pos >= (MAX_MESSAGE_LENGTH - 1)) // End of line or message is too long
        {
            playlist->messages[playlist->count][message_pos] = '\0'; // Null-terminate the message
            playlist->count++;                                       // Move to the next message
            message_pos = 0;                                         // Reset for the next message
            message_started = false;

            // Ensure the playlist count does not exceed the maximum
            if (playlist->count >= MAX_PRE_SAVED_MESSAGES)
            {
                FURI_LOG_W(TAG, "Reached maximum playlist messages");
                break;
            }
        }
        else
        {
            playlist->messages[playlist->count][message_pos++] = ch; // Add character to current message
        }
    }

    // Handle the case where the last message does not end with a newline
    if (message_started && message_pos > 0)
    {
        playlist->messages[playlist->count][message_pos] = '\0'; // Null-terminate the last message
        playlist->count++;                                       // Increment the count for the last message

        // Ensure the playlist count does not exceed the maximum
        if (playlist->count >= MAX_PRE_SAVED_MESSAGES)
        {
            FURI_LOG_W(TAG, "Reached maximum playlist messages");
        }
    }

    // Close the file and storage
    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);

    return true;
}
void save_settings(
    const char *ssid,
    const char *password,
    const char *login_username_logged_out,
    const char *login_username_logged_in,
    const char *login_password_logged_out,
    const char *change_password_logged_in,
    const char *change_bio_logged_in,
    const char *is_logged_in)
{
    // Create the directory for saving settings
    char directory_path[128];
    snprintf(directory_path, sizeof(directory_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_social");

    // Create the directory
    Storage *storage = furi_record_open(RECORD_STORAGE);
    storage_common_mkdir(storage, directory_path);

    // Open the settings file
    File *file = storage_file_alloc(storage);
    if (!storage_file_open(file, SETTINGS_PATH, FSAM_WRITE, FSOM_CREATE_ALWAYS))
    {
        FURI_LOG_E(TAG, "Failed to open settings file for writing: %s", SETTINGS_PATH);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return;
    }

    // Save the ssid length and data
    size_t ssid_length = strlen(ssid) + 1; // Include null terminator
    if (storage_file_write(file, &ssid_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, ssid, ssid_length) != ssid_length)
    {
        FURI_LOG_E(TAG, "Failed to write SSID");
    }

    // Save the password length and data
    size_t password_length = strlen(password) + 1; // Include null terminator
    if (storage_file_write(file, &password_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, password, password_length) != password_length)
    {
        FURI_LOG_E(TAG, "Failed to write password");
    }

    // Save the login_username_logged_out length and data
    size_t username_out_length = strlen(login_username_logged_out) + 1; // Include null terminator
    if (storage_file_write(file, &username_out_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, login_username_logged_out, username_out_length) != username_out_length)
    {
        FURI_LOG_E(TAG, "Failed to write login_username_logged_out");
    }

    // Save the login_username_logged_in length and data
    size_t username_in_length = strlen(login_username_logged_in) + 1; // Include null terminator
    if (storage_file_write(file, &username_in_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, login_username_logged_in, username_in_length) != username_in_length)
    {
        FURI_LOG_E(TAG, "Failed to write login_username_logged_in");
    }

    // Save the login_password_logged_out length and data
    size_t password_out_length = strlen(login_password_logged_out) + 1; // Include null terminator
    if (storage_file_write(file, &password_out_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, login_password_logged_out, password_out_length) != password_out_length)
    {
        FURI_LOG_E(TAG, "Failed to write login_password_logged_out");
    }

    // Save the change_password_logged_in length and data
    size_t change_password_length = strlen(change_password_logged_in) + 1; // Include null terminator
    if (storage_file_write(file, &change_password_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, change_password_logged_in, change_password_length) != change_password_length)
    {
        FURI_LOG_E(TAG, "Failed to write change_password_logged_in");
    }

    // Save the is_logged_in length and data
    size_t is_logged_in_length = strlen(is_logged_in) + 1; // Include null terminator
    if (storage_file_write(file, &is_logged_in_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, is_logged_in, is_logged_in_length) != is_logged_in_length)
    {
        FURI_LOG_E(TAG, "Failed to write is_logged_in");
    }

    // Save the change_bio_logged_in length and data
    size_t change_bio_length = strlen(change_bio_logged_in) + 1; // Include null terminator
    if (storage_file_write(file, &change_bio_length, sizeof(size_t)) != sizeof(size_t) ||
        storage_file_write(file, change_bio_logged_in, change_bio_length) != change_bio_length)
    {
        FURI_LOG_E(TAG, "Failed to write change_bio_logged_in");
    }

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

bool load_settings(
    char *ssid,
    size_t ssid_size,
    char *password,
    size_t password_size,
    char *login_username_logged_out,
    size_t username_out_size,
    char *login_username_logged_in,
    size_t username_in_size,
    char *login_password_logged_out,
    size_t password_out_size,
    char *change_password_logged_in,
    size_t change_password_size,
    char *change_bio_logged_in,
    size_t change_bio_size,
    char *is_logged_in,
    size_t is_logged_in_size)
{
    Storage *storage = furi_record_open(RECORD_STORAGE);
    File *file = storage_file_alloc(storage);

    if (!storage_file_open(file, SETTINGS_PATH, FSAM_READ, FSOM_OPEN_EXISTING))
    {
        FURI_LOG_E(TAG, "Failed to open settings file for reading: %s", SETTINGS_PATH);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return false; // Return false if the file does not exist
    }

    // Load the ssid
    size_t ssid_length;
    if (storage_file_read(file, &ssid_length, sizeof(size_t)) != sizeof(size_t) || ssid_length > ssid_size ||
        storage_file_read(file, ssid, ssid_length) != ssid_length)
    {
        FURI_LOG_E(TAG, "Failed to read SSID");
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return false;
    }
    else
    {
        ssid[ssid_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the password
    size_t password_length;
    if (storage_file_read(file, &password_length, sizeof(size_t)) != sizeof(size_t) || password_length > password_size ||
        storage_file_read(file, password, password_length) != password_length)
    {
        FURI_LOG_E(TAG, "Failed to read password");
        storage_file_close(file);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return false;
    }
    else
    {
        password[password_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the login_username_logged_out
    size_t username_out_length;
    if (storage_file_read(file, &username_out_length, sizeof(size_t)) != sizeof(size_t) || username_out_length > username_out_size ||
        storage_file_read(file, login_username_logged_out, username_out_length) != username_out_length)
    {
        FURI_LOG_E(TAG, "Failed to read login_username_logged_out");
        // storage_file_close(file);
        // storage_file_free(file);
        // furi_record_close(RECORD_STORAGE);
        // return false;
    }
    else
    {
        login_username_logged_out[username_out_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the login_username_logged_in
    size_t username_in_length;
    if (storage_file_read(file, &username_in_length, sizeof(size_t)) != sizeof(size_t) || username_in_length > username_in_size ||
        storage_file_read(file, login_username_logged_in, username_in_length) != username_in_length)
    {
        FURI_LOG_E(TAG, "Failed to read login_username_logged_in");
        // storage_file_close(file);
        // storage_file_free(file);
        // furi_record_close(RECORD_STORAGE);
        // return false;
    }
    else
    {
        login_username_logged_in[username_in_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the login_password_logged_out
    size_t password_out_length;
    if (storage_file_read(file, &password_out_length, sizeof(size_t)) != sizeof(size_t) || password_out_length > password_out_size ||
        storage_file_read(file, login_password_logged_out, password_out_length) != password_out_length)
    {
        FURI_LOG_E(TAG, "Failed to read login_password_logged_out");
        // storage_file_close(file);
        // storage_file_free(file);
        // furi_record_close(RECORD_STORAGE);
        // return false;
    }
    else
    {
        login_password_logged_out[password_out_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the change_password_logged_in
    size_t change_password_length;
    if (storage_file_read(file, &change_password_length, sizeof(size_t)) != sizeof(size_t) || change_password_length > change_password_size ||
        storage_file_read(file, change_password_logged_in, change_password_length) != change_password_length)
    {
        FURI_LOG_E(TAG, "Failed to read change_password_logged_in");
        // storage_file_close(file);
        // storage_file_free(file);
        // furi_record_close(RECORD_STORAGE);
        //  return false;
    }
    else
    {
        change_password_logged_in[change_password_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the is_logged_in
    size_t is_logged_in_length;
    if (storage_file_read(file, &is_logged_in_length, sizeof(size_t)) != sizeof(size_t) || is_logged_in_length > is_logged_in_size ||
        storage_file_read(file, is_logged_in, is_logged_in_length) != is_logged_in_length)
    {
        FURI_LOG_E(TAG, "Failed to read is_logged_in");
        // storage_file_close(file);
        // storage_file_free(file);
        // furi_record_close(RECORD_STORAGE);
        //  return false;
    }
    else
    {
        is_logged_in[is_logged_in_length - 1] = '\0'; // Ensure null-termination
    }

    // Load the change_bio_logged_in
    size_t change_bio_length;
    if (storage_file_read(file, &change_bio_length, sizeof(size_t)) != sizeof(size_t) || change_bio_length > change_bio_size ||
        storage_file_read(file, change_bio_logged_in, change_bio_length) != change_bio_length)
    {
        FURI_LOG_E(TAG, "Failed to read change_bio_logged_in");
        // storage_file_close(file);
        // storage_file_free(file);
        // furi_record_close(RECORD_STORAGE);
        //  return false;
    }
    else
    {
        change_bio_logged_in[change_bio_length - 1] = '\0'; // Ensure null-termination
    }

    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);

    return true;
}

bool flip_social_save_post(char *post_id, char *json_feed_data)
{
    Storage *storage = furi_record_open(RECORD_STORAGE);
    File *file = storage_file_alloc(storage);

    char file_path[128];
    snprintf(file_path, sizeof(file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_social/feed_post_%s.json", post_id);

    if (!storage_file_open(file, file_path, FSAM_WRITE, FSOM_CREATE_ALWAYS))
    {
        FURI_LOG_E(TAG, "Failed to open file for writing: %s", file_path);
        storage_file_free(file);
        furi_record_close(RECORD_STORAGE);
        return false;
    }

    if (storage_file_write(file, json_feed_data, strlen(json_feed_data)) != strlen(json_feed_data))
    {
        FURI_LOG_E(TAG, "Failed to write feed post data");
        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;
}