Momentum-Apps/flip_store/flip_store_storage.h

#ifndef FLIP_STORE_STORAGE_H
#define FLIP_STORE_STORAGE_H

#include <furi.h>
#include <storage/storage.h>

#define SETTINGS_PATH STORAGE_EXT_PATH_PREFIX "/apps_data/flip_store/settings.bin"

static void save_settings(const char* ssid, const char* password) {
    // Create the directory for saving settings
    char directory_path[128];
    snprintf(
        directory_path, sizeof(directory_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_store");

    // 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");
    }

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

static bool load_settings(char* ssid, size_t ssid_size, char* password, size_t password_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;
    }
    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;
    }
    password[password_length - 1] = '\0'; // Ensure null-termination

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

    return true;
}

// future implenetation because we need the app category
bool delete_app(const char* app_id, const char* app_category) {
    // Create the directory for saving settings
    char directory_path[128];
    snprintf(
        directory_path,
        sizeof(directory_path),
        STORAGE_EXT_PATH_PREFIX "/apps/%s/%s",
        app_category,
        app_id);

    // Create the directory
    Storage* storage = furi_record_open(RECORD_STORAGE);
    if(!storage_simply_remove_recursive(storage, directory_path)) {
        FURI_LOG_E(TAG, "Failed to delete app: %s", app_id);
        furi_record_close(RECORD_STORAGE);
        return false;
    }

    furi_record_close(RECORD_STORAGE);
    return true;
}

#define BUFFER_SIZE      64
#define MAX_KEY_LENGTH   32
#define MAX_VALUE_LENGTH 64

// Function to parse JSON incrementally from a file
bool parse_json_incrementally(
    const char* file_path,
    const char* target_key,
    char* value_buffer,
    size_t value_buffer_size) {
    Storage* _storage = NULL;
    File* _file = NULL;
    char buffer[BUFFER_SIZE];
    size_t bytes_read;
    bool key_found = false;
    bool in_string = false;
    bool is_escaped = false;
    bool reading_key = false;
    bool reading_value = false;
    char current_key[MAX_KEY_LENGTH] = {0};
    size_t key_index = 0;
    size_t value_index = 0;

    // Open storage and file
    _storage = furi_record_open(RECORD_STORAGE);
    if(!_storage) {
        FURI_LOG_E("JSON_PARSE", "Failed to open storage.");
        return false;
    }

    _file = storage_file_alloc(_storage);
    if(!_file) {
        FURI_LOG_E("JSON_PARSE", "Failed to allocate file.");
        furi_record_close(RECORD_STORAGE);
        return false;
    }

    if(!storage_file_open(_file, file_path, FSAM_READ, FSOM_OPEN_EXISTING)) {
        FURI_LOG_E("JSON_PARSE", "Failed to open JSON file for reading.");
        goto cleanup;
    }

    while((bytes_read = storage_file_read(_file, buffer, BUFFER_SIZE)) > 0) {
        for(size_t i = 0; i < bytes_read; ++i) {
            char c = buffer[i];

            if(is_escaped) {
                is_escaped = false;
                if(reading_key) {
                    if(key_index < MAX_KEY_LENGTH - 1) {
                        current_key[key_index++] = c;
                    }
                } else if(reading_value) {
                    if(value_index < value_buffer_size - 1) {
                        value_buffer[value_index++] = c;
                    }
                }
                continue;
            }

            if(c == '\\') {
                is_escaped = true;
                continue;
            }

            if(c == '\"') {
                in_string = !in_string;

                if(in_string) {
                    // Start of a string
                    if(!reading_key && !reading_value) {
                        // Possible start of a key
                        reading_key = true;
                        key_index = 0;
                        current_key[0] = '\0';
                    }
                } else {
                    // End of a string
                    if(reading_key) {
                        reading_key = false;
                        current_key[key_index] = '\0';

                        if(strcmp(current_key, target_key) == 0) {
                            key_found = true;
                        }
                    } else if(reading_value) {
                        reading_value = false;
                        value_buffer[value_index] = '\0';

                        if(key_found) {
                            // Found the target value
                            goto success;
                        }
                    }
                }
                continue;
            }

            if(in_string) {
                if(reading_key) {
                    if(key_index < MAX_KEY_LENGTH - 1) {
                        current_key[key_index++] = c;
                    }
                } else if(reading_value) {
                    if(value_index < value_buffer_size - 1) {
                        value_buffer[value_index++] = c;
                    }
                }
                continue;
            }

            if(c == ':' && key_found && !reading_value) {
                // After colon, start reading the value
                // Skip whitespace and possible opening quote
                while(i + 1 < bytes_read &&
                      (buffer[i + 1] == ' ' || buffer[i + 1] == '\n' || buffer[i + 1] == '\r')) {
                    i++;
                }

                if(i + 1 < bytes_read && buffer[i + 1] == '\"') {
                    i++; // Move to the quote
                    in_string = true;
                    reading_value = true;
                    value_index = 0;
                } else {
                    // Handle non-string values (e.g., numbers, booleans)
                    reading_value = true;
                    value_index = 0;
                }
                continue;
            }

            if(reading_value && (c == ',' || c == '}' || c == ']')) {
                // End of the value
                reading_value = false;
                value_buffer[value_index] = '\0';

                if(key_found) {
                    // Found the target value
                    goto success;
                }
                key_found = false;
            }
        }
    }

success:
    storage_file_close(_file);
    storage_file_free(_file);
    furi_record_close(RECORD_STORAGE);
    return key_found;

cleanup:
    if(_file) {
        storage_file_free(_file);
    }
    if(_storage) {
        furi_record_close(RECORD_STORAGE);
    }
    return false;
}

#endif